}
	s.elems[name] = obj
}

// Squash merges s with its parent scope p by adding all
// objects of s to p, adding all children of s to the
// children of p, and removing s from p's children.
// The function f is called for each object obj in s which
// has an object alt in p. s should be discarded after
// having been squashed.
func (s *Scope) Squash(err func(obj, alt Object)) {
	p := s.parent
	assert(p != nil)

	}
	s.elems[name] = obj
}

// Squash merges s with its parent scope p by adding all
// objects of s to p, adding all children of s to the
// children of p, and removing s from p's children.
// The function f is called for each object obj in s which
// has an object alt in p. s should be discarded after
// having been squashed.
func (s *Scope) squash(err func(obj, alt Object)) {
	p := s.parent
	assert(p != nil)

		if recvPar != nil {
			check.error(ftyp.TypeParams, InvalidMethodTypeParams, "methods cannot have type parameters")
		}
	}

	// Use a temporary scope for all parameter declarations and then
	// squash that scope into the parent scope (and report any
	// redeclarations at that time).
	//
	// TODO(adonovan): now that each declaration has the correct
	// scopePos, there should be no need for scope squashing.

	if tparams != nil {
		// The parser will complain about invalid type parameters for methods.
		check.collectTypeParams(&sig.tparams, tparams)
	}

	// Use a temporary scope for all parameter declarations and then
	// squash that scope into the parent scope (and report any
	// redeclarations at that time).
	//
	// TODO(adonovan): now that each declaration has the correct
	// scopePos, there should be no need for scope squashing.

		renameIdents(f, "syntax->ast")
	},
	"package.go":       nil,
	"pointer.go":       nil,
	"predicates.go":    nil,
	"scope.go":         func(f *ast.File) { fixTokenPos(f); renameIdents(f, "Squash->squash", "InsertLazy->_InsertLazy") },
	"selection.go":     nil,
	"sizes.go":         func(f *ast.File) { renameIdents(f, "IsSyncAtomicAlign64->_IsSyncAtomicAlign64") },
	"slice.go":         nil,

performanceTest.registerTestProject("gradleBuildBaseline", RemoteProject) {
    remoteUri = repoRoot(project).asFile.absolutePath
    // Remember to update accordingly when rebasing/squashing
    // Do not use the "Rebase and merge" nor "Squash and merge" Github buttons when merging a PR that change the baseline
    ref = '264bd7744d2e89b2708303cd56bb11bc5003fa7e'
}

// === Declarative DSL ===

	// TODO: If this will appear to be computationally expensive, consider
	// computing this incrementally similarly to endpointsMap.

	// (Note that we need to call getLocalEndpointIPs first to squash the data by IP,
	// because the EndpointsMap is sorted by IP+port, not just IP, and we want to
	// consider a Service pointing to 10.0.0.1:80 and 10.0.0.1:443 to have 1 endpoint,
	// not 2.)

	}
}

func TestDockerKeyringLookup(t *testing.T) {
	ada := AuthConfig{
		Username: "ada",
		Password: "smash", // Fake value for testing.
		Email:    "******@****.***",
	}

	grace := AuthConfig{
		Username: "grace",
		Password: "squash", // Fake value for testing.
		Email:    "******@****.***",
	}

	dk := &BasicDockerKeyring{}
	dk.Add(DockerConfig{

### Don't worry about style

* Don't worry too much about things like commit message styles, I will squash and merge customizing the commit manually.

* Also don't worry about style rules, there are already automatized tools checking that.

        0x10040000, 0x10001000, 0x10001040, 0x00000000,
        0x10041040, 0x00041000, 0x00041000, 0x00001040,
        0x00001040, 0x00040040, 0x10000000, 0x10041000
    };


 /// Squash bytes down to ints.
    public static void squashBytesToInts( byte[] inBytes, int inOff, int[] outInts,
                                           int outOff, int intLen ) {

        for ( int i = 0; i < intLen; ++i )