for x := 0; x <= size-n; x = x*7 + 1 { // offset in src
			for y := 0; y <= size-n; y = y*9 + 1 { // offset in dst
				// Reset input
				copyref(test, src)
				copyref(ref, src)
				copy(test[y:y+n], test[x:x+n])
				if y <= x {
					copyref(ref[y:y+n], ref[x:x+n])
				} else {
					copybw(ref[y:y+n], ref[x:x+n])
				}
				p := cmpb(test, ref)
				if p >= 0 {

import (
	"bytes"
	"fmt"
	"go/format"
	"log"
	"os"
)

// This program generates tests to verify that copying operations
// copy the data they are supposed to and clobber no adjacent values.

// run as `go run copyGen.go`.  A file called copy.go
// will be written into the parent directory containing the tests.

        this.type = type;
        this.lenientErrors = ImmutableList.copyOf(lenientErrors);
        this.attributes = ImmutableList.copyOf(attributes);
        this.capabilities = ImmutableList.copyOf(capabilities);
        this.artifacts = ImmutableList.copyOf(artifacts);
        this.variants = ImmutableList.copyOf(variants);
        this.extendedConfigurations = ImmutableList.copyOf(extendedConfigurations);
    }

    public String getName() {

		tomem = et.Size_ * uintptr(tolen)
		copymem = tomem
	}

	var to unsafe.Pointer
	if !et.Pointers() {
		to = mallocgc(tomem, nil, false)
		if copymem < tomem {
			memclrNoHeapPointers(add(to, copymem), tomem-copymem)
		}
	} else {
		// Note: can't use rawmem (which avoids zeroing of memory), because then GC can scan uninitialized memory.
		to = mallocgc(tomem, et, true)
		if copymem > 0 && writeBarrier.enabled {

        this.externalRepositories = List.copyOf(externalRepositories);
        this.repositories = List.copyOf(externalRepositories);
        this.ids = new HashSet<>();
    }

    protected DefaultModelRepositoryHolder(DefaultModelRepositoryHolder holder) {
        this.session = holder.session;
        this.repositoryMerging = holder.repositoryMerging;
        this.pomRepositories = List.copyOf(holder.pomRepositories);

  private ListGenerators() {}

  public static class ImmutableListOfGenerator extends TestStringListGenerator {
    @Override
    protected List<String> create(String[] elements) {
      return ImmutableList.copyOf(elements);
    }
  }

  public static class BuilderAddListGenerator extends TestStringListGenerator {
    @Override
    protected List<String> create(String[] elements) {

    Collections.addAll(all, others);
    return copyOf(all.iterator());
  }

  /** ImmutableSet.of API that is friendly to use from JavaScript. */
  @JsMethod(name = "of")
  static <E> ImmutableSet<E> jsOf(E... elements) {
    return copyOf(elements);
  }

  @JsMethod
  public static <E> ImmutableSet<E> copyOf(E[] elements) {
    checkNotNull(elements);
    switch (elements.length) {

        }

        this.original = original;
        this.stackTrace = ImmutableList.copyOf(stackTrace);
        this.frameRelevance = ImmutableList.copyOf(frameRelevance);
        this.suppressed = ImmutableList.copyOf(suppressed);
        this.causes = ImmutableList.copyOf(causes);
    }

    @Override
    public Class<? extends Throwable> getExceptionType() {
        return original.getClass();

    if os.path.isdir("./static"):  # pragma: nocover
        shutil.rmtree("./static")
    if os.path.isdir("./templates"):  # pragma: nocover
        shutil.rmtree("./templates")
    shutil.copytree("./docs_src/templates/templates/", "./templates")
    shutil.copytree("./docs_src/templates/static/", "./static")
    from docs_src.templates.tutorial001 import app

    client = TestClient(app)
    response = client.get("/items/foo")

    ) {
        this.includePatterns = ImmutableSet.copyOf(includePatterns);
        this.commandLineIncludePatterns = ImmutableSet.copyOf(commandLineIncludePatterns);
        this.excludePatterns = ImmutableSet.copyOf(excludePatterns);
        this.includeTags = ImmutableSet.copyOf(includeTags);
        this.excludeTags = ImmutableSet.copyOf(excludeTags);
        this.includeEngines = ImmutableSet.copyOf(includeEngines);