import java.util.*;
import java.util.zip.*;
import java.util.List;
import java.util.regex.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import java.util.concurrent.locks.*;
import java.util.function.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.*;
import javax.swing.table.*;
import java.io.*;
import java.net.*;
import java.lang.reflect.*;
import java.lang.ref.*;
import java.lang.management.*;
import java.security.*;
import java.security.spec.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.awt.geom.*;
import javax.imageio.*;
import java.math.*;
import java.time.Duration;
// returns Int.MAX_VALUE if not applicable
// returns -score if conversions are needed
// or +score if no conversions are needed
// Lower score is better
// assumes no arguments are null
class main {

static int methodApplicabilityScore_withPrimitiveWidening_onTypes(Executable m, Class[] argTypes) {
  Class<?>[] types = m.getParameterTypes();
  if (types.length != l(argTypes)) return Integer.MAX_VALUE;
  int score = 0;
  boolean widenings = false;
  for (int i = 0; i < types.length; i++) {
    Class t = argTypes[i];
    Class c = types[i];
     
     int s = typeConversionScoreWithUnboxing(t, c);
      

     if (s == Integer.MAX_VALUE)
       return Integer.MAX_VALUE;
     if (s < 0) widenings = true;
     score += abs(s);
  }
  
  return widenings ? -score : score;
}
static int l(Object[] a) { return a == null ? 0 : a.length; }
static int l(boolean[] a) { return a == null ? 0 : a.length; }
static int l(byte[] a) { return a == null ? 0 : a.length; }
static int l(short[] a) { return a == null ? 0 : a.length; }
static int l(long[] a) { return a == null ? 0 : a.length; }
static int l(int[] a) { return a == null ? 0 : a.length; }
static int l(float[] a) { return a == null ? 0 : a.length; }
static int l(double[] a) { return a == null ? 0 : a.length; }
static int l(char[] a) { return a == null ? 0 : a.length; }
static int l(Collection c) { return c == null ? 0 : c.size(); }

static int l(Iterator i) { return iteratorCount_int_close(i); } // consumes the iterator && closes it if possible

static int l(Map m) { return m == null ? 0 : m.size(); }
static int l(CharSequence s) { return s == null ? 0 : s.length(); }
static long l(File f) { return f == null ? 0 : f.length(); }



























// Can a be converted to b?

// score 0 = exact match
// score Int.MAX_VALUE = no match
// score 1 = conversion needed (boxing/unboxing or non-primitve widening)
// score -2 = primitive widening needed

static int typeConversionScoreWithUnboxing(Class a, Class b) {
  int score = typeConversionScore(a, b);
  if (score == 0 || score == 1) return score;
  
  Class aPrim = boxedToPrimitiveType(a);
  if (aPrim != null) {
    int score2 = typeConversionScore(aPrim, b);
    if (score2 == 0) return 1;
    else if (score2 != Integer.MAX_VALUE) return score2;
  }
  return score;
}


static float abs(float f) { return Math.abs(f); }
static int abs(int i) { return Math.abs(i); }
static double abs(double d) { return Math.abs(d); }






static <A> int iteratorCount_int_close(Iterator<A> i) { try {
  int n = 0;
  if (i != null) while (i.hasNext()) { i.next(); ++n; }
  if (i instanceof AutoCloseable) ((AutoCloseable) i).close();
  return n;
} catch (Exception __e) { throw rethrow(__e); } }


// Can a be converted to b?

// score 0 = exact match
// score Int.MAX_VALUE = no match
// score 1 = conversion needed (boxing/unboxing or non-primitve widening)
// score -2 = primitive widening needed

static int typeConversionScore(Class a, Class b) {
  if (a == b) return 0;
  
  if (b.isPrimitive()) {
    // target type is primitive
    
    if (a.isPrimitive()) {
      // both types are primitive
      
      // No widenings to bool
      if (b == boolean.class) return Integer.MAX_VALUE;
      
      // No widenings to byte
      if (b == byte.class) return Integer.MAX_VALUE;
      
      // byte can be converted to char
      if (b == char.class) return a == byte.class ? -2 : Integer.MAX_VALUE;
      
      // byte can be converted to short
      if (b == short.class) return a == byte.class ? -2 : Integer.MAX_VALUE;
      
      // byte, char and short can be converted to int
      if (b == int.class) return a == byte.class || a == char.class || a == short.class ? -2 : Integer.MAX_VALUE;
      
      // byte, char, short and int can be converted to long
      if (b == long.class) return a == byte.class || a == char.class || a == short.class || a == int.class ? -2 : Integer.MAX_VALUE;
      
      // byte, char, short and int can be converted to float
      if (b == float.class) return a == byte.class || a == char.class || a == short.class || a == int.class ? -2 : Integer.MAX_VALUE;
      
      // all primitive types except bool can be converted to double
      return a != boolean.class ? -2 : Integer.MAX_VALUE;
    } else {
      // source type is boxed - check if they're a match 
      return primitiveToBoxedType(b) == a ?  1 : Integer.MAX_VALUE;
    }
  } else {
    // target type is not primitive
    
    // object type is primitive - check for exact match
    if (a.isPrimitive()) return primitiveToBoxedType(a) == b ? 1 : Integer.MAX_VALUE;

    // both types are not primitive.
    // if not assignable, no match
    if (!b.isAssignableFrom(a)) return Integer.MAX_VALUE;
    
    // if assignable, get precise score
    
    // if any is an interface, just get score 1
    if (a.isInterface() || b.isInterface()) return 1;
    
    // for classes, count subclass distance
    return subclassDistance(a, b);
  }
}


static Class boxedToPrimitiveType(Class type) {
  if (type == Boolean.class) return boolean.class;
  if (type == Integer.class) return int.class;
  if (type == Long.class) return long.class;
  if (type == Float.class) return float.class;
  if (type == Short.class) return short.class;
  if (type == Character.class) return char.class;
  if (type == Byte.class) return byte.class;
  if (type == Double.class) return double.class;
  return null;
}




static RuntimeException rethrow(Throwable t) {
  
  if (t instanceof Error)
    _handleError((Error) t);
  
  throw t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t);
}

static RuntimeException rethrow(String msg, Throwable t) {
  throw new RuntimeException(msg, t);
}


static Class primitiveToBoxedType(Class type) {
  if (type == boolean.class) return Boolean.class;
  if (type == int.class) return Integer.class;
  if (type == long.class) return Long.class;
  if (type == float.class) return Float.class;
  if (type == short.class) return Short.class;
  if (type == char.class) return Character.class;
  if (type == byte.class) return Byte.class;
  if (type == double.class) return Double.class;
  return null;
}


static int subclassDistance(Class a, Class b) {
  int n = 0;
  while (a != b) {
    a = a.getSuperclass();
    if (a == null) return Integer.MAX_VALUE;
    ++n;
  }
  return n;
}




static void _handleError(Error e) {
  //call(javax(), '_handleError, e);
}



}