@Override
  public int count(@Nullable Object element) {
    throw new AssertionError();
  }

  @Override
  public ImmutableSet<E> elementSet() {
    throw new AssertionError();
  }

  @Override
  Entry<E> getEntry(int index) {
    throw new AssertionError();
  }

  @Override
  boolean isPartialView() {
    throw new AssertionError();
  }

  @Override
  public int size() {

      try {
        output.write(b);
      } catch (IOException impossible) {
        throw new AssertionError(impossible);
      }
    }

    @Override
    public void write(byte[] b) {
      try {
        output.write(b);
      } catch (IOException impossible) {
        throw new AssertionError(impossible);
      }
    }

    @Override
    public void write(byte[] b, int off, int len) {

          @Override
          public Integer computeNext() {
            if (haveBeenCalled) {
              throw new AssertionError("Should not have been called again");
            } else {
              haveBeenCalled = true;
              sneakyThrow(new SomeCheckedException());
              throw new AssertionError(); // unreachable
            }
          }
        };

        BoundType boundType, DiscreteDomain<Comparable<?>> domain) {
      throw new AssertionError("this statement should be unreachable");
    }

    @Override
    void describeAsLowerBound(StringBuilder sb) {
      sb.append("(-\u221e");
    }

    @Override
    void describeAsUpperBound(StringBuilder sb) {
      throw new AssertionError();
    }

    @Override

          @Override
          public Integer computeNext() {
            if (haveBeenCalled) {
              throw new AssertionError("Should not have been called again");
            } else {
              haveBeenCalled = true;
              sneakyThrow(new SomeCheckedException());
              throw new AssertionError(); // unreachable
            }
          }
        };

    // The first time, the sneakily-thrown exception comes out

          @Override
          public Integer computeNext() {
            if (haveBeenCalled) {
              throw new AssertionError("Should not have been called again");
            } else {
              haveBeenCalled = true;
              sneakyThrow(new SomeCheckedException());
              throw new AssertionError(); // unreachable
            }
          }
        };

    // The first time, the sneakily-thrown exception comes out

        throw new AssertionError(e);
      }
    }
  }

  /** Looks up Finalizer.startFinalizer(). */
  static Method getStartFinalizer(Class<?> finalizer) {
    try {
      return finalizer.getMethod(
          "startFinalizer", Class.class, ReferenceQueue.class, PhantomReference.class);
    } catch (NoSuchMethodException e) {
      throw new AssertionError(e);
    }
  }

        throw new AssertionError(e);
      }
    }
  }

  /** Looks up Finalizer.startFinalizer(). */
  static Method getStartFinalizer(Class<?> finalizer) {
    try {
      return finalizer.getMethod(
          "startFinalizer", Class.class, ReferenceQueue.class, PhantomReference.class);
    } catch (NoSuchMethodException e) {
      throw new AssertionError(e);
    }
  }

          urls.add(new URL("file", null, new File(entry).getAbsolutePath()));
        }
      } catch (MalformedURLException e) {
        AssertionError error = new AssertionError("malformed class path entry: " + entry);
        error.initCause(e);
        throw error;
      }
    }
    return urls.build().toArray(new URL[0]);
  }

      rethrow(e);
    }
    throw new AssertionError("Unreachable");
  }

  @Override
  public V get(long timeout, TimeUnit unit)
      throws InterruptedException, ExecutionException, TimeoutException {
    try {
      super.get(timeout, unit);
    } catch (ExecutionException e) {
      rethrow(e);
    }
    throw new AssertionError("Unreachable");
  }