1 /*
   2  * Copyright (c) 2008, 2009, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package sun.dyn;
  27 
  28 import java.dyn.*;
  29 import java.lang.reflect.Constructor;
  30 import java.lang.reflect.InvocationTargetException;
  31 import sun.dyn.util.ValueConversions;
  32 import sun.dyn.util.Wrapper;
  33 import static sun.dyn.MemberName.newIllegalArgumentException;
  34 
  35 /**
  36  * Adapters which mediate between incoming calls which are not generic
  37  * and outgoing calls which are.  Any call can be represented generically
  38  * boxing up its arguments, and (on return) unboxing the return value.
  39  * <p>
  40  * A call is "generic" (in MethodHandle terms) if its MethodType features
  41  * only Object arguments.  A non-generic call therefore features
  42  * primitives and/or reference types other than Object.
  43  * An adapter has types for its incoming and outgoing calls.
  44  * The incoming call type is simply determined by the adapter's type
  45  * (the MethodType it presents to callers).  The outgoing call type
  46  * is determined by the adapter's target (a MethodHandle that the adapter
  47  * either binds internally or else takes as a leading argument).
  48  * (To stretch the term, adapter-like method handles may have multiple
  49  * targets or be polymorphic across multiple call types.)
  50  * @author jrose
  51  */
  52 class ToGeneric {
  53     // type for the incoming call (may be erased)
  54     private final MethodType entryType;
  55     // incoming type with primitives moved to the end and turned to int/long
  56     private final MethodType rawEntryType;
  57     // adapter for the erased type
  58     private final Adapter adapter;
  59     // entry point for adapter (Adapter mh, a...) => ...
  60     private final MethodHandle entryPoint;
  61     // permutation of arguments for primsAtEndType
  62     private final int[] primsAtEndOrder;
  63     // optional final argument list conversions (at least, invokes the target)
  64     private final MethodHandle invoker;
  65     // conversion which unboxes a primitive return value
  66     private final MethodHandle returnConversion;
  67 
  68     /** Compute and cache information common to all generifying (boxing) adapters
  69      *  that implement members of the erasure-family of the given erased type.
  70      */
  71     private ToGeneric(MethodType entryType) {
  72         assert(entryType.erase() == entryType); // for now
  73         // incoming call will first "forget" all reference types except Object
  74         this.entryType = entryType;
  75         MethodHandle invoker0 = MethodHandles.exactInvoker(entryType.generic());
  76         MethodType rawEntryTypeInit;
  77         Adapter ad = findAdapter(rawEntryTypeInit = entryType);
  78         if (ad != null) {
  79             // Immediate hit to exactly the adapter we want,
  80             // with no monkeying around with primitive types.
  81             this.returnConversion = computeReturnConversion(entryType, rawEntryTypeInit, false);
  82             this.rawEntryType = rawEntryTypeInit;
  83             this.adapter = ad;
  84             this.entryPoint = ad.prototypeEntryPoint();
  85             this.primsAtEndOrder = null;
  86             this.invoker = invoker0;
  87             return;
  88         }
  89 
  90         // next, it will reorder primitives after references
  91         MethodType primsAtEnd = MethodTypeImpl.of(entryType).primsAtEnd();
  92         // at the same time, it will "forget" all primitive types except int/long
  93         this.primsAtEndOrder = MethodTypeImpl.primsAtEndOrder(entryType);
  94         if (primsAtEndOrder != null) {
  95             // reordering is required; build on top of a simpler ToGeneric
  96             ToGeneric va2 = ToGeneric.of(primsAtEnd);
  97             this.adapter = va2.adapter;
  98             if (true) throw new UnsupportedOperationException("NYI: primitive parameters must follow references; entryType = "+entryType);
  99             this.entryPoint = MethodHandleImpl.convertArguments(Access.TOKEN,
 100                     va2.entryPoint, primsAtEnd, entryType, primsAtEndOrder);
 101             // example: for entryType of (int,Object,Object), the reordered
 102             // type is (Object,Object,int) and the order is {1,2,0},
 103             // and putPAE is (mh,int0,obj1,obj2) => mh.invokeExact(obj1,obj2,int0)
 104             return;
 105         }
 106 
 107         // after any needed argument reordering, it will reinterpret
 108         // primitive arguments according to their "raw" types int/long
 109         MethodType intsAtEnd = MethodTypeImpl.of(primsAtEnd).primsAsInts();
 110         ad = findAdapter(rawEntryTypeInit = intsAtEnd);
 111         MethodHandle rawEntryPoint;
 112         if (ad != null) {
 113             rawEntryPoint = ad.prototypeEntryPoint();
 114         } else {
 115             // Perhaps the adapter is available only for longs.
 116             // If so, we can use it, but there will have to be a little
 117             // more stack motion on each call.
 118             MethodType longsAtEnd = MethodTypeImpl.of(primsAtEnd).primsAsLongs();
 119             ad = findAdapter(rawEntryTypeInit = longsAtEnd);
 120             if (ad != null) {
 121                 MethodType eptWithLongs = longsAtEnd.insertParameterTypes(0, ad.getClass());
 122                 MethodType eptWithInts  =  intsAtEnd.insertParameterTypes(0, ad.getClass());
 123                 rawEntryPoint = ad.prototypeEntryPoint();
 124                 MethodType midType = eptWithLongs;  // will change longs to ints
 125                 for (int i = 0, nargs = midType.parameterCount(); i < nargs; i++) {
 126                     if (midType.parameterType(i) != eptWithInts.parameterType(i)) {
 127                         assert(midType.parameterType(i) == long.class);
 128                         assert(eptWithInts.parameterType(i) == int.class);
 129                         MethodType nextType = midType.changeParameterType(i, int.class);
 130                         rawEntryPoint = MethodHandle.convertArguments(Access.TOKEN,
 131                                 rawEntryPoint, nextType, midType, null);
 132                         midType = nextType;
 133                     }
 134                 }
 135                 assert(midType == eptWithInts);
 136             } else {
 137                 // If there is no statically compiled adapter,
 138                 // build one by means of dynamic bytecode generation.
 139                 ad = buildAdapterFromBytecodes(rawEntryTypeInit = intsAtEnd);
 140                 rawEntryPoint = ad.prototypeEntryPoint();
 141             }
 142         }
 143         MethodType tepType = entryType.insertParameterTypes(0, ad.getClass());
 144         this.entryPoint =
 145             AdapterMethodHandle.makeRetypeRaw(Access.TOKEN, tepType, rawEntryPoint);
 146         if (this.entryPoint == null)
 147             throw new UnsupportedOperationException("cannot retype to "+entryType
 148                     +" from "+rawEntryPoint.type().dropParameterTypes(0, 1));
 149         this.returnConversion = computeReturnConversion(entryType, rawEntryTypeInit, false);
 150         this.rawEntryType = rawEntryTypeInit;
 151         this.adapter = ad;
 152         this.invoker = makeRawArgumentFilter(invoker0, rawEntryTypeInit, entryType);
 153     }
 154 
 155     /** A generic argument list will be created by a call of type 'raw'.
 156      *  The values need to be reboxed for to match 'cooked'.
 157      *  Do this on the fly.
 158      */
 159     // TO DO: Use a generic argument converter in a different file
 160     static MethodHandle makeRawArgumentFilter(MethodHandle invoker,
 161             MethodType raw, MethodType cooked) {
 162         MethodHandle filteredInvoker = null;
 163         for (int i = 0, nargs = raw.parameterCount(); i < nargs; i++) {
 164             Class<?> src = raw.parameterType(i);
 165             Class<?> dst = cooked.parameterType(i);
 166             if (src == dst)  continue;
 167             assert(src.isPrimitive() && dst.isPrimitive());
 168             if (filteredInvoker == null) {
 169                 filteredInvoker =
 170                         AdapterMethodHandle.makeCheckCast(Access.TOKEN,
 171                             invoker.type().generic(), invoker, 0, MethodHandle.class);
 172                 if (filteredInvoker == null)  throw new UnsupportedOperationException("NYI");
 173             }
 174             MethodHandle reboxer = ValueConversions.rebox(dst, false);
 175             filteredInvoker = FilterGeneric.makeArgumentFilter(1+i, reboxer, filteredInvoker);
 176             if (filteredInvoker == null)  throw new InternalError();
 177         }
 178         if (filteredInvoker == null)  return invoker;
 179         return AdapterMethodHandle.makeRetypeOnly(Access.TOKEN, invoker.type(), filteredInvoker);
 180     }
 181 
 182     /**
 183      * Caller will be expecting a result from a call to {@code type},
 184      * while the internal adapter entry point is rawEntryType.
 185      * Also, the internal target method will be returning a boxed value,
 186      * as an untyped object.
 187      * <p>
 188      * Produce a value converter which will be typed to convert from
 189      * {@code Object} to the return value of {@code rawEntryType}, and will
 190      * in fact ensure that the value is compatible with the return type of
 191      * {@code type}.
 192      */
 193     private static MethodHandle computeReturnConversion(
 194             MethodType type, MethodType rawEntryType, boolean mustCast) {
 195         Class<?> tret = type.returnType();
 196         Class<?> rret = rawEntryType.returnType();
 197         if (mustCast || !tret.isPrimitive()) {
 198             assert(!tret.isPrimitive());
 199             assert(!rret.isPrimitive());
 200             if (rret == Object.class && !mustCast)
 201                 return null;
 202             return ValueConversions.cast(tret, false);
 203         } else if (tret == rret) {
 204             return ValueConversions.unbox(tret, false);
 205         } else {
 206             assert(rret.isPrimitive());
 207             assert(tret == double.class ? rret == long.class : rret == int.class);
 208             return ValueConversions.unboxRaw(tret, false);
 209         }
 210     }
 211 
 212     Adapter makeInstance(MethodType type, MethodHandle genericTarget) {
 213         genericTarget.getClass();  // check for NPE
 214         MethodHandle convert = returnConversion;
 215         if (primsAtEndOrder != null)
 216             // reorder arguments passed to genericTarget, if primsAtEndOrder
 217             throw new UnsupportedOperationException("NYI");
 218         if (type == entryType) {
 219             if (convert == null)  convert = ValueConversions.identity();
 220             return adapter.makeInstance(entryPoint, invoker, convert, genericTarget);
 221         }
 222         // my erased-type is not exactly the same as the desired type
 223         assert(type.erase() == entryType);  // else we are busted
 224         if (convert == null)
 225             convert = computeReturnConversion(type, rawEntryType, true);
 226         // retype erased reference arguments (the cast makes it safe to do this)
 227         MethodType tepType = type.insertParameterTypes(0, adapter.getClass());
 228         MethodHandle typedEntryPoint =
 229             AdapterMethodHandle.makeRetypeRaw(Access.TOKEN, tepType, entryPoint);
 230         return adapter.makeInstance(typedEntryPoint, invoker, convert, genericTarget);
 231     }
 232 
 233     /** Build an adapter of the given type, which invokes genericTarget
 234      *  on the incoming arguments, after boxing as necessary.
 235      *  The return value is unboxed if necessary.
 236      * @param type  the required type of the
 237      * @param genericTarget the target, which must accept and return only Object values
 238      * @return an adapter method handle
 239      */
 240     public static MethodHandle make(MethodType type, MethodHandle genericTarget) {
 241         MethodType gtype = genericTarget.type();
 242         if (type.generic() != gtype)
 243             throw newIllegalArgumentException("type must be generic");
 244         if (type == gtype)  return genericTarget;
 245         return ToGeneric.of(type).makeInstance(type, genericTarget);
 246     }
 247 
 248     /** Return the adapter information for this type's erasure. */
 249     static ToGeneric of(MethodType type) {
 250         MethodTypeImpl form = MethodTypeImpl.of(type);
 251         ToGeneric toGen = form.toGeneric;
 252         if (toGen == null)
 253             form.toGeneric = toGen = new ToGeneric(form.erasedType());
 254         return toGen;
 255     }
 256 
 257     public String toString() {
 258         return "ToGeneric"+entryType
 259                 +(primsAtEndOrder!=null?"[reorder]":"");
 260     }
 261 
 262     /* Create an adapter for the given incoming call type. */
 263     static Adapter findAdapter(MethodType entryPointType) {
 264         MethodTypeImpl form = MethodTypeImpl.of(entryPointType);
 265         Class<?> rtype = entryPointType.returnType();
 266         int argc = form.parameterCount();
 267         int lac = form.longPrimitiveParameterCount();
 268         int iac = form.primitiveParameterCount() - lac;
 269         String intsAndLongs = (iac > 0 ? "I"+iac : "")+(lac > 0 ? "J"+lac : "");
 270         String rawReturn = String.valueOf(Wrapper.forPrimitiveType(rtype).basicTypeChar());
 271         String iname0 = "invoke_"+rawReturn;
 272         String iname1 = "invoke";
 273         String[] inames = { iname0, iname1 };
 274         String cname0 = rawReturn + argc;
 275         String cname1 = "A"       + argc;
 276         String[] cnames = { cname1, cname1+intsAndLongs, cname0, cname0+intsAndLongs };
 277         // e.g., D5I2, D5, L5I2, L5
 278         for (String cname : cnames) {
 279             Class<? extends Adapter> acls = Adapter.findSubClass(cname);
 280             if (acls == null)  continue;
 281             // see if it has the required invoke method
 282             for (String iname : inames) {
 283                 MethodHandle entryPoint = null;
 284                 try {
 285                     entryPoint = MethodHandleImpl.IMPL_LOOKUP.
 286                                     findSpecial(acls, iname, entryPointType, acls);
 287                 } catch (NoAccessException ex) {
 288                 }
 289                 if (entryPoint == null)  continue;
 290                 Constructor<? extends Adapter> ctor = null;
 291                 try {
 292                     // Prototype builder:
 293                     ctor = acls.getDeclaredConstructor(MethodHandle.class);
 294                 } catch (NoSuchMethodException ex) {
 295                 } catch (SecurityException ex) {
 296                 }
 297                 if (ctor == null)  continue;
 298                 try {
 299                     return ctor.newInstance(entryPoint);
 300                 } catch (IllegalArgumentException ex) {
 301                 } catch (InvocationTargetException wex) {
 302                     Throwable ex = wex.getTargetException();
 303                     if (ex instanceof Error)  throw (Error)ex;
 304                     if (ex instanceof RuntimeException)  throw (RuntimeException)ex;
 305                 } catch (InstantiationException ex) {
 306                 } catch (IllegalAccessException ex) {
 307                 }
 308             }
 309         }
 310         return null;
 311     }
 312 
 313     static Adapter buildAdapterFromBytecodes(MethodType entryPointType) {
 314         throw new UnsupportedOperationException("NYI");
 315     }
 316 
 317     /**
 318      * The invoke method takes some particular but unconstrained spread
 319      * of raw argument types, and returns a raw return type (in L/I/J/F/D).
 320      * Internally, it converts the incoming arguments uniformly into objects.
 321      * This series of objects is then passed to the {@code target} method,
 322      * which returns a result object.  This result is finally converted,
 323      * via another method handle {@code convert}, which is responsible for
 324      * converting the object result into the raw return value.
 325      */
 326     static abstract class Adapter extends BoundMethodHandle {
 327         /*
 328          * class X<<R,A...>> extends Adapter {
 329          *   Object...=>Object target;
 330          *   Object=>R convert;
 331          *   R invoke(A... a...) = convert(invoker(target, a...)))
 332          * }
 333          */
 334         protected final MethodHandle invoker;  // (MH, Object...) -> Object
 335         protected final MethodHandle target;   // Object... -> Object
 336         protected final MethodHandle convert;  // Object -> R
 337 
 338         @Override
 339         public String toString() {
 340             return target == null ? "prototype:"+convert : MethodHandleImpl.addTypeString(target, this);
 341         }
 342 
 343         protected boolean isPrototype() { return target == null; }
 344         /* Prototype constructor. */
 345         protected Adapter(MethodHandle entryPoint) {
 346             super(Access.TOKEN, entryPoint);
 347             this.invoker = null;
 348             this.convert = entryPoint;
 349             this.target = null;
 350             assert(isPrototype());
 351         }
 352         protected MethodHandle prototypeEntryPoint() {
 353             if (!isPrototype())  throw new InternalError();
 354             return convert;
 355         }
 356 
 357         protected Adapter(MethodHandle entryPoint, MethodHandle invoker, MethodHandle convert, MethodHandle target) {
 358             super(Access.TOKEN, entryPoint);
 359             this.invoker = invoker;
 360             this.convert = convert;
 361             this.target = target;
 362         }
 363 
 364         /** Make a copy of self, with new fields. */
 365         protected abstract Adapter makeInstance(MethodHandle entryPoint,
 366                 MethodHandle invoker, MethodHandle convert, MethodHandle target);
 367         // { return new ThisType(entryPoint, convert, target); }
 368 
 369         // Code to run when the arguments (<= 4) have all been boxed.
 370         protected Object target()               throws Throwable { return invoker.invokeExact(target); }
 371         protected Object target(Object a0)      throws Throwable { return invoker.invokeExact(target, a0); }
 372         protected Object target(Object a0, Object a1)
 373                                                 throws Throwable { return invoker.invokeExact(target, a0, a1); }
 374         protected Object target(Object a0, Object a1, Object a2)
 375                                                 throws Throwable { return invoker.invokeExact(target, a0, a1, a2); }
 376         protected Object target(Object a0, Object a1, Object a2, Object a3)
 377                                                 throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3); }
 378         /*
 379         protected Object target_0(Object... av) throws Throwable { return invoker.invokeExact(target, av); }
 380         protected Object target_1(Object a0, Object... av)
 381                                                 throws Throwable { return invoker.invokeExact(target, a0, (Object)av); }
 382         protected Object target_2(Object a0, Object a1, Object... av)
 383                                                 throws Throwable { return invoker.invokeExact(target, a0, a1, (Object)av); }
 384         protected Object target_3(Object a0, Object a1, Object a2, Object... av)
 385                                                 throws Throwable { return invoker.invokeExact(target, a0, a1, a2, (Object)av); }
 386         protected Object target_4(Object a0, Object a1, Object a2, Object a3, Object... av)
 387                                                 throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, (Object)av); }
 388         // */
 389         // (For more than 4 arguments, generate the code in the adapter itself.)
 390 
 391         // Code to run when the generic target has finished and produced a value.
 392         protected Object return_L(Object res) throws Throwable { return (Object)convert.invokeExact(res); }
 393         protected int    return_I(Object res) throws Throwable { return (int)   convert.invokeExact(res); }
 394         protected long   return_J(Object res) throws Throwable { return (long)  convert.invokeExact(res); }
 395         protected float  return_F(Object res) throws Throwable { return (float) convert.invokeExact(res); }
 396         protected double return_D(Object res) throws Throwable { return (double)convert.invokeExact(res); }
 397 
 398         static private final String CLASS_PREFIX; // "sun.dyn.ToGeneric$"
 399         static {
 400             String aname = Adapter.class.getName();
 401             String sname = Adapter.class.getSimpleName();
 402             if (!aname.endsWith(sname))  throw new InternalError();
 403             CLASS_PREFIX = aname.substring(0, aname.length() - sname.length());
 404         }
 405         /** Find a sibing class of Adapter. */
 406         static Class<? extends Adapter> findSubClass(String name) {
 407             String cname = Adapter.CLASS_PREFIX + name;
 408             try {
 409                 return Class.forName(cname).asSubclass(Adapter.class);
 410             } catch (ClassNotFoundException ex) {
 411                 return null;
 412             } catch (ClassCastException ex) {
 413                 return null;
 414             }
 415         }
 416     }
 417 
 418     /* generated classes follow this pattern:
 419     static class A1 extends Adapter {
 420         protected A1(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
 421         protected A1(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
 422         protected A1 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A1(e, i, c, t); }
 423         protected Object target(Object a0)   throws Throwable { return invoker.invokeExact(target, a0); }
 424         protected Object targetA1(Object a0) throws Throwable { return target(a0); }
 425         protected Object targetA1(int    a0) throws Throwable { return target(a0); }
 426         protected Object targetA1(long   a0) throws Throwable { return target(a0); }
 427         protected Object invoke_L(Object a0) throws Throwable { return return_L(targetA1(a0)); }
 428         protected int    invoke_I(Object a0) throws Throwable { return return_I(targetA1(a0)); }
 429         protected long   invoke_J(Object a0) throws Throwable { return return_J(targetA1(a0)); }
 430         protected float  invoke_F(Object a0) throws Throwable { return return_F(targetA1(a0)); }
 431         protected double invoke_D(Object a0) throws Throwable { return return_D(targetA1(a0)); }
 432         protected Object invoke_L(int    a0) throws Throwable { return return_L(targetA1(a0)); }
 433         protected int    invoke_I(int    a0) throws Throwable { return return_I(targetA1(a0)); }
 434         protected long   invoke_J(int    a0) throws Throwable { return return_J(targetA1(a0)); }
 435         protected float  invoke_F(int    a0) throws Throwable { return return_F(targetA1(a0)); }
 436         protected double invoke_D(int    a0) throws Throwable { return return_D(targetA1(a0)); }
 437         protected Object invoke_L(long   a0) throws Throwable { return return_L(targetA1(a0)); }
 438         protected int    invoke_I(long   a0) throws Throwable { return return_I(targetA1(a0)); }
 439         protected long   invoke_J(long   a0) throws Throwable { return return_J(targetA1(a0)); }
 440         protected float  invoke_F(long   a0) throws Throwable { return return_F(targetA1(a0)); }
 441         protected double invoke_D(long   a0) throws Throwable { return return_D(targetA1(a0)); }
 442     }
 443     // */
 444 
 445 /*
 446 : SHELL; n=ToGeneric; cp -p $n.java $n.java-; sed < $n.java- > $n.java+ -e '/{{*{{/,/}}*}}/w /tmp/genclasses.java' -e '/}}*}}/q'; (cd /tmp; javac -d . genclasses.java; java -cp . genclasses) >> $n.java+; echo '}' >> $n.java+; mv $n.java+ $n.java; mv $n.java- $n.java~
 447 //{{{
 448 import java.util.*;
 449 class genclasses {
 450     static String[] TYPES = { "Object", "int   ", "long  ", "float ", "double" };
 451     static String[] TCHARS = { "L",     "I",      "J",      "F",      "D",     "A" };
 452     static String[][] TEMPLATES = { {
 453         "@for@ arity=0..3   rcat<=4 nrefs<=99 nints<=99 nlongs<=99",
 454         "@for@ arity=4..5   rcat<=2 nrefs<=99 nints<=99 nlongs<=99",
 455         "@for@ arity=6..10  rcat<=2 nrefs<=99 nints=0   nlongs<=99",
 456         "    //@each-cat@",
 457         "    static class @cat@ extends Adapter {",
 458         "        protected @cat@(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype",
 459         "        protected @cat@(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }",
 460         "        protected @cat@ makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new @cat@(e, i, c, t); }",
 461         "        protected Object target(@Ovav@)   throws Throwable { return invoker.invokeExact(target, @av@); }",
 462         "        //@each-Tv@",
 463         "        protected Object target@cat@(@Tvav@) throws Throwable { return target(@av@); }",
 464         "        //@end-Tv@",
 465         "        //@each-Tv@",
 466         "        //@each-R@",
 467         "        protected @R@ invoke_@Rc@(@Tvav@) throws Throwable { return return_@Rc@(target@cat@(@av@)); }",
 468         "        //@end-R@",
 469         "        //@end-Tv@",
 470         "    }",
 471     } };
 472     enum VAR {
 473         cat, R, Rc, Tv, av, Tvav, Ovav;
 474         public final String pattern = "@"+toString().replace('_','.')+"@";
 475         public String binding;
 476         static void makeBindings(boolean topLevel, int rcat, int nrefs, int nints, int nlongs) {
 477             int nargs = nrefs + nints + nlongs;
 478             if (topLevel)
 479                 VAR.cat.binding = catstr(ALL_RETURN_TYPES ? TYPES.length : rcat, nrefs, nints, nlongs);
 480             VAR.R.binding = TYPES[rcat];
 481             VAR.Rc.binding = TCHARS[rcat];
 482             String[] Tv = new String[nargs];
 483             String[] av = new String[nargs];
 484             String[] Tvav = new String[nargs];
 485             String[] Ovav = new String[nargs];
 486             for (int i = 0; i < nargs; i++) {
 487                 int tcat = (i < nrefs) ? 0 : (i < nrefs + nints) ? 1 : 2;
 488                 Tv[i] = TYPES[tcat];
 489                 av[i] = arg(i);
 490                 Tvav[i] = param(Tv[i], av[i]);
 491                 Ovav[i] = param("Object", av[i]);
 492             }
 493             VAR.Tv.binding = comma(Tv);
 494             VAR.av.binding = comma(av);
 495             VAR.Tvav.binding = comma(Tvav);
 496             VAR.Ovav.binding = comma(Ovav);
 497         }
 498         static String arg(int i) { return "a"+i; }
 499         static String param(String t, String a) { return t+" "+a; }
 500         static String comma(String[] v) { return comma(v, ""); }
 501         static String comma(String sep, String[] v) {
 502             if (v.length == 0)  return "";
 503             String res = sep+v[0];
 504             for (int i = 1; i < v.length; i++)  res += ", "+v[i];
 505             return res;
 506         }
 507         static String transform(String string) {
 508             for (VAR var : values())
 509                 string = string.replaceAll(var.pattern, var.binding);
 510             return string;
 511         }
 512     }
 513     static String[] stringsIn(String[] strings, int beg, int end) {
 514         return Arrays.copyOfRange(strings, beg, Math.min(end, strings.length));
 515     }
 516     static String[] stringsBefore(String[] strings, int pos) {
 517         return stringsIn(strings, 0, pos);
 518     }
 519     static String[] stringsAfter(String[] strings, int pos) {
 520         return stringsIn(strings, pos, strings.length);
 521     }
 522     static int indexAfter(String[] strings, int pos, String tag) {
 523         return Math.min(indexBefore(strings, pos, tag) + 1, strings.length);
 524     }
 525     static int indexBefore(String[] strings, int pos, String tag) {
 526         for (int i = pos, end = strings.length; ; i++) {
 527             if (i == end || strings[i].endsWith(tag))  return i;
 528         }
 529     }
 530     static int MIN_ARITY, MAX_ARITY, MAX_RCAT, MAX_REFS, MAX_INTS, MAX_LONGS;
 531     static boolean ALL_ARG_TYPES, ALL_RETURN_TYPES;
 532     static HashSet<String> done = new HashSet<String>();
 533     public static void main(String... av) {
 534         for (String[] template : TEMPLATES) {
 535             int forLinesLimit = indexBefore(template, 0, "@each-cat@");
 536             String[] forLines = stringsBefore(template, forLinesLimit);
 537             template = stringsAfter(template, forLinesLimit);
 538             for (String forLine : forLines)
 539                 expandTemplate(forLine, template);
 540         }
 541     }
 542     static void expandTemplate(String forLine, String[] template) {
 543         String[] params = forLine.split("[^0-9]+");
 544         if (params[0].length() == 0)  params = stringsAfter(params, 1);
 545         System.out.println("//params="+Arrays.asList(params));
 546         int pcur = 0;
 547         MIN_ARITY = Integer.valueOf(params[pcur++]);
 548         MAX_ARITY = Integer.valueOf(params[pcur++]);
 549         MAX_RCAT  = Integer.valueOf(params[pcur++]);
 550         MAX_REFS  = Integer.valueOf(params[pcur++]);
 551         MAX_INTS  = Integer.valueOf(params[pcur++]);
 552         MAX_LONGS = Integer.valueOf(params[pcur++]);
 553         if (pcur != params.length)  throw new RuntimeException("bad extra param: "+forLine);
 554         if (MAX_RCAT >= TYPES.length)  MAX_RCAT = TYPES.length - 1;
 555         ALL_ARG_TYPES = (indexBefore(template, 0, "@each-Tv@") < template.length);
 556         ALL_RETURN_TYPES = (indexBefore(template, 0, "@each-R@") < template.length);
 557         for (int nargs = MIN_ARITY; nargs <= MAX_ARITY; nargs++) {
 558             for (int rcat = 0; rcat <= MAX_RCAT; rcat++) {
 559                 expandTemplate(template, true, rcat, nargs, 0, 0);
 560                 if (ALL_ARG_TYPES)  break;
 561                 expandTemplateForPrims(template, true, rcat, nargs, 1, 1);
 562                 if (ALL_RETURN_TYPES)  break;
 563             }
 564         }
 565     }
 566     static String catstr(int rcat, int nrefs, int nints, int nlongs) {
 567         int nargs = nrefs + nints + nlongs;
 568         String cat = TCHARS[rcat] + nargs;
 569         if (!ALL_ARG_TYPES)  cat += (nints==0?"":"I"+nints)+(nlongs==0?"":"J"+nlongs);
 570         return cat;
 571     }
 572     static void expandTemplateForPrims(String[] template, boolean topLevel, int rcat, int nargs, int minints, int minlongs) {
 573         for (int isLong = 0; isLong <= 1; isLong++) {
 574             for (int nprims = 1; nprims <= nargs; nprims++) {
 575                 int nrefs = nargs - nprims;
 576                 int nints = ((1-isLong) * nprims);
 577                 int nlongs = (isLong * nprims);
 578                 expandTemplate(template, topLevel, rcat, nrefs, nints, nlongs);
 579             }
 580         }
 581     }
 582     static void expandTemplate(String[] template, boolean topLevel,
 583                                int rcat, int nrefs, int nints, int nlongs) {
 584         int nargs = nrefs + nints + nlongs;
 585         if (nrefs > MAX_REFS || nints > MAX_INTS || nlongs > MAX_LONGS)  return;
 586         VAR.makeBindings(topLevel, rcat, nrefs, nints, nlongs);
 587         if (topLevel && !done.add(VAR.cat.binding)) {
 588             System.out.println("    //repeat "+VAR.cat.binding);
 589             return;
 590         }
 591         for (int i = 0; i < template.length; i++) {
 592             String line = template[i];
 593             if (line.endsWith("@each-cat@")) {
 594                 // ignore
 595             } else if (line.endsWith("@each-R@")) {
 596                 int blockEnd = indexAfter(template, i, "@end-R@");
 597                 String[] block = stringsIn(template, i+1, blockEnd-1);
 598                 for (int rcat1 = rcat; rcat1 <= MAX_RCAT; rcat1++)
 599                     expandTemplate(block, false, rcat1, nrefs, nints, nlongs);
 600                 VAR.makeBindings(topLevel, rcat, nrefs, nints, nlongs);
 601                 i = blockEnd-1; continue;
 602             } else if (line.endsWith("@each-Tv@")) {
 603                 int blockEnd = indexAfter(template, i, "@end-Tv@");
 604                 String[] block = stringsIn(template, i+1, blockEnd-1);
 605                 expandTemplate(block, false, rcat, nrefs, nints, nlongs);
 606                 expandTemplateForPrims(block, false, rcat, nargs, nints+1, nlongs+1);
 607                 VAR.makeBindings(topLevel, rcat, nrefs, nints, nlongs);
 608                 i = blockEnd-1; continue;
 609             } else {
 610                 System.out.println(VAR.transform(line));
 611             }
 612         }
 613     }
 614 }
 615 //}}} */
 616 //params=[0, 3, 4, 99, 99, 99]
 617     static class A0 extends Adapter {
 618         protected A0(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
 619         protected A0(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
 620         protected A0 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A0(e, i, c, t); }
 621         protected Object target()   throws Throwable { return invoker.invokeExact(target); }
 622         protected Object targetA0() throws Throwable { return target(); }
 623         protected Object invoke_L() throws Throwable { return return_L(targetA0()); }
 624         protected int    invoke_I() throws Throwable { return return_I(targetA0()); }
 625         protected long   invoke_J() throws Throwable { return return_J(targetA0()); }
 626         protected float  invoke_F() throws Throwable { return return_F(targetA0()); }
 627         protected double invoke_D() throws Throwable { return return_D(targetA0()); }
 628     }
 629     static class A1 extends Adapter {
 630         protected A1(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
 631         protected A1(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
 632         protected A1 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A1(e, i, c, t); }
 633         protected Object target(Object a0)   throws Throwable { return invoker.invokeExact(target, a0); }
 634         protected Object targetA1(Object a0) throws Throwable { return target(a0); }
 635         protected Object targetA1(int    a0) throws Throwable { return target(a0); }
 636         protected Object targetA1(long   a0) throws Throwable { return target(a0); }
 637         protected Object invoke_L(Object a0) throws Throwable { return return_L(targetA1(a0)); }
 638         protected int    invoke_I(Object a0) throws Throwable { return return_I(targetA1(a0)); }
 639         protected long   invoke_J(Object a0) throws Throwable { return return_J(targetA1(a0)); }
 640         protected float  invoke_F(Object a0) throws Throwable { return return_F(targetA1(a0)); }
 641         protected double invoke_D(Object a0) throws Throwable { return return_D(targetA1(a0)); }
 642         protected Object invoke_L(int    a0) throws Throwable { return return_L(targetA1(a0)); }
 643         protected int    invoke_I(int    a0) throws Throwable { return return_I(targetA1(a0)); }
 644         protected long   invoke_J(int    a0) throws Throwable { return return_J(targetA1(a0)); }
 645         protected float  invoke_F(int    a0) throws Throwable { return return_F(targetA1(a0)); }
 646         protected double invoke_D(int    a0) throws Throwable { return return_D(targetA1(a0)); }
 647         protected Object invoke_L(long   a0) throws Throwable { return return_L(targetA1(a0)); }
 648         protected int    invoke_I(long   a0) throws Throwable { return return_I(targetA1(a0)); }
 649         protected long   invoke_J(long   a0) throws Throwable { return return_J(targetA1(a0)); }
 650         protected float  invoke_F(long   a0) throws Throwable { return return_F(targetA1(a0)); }
 651         protected double invoke_D(long   a0) throws Throwable { return return_D(targetA1(a0)); }
 652     }
 653     static class A2 extends Adapter {
 654         protected A2(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
 655         protected A2(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
 656         protected A2 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A2(e, i, c, t); }
 657         protected Object target(Object a0, Object a1)   throws Throwable { return invoker.invokeExact(target, a0, a1); }
 658         protected Object targetA2(Object a0, Object a1) throws Throwable { return target(a0, a1); }
 659         protected Object targetA2(Object a0, int    a1) throws Throwable { return target(a0, a1); }
 660         protected Object targetA2(int    a0, int    a1) throws Throwable { return target(a0, a1); }
 661         protected Object targetA2(Object a0, long   a1) throws Throwable { return target(a0, a1); }
 662         protected Object targetA2(long   a0, long   a1) throws Throwable { return target(a0, a1); }
 663         protected Object invoke_L(Object a0, Object a1) throws Throwable { return return_L(targetA2(a0, a1)); }
 664         protected int    invoke_I(Object a0, Object a1) throws Throwable { return return_I(targetA2(a0, a1)); }
 665         protected long   invoke_J(Object a0, Object a1) throws Throwable { return return_J(targetA2(a0, a1)); }
 666         protected float  invoke_F(Object a0, Object a1) throws Throwable { return return_F(targetA2(a0, a1)); }
 667         protected double invoke_D(Object a0, Object a1) throws Throwable { return return_D(targetA2(a0, a1)); }
 668         protected Object invoke_L(Object a0, int    a1) throws Throwable { return return_L(targetA2(a0, a1)); }
 669         protected int    invoke_I(Object a0, int    a1) throws Throwable { return return_I(targetA2(a0, a1)); }
 670         protected long   invoke_J(Object a0, int    a1) throws Throwable { return return_J(targetA2(a0, a1)); }
 671         protected float  invoke_F(Object a0, int    a1) throws Throwable { return return_F(targetA2(a0, a1)); }
 672         protected double invoke_D(Object a0, int    a1) throws Throwable { return return_D(targetA2(a0, a1)); }
 673         protected Object invoke_L(int    a0, int    a1) throws Throwable { return return_L(targetA2(a0, a1)); }
 674         protected int    invoke_I(int    a0, int    a1) throws Throwable { return return_I(targetA2(a0, a1)); }
 675         protected long   invoke_J(int    a0, int    a1) throws Throwable { return return_J(targetA2(a0, a1)); }
 676         protected float  invoke_F(int    a0, int    a1) throws Throwable { return return_F(targetA2(a0, a1)); }
 677         protected double invoke_D(int    a0, int    a1) throws Throwable { return return_D(targetA2(a0, a1)); }
 678         protected Object invoke_L(Object a0, long   a1) throws Throwable { return return_L(targetA2(a0, a1)); }
 679         protected int    invoke_I(Object a0, long   a1) throws Throwable { return return_I(targetA2(a0, a1)); }
 680         protected long   invoke_J(Object a0, long   a1) throws Throwable { return return_J(targetA2(a0, a1)); }
 681         protected float  invoke_F(Object a0, long   a1) throws Throwable { return return_F(targetA2(a0, a1)); }
 682         protected double invoke_D(Object a0, long   a1) throws Throwable { return return_D(targetA2(a0, a1)); }
 683         protected Object invoke_L(long   a0, long   a1) throws Throwable { return return_L(targetA2(a0, a1)); }
 684         protected int    invoke_I(long   a0, long   a1) throws Throwable { return return_I(targetA2(a0, a1)); }
 685         protected long   invoke_J(long   a0, long   a1) throws Throwable { return return_J(targetA2(a0, a1)); }
 686         protected float  invoke_F(long   a0, long   a1) throws Throwable { return return_F(targetA2(a0, a1)); }
 687         protected double invoke_D(long   a0, long   a1) throws Throwable { return return_D(targetA2(a0, a1)); }
 688     }
 689     static class A3 extends Adapter {
 690         protected A3(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
 691         protected A3(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
 692         protected A3 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A3(e, i, c, t); }
 693         protected Object target(Object a0, Object a1, Object a2)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2); }
 694         protected Object targetA3(Object a0, Object a1, Object a2) throws Throwable { return target(a0, a1, a2); }
 695         protected Object targetA3(Object a0, Object a1, int    a2) throws Throwable { return target(a0, a1, a2); }
 696         protected Object targetA3(Object a0, int    a1, int    a2) throws Throwable { return target(a0, a1, a2); }
 697         protected Object targetA3(int    a0, int    a1, int    a2) throws Throwable { return target(a0, a1, a2); }
 698         protected Object targetA3(Object a0, Object a1, long   a2) throws Throwable { return target(a0, a1, a2); }
 699         protected Object targetA3(Object a0, long   a1, long   a2) throws Throwable { return target(a0, a1, a2); }
 700         protected Object targetA3(long   a0, long   a1, long   a2) throws Throwable { return target(a0, a1, a2); }
 701         protected Object invoke_L(Object a0, Object a1, Object a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
 702         protected int    invoke_I(Object a0, Object a1, Object a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
 703         protected long   invoke_J(Object a0, Object a1, Object a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
 704         protected float  invoke_F(Object a0, Object a1, Object a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
 705         protected double invoke_D(Object a0, Object a1, Object a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
 706         protected Object invoke_L(Object a0, Object a1, int    a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
 707         protected int    invoke_I(Object a0, Object a1, int    a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
 708         protected long   invoke_J(Object a0, Object a1, int    a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
 709         protected float  invoke_F(Object a0, Object a1, int    a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
 710         protected double invoke_D(Object a0, Object a1, int    a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
 711         protected Object invoke_L(Object a0, int    a1, int    a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
 712         protected int    invoke_I(Object a0, int    a1, int    a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
 713         protected long   invoke_J(Object a0, int    a1, int    a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
 714         protected float  invoke_F(Object a0, int    a1, int    a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
 715         protected double invoke_D(Object a0, int    a1, int    a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
 716         protected Object invoke_L(int    a0, int    a1, int    a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
 717         protected int    invoke_I(int    a0, int    a1, int    a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
 718         protected long   invoke_J(int    a0, int    a1, int    a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
 719         protected float  invoke_F(int    a0, int    a1, int    a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
 720         protected double invoke_D(int    a0, int    a1, int    a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
 721         protected Object invoke_L(Object a0, Object a1, long   a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
 722         protected int    invoke_I(Object a0, Object a1, long   a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
 723         protected long   invoke_J(Object a0, Object a1, long   a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
 724         protected float  invoke_F(Object a0, Object a1, long   a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
 725         protected double invoke_D(Object a0, Object a1, long   a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
 726         protected Object invoke_L(Object a0, long   a1, long   a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
 727         protected int    invoke_I(Object a0, long   a1, long   a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
 728         protected long   invoke_J(Object a0, long   a1, long   a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
 729         protected float  invoke_F(Object a0, long   a1, long   a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
 730         protected double invoke_D(Object a0, long   a1, long   a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
 731         protected Object invoke_L(long   a0, long   a1, long   a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
 732         protected int    invoke_I(long   a0, long   a1, long   a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
 733         protected long   invoke_J(long   a0, long   a1, long   a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
 734         protected float  invoke_F(long   a0, long   a1, long   a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
 735         protected double invoke_D(long   a0, long   a1, long   a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
 736     }
 737 //params=[4, 5, 2, 99, 99, 99]
 738     static class A4 extends Adapter {
 739         protected A4(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
 740         protected A4(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
 741         protected A4 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A4(e, i, c, t); }
 742         protected Object target(Object a0, Object a1, Object a2, Object a3)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3); }
 743         protected Object targetA4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return target(a0, a1, a2, a3); }
 744         protected Object targetA4(Object a0, Object a1, Object a2, int    a3) throws Throwable { return target(a0, a1, a2, a3); }
 745         protected Object targetA4(Object a0, Object a1, int    a2, int    a3) throws Throwable { return target(a0, a1, a2, a3); }
 746         protected Object targetA4(Object a0, int    a1, int    a2, int    a3) throws Throwable { return target(a0, a1, a2, a3); }
 747         protected Object targetA4(int    a0, int    a1, int    a2, int    a3) throws Throwable { return target(a0, a1, a2, a3); }
 748         protected Object targetA4(Object a0, Object a1, Object a2, long   a3) throws Throwable { return target(a0, a1, a2, a3); }
 749         protected Object targetA4(Object a0, Object a1, long   a2, long   a3) throws Throwable { return target(a0, a1, a2, a3); }
 750         protected Object targetA4(Object a0, long   a1, long   a2, long   a3) throws Throwable { return target(a0, a1, a2, a3); }
 751         protected Object targetA4(long   a0, long   a1, long   a2, long   a3) throws Throwable { return target(a0, a1, a2, a3); }
 752         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
 753         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
 754         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
 755         protected Object invoke_L(Object a0, Object a1, Object a2, int    a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
 756         protected int    invoke_I(Object a0, Object a1, Object a2, int    a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
 757         protected long   invoke_J(Object a0, Object a1, Object a2, int    a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
 758         protected Object invoke_L(Object a0, Object a1, int    a2, int    a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
 759         protected int    invoke_I(Object a0, Object a1, int    a2, int    a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
 760         protected long   invoke_J(Object a0, Object a1, int    a2, int    a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
 761         protected Object invoke_L(Object a0, int    a1, int    a2, int    a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
 762         protected int    invoke_I(Object a0, int    a1, int    a2, int    a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
 763         protected long   invoke_J(Object a0, int    a1, int    a2, int    a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
 764         protected Object invoke_L(int    a0, int    a1, int    a2, int    a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
 765         protected int    invoke_I(int    a0, int    a1, int    a2, int    a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
 766         protected long   invoke_J(int    a0, int    a1, int    a2, int    a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
 767         protected Object invoke_L(Object a0, Object a1, Object a2, long   a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
 768         protected int    invoke_I(Object a0, Object a1, Object a2, long   a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
 769         protected long   invoke_J(Object a0, Object a1, Object a2, long   a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
 770         protected Object invoke_L(Object a0, Object a1, long   a2, long   a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
 771         protected int    invoke_I(Object a0, Object a1, long   a2, long   a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
 772         protected long   invoke_J(Object a0, Object a1, long   a2, long   a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
 773         protected Object invoke_L(Object a0, long   a1, long   a2, long   a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
 774         protected int    invoke_I(Object a0, long   a1, long   a2, long   a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
 775         protected long   invoke_J(Object a0, long   a1, long   a2, long   a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
 776         protected Object invoke_L(long   a0, long   a1, long   a2, long   a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
 777         protected int    invoke_I(long   a0, long   a1, long   a2, long   a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
 778         protected long   invoke_J(long   a0, long   a1, long   a2, long   a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
 779     }
 780     static class A5 extends Adapter {
 781         protected A5(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
 782         protected A5(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
 783         protected A5 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A5(e, i, c, t); }
 784         protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4); }
 785         protected Object targetA5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
 786         protected Object targetA5(Object a0, Object a1, Object a2, Object a3, int    a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
 787         protected Object targetA5(Object a0, Object a1, Object a2, int    a3, int    a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
 788         protected Object targetA5(Object a0, Object a1, int    a2, int    a3, int    a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
 789         protected Object targetA5(Object a0, int    a1, int    a2, int    a3, int    a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
 790         protected Object targetA5(int    a0, int    a1, int    a2, int    a3, int    a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
 791         protected Object targetA5(Object a0, Object a1, Object a2, Object a3, long   a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
 792         protected Object targetA5(Object a0, Object a1, Object a2, long   a3, long   a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
 793         protected Object targetA5(Object a0, Object a1, long   a2, long   a3, long   a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
 794         protected Object targetA5(Object a0, long   a1, long   a2, long   a3, long   a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
 795         protected Object targetA5(long   a0, long   a1, long   a2, long   a3, long   a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
 796         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
 797         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
 798         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
 799         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, int    a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
 800         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, int    a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
 801         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, int    a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
 802         protected Object invoke_L(Object a0, Object a1, Object a2, int    a3, int    a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
 803         protected int    invoke_I(Object a0, Object a1, Object a2, int    a3, int    a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
 804         protected long   invoke_J(Object a0, Object a1, Object a2, int    a3, int    a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
 805         protected Object invoke_L(Object a0, Object a1, int    a2, int    a3, int    a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
 806         protected int    invoke_I(Object a0, Object a1, int    a2, int    a3, int    a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
 807         protected long   invoke_J(Object a0, Object a1, int    a2, int    a3, int    a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
 808         protected Object invoke_L(Object a0, int    a1, int    a2, int    a3, int    a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
 809         protected int    invoke_I(Object a0, int    a1, int    a2, int    a3, int    a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
 810         protected long   invoke_J(Object a0, int    a1, int    a2, int    a3, int    a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
 811         protected Object invoke_L(int    a0, int    a1, int    a2, int    a3, int    a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
 812         protected int    invoke_I(int    a0, int    a1, int    a2, int    a3, int    a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
 813         protected long   invoke_J(int    a0, int    a1, int    a2, int    a3, int    a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
 814         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long   a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
 815         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, long   a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
 816         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, long   a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
 817         protected Object invoke_L(Object a0, Object a1, Object a2, long   a3, long   a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
 818         protected int    invoke_I(Object a0, Object a1, Object a2, long   a3, long   a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
 819         protected long   invoke_J(Object a0, Object a1, Object a2, long   a3, long   a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
 820         protected Object invoke_L(Object a0, Object a1, long   a2, long   a3, long   a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
 821         protected int    invoke_I(Object a0, Object a1, long   a2, long   a3, long   a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
 822         protected long   invoke_J(Object a0, Object a1, long   a2, long   a3, long   a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
 823         protected Object invoke_L(Object a0, long   a1, long   a2, long   a3, long   a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
 824         protected int    invoke_I(Object a0, long   a1, long   a2, long   a3, long   a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
 825         protected long   invoke_J(Object a0, long   a1, long   a2, long   a3, long   a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
 826         protected Object invoke_L(long   a0, long   a1, long   a2, long   a3, long   a4) throws Throwable { return return_L(targetA5(a0, a1, a2, a3, a4)); }
 827         protected int    invoke_I(long   a0, long   a1, long   a2, long   a3, long   a4) throws Throwable { return return_I(targetA5(a0, a1, a2, a3, a4)); }
 828         protected long   invoke_J(long   a0, long   a1, long   a2, long   a3, long   a4) throws Throwable { return return_J(targetA5(a0, a1, a2, a3, a4)); }
 829     }
 830 //params=[6, 10, 2, 99, 0, 99]
 831     static class A6 extends Adapter {
 832         protected A6(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
 833         protected A6(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
 834         protected A6 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A6(e, i, c, t); }
 835         protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5); }
 836         protected Object targetA6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
 837         protected Object targetA6(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
 838         protected Object targetA6(Object a0, Object a1, Object a2, Object a3, long   a4, long   a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
 839         protected Object targetA6(Object a0, Object a1, Object a2, long   a3, long   a4, long   a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
 840         protected Object targetA6(Object a0, Object a1, long   a2, long   a3, long   a4, long   a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
 841         protected Object targetA6(Object a0, long   a1, long   a2, long   a3, long   a4, long   a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
 842         protected Object targetA6(long   a0, long   a1, long   a2, long   a3, long   a4, long   a5) throws Throwable { return target(a0, a1, a2, a3, a4, a5); }
 843         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
 844         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
 845         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
 846         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5) throws Throwable { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
 847         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5) throws Throwable { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
 848         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5) throws Throwable { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
 849         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long   a4, long   a5) throws Throwable { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
 850         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, long   a4, long   a5) throws Throwable { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
 851         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, long   a4, long   a5) throws Throwable { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
 852         protected Object invoke_L(Object a0, Object a1, Object a2, long   a3, long   a4, long   a5) throws Throwable { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
 853         protected int    invoke_I(Object a0, Object a1, Object a2, long   a3, long   a4, long   a5) throws Throwable { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
 854         protected long   invoke_J(Object a0, Object a1, Object a2, long   a3, long   a4, long   a5) throws Throwable { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
 855         protected Object invoke_L(Object a0, Object a1, long   a2, long   a3, long   a4, long   a5) throws Throwable { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
 856         protected int    invoke_I(Object a0, Object a1, long   a2, long   a3, long   a4, long   a5) throws Throwable { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
 857         protected long   invoke_J(Object a0, Object a1, long   a2, long   a3, long   a4, long   a5) throws Throwable { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
 858         protected Object invoke_L(Object a0, long   a1, long   a2, long   a3, long   a4, long   a5) throws Throwable { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
 859         protected int    invoke_I(Object a0, long   a1, long   a2, long   a3, long   a4, long   a5) throws Throwable { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
 860         protected long   invoke_J(Object a0, long   a1, long   a2, long   a3, long   a4, long   a5) throws Throwable { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
 861         protected Object invoke_L(long   a0, long   a1, long   a2, long   a3, long   a4, long   a5) throws Throwable { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
 862         protected int    invoke_I(long   a0, long   a1, long   a2, long   a3, long   a4, long   a5) throws Throwable { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
 863         protected long   invoke_J(long   a0, long   a1, long   a2, long   a3, long   a4, long   a5) throws Throwable { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
 864     }
 865     static class A7 extends Adapter {
 866         protected A7(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
 867         protected A7(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
 868         protected A7 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A7(e, i, c, t); }
 869         protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6); }
 870         protected Object targetA7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
 871         protected Object targetA7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long   a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
 872         protected Object targetA7(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5, long   a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
 873         protected Object targetA7(Object a0, Object a1, Object a2, Object a3, long   a4, long   a5, long   a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
 874         protected Object targetA7(Object a0, Object a1, Object a2, long   a3, long   a4, long   a5, long   a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
 875         protected Object targetA7(Object a0, Object a1, long   a2, long   a3, long   a4, long   a5, long   a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
 876         protected Object targetA7(Object a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
 877         protected Object targetA7(long   a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6); }
 878         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 879         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 880         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 881         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long   a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 882         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long   a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 883         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long   a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 884         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5, long   a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 885         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5, long   a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 886         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5, long   a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 887         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long   a4, long   a5, long   a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 888         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, long   a4, long   a5, long   a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 889         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, long   a4, long   a5, long   a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 890         protected Object invoke_L(Object a0, Object a1, Object a2, long   a3, long   a4, long   a5, long   a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 891         protected int    invoke_I(Object a0, Object a1, Object a2, long   a3, long   a4, long   a5, long   a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 892         protected long   invoke_J(Object a0, Object a1, Object a2, long   a3, long   a4, long   a5, long   a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 893         protected Object invoke_L(Object a0, Object a1, long   a2, long   a3, long   a4, long   a5, long   a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 894         protected int    invoke_I(Object a0, Object a1, long   a2, long   a3, long   a4, long   a5, long   a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 895         protected long   invoke_J(Object a0, Object a1, long   a2, long   a3, long   a4, long   a5, long   a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 896         protected Object invoke_L(Object a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 897         protected int    invoke_I(Object a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 898         protected long   invoke_J(Object a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 899         protected Object invoke_L(long   a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6) throws Throwable { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 900         protected int    invoke_I(long   a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6) throws Throwable { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 901         protected long   invoke_J(long   a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6) throws Throwable { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
 902     }
 903     static class A8 extends Adapter {
 904         protected A8(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
 905         protected A8(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
 906         protected A8 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A8(e, i, c, t); }
 907         protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7); }
 908         protected Object targetA8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
 909         protected Object targetA8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long   a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
 910         protected Object targetA8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long   a6, long   a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
 911         protected Object targetA8(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5, long   a6, long   a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
 912         protected Object targetA8(Object a0, Object a1, Object a2, Object a3, long   a4, long   a5, long   a6, long   a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
 913         protected Object targetA8(Object a0, Object a1, Object a2, long   a3, long   a4, long   a5, long   a6, long   a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
 914         protected Object targetA8(Object a0, Object a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
 915         protected Object targetA8(Object a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
 916         protected Object targetA8(long   a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
 917         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 918         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 919         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 920         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long   a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 921         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long   a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 922         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long   a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 923         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long   a6, long   a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 924         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long   a6, long   a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 925         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long   a6, long   a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 926         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5, long   a6, long   a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 927         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5, long   a6, long   a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 928         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5, long   a6, long   a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 929         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long   a4, long   a5, long   a6, long   a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 930         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, long   a4, long   a5, long   a6, long   a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 931         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, long   a4, long   a5, long   a6, long   a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 932         protected Object invoke_L(Object a0, Object a1, Object a2, long   a3, long   a4, long   a5, long   a6, long   a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 933         protected int    invoke_I(Object a0, Object a1, Object a2, long   a3, long   a4, long   a5, long   a6, long   a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 934         protected long   invoke_J(Object a0, Object a1, Object a2, long   a3, long   a4, long   a5, long   a6, long   a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 935         protected Object invoke_L(Object a0, Object a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 936         protected int    invoke_I(Object a0, Object a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 937         protected long   invoke_J(Object a0, Object a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 938         protected Object invoke_L(Object a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 939         protected int    invoke_I(Object a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 940         protected long   invoke_J(Object a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 941         protected Object invoke_L(long   a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7) throws Throwable { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 942         protected int    invoke_I(long   a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7) throws Throwable { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 943         protected long   invoke_J(long   a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7) throws Throwable { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
 944     }
 945     static class A9 extends Adapter {
 946         protected A9(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
 947         protected A9(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
 948         protected A9 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A9(e, i, c, t); }
 949         protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8); }
 950         protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
 951         protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long   a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
 952         protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long   a7, long   a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
 953         protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long   a6, long   a7, long   a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
 954         protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
 955         protected Object targetA9(Object a0, Object a1, Object a2, Object a3, long   a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
 956         protected Object targetA9(Object a0, Object a1, Object a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
 957         protected Object targetA9(Object a0, Object a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
 958         protected Object targetA9(Object a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
 959         protected Object targetA9(long   a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
 960         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 961         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 962         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 963         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long   a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 964         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long   a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 965         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long   a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 966         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long   a7, long   a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 967         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long   a7, long   a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 968         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long   a7, long   a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 969         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long   a6, long   a7, long   a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 970         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long   a6, long   a7, long   a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 971         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long   a6, long   a7, long   a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 972         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 973         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 974         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 975         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long   a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 976         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, long   a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 977         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, long   a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 978         protected Object invoke_L(Object a0, Object a1, Object a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 979         protected int    invoke_I(Object a0, Object a1, Object a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 980         protected long   invoke_J(Object a0, Object a1, Object a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 981         protected Object invoke_L(Object a0, Object a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 982         protected int    invoke_I(Object a0, Object a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 983         protected long   invoke_J(Object a0, Object a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 984         protected Object invoke_L(Object a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 985         protected int    invoke_I(Object a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 986         protected long   invoke_J(Object a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 987         protected Object invoke_L(long   a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 988         protected int    invoke_I(long   a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 989         protected long   invoke_J(long   a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8) throws Throwable { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
 990     }
 991     static class A10 extends Adapter {
 992         protected A10(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
 993         protected A10(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
 994         protected A10 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A10(e, i, c, t); }
 995         protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9)   throws Throwable { return invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
 996         protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
 997         protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, long   a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
 998         protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long   a8, long   a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
 999         protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long   a7, long   a8, long   a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
1000         protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
1001         protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
1002         protected Object targetA10(Object a0, Object a1, Object a2, Object a3, long   a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
1003         protected Object targetA10(Object a0, Object a1, Object a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
1004         protected Object targetA10(Object a0, Object a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
1005         protected Object targetA10(Object a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
1006         protected Object targetA10(long   a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
1007         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1008         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1009         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1010         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, long   a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1011         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, long   a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1012         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, long   a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1013         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long   a8, long   a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1014         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long   a8, long   a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1015         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long   a8, long   a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1016         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long   a7, long   a8, long   a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1017         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long   a7, long   a8, long   a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1018         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long   a7, long   a8, long   a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1019         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1020         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1021         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1022         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1023         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1024         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1025         protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long   a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1026         protected int    invoke_I(Object a0, Object a1, Object a2, Object a3, long   a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1027         protected long   invoke_J(Object a0, Object a1, Object a2, Object a3, long   a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1028         protected Object invoke_L(Object a0, Object a1, Object a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1029         protected int    invoke_I(Object a0, Object a1, Object a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1030         protected long   invoke_J(Object a0, Object a1, Object a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1031         protected Object invoke_L(Object a0, Object a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1032         protected int    invoke_I(Object a0, Object a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1033         protected long   invoke_J(Object a0, Object a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1034         protected Object invoke_L(Object a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1035         protected int    invoke_I(Object a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1036         protected long   invoke_J(Object a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1037         protected Object invoke_L(long   a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1038         protected int    invoke_I(long   a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1039         protected long   invoke_J(long   a0, long   a1, long   a2, long   a3, long   a4, long   a5, long   a6, long   a7, long   a8, long   a9) throws Throwable { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
1040     }
1041 }
--- EOF ---