}

	var shnum int
	var shoff, shentsize int64
	switch buf[4] {
	default:
		return "", errBadELF
	case 1: // 32-bit file header
		shoff = int64(byteOrder.Uint32(buf[32:]))
		shentsize = int64(byteOrder.Uint16(buf[46:]))
		if shentsize != 40 {
			return "", errBadELF
		}
		shnum = int(byteOrder.Uint16(buf[48:]))
	case 2: // 64-bit file header
		shoff = int64(byteOrder.Uint64(buf[40:]))

		shstrndx = int(bo.Uint16(data[unsafe.Offsetof(hdr.Shstrndx):]))
	}

	if shoff < 0 {
		return nil, &FormatError{0, "invalid shoff", shoff}
	}
	if phoff < 0 {
		return nil, &FormatError{0, "invalid phoff", phoff}
	}

	if shoff == 0 && shnum != 0 {
		return nil, &FormatError{0, "invalid ELF shnum for shoff=0", shnum}
	}

	if shnum > 0 && shstrndx >= shnum {

		binary.Read(bytes.NewReader(hdrbuf[:]), e, hdr)
		elfobj.type_ = uint32(hdr.Type)
		elfobj.machine = uint32(hdr.Machine)
		elfobj.version = hdr.Version
		elfobj.entry = hdr.Entry
		elfobj.phoff = hdr.Phoff
		elfobj.shoff = hdr.Shoff
		elfobj.flags = hdr.Flags
		elfobj.ehsize = uint32(hdr.Ehsize)
		elfobj.phentsize = uint32(hdr.Phentsize)
		elfobj.phnum = uint32(hdr.Phnum)
		elfobj.shentsize = uint32(hdr.Shentsize)

func newElfPhdr() *ElfPhdr {
	e := new(ElfPhdr)
	if ehdr.Phnum >= NSECT {
		Errorf(nil, "too many phdrs")
	} else {
		phdr[ehdr.Phnum] = e
		ehdr.Phnum++
	}
	if elf64 {
		ehdr.Shoff += ELF64PHDRSIZE
	} else {
		ehdr.Shoff += ELF32PHDRSIZE
	}
	return e
}

func newElfShdr(name int64) *ElfShdr {
	e := new(ElfShdr)
	e.Name = uint32(name)
	e.shnum = elf.SectionIndex(ehdr.Shnum)

// at least 4 kB out, in data.
func readELF(name string, f *os.File, data []byte) (buildid string, err error) {
	// Assume the note content is in the data, already read.
	// Rewrite the ELF header to set shoff and shnum to 0, so that we can pass
	// the data to elf.NewFile and it will decode the Prog list but not
	// try to read the section headers and the string table from disk.

	Machine   uint16          /* Machine architecture. */
	Version   uint32          /* ELF format version. */
	Entry     uint32          /* Entry point. */
	Phoff     uint32          /* Program header file offset. */
	Shoff     uint32          /* Section header file offset. */
	Flags     uint32          /* Architecture-specific flags. */
	Ehsize    uint16          /* Size of ELF header in bytes. */

	{
		buf.Grow(0x55AF1C) // 3003468 + 40 * 65298

		h := Header32{
			Ident:     [16]byte{0x7F, 'E', 'L', 'F', 0x01, 0x01, 0x01},
			Type:      1,
			Machine:   3,
			Version:   1,
			Shoff:     0x2DD44C,
			Ehsize:    0x34,
			Shentsize: 0x28,
			Shnum:     0,
			Shstrndx:  0xFFFF,
		}
		binary.Write(&buf, binary.LittleEndian, h)

		// Zero out sections [1]~[65294].

			if err := binary.Read(bytes.NewReader(data), order, &hdr); err != nil {
				t.Error(err)
				continue
			}

			phoff := hdr.Phoff
			phnum := int(hdr.Phnum)
			phsize := uint64(hdr.Phentsize)

			for i := 0; i < phnum; i++ {
				var phdr elf.Prog64
				if err := binary.Read(bytes.NewReader(data[phoff:]), order, &phdr); err != nil {
					t.Error(err)
					continue
				}

    private long sourceOffset;
    private long targetOffset;
    private int length;


    /**
     * @param soff
     * @param toff
     * @param len
     */
    public SrvCopychunk ( long soff, long toff, int len ) {
        this.sourceOffset = soff;
        this.targetOffset = toff;
        this.length = len;
    }


    /**
     * {@inheritDoc}
     *

        i = j = 0;
    }
    public void update(byte[] src, int soff, int slen, byte[] dst, int doff)
    {
        int slim;

        slim = soff + slen;
        while (soff < slim) {
            i = (i + 1) & 0xff;
            j = (j + s[i]) & 0xff;
            byte t = s[i];
            s[i] = s[j];
            s[j] = t;
            dst[doff++] = (byte)(src[soff++] ^ s[(s[i] + s[j]) & 0xff]);
        }
    }