}
			xpos = xposWith
		}
	}

	if len(tab.baseList) != 1+len(tab.indexMap) { // indexMap omits nil
		t.Errorf("table length discrepancy: %d != 1+%d", len(tab.baseList), len(tab.indexMap))
	}

	const wantLen = 4
	if len(tab.baseList) != wantLen {
		t.Errorf("got table length %d; want %d", len(tab.baseList), wantLen)
	}

	if got := tab.XPos(NoPos); got != NoXPos {

	if base.fileIndex >= 0 {
		panic("PosBase already registered with a PosTable")
	}

	if t.indexMap == nil {
		t.baseList = append(t.baseList, nil)
		t.indexMap = make(map[*PosBase]int)
		t.nameMap = make(map[string]int)
	}

	i := len(t.baseList)
	t.indexMap[base] = i
	t.baseList = append(t.baseList, base)

	fileIndex, ok := t.nameMap[base.absFilename]
	if !ok {
		fileIndex = len(t.nameMap)

				}
			}
		}
	}
	return tags
}

func createArgs(args Args, target string, variant string, architecture string) map[string]string {
	baseDist := variant
	if baseDist == DefaultVariant {
		baseDist = PrimaryVariant
	}
	m := map[string]string{
		// Base version defines the tag of the base image to use. Typically, set in the Makefile and not overridden.
		"BASE_VERSION": args.BaseVersion,

		ReadOnly *bool
	}

	type BasePost struct {
		Id    int64
		Title string
		URL   string
		ReadOnly
	}

	type Author struct {
		ID    string
		Name  string
		Email string
	}

	type HNPost struct {
		BasePost
		Author  `gorm:"EmbeddedPrefix:user_"` // Embedded struct
		Upvotes int32
	}

	type EngadgetPost struct {
		BasePost BasePost `gorm:"Embedded"`

		}
		if e.sym < literalLengthOffset {
			be.baseline = uint32(e.sym)
			be.basebits = 0
		} else {
			if e.sym > 35 {
				return r.makeError(off, "FSE baseline symbol overflow")
			}
			idx := e.sym - literalLengthOffset
			basebits := literalLengthBase[idx]
			be.baseline = basebits & 0xffffff
			be.basebits = uint8(basebits >> 24)
		}
		baselineTable[i] = be
	}
	return nil
}

            return NoopHttpRedirectVerifier.instance;
        } else {
            // Verify that the base URL is secure now.
            if (baseHost != null && !GUtil.isSecureUrl(baseHost)) {
                insecureBaseHost.run();
            }

            // Verify that any future redirect locations are secure.
            // Lambda will be called back on for every redirect in the chain.
            return redirectLocations ->

            }
            test {
                ${configureTestFramework}
                exclude '**/BaseTest.*'
            }
        """.stripIndent()
        file('src/test/java/org/gradle/BaseTest.java') << """
            package org.gradle;
            ${testFrameworkImports}
            public class BaseTest {
                @Test public void ok() { }
            }
        """.stripIndent()

            }
        """
        file("src/test/groovy/BaseTest.groovy").text = """
            import spock.lang.Specification
            class BaseTest extends Specification {}
        """
        file("src/test/groovy/UnrelatedClass.groovy").text = "class UnrelatedClass {}"
        file("src/test/groovy/AppTest.groovy").text = """
            class AppTest extends BaseTest {
                def "some test"() {

		ptliteral := &r.seqTables[seqLiteral][literalState]

		add, err := rbr.val(ptoffset.basebits)
		if err != nil {
			return err
		}
		offset := ptoffset.baseline + add

		add, err = rbr.val(ptmatch.basebits)
		if err != nil {
			return err
		}
		match := ptmatch.baseline + add

		add, err = rbr.val(ptliteral.basebits)
		if err != nil {
			return err
		}
		literal := ptliteral.baseline + add

			// this should replicate real-world scenarios of mixed specific and wildcard hosts
			specific := host.Name(strconv.Itoa(i) + "." + bm.baseHost)
			// generate correct wildcard hosts, one of these will match
			wildcard := host.Name("*." + bm.baseHost + "." + strconv.Itoa(i))

			bm.specificHostsMap[specific] = struct{}{}
			bm.wildcardHostsMap[wildcard] = struct{}{}
		}