* @param dictId the dictionary ID
     * @param protwordsPager the pager for pagination
     * @return the list of protected words items
     */
    public List<ProtwordsItem> getProtwordsList(final String dictId, final ProtwordsPager protwordsPager) {
        return getProtwordsFile(dictId).map(file -> {
            final int pageSize = protwordsPager.getPageSize();

        }
      }
    }
    return super.containsAll(collection);
  }

  @Override
  public Iterator<E> iterator() {
    return asList(contents).iterator();
  }

  @Override
  public @Nullable Object[] toArray() {
    @Nullable Object[] result = new @Nullable Object[contents.length];
    arraycopy(contents, 0, result, 0, contents.length);
    return result;
  }

  /*

  private static MultiInputStream tenMillionEmptySources() throws IOException {
    return new MultiInputStream(Collections.nCopies(10_000_000, ByteSource.empty()).iterator());
  }

  private static ByteSource newByteSource(int start, int size) {
    return new ByteSource() {
      @Override
      public InputStream openStream() {
        return new ByteArrayInputStream(newPreFilledByteArray(start, size));
      }
    };
  }

    }
  }

  /** Previous version of BigIntegerMath.factorial, kept for timing purposes. */
  private static BigInteger oldSlowFactorial(int n) {
    if (n <= 20) {
      return BigInteger.valueOf(LongMath.factorial(n));
    } else {
      int k = 20;
      return BigInteger.valueOf(LongMath.factorial(k)).multiply(oldSlowFactorial(k, n));
    }
  }

  /** Returns the product of {@code n1} exclusive through {@code n2} inclusive. */

  public void invalidateAll() {
    delegate().invalidateAll();
  }

  @Override
  public long size() {
    return delegate().size();
  }

  @Override
  public CacheStats stats() {
    return delegate().stats();
  }

  @Override
  public ConcurrentMap<K, V> asMap() {
    return delegate().asMap();
  }

  @Override
  public void cleanUp() {
    delegate().cleanUp();
  }

   * half of that is more awkward to arrange...
   */
  private static <T> Iterable<T> iterable(Collection<T> collection) {
    // return collection::iterator;
    return new Iterable<T>() {
      @Override
      public Iterator<T> iterator() {
        return collection.iterator();
      }
    };
  }

  public void testEquals() {
    new EqualsTester()

        }
    }

    @Override
    public List<String> getExplicitlyActivatedIds() {
        return activatedIds;
    }

    @Override
    public List<String> getExplicitlyDeactivatedIds() {
        return deactivatedIds;
    }

    @Override
    public List getIdsActivatedByDefault() {
        return defaultIds;
    }

    return doAssertThrows(expectedThrowable, supplier, /* userPassedSupplier= */ true);
  }

  @CanIgnoreReturnValue
  static <T extends Throwable> T assertThrows(
      Class<T> expectedThrowable, ThrowingRunnable runnable) {
    return doAssertThrows(
        expectedThrowable,
        () -> {
          runnable.run();
          return null;
        },

            jarFileSystem.rootDirectories.forEach {
                visitClassDirectory(it, classGraph, classesDir, manifestFile.toPath(), buildReceipt.toPath())
            }
        }
        return classGraph
    }

    private
    fun classGraph() =
        ClassGraph(
            PackagePatterns(keepPackages),
            PackagePatterns(unshadedPackages),
            PackagePatterns(ignorePackages),

	conds = append(conds, clause.IN{Column: column, Values: values})
	return
}

func copyableDataType(str DataType) bool {
	lowerStr := strings.ToLower(string(str))
	for _, s := range []string{"auto_increment", "primary key"} {
		if strings.Contains(lowerStr, s) {
			return false
		}
	}
	return true