compute=_=>1

const printArray = eval('ha ha'.replace(' ', '=>'));

function compute() {
  return 3;
}

const ageSumDigits = (a1, a2, a3, d=a=>[...a+''].reduce((a, n) => a- -n)) => d(a1) < d(a2+[a3])

using System.Linq;

class Palindrome
{
  public static bool Check(string word) => word.ToLower() == new string(word.ToLower().Reverse().ToArray());
}

class ThirdAngle{static int otherAngle(int a,int b){return 180-a-b;}}

import java.util.*;
import java.util.stream.*;

public class Cashier {
    private String[] names = {"note", "coin"};
    private int[] types  = { 0,  0,  0, 0, 1, 1}; // can be adjusted
    private int[] values = {50, 20, 10, 5, 2, 1};

    public Cashier() {}

    public String produceChange(int cash) {
      int[] typTotals = new int[names.length];
      List<String> texTotals = new ArrayList<String>();
    
      for (int i = 0, c = cash; i < values.length; c %= values[i++]) {
        int val = c / values[i];
        typTotals[types[i]] += val;
        boolean t = val > 0 && texTotals.add(val + "x £" + values[i] + " " + names[types[i]]/* + (val == 1 ? "" : "s")*/);
      }
      
      return "For £" + cash + " - change was " +
        IntStream.range(0, names.length).mapToObj(i -> typTotals[i] + " " + names[i] + (typTotals[i] == 1 ? "" : "s")).collect(Collectors.joining(" and ")) + 
        ": " + String.join(", ", texTotals);
    }
}

const returnhundred = _ => [_=+!_+[+!!_]]*_

public class BiggerNum{

  public static int compare(int a, int b) {
    return a>b ? a : b;
  }

}

ok=_=>"ok"

function returnhundred() {
  return new Date().getMinutes() + new Date().getMinutes() + new Date().getMinutes() + new Date().getMinutes();
}

// there are three conditions that could cause the rules to fail:
// - a name in the rules doesn't exist in the family
// - a family member wants to sit next to three other people, or themself
// - a loop consisting of a smaller subset of the family exists
// this solution checks for these three

function canTheySit(familyMembers, rules) {
  var desiredSeating = {};
  familyMembers.forEach(member => desiredSeating[member] = []);
  
  if (rules.some(rule => {
    if (rule.some(member => !desiredSeating[member]) || rule[0] == rule[1])
      return true;
  
    desiredSeating[rule[0]].push(rule[1]);
    desiredSeating[rule[1]].push(rule[0]);
    
    return rule.some(member => desiredSeating[member].length > 2);
  }))
    return false;
  
  var visited = {};
  for (var m = 0; m < familyMembers.length; m++) {
    var member = familyMembers[m];
  
    if (visited[member]) continue;
    visited[member] = true;
    
    var loopLength = 0;
    var currMember = member;
    while (desiredSeating[currMember].length > 0) {
      var prevMember = currMember;
      currMember = desiredSeating[currMember][0];
      visited[currMember] = true;
      loopLength++;
      
      if (currMember == member)
        return loopLength == familyMembers.length;
      
      var currSeating = desiredSeating[currMember];
      currSeating.splice(currSeating.indexOf(prevMember), 1);
    }
  }
  
  return true;
}

public class BiggerNum{

  /**
   * @param a integer of param1
   * @param b integer of param2
   * @return the bigger integer of a and b
   * If a equals b, return either one
   */
  public static int compare(int a, int b) {
    return a > b ? a : b;
  }
}

// e.g.:
// simplify( 15,   5) == [  3,  1]
// simplify(-50,  20) == [- 5,  2]
// simplify( 20, - 2) == [-10,  1]
// simplify(- 6, - 3) == [  2,  1]
// simplify(- 0,   3) == [  0,  1]
// simplify(  0,   0) == undefined
// simplify(  5, - 0) == undefined

function simplify(n, d){
  if (d === 0)
    return undefined;
  if (n === 0)
    return [0, 1];

  // fraction_sign contains the sign of the fraction (1 if positive, -1 if negative)
  const fraction_sign = Math.sign(n * d);
  // fraction_gcd contains the greatest common divisor of n and d
  const fraction_gcd = gcd(Math.abs(n), Math.abs(d));
  // we calculate the reduced numerator (it has the same sign as the fraction)
  const result_n = fraction_sign * Math.abs(n) / fraction_gcd;
  // we calculate the reduced denominator
  const result_d = Math.abs(d) / fraction_gcd;

  return [result_n, result_d];
}



// gcd(x, y) calculates the greatest common divisor of x and y
// x and y must be non-negative integers
// USED ALGORITHM: binary method
// BASED ON: https://en.wikipedia.org/wiki/Binary_GCD_algorithm

function gcd(x, y){
  if (x === y)
    return x;
  if (x > y)
    return gcd(y, x);
  if (x === 0)
    return y;

  switch(2 * (x % 2) + (y % 2)) {
    case 0:                           // both are divisible by 2
      return gcd(x >> 1, y >> 1) << 1;
    case 1:                           // only y is divisible by 2
      return gcd(x >> 1, y);
    case 2:                           // only x is divisible by 2
      return gcd(x, y >> 1);
    case 3:                           // neither are divisible by 2
      return gcd((y - x) >> 1, x);
    default:                          // default case should not run
      return 0;
  }
}

const validate = str => !(acc = 0) && str.split``.every(c => (acc += (c === '(' ? 1 : -1)) >= 0) && acc === 0;