request.flags2 |= flags2;
        request.useUnicode = useUnicode;
        request.response = response; /* needed by sign */
        if (request.digest == null)
            request.digest = digest; /* for sign called in encode */

        try {
            if (response == null) {
                doSend0( request );
                return;

                }
            """

            file("direct/build.gradle") << """
                plugins {
                    id 'java'
                    id 'jacoco'
                }

                dependencies {
                    implementation project(":transitive")
                }
            """
            file("direct/src/main/java/direct/Multiplier.java").java """
                package direct;

		panic("d.nx != 0")
	}

	var digest [Size]byte

	binary.BigEndian.PutUint32(digest[0:], d.h[0]^0xFFFFFFFF)
	binary.BigEndian.PutUint32(digest[4:], d.h[1]^0xFFFFFFFF)
	binary.BigEndian.PutUint32(digest[8:], d.h[2]^0xFFFFFFFF)
	binary.BigEndian.PutUint32(digest[12:], d.h[3]^0xFFFFFFFF)
	binary.BigEndian.PutUint32(digest[16:], d.h[4]^0xFFFFFFFF)
	binary.BigEndian.PutUint32(digest[20:], d.h[5]^0xFFFFFFFF)

			callee: "Add.Add",
		},
		// ExerciseFuncConcrete
		{
			pos:    "./devirt.go:173:36",
			callee: "AddFn",
		},
		{
			pos:    "./devirt.go:173:15",
			callee: "mult.MultFn",
		},
		// ExerciseFuncField
		{
			pos:    "./devirt.go:207:35",
			callee: "AddFn",
		},
		{
			pos:    "./devirt.go:207:19",
			callee: "mult.MultFn",
		},
		// ExerciseFuncClosure

            return; /* CRITICAL */
        }
        this.digest.update(input, offset, len);
        this.updates++;
    }


    /**
     * @return calculated digest
     */
    public byte[] digest () {
        byte[] b;

        b = this.digest.digest();

        if ( log.isTraceEnabled() ) {
            log.trace("digest: ");
            log.trace(Hexdump.toHexString(b, 0, b.length));

			return hdr, noEOF(err)
		}
		digest := le.Uint16(z.buf[:2])
		if digest != uint16(z.digest) {
			return hdr, ErrHeader
		}
	}

	z.digest = 0
	if z.decompressor == nil {
		z.decompressor = flate.NewReader(z.r)
	} else {
		z.decompressor.(flate.Resetter).Reset(z.r, nil)
	}
	return hdr, nil
}

// state of the hash.
func New() hash.Hash32 {
	d := new(digest)
	d.Reset()
	return d
}

func (d *digest) Size() int { return Size }

func (d *digest) BlockSize() int { return 4 }

const (
	magic         = "adl\x01"
	marshaledSize = len(magic) + 4
)

func (d *digest) MarshalBinary() ([]byte, error) {
	b := make([]byte, 0, marshaledSize)
	b = append(b, magic...)

module use

go 1.17

require (
	direct v0.0.0
	example.com/lazyupgrade v0.1.0
)

replace (
	direct => ./direct
	example.com/lazyupgrade v0.1.0 => ./lazyupgrade@v0.1.0
	example.com/lazyupgrade v0.1.1 => ./lazyupgrade@v0.1.1
)
-- usedirect/usedirect.go --
package use

import _ "example.com/lazyupgrade"
-- useindirect/useindirect.go --
package use

import _ "direct"
-- direct/go.mod --
module direct

	if d.nx != 0 {
		panic("d.nx != 0")
	}

	var digest [Size]byte

	byteorder.BePutUint32(digest[0:], d.h[0])
	byteorder.BePutUint32(digest[4:], d.h[1])
	byteorder.BePutUint32(digest[8:], d.h[2])
	byteorder.BePutUint32(digest[12:], d.h[3])
	byteorder.BePutUint32(digest[16:], d.h[4])
	byteorder.BePutUint32(digest[20:], d.h[5])
	byteorder.BePutUint32(digest[24:], d.h[6])
	if !d.is224 {

  @Nested
  @TestMetadata("analysis/analysis-api/testData/annotations/annotationsOnDeclaration/direct")
  @TestDataPath("$PROJECT_ROOT")
  public class Direct {
    @Test
    @TestMetadata("aliasedThrowsOnFunction.kt")
    public void testAliasedThrowsOnFunction() {
      runTest("analysis/analysis-api/testData/annotations/annotationsOnDeclaration/direct/aliasedThrowsOnFunction.kt");
    }

    @Test