LZNT1 decompress error

[Tupler]

But RtlDecompressBuffer can decompress normally.

[Tupler]

this is my code

package main

import (
    "encoding/binary"
    "errors"
    "log"
    "os"
)

/*
Decompression support for the LZNT1 compression algorithm.

Reference:
http://msdn.microsoft.com/en-us/library/jj665697.aspx
(2.5 LZNT1 Algorithm Details)

https://github.com/libyal/reviveit/
https://github.com/sleuthkit/sleuthkit/blob/develop/tsk/fs/ntfs.c
*/

var (
    COMPRESSED_MASK = uint16(1 << 15)
    SIGNATURE_MASK  = uint16(3 << 12)
    SIZE_MASK       = uint16(1<<12) - 1

    shiftTooLargeError = errors.New(
        "Decompression error - shift is too large")
    blockTooSmallError = errors.New("Block too small!")
)

func get_displacement(offset uint16) byte {
    result := byte(0)
    for {
        if offset < 0x10 {
            return result
        }

        offset >>= 1
        result += 1
    }
}

func LZNT1Decompress(in []byte) ([]byte, error) {

    // Index into the in buffer
    i := 0
    out := []byte{}

    for {
        if len(in) < i+2 {
            break
        }
        uncompressed_chunk_offset := len(out)
        block_offset := i

        block_header := binary.LittleEndian.Uint16(in[i:])

        i += 2

        size := int(block_header & SIZE_MASK)
        block_end := block_offset + size + 3

        if size == 0 {
            break
        }

        if len(in) < i+size {
            return nil, blockTooSmallError
        }

        if block_header&COMPRESSED_MASK != 0 {
            for i < block_end {
                header := uint8(in[i])

                i++

                for mask_idx := uint8(0); mask_idx < 8 && i < block_end; mask_idx++ {
                    if (header & 1) == 0 {

                        out = append(out, in[i])
                        i++

                    } else {
                        pointer := binary.LittleEndian.Uint16(in[i:])
                        i += 2

                        displacement := get_displacement(
                            uint16(len(out) - uncompressed_chunk_offset - 1))
                        symbol_offset := int(pointer>>(12-displacement)) + 1
                        symbol_length := int(pointer&(0xFFF>>displacement)) + 2
                        start_offset := len(out) - symbol_offset
                        for j := 0; j < symbol_length+1; j++ {
                            idx := start_offset + j
                            if idx < 0 || idx >= len(out) {

                                return out, shiftTooLargeError
                            }
                            out = append(out, out[idx])
                        }
                    }
                    header >>= 1
                }
            }

            // Block is not compressed.
        } else {
            out = append(out, in[i:i+size+1]...)
            i += size + 1
        }

    }

    return out, nil
}
func main() {

    source, err := os.ReadFile("PX_dec.TXT")
    if err != nil {
        log.Fatalln(err)
    }

    result, err := LZNT1Decompress(source)
    if err != nil {
        panic(err)
    }

    if err = os.WriteFile("PXX.TXT", result, 0666); err != nil {
        log.Fatalln(err)
    }

}