1 /*
   2  * Copyright (c) 2008, 2013, 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 java.lang.invoke;
  27 
  28 import java.lang.reflect.Array;
  29 import java.util.Arrays;
  30 
  31 import static java.lang.invoke.MethodHandleStatics.*;
  32 import static java.lang.invoke.MethodHandleNatives.Constants.*;
  33 import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
  34 import static java.lang.invoke.LambdaForm.*;
  35 
  36 /**
  37  * Construction and caching of often-used invokers.
  38  * @author jrose
  39  */
  40 class Invokers {
  41     // exact type (sans leading target MH) for the outgoing call
  42     private final MethodType targetType;
  43 
  44     // Cached adapter information:
  45     private final @Stable MethodHandle[] invokers = new MethodHandle[INV_LIMIT];
  46     // Indexes into invokers:
  47     static final int
  48             INV_EXACT          =  0,  // MethodHandles.exactInvoker
  49             INV_GENERIC        =  1,  // MethodHandles.invoker (generic invocation)
  50             INV_BASIC          =  2,  // MethodHandles.basicInvoker
  51             INV_LIMIT          =  3;
  52 
  53     /** Compute and cache information common to all collecting adapters
  54      *  that implement members of the erasure-family of the given erased type.
  55      */
  56     /*non-public*/ Invokers(MethodType targetType) {
  57         this.targetType = targetType;
  58     }
  59 
  60     /*non-public*/ MethodHandle exactInvoker() {
  61         MethodHandle invoker = cachedInvoker(INV_EXACT);
  62         if (invoker != null)  return invoker;
  63         invoker = makeExactOrGeneralInvoker(true);
  64         return setCachedInvoker(INV_EXACT, invoker);
  65     }
  66 
  67     /*non-public*/ MethodHandle genericInvoker() {
  68         MethodHandle invoker = cachedInvoker(INV_GENERIC);
  69         if (invoker != null)  return invoker;
  70         invoker = makeExactOrGeneralInvoker(false);
  71         return setCachedInvoker(INV_GENERIC, invoker);
  72     }
  73 
  74     /*non-public*/ MethodHandle basicInvoker() {
  75         MethodHandle invoker = cachedInvoker(INV_BASIC);
  76         if (invoker != null)  return invoker;
  77         MethodType basicType = targetType.basicType();
  78         if (basicType != targetType) {
  79             // double cache; not used significantly
  80             return setCachedInvoker(INV_BASIC, basicType.invokers().basicInvoker());
  81         }
  82         invoker = basicType.form().cachedMethodHandle(MethodTypeForm.MH_BASIC_INV);
  83         if (invoker == null) {
  84             MemberName method = invokeBasicMethod(basicType);
  85             invoker = DirectMethodHandle.make(method);
  86             assert(checkInvoker(invoker));
  87             invoker = basicType.form().setCachedMethodHandle(MethodTypeForm.MH_BASIC_INV, invoker);
  88         }
  89         return setCachedInvoker(INV_BASIC, invoker);
  90     }
  91 
  92     private MethodHandle cachedInvoker(int idx) {
  93         return invokers[idx];
  94     }
  95 
  96     private synchronized MethodHandle setCachedInvoker(int idx, final MethodHandle invoker) {
  97         // Simulate a CAS, to avoid racy duplication of results.
  98         MethodHandle prev = invokers[idx];
  99         if (prev != null)  return prev;
 100         return invokers[idx] = invoker;
 101     }
 102 
 103     private MethodHandle makeExactOrGeneralInvoker(boolean isExact) {
 104         MethodType mtype = targetType;
 105         MethodType invokerType = mtype.invokerType();
 106         int which = (isExact ? MethodTypeForm.LF_EX_INVOKER : MethodTypeForm.LF_GEN_INVOKER);
 107         LambdaForm lform = invokeHandleForm(mtype, false, which);
 108         MethodHandle invoker = BoundMethodHandle.bindSingle(invokerType, lform, mtype);
 109         String whichName = (isExact ? "invokeExact" : "invoke");
 110         invoker = invoker.withInternalMemberName(MemberName.makeMethodHandleInvoke(whichName, mtype), false);
 111         assert(checkInvoker(invoker));
 112         maybeCompileToBytecode(invoker);
 113         return invoker;
 114     }
 115 
 116     /** If the target type seems to be common enough, eagerly compile the invoker to bytecodes. */
 117     private void maybeCompileToBytecode(MethodHandle invoker) {
 118         final int EAGER_COMPILE_ARITY_LIMIT = 10;
 119         if (targetType == targetType.erase() &&
 120             targetType.parameterCount() < EAGER_COMPILE_ARITY_LIMIT) {
 121             invoker.form.compileToBytecode();
 122         }
 123     }
 124 
 125     // This next one is called from LambdaForm.NamedFunction.<init>.
 126     /*non-public*/ static MemberName invokeBasicMethod(MethodType basicType) {
 127         assert(basicType == basicType.basicType());
 128         try {
 129             //Lookup.findVirtual(MethodHandle.class, name, type);
 130             return IMPL_LOOKUP.resolveOrFail(REF_invokeVirtual, MethodHandle.class, "invokeBasic", basicType);
 131         } catch (ReflectiveOperationException ex) {
 132             throw newInternalError("JVM cannot find invoker for "+basicType, ex);
 133         }
 134     }
 135 
 136     private boolean checkInvoker(MethodHandle invoker) {
 137         assert(targetType.invokerType().equals(invoker.type()))
 138                 : java.util.Arrays.asList(targetType, targetType.invokerType(), invoker);
 139         assert(invoker.internalMemberName() == null ||
 140                invoker.internalMemberName().getMethodType().equals(targetType));
 141         assert(!invoker.isVarargsCollector());
 142         return true;
 143     }
 144 
 145     /**
 146      * Find or create an invoker which passes unchanged a given number of arguments
 147      * and spreads the rest from a trailing array argument.
 148      * The invoker target type is the post-spread type {@code (TYPEOF(uarg*), TYPEOF(sarg*))=>RT}.
 149      * All the {@code sarg}s must have a common type {@code C}.  (If there are none, {@code Object} is assumed.}
 150      * @param leadingArgCount the number of unchanged (non-spread) arguments
 151      * @return {@code invoker.invokeExact(mh, uarg*, C[]{sarg*}) := (RT)mh.invoke(uarg*, sarg*)}
 152      */
 153     /*non-public*/ MethodHandle spreadInvoker(int leadingArgCount) {
 154         int spreadArgCount = targetType.parameterCount() - leadingArgCount;
 155         MethodType postSpreadType = targetType;
 156         Class<?> argArrayType = impliedRestargType(postSpreadType, leadingArgCount);
 157         if (postSpreadType.parameterSlotCount() <= MethodType.MAX_MH_INVOKER_ARITY) {
 158             return genericInvoker().asSpreader(argArrayType, spreadArgCount);
 159         }
 160         // Cannot build a generic invoker here of type ginvoker.invoke(mh, a*[254]).
 161         // Instead, factor sinvoker.invoke(mh, a) into ainvoker.invoke(filter(mh), a)
 162         // where filter(mh) == mh.asSpreader(Object[], spreadArgCount)
 163         MethodType preSpreadType = postSpreadType
 164             .replaceParameterTypes(leadingArgCount, postSpreadType.parameterCount(), argArrayType);
 165         MethodHandle arrayInvoker = MethodHandles.invoker(preSpreadType);
 166         MethodHandle makeSpreader = MethodHandles.insertArguments(Lazy.MH_asSpreader, 1, argArrayType, spreadArgCount);
 167         return MethodHandles.filterArgument(arrayInvoker, 0, makeSpreader);
 168     }
 169 
 170     private static Class<?> impliedRestargType(MethodType restargType, int fromPos) {
 171         if (restargType.isGeneric())  return Object[].class;  // can be nothing else
 172         int maxPos = restargType.parameterCount();
 173         if (fromPos >= maxPos)  return Object[].class;  // reasonable default
 174         Class<?> argType = restargType.parameterType(fromPos);
 175         for (int i = fromPos+1; i < maxPos; i++) {
 176             if (argType != restargType.parameterType(i))
 177                 throw newIllegalArgumentException("need homogeneous rest arguments", restargType);
 178         }
 179         if (argType == Object.class)  return Object[].class;
 180         return Array.newInstance(argType, 0).getClass();
 181     }
 182 
 183     public String toString() {
 184         return "Invokers"+targetType;
 185     }
 186 
 187     static MemberName methodHandleInvokeLinkerMethod(String name,
 188                                                      MethodType mtype,
 189                                                      Object[] appendixResult) {
 190         int which;
 191         switch (name) {
 192         case "invokeExact":  which = MethodTypeForm.LF_EX_LINKER; break;
 193         case "invoke":       which = MethodTypeForm.LF_GEN_LINKER; break;
 194         default:             throw new InternalError("not invoker: "+name);
 195         }
 196         LambdaForm lform;
 197         if (mtype.parameterSlotCount() <= MethodType.MAX_MH_ARITY - MH_LINKER_ARG_APPENDED) {
 198             lform = invokeHandleForm(mtype, false, which);
 199             appendixResult[0] = mtype;
 200         } else {
 201             lform = invokeHandleForm(mtype, true, which);
 202         }
 203         return lform.vmentry;
 204     }
 205 
 206     // argument count to account for trailing "appendix value" (typically the mtype)
 207     private static final int MH_LINKER_ARG_APPENDED = 1;
 208 
 209     /** Returns an adapter for invokeExact or generic invoke, as a MH or constant pool linker.
 210      * If !customized, caller is responsible for supplying, during adapter execution,
 211      * a copy of the exact mtype.  This is because the adapter might be generalized to
 212      * a basic type.
 213      * @param mtype the caller's method type (either basic or full-custom)
 214      * @param customized whether to use a trailing appendix argument (to carry the mtype)
 215      * @param which bit-encoded 0x01 whether it is a CP adapter ("linker") or MHs.invoker value ("invoker");
 216      *                          0x02 whether it is for invokeExact or generic invoke
 217      */
 218     private static LambdaForm invokeHandleForm(MethodType mtype, boolean customized, int which) {
 219         boolean isCached;
 220         if (!customized) {
 221             mtype = mtype.basicType();  // normalize Z to I, String to Object, etc.
 222             isCached = true;
 223         } else {
 224             isCached = false;  // maybe cache if mtype == mtype.basicType()
 225         }
 226         boolean isLinker, isGeneric;
 227         String debugName;
 228         switch (which) {
 229         case MethodTypeForm.LF_EX_LINKER:   isLinker = true;  isGeneric = false; debugName = "invokeExact_MT"; break;
 230         case MethodTypeForm.LF_EX_INVOKER:  isLinker = false; isGeneric = false; debugName = "exactInvoker"; break;
 231         case MethodTypeForm.LF_GEN_LINKER:  isLinker = true;  isGeneric = true;  debugName = "invoke_MT"; break;
 232         case MethodTypeForm.LF_GEN_INVOKER: isLinker = false; isGeneric = true;  debugName = "invoker"; break;
 233         default: throw new InternalError();
 234         }
 235         LambdaForm lform;
 236         if (isCached) {
 237             lform = mtype.form().cachedLambdaForm(which);
 238             if (lform != null)  return lform;
 239         }
 240         // exactInvokerForm (Object,Object)Object
 241         //   link with java.lang.invoke.MethodHandle.invokeBasic(MethodHandle,Object,Object)Object/invokeSpecial
 242         final int THIS_MH      = 0;
 243         final int CALL_MH      = THIS_MH + (isLinker ? 0 : 1);
 244         final int ARG_BASE     = CALL_MH + 1;
 245         final int OUTARG_LIMIT = ARG_BASE + mtype.parameterCount();
 246         final int INARG_LIMIT  = OUTARG_LIMIT + (isLinker && !customized ? 1 : 0);
 247         int nameCursor = OUTARG_LIMIT;
 248         final int MTYPE_ARG    = customized ? -1 : nameCursor++;  // might be last in-argument
 249         final int CHECK_TYPE   = nameCursor++;
 250         final int CHECK_CUSTOM = (CUSTOMIZE_THRESHOLD >= 0) ? nameCursor++ : -1;
 251         final int LINKER_CALL  = nameCursor++;
 252         MethodType invokerFormType = mtype.invokerType();
 253         if (isLinker) {
 254             if (!customized)
 255                 invokerFormType = invokerFormType.appendParameterTypes(MemberName.class);
 256         } else {
 257             invokerFormType = invokerFormType.invokerType();
 258         }
 259         Name[] names = arguments(nameCursor - INARG_LIMIT, invokerFormType);
 260         assert(names.length == nameCursor)
 261                 : Arrays.asList(mtype, customized, which, nameCursor, names.length);
 262         if (MTYPE_ARG >= INARG_LIMIT) {
 263             assert(names[MTYPE_ARG] == null);
 264             BoundMethodHandle.SpeciesData speciesData = BoundMethodHandle.speciesData_L();
 265             names[THIS_MH] = names[THIS_MH].withConstraint(speciesData);
 266             NamedFunction getter = speciesData.getterFunction(0);
 267             names[MTYPE_ARG] = new Name(getter, names[THIS_MH]);
 268             // else if isLinker, then MTYPE is passed in from the caller (e.g., the JVM)
 269         }
 270 
 271         // Make the final call.  If isGeneric, then prepend the result of type checking.
 272         MethodType outCallType = mtype.basicType();
 273         Object[] outArgs = Arrays.copyOfRange(names, CALL_MH, OUTARG_LIMIT, Object[].class);
 274         Object mtypeArg = (customized ? mtype : names[MTYPE_ARG]);
 275         if (!isGeneric) {
 276             names[CHECK_TYPE] = new Name(getConstantFunction(NF_checkExactType), names[CALL_MH], mtypeArg);
 277             // mh.invokeExact(a*):R => checkExactType(mh, TYPEOF(a*:R)); mh.invokeBasic(a*)
 278         } else {
 279             names[CHECK_TYPE] = new Name(getConstantFunction(NF_checkGenericType), names[CALL_MH], mtypeArg);
 280             // mh.invokeGeneric(a*):R => checkGenericType(mh, TYPEOF(a*:R)).invokeBasic(a*)
 281             outArgs[0] = names[CHECK_TYPE];
 282         }
 283         if (CHECK_CUSTOM != -1) {
 284             names[CHECK_CUSTOM] = new Name(getConstantFunction(NF_checkCustomized), outArgs[0]);
 285         }
 286         names[LINKER_CALL] = new Name(outCallType, outArgs);
 287         lform = new LambdaForm(debugName, INARG_LIMIT, names);
 288         if (isLinker)
 289             lform.compileToBytecode();  // JVM needs a real methodOop
 290         if (isCached)
 291             lform = mtype.form().setCachedLambdaForm(which, lform);
 292         return lform;
 293     }
 294 
 295     /*non-public*/ static
 296     WrongMethodTypeException newWrongMethodTypeException(MethodType actual, MethodType expected) {
 297         // FIXME: merge with JVM logic for throwing WMTE
 298         return new WrongMethodTypeException("expected "+expected+" but found "+actual);
 299     }
 300 
 301     /** Static definition of MethodHandle.invokeExact checking code. */
 302     /*non-public*/ static
 303     @ForceInline
 304     void checkExactType(Object mhObj, Object expectedObj) {
 305         MethodHandle mh = (MethodHandle) mhObj;
 306         MethodType expected = (MethodType) expectedObj;
 307         MethodType actual = mh.type();
 308         if (actual != expected)
 309             throw newWrongMethodTypeException(expected, actual);
 310     }
 311 
 312     /** Static definition of MethodHandle.invokeGeneric checking code.
 313      * Directly returns the type-adjusted MH to invoke, as follows:
 314      * {@code (R)MH.invoke(a*) => MH.asType(TYPEOF(a*:R)).invokeBasic(a*)}
 315      */
 316     /*non-public*/ static
 317     @ForceInline
 318     Object checkGenericType(Object mhObj, Object expectedObj) {
 319         MethodHandle mh = (MethodHandle) mhObj;
 320         MethodType expected = (MethodType) expectedObj;
 321         return mh.asType(expected);
 322         /* Maybe add more paths here.  Possible optimizations:
 323          * for (R)MH.invoke(a*),
 324          * let MT0 = TYPEOF(a*:R), MT1 = MH.type
 325          *
 326          * if MT0==MT1 or MT1 can be safely called by MT0
 327          *  => MH.invokeBasic(a*)
 328          * if MT1 can be safely called by MT0[R := Object]
 329          *  => MH.invokeBasic(a*) & checkcast(R)
 330          * if MT1 can be safely called by MT0[* := Object]
 331          *  => checkcast(A)* & MH.invokeBasic(a*) & checkcast(R)
 332          * if a big adapter BA can be pulled out of (MT0,MT1)
 333          *  => BA.invokeBasic(MT0,MH,a*)
 334          * if a local adapter LA can cached on static CS0 = new GICS(MT0)
 335          *  => CS0.LA.invokeBasic(MH,a*)
 336          * else
 337          *  => MH.asType(MT0).invokeBasic(A*)
 338          */
 339     }
 340 
 341     static MemberName linkToCallSiteMethod(MethodType mtype) {
 342         LambdaForm lform = callSiteForm(mtype, false);
 343         return lform.vmentry;
 344     }
 345 
 346     static MemberName linkToTargetMethod(MethodType mtype) {
 347         LambdaForm lform = callSiteForm(mtype, true);
 348         return lform.vmentry;
 349     }
 350 
 351     // skipCallSite is true if we are optimizing a ConstantCallSite
 352     private static LambdaForm callSiteForm(MethodType mtype, boolean skipCallSite) {
 353         mtype = mtype.basicType();  // normalize Z to I, String to Object, etc.
 354         final int which = (skipCallSite ? MethodTypeForm.LF_MH_LINKER : MethodTypeForm.LF_CS_LINKER);
 355         LambdaForm lform = mtype.form().cachedLambdaForm(which);
 356         if (lform != null)  return lform;
 357         // exactInvokerForm (Object,Object)Object
 358         //   link with java.lang.invoke.MethodHandle.invokeBasic(MethodHandle,Object,Object)Object/invokeSpecial
 359         final int ARG_BASE     = 0;
 360         final int OUTARG_LIMIT = ARG_BASE + mtype.parameterCount();
 361         final int INARG_LIMIT  = OUTARG_LIMIT + 1;
 362         int nameCursor = OUTARG_LIMIT;
 363         final int APPENDIX_ARG = nameCursor++;  // the last in-argument
 364         final int CSITE_ARG    = skipCallSite ? -1 : APPENDIX_ARG;
 365         final int CALL_MH      = skipCallSite ? APPENDIX_ARG : nameCursor++;  // result of getTarget
 366         final int LINKER_CALL  = nameCursor++;
 367         MethodType invokerFormType = mtype.appendParameterTypes(skipCallSite ? MethodHandle.class : CallSite.class);
 368         Name[] names = arguments(nameCursor - INARG_LIMIT, invokerFormType);
 369         assert(names.length == nameCursor);
 370         assert(names[APPENDIX_ARG] != null);
 371         if (!skipCallSite)
 372             names[CALL_MH] = new Name(getConstantFunction(NF_getCallSiteTarget), names[CSITE_ARG]);
 373         // (site.)invokedynamic(a*):R => mh = site.getTarget(); mh.invokeBasic(a*)
 374         final int PREPEND_MH = 0, PREPEND_COUNT = 1;
 375         Object[] outArgs = Arrays.copyOfRange(names, ARG_BASE, OUTARG_LIMIT + PREPEND_COUNT, Object[].class);
 376         // prepend MH argument:
 377         System.arraycopy(outArgs, 0, outArgs, PREPEND_COUNT, outArgs.length - PREPEND_COUNT);
 378         outArgs[PREPEND_MH] = names[CALL_MH];
 379         names[LINKER_CALL] = new Name(mtype, outArgs);
 380         lform = new LambdaForm((skipCallSite ? "linkToTargetMethod" : "linkToCallSite"), INARG_LIMIT, names);
 381         lform.compileToBytecode();  // JVM needs a real methodOop
 382         lform = mtype.form().setCachedLambdaForm(which, lform);
 383         return lform;
 384     }
 385 
 386     /** Static definition of MethodHandle.invokeGeneric checking code. */
 387     /*non-public*/ static
 388     @ForceInline
 389     Object getCallSiteTarget(Object site) {
 390         return ((CallSite)site).getTarget();
 391     }
 392 
 393     /*non-public*/ static
 394     @ForceInline
 395     void checkCustomized(Object o) {
 396         MethodHandle mh = (MethodHandle)o;
 397         if (MethodHandleImpl.isCompileConstant(mh)) return;
 398         if (mh.form.customized == null) {
 399             maybeCustomize(mh);
 400         }
 401     }
 402 
 403     /*non-public*/ static
 404     @DontInline
 405     void maybeCustomize(MethodHandle mh) {
 406         byte count = mh.customizationCount;
 407         if (count >= CUSTOMIZE_THRESHOLD) {
 408             mh.customize();
 409         } else {
 410             mh.customizationCount = (byte)(count+1);
 411         }
 412     }
 413 
 414     private static NamedFunction getConstantFunction(int idx) {
 415         NamedFunction function = FUNCTIONS[idx];
 416         if (function != null) {
 417             return function;
 418         }
 419         return setCachedFunction(idx, makeConstantFunction(idx));
 420     }
 421 
 422     private static synchronized NamedFunction setCachedFunction(int idx, final NamedFunction function) {
 423         // Simulate a CAS, to avoid racy duplication of results.
 424         NamedFunction prev = FUNCTIONS[idx];
 425         if (prev != null) {
 426             return prev;
 427         }
 428         function.resolve();
 429         UNSAFE.storeFence();
 430         FUNCTIONS[idx] = function;
 431         return function;
 432     }
 433 
 434     // Indexes into constant functions:
 435     private static final int
 436             NF_checkExactType    =  0,
 437             NF_checkGenericType  =  1,
 438             NF_getCallSiteTarget =  2,
 439             NF_checkCustomized   =  3,
 440             NF_LIMIT             =  4;
 441 
 442     // Local constant functions:
 443     private static final @Stable NamedFunction[] FUNCTIONS = new NamedFunction[NF_LIMIT];
 444 
 445     private static NamedFunction makeConstantFunction(int idx) {
 446         try {
 447             switch (idx) {
 448                 case NF_checkExactType:
 449                     return new NamedFunction(Invokers.class
 450                             .getDeclaredMethod("checkExactType", Object.class, Object.class));
 451                 case NF_checkGenericType:
 452                     return new NamedFunction(Invokers.class
 453                             .getDeclaredMethod("checkGenericType", Object.class, Object.class));
 454                 case NF_getCallSiteTarget:
 455                     return new NamedFunction(Invokers.class
 456                             .getDeclaredMethod("getCallSiteTarget", Object.class));
 457                 case NF_checkCustomized:
 458                     return new NamedFunction(Invokers.class
 459                             .getDeclaredMethod("checkCustomized", Object.class));
 460             }
 461         } catch (ReflectiveOperationException ex) {
 462             throw newInternalError(ex);
 463         }
 464         throw newInternalError("Unknown function index: " + idx);
 465     }
 466 
 467     private static class Lazy {
 468         private static final MethodHandle MH_asSpreader;
 469 
 470         static {
 471             try {
 472                 MH_asSpreader = IMPL_LOOKUP.findVirtual(MethodHandle.class, "asSpreader",
 473                         MethodType.methodType(MethodHandle.class, Class.class, int.class));
 474             } catch (ReflectiveOperationException ex) {
 475                 throw newInternalError(ex);
 476             }
 477         }
 478     }
 479 }