continue
            }

            val cacheVersion =
                try {
                    GradleVersion.version(dirVersion)
                } catch (_: IllegalArgumentException) {
                    // Ignore
                    continue
                }

            if (shouldDelete(cacheVersion)) {

                                        list.add(QueryBuilders.geoDistanceQuery(geoField).distance(distance).point(lat, lon));
                                    } catch (final Exception ex) {
                                        throw new InvalidQueryException(
                                                messages -> messages.addErrorsInvalidQueryUnknown(UserMessages.GLOBAL_PROPERTY_KEY),

    for (String propertyName : new String[] {"value", "absent"}) {
      Method method = null;
      try {
        method = annotationClass.getMethod(propertyName);
      } catch (NoSuchMethodException e) {
        throw new AssertionError("Annotation is missing required method", e);
      }
      final Class<?> returnType = method.getReturnType();
      assertTrue(

        public Model get() {
            if (!set) {
                synchronized (this) {
                    if (!set) {
                        try {
                            this.wait();
                        } catch (InterruptedException e) {
                            // Ignore
                        }
                    }
                }
            }
            return model;
        }

     * 4 = SMB_COM_DELETE_DIRECTORY
     * 5 = SMB_COM_OPEN_ANDX
     * 6 = SMB_COM_RENAME
     * 7 = SMB_COM_TRANSACTION
     * 8 = SMB_COM_QUERY_INFORMATION
     */

    /* All batch limits are single batch only until further notice
     */

    private static byte[] batchLimits = {
        1, 1, 1, 1, 1, 1, 1, 1, 0
    };

    static {
        String s;

      try {
        val testClass = access.findClassByName(it)

        if (testClass != null) {
          access.registerAsUsed(testClass)
          registerTest(access, testClass)
        }
      } catch (e: Exception) {
        // If you throw an exception here then native image building fails half way through
        // silently without rewriting the binary. So we report noisily, but keep going and prefer

  protected AbstractLoadingCache() {}

  @CanIgnoreReturnValue // TODO(b/27479612): consider removing this?
  @Override
  public V getUnchecked(K key) {
    try {
      return get(key);
    } catch (ExecutionException e) {
      throw new UncheckedExecutionException(e.getCause());
    }
  }

  @Override
  public ImmutableMap<K, V> getAll(Iterable<? extends K> keys) throws ExecutionException {

     * {@inheritDoc}
     *
     * @see java.lang.Thread#run()
     */
    @Override
    public void run () {
        try {
            this.closed = true;
            close();
        }
        catch ( CIFSException e ) {
            log.warn("Failed to close context on shutdown", e);
        }
    }

    axesSizeProduct[axes.size()] = 1;
    try {
      for (int i = axes.size() - 1; i >= 0; i--) {
        axesSizeProduct[i] = IntMath.checkedMultiply(axesSizeProduct[i + 1], axes.get(i).size());
      }
    } catch (ArithmeticException e) {
      throw new IllegalArgumentException(
          "Cartesian product too large; must have size at most Integer.MAX_VALUE");
    }
    this.axesSizeProduct = axesSizeProduct;
  }

                    println("Found bad file $filePath in merge commit $mergeCommit: '$line' only exists in $releaseCommit but not in $masterCommit")
                    return true
                }
            }
        } catch (AbortException ignore) {
            return false
        }
        return false
    }

    static class AbortException extends RuntimeException {
    }