continue
		}

		for len(d) > 0 {
			namesz := f.ByteOrder.Uint32(d)
			descsz := f.ByteOrder.Uint32(d[4:])
			typ := f.ByteOrder.Uint32(d[8:])

			an := (namesz + 3) &^ 3
			ad := (descsz + 3) &^ 3

			if int(12+an+ad) > len(d) {
				fmt.Fprintf(os.Stderr, "note section %d too short for header (%d < 12 + align(%d,4) + align(%d,4))\n", i, len(d), namesz, descsz)
				break
			}

			// 3 == NT_GNU_BUILD_ID

				continue sections
			}

			namesz := f.ByteOrder.Uint32(d)
			descsz := f.ByteOrder.Uint32(d[4:])
			typ := f.ByteOrder.Uint32(d[8:])

			an := (namesz + 3) &^ 3
			ad := (descsz + 3) &^ 3

			if int(12+an+ad) > len(d) {
				t.Logf("note section %d too short for header (%d < 12 + align(%d,4) + align(%d,4))", i, len(d), namesz, descsz)
				continue sections
			}

			// 3 == NT_GNU_BUILD_ID

		} else if err != nil {
			return nil, err
		}
		namesz := order.Uint32(noteHeader[0:4])
		descsz := order.Uint32(noteHeader[4:8])
		typ := order.Uint32(noteHeader[8:12])

		if uint64(namesz) > uint64(maxNoteSize) {
			return nil, fmt.Errorf("note name too long (%d bytes)", namesz)
		}
		var name string
		if namesz > 0 {
			// Documentation differs as to whether namesz is meant to include the

// Create a duplicate if one already exists with that name.
func elfshnamedup(name string) *ElfShdr {
	for i := 0; i < nelfstr; i++ {
		if name == elfstr[i].s {
			off := elfstr[i].off
			return newElfShdr(int64(off))
		}
	}

	Errorf(nil, "cannot find elf name %s", name)
	errorexit()
	return nil
}

func elfshalloc(sect *sym.Section) *ElfShdr {

//	Names(["foo.com","*.net"]).Intersection(Names(["*.com","bar.net"])) = Names(["foo.com","bar.net"])
//	Names(["foo.com","*.net"]).Intersection(Names(["*.bar.net"]))       = Names(["*.bar.net"])
//	Names(["foo.com"]).Intersection(Names(["bar.com"]))                 = Names([])
//	Names([]).Intersection(Names(["bar.com"])                           = Names([])
func (h Names) Intersection(other Names) Names {
	result := make(Names, 0, len(h))
	for _, hHost := range h {

import org.apache.commons.lang.StringUtils;

public abstract class Names {

    public static Names of(String name) {
        if (name.equals("main")) {
            return new Main();
        }
        return new Other(name, name);
    }

    public static Names of(String name, String baseName) {
        return new Other(name, baseName);
    }

    public abstract Names append(String suffix);

    /**
     * The raw name.

// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package s390x

var cnamesz = []string{
	"NONE",
	"REG",
	"FREG",
	"VREG",
	"AREG",
	"ZCON",
	"SCON",
	"UCON",
	"ADDCON",
	"ANDCON",
	"LCON",
	"DCON",
	"SACON",
	"LACON",
	"DACON",
	"SBRA",
	"LBRA",
	"SAUTO",
	"LAUTO",
	"ZOREG",

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package names

const (
	PrioritySort                    = "PrioritySort"
	DefaultBinder                   = "DefaultBinder"
	DefaultPreemption               = "DefaultPreemption"
	DynamicResources                = "DynamicResources"

import com.google.common.base.Joiner;

import java.util.Locale;

class Names {
    static String displayNameFor(Enum<?> value) {
        String[] parts = value.name().toLowerCase(Locale.US).split("_");
        return Joiner.on(' ').join(parts);
    }

    static String idFor(Enum<?> value) {
        String[] parts = value.name().toLowerCase(Locale.US).split("_");
        return Joiner.on('-').join(parts);
    }

  EXPECT_EQ(names2[2], "linear_2/c1");
  EXPECT_EQ(names2[3], "linear_2/mul_1");
  EXPECT_EQ(names2[4], "linear_2");

  const auto names3 = LinearOp(root.WithOpName("c"));

  EXPECT_EQ(names3[0], "c/mul");
  EXPECT_EQ(names3[1], "c/bias_add");
  EXPECT_EQ(names3[2], "c/c1");
  EXPECT_EQ(names3[3], "c/mul_1");
  EXPECT_EQ(names3[4], "c");
}

TEST(ScopeTest, SingleUseScope) {