Colobu | 鸟窝 晁岳攀修改

sum := simd.SumFloat32s([]float32{1, 2, 3, 4, 5})

package main

import (
	"log"
	"github.com/alivanz/go-simd/arm"
	"github.com/alivanz/go-simd/arm/neon"
)

func main() {
	var a, b arm.Int8X8
	var add, mul arm.Int16X8
	for i := 0; i < 8; i++ {
		a[i] = arm.Int8(i)
		b[i] = arm.Int8(i * i)
	}
	log.Printf("a = %+v", b)
	log.Printf("b = %+v", a)
	neon.VaddlS8(&add, &a, &b)
	neon.VmullS8(&mul, &a, &b)
	log.Printf("add = %+v", add)
	log.Printf("mul = %+v", mul)
}

// 以下是一个简单的Go汇编示例，使用AVX指令集进行向量加法
TEXT ·add(SB), $0-32
    MOVQ a+0(FP), DI
    MOVQ b+8(FP), SI
    MOVQ result+16(FP), DX
    MOVQ len+24(FP), CX
    
    TESTQ CX, CX        ; 检查长度是否为0
    JZ done             ; 如果为0直接返回
    
    MOVQ CX, R8         ; 保存原始长度
    SHRQ $2, CX         ; 除以4得到循环次数
    JZ remainder        ; 如果不足4个元素，跳到处理余数
    
    XORQ R9, R9         ; 用于索引的计数器，从0开始
loop:
    VMOVUPD (DI)(R9*8), Y0
    VMOVUPD (SI)(R9*8), Y1
    VADDPD Y0, Y1, Y0
    VMOVUPD Y0, (DX)(R9*8)
    ADDQ $4, R9
    DECQ CX
    JNZ loop
remainder:              ; 处理剩余的元素
    ANDQ $3, R8        ; 获取余数
    JZ done
    ; 这里添加处理余数的代码
done:
    RET

package fishfinding

import (
	"net"
	"os"
	"time"
	"github.com/kataras/golog"
	"golang.org/x/net/bpf"
	"golang.org/x/net/ipv4"
)

type TCPScanner struct {
	src     net.IP
	srcPort int
	dstPort int
	input   chan string
	output  chan string
}

func NewTCPScanner(srcPort, dstPort int, input chan string, output chan string) *TCPScanner {
	localIP := GetLocalIP()
	s := &TCPScanner{
		input:   input,
		output:  output,
		src:     net.ParseIP(localIP).To4(),
		srcPort: srcPort,
		dstPort: dstPort,
	}
	return s
}

func (s *TCPScanner) Scan() {
	go s.recv()
	go s.send(s.input)
}

func (s *TCPScanner) send(input chan string) error {
	defer func() {
		time.Sleep(5 * time.Second)
		close(s.output)
		golog.Infof("send goroutine exit")
	}()
	// 创建原始套接字
	conn, err := net.ListenPacket("ip4:tcp", s.src.To4().String())
	if err != nil {
		golog.Fatal(err)
	}
	defer conn.Close()
	pconn := ipv4.NewPacketConn(conn)
	// 不接收数据
	filter := createEmptyFilter()
	if assembled, err := bpf.Assemble(filter); err == nil {
		pconn.SetBPF(assembled)
	}
	seq := uint32(os.Getpid())
	for ip := range input {
		dstIP := net.ParseIP(ip)
		if dstIP == nil {
			golog.Errorf("failed to resolve IP address %s", ip)
			continue
		}
		// 构造 TCP SYN 包
		tcpHeader := &TCPHeader{
			Source:      uint16(s.srcPort), // 源端口
			Destination: uint16(s.dstPort), // 目标端口(这里探测80端口)
			SeqNum:      seq,
			AckNum:      0,
			Flags:       0x002, // SYN
			Window:      65535,
			Checksum:    0,
			Urgent:      0,
		}
		// 计算校验和
		tcpHeader.Checksum = tcpChecksum(tcpHeader, s.src, dstIP)
		// 序列化 TCP 头
		packet := tcpHeader.Marshal()
		// 发送 TCP SYN 包
		_, err = conn.WriteTo(packet, &net.IPAddr{IP: dstIP})
		if err != nil {
			golog.Errorf("failed to send TCP packet: %v", err)
		}
	}
	return nil
}

func (s *TCPScanner) recv() error {
	defer recover()
	// 创建原始套接字
	conn, err := net.ListenIP("ip4:tcp", &net.IPAddr{IP: s.src})
	if err != nil {
		golog.Fatal(err)
	}
	defer conn.Close()
	pconn := ipv4.NewPacketConn(conn)
	if err := pconn.SetControlMessage(ipv4.FlagSrc|ipv4.FlagDst|ipv4.FlagInterface, true); err != nil {
		golog.Fatalf("set control message error: %v\n", err)
	}
	seq := uint32(os.Getpid()) + 1
	buf := make([]byte, 1024)
	for {
		n, peer, err := conn.ReadFrom(buf)
		if err != nil {
			golog.Errorf("failed to read: %v", err)
			continue
		}
		if n < tcpHeaderLength {
			continue
		}
		// 解析 TCP 头
		tcpHeader := ParseTCPHeader(buf[:n])
		if tcpHeader.Destination != uint16(s.srcPort) || tcpHeader.Source != uint16(s.dstPort) {
			continue
		}
		// golog.Info("peer: %s, flags: %d", peer.String(), tcpHeader.Flags)
		// 检查是否是 SYN+ACK, 同时检查ACK是否和发送的seq对应
		if tcpHeader.Flags == 0x012 && tcpHeader.AckNum == seq { // SYN + ACK
			s.output <- peer.String()
		}
	}
}

package fishfinding

import (
	"context"
	"fmt"
	"runtime"
	"sync"
	"time"
	"github.com/ClickHouse/clickhouse-go/v2"
	_ "github.com/ClickHouse/clickhouse-go/v2"
	"github.com/kataras/golog"
)

type ClickHouseChecker struct {
	wg   *sync.WaitGroup
	port int
	input  chan string
	output chan string
}

func NewClickHouseChecker(port int, input chan string, output chan string, wg *sync.WaitGroup) *ClickHouseChecker {
	s := &ClickHouseChecker{
		port:   port,
		input:  input,
		output: output,
		wg:     wg,
	}
	return s
}

func (s *ClickHouseChecker) Check() {
	parallel := runtime.NumCPU()
	for i := 0; i < parallel; i++ {
		s.wg.Add(1)
		go s.check()
	}
}

func (s *ClickHouseChecker) check() {
	defer s.wg.Done()
	for ip := range s.input {
		if ip == "splitting" || ip == "failed" {
			continue
		}
		if isClickHouse(ip, s.port) {
			s.output <- ip
		}
	}
}

func isClickHouse(ip string, port int) bool {
	conn, err := clickhouse.Open(&clickhouse.Options{
		Addr: []string{fmt.Sprintf("%s:%d", ip, port)},
		// Auth: clickhouse.Auth{
		// 	Database: "default",
		// 	Username: "default",
		// 	Password: "",
		// },
		Settings: clickhouse.Settings{
			"max_execution_time": 1,
		},
		DialTimeout:          time.Second,
		MaxOpenConns:         1,
		MaxIdleConns:         1,
		ConnMaxLifetime:      time.Duration(1) * time.Minute,
		ConnOpenStrategy:     clickhouse.ConnOpenInOrder,
		BlockBufferSize:      10,
		MaxCompressionBuffer: 1024,
	})
	if err != nil {
		golog.Errorf("open %s:%d failed: %v", ip, port, err)
		return false
	}
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()
	err = conn.Ping(ctx)
	if err != nil {
		golog.Warnf("ping %s:%d failed: %v", ip, port, err)
		return false
	}
	return true
}

package main

import (
	"fmt"
	"io/fs"
	"log"
	"os"
)

func main() {
	// 创建一个表示当前目录的文件系统
	fsys := os.DirFS(".")
	// 打开一个文件
	f, err := fsys.Open("README.md")
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()
	// 读取文件内容
	data := make([]byte, 100)
	n, err := f.Read(data)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(data[:n]))
}

package main

import (
	"fmt"
	"io/fs"
	"log"
	"os"
)

func main() {
	fsys := os.DirFS(".")
	f, err := fsys.Open("README.md")
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()
	// 获取文件信息
	info, err := f.Stat()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("File size:", info.Size())
}

package main

import (
	"fmt"
	"io/fs"
	"log"
	"os"
)

func main() {
	fsys := os.DirFS(".")
	entries, err := fs.ReadDir(fsys, ".")
	if err != nil {
		log.Fatal(err)
	}
	for _, entry := range entries {
		fmt.Println("Name:", entry.Name())
		fmt.Println("Is directory:", entry.IsDir())
	}
}

package main

import (
	"fmt"
	"io/fs"
	"log"
	"os"
)

func main() {
	fsys := os.DirFS(".")
	if globFS, ok := fsys.(fs.GlobFS); ok {
		matches, err := globFS.Glob("*.go")
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println("Go files:", matches)
	}
}

package main

import (
	"fmt"
	"io/fs"
	"log"
	"os"
)

func main() {
	fsys := os.DirFS(".")
	if readDirFS, ok := fsys.(fs.ReadDirFS); ok {
		entries, err := readDirFS.ReadDir(".")
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println("Directory contents:")
		for _, entry := range entries {
			fmt.Println(entry.Name())
		}
	}
}

package main

import (
	"fmt"
	"io/fs"
	"log"
	"os"
)

func main() {
	fsys := os.DirFS(".")
	if subFS, ok := fsys.(fs.SubFS); ok {
		sub, err := subFS.Sub("subdir")
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println("Sub directory contents:")
		entries, err := fs.ReadDir(sub, ".")
		if err != nil {
			log.Fatal(err)
		}
		for _, entry := range entries {
			fmt.Println(entry.Name())
		}
	}
}

package main

import (
	"fmt"
	"io/fs"
	"log"
	"os"
)

func main() {
	fsys := os.DirFS(".")
	err := fs.WalkDir(fsys, ".", func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}
		fmt.Println("Walking:", path)
		return nil
	})
	if err != nil {
		log.Fatal(err)
	}
}

package main

import (
	"fmt"
	"io/fs"
	"log"
	"os"
	"testing/fstest"
)

func main() {
	// 创建一个内存文件系统
	fsys := fstest.MapFS{
		"file1.txt": {Data: []byte("Hello, world!")},
		"dir1/file2.txt": {Data: []byte("This is file2.")},
	}
	// 打开一个文件
	f, err := fsys.Open("file1.txt")
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()
	// 读取文件内容
	data := make([]byte, 100)
	n, err := f.Read(data)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(data[:n]))
    // 遍历文件系统
    err = fs.WalkDir(fsys, ".", func(path string, d fs.DirEntry, err error) error {
        if err != nil {
            return err
        }
        fmt.Println("Walking:", path)
        return nil
    })
    if err != nil {
        log.Fatal(err)
    }
}

package main

import (
	"fmt"
	"io/fs"
	"github.com/psanford/memfs"
)

func main() {
	rootFS := memfs.New()
	err := rootFS.MkdirAll("dir1/dir2", 0777)
	if err != nil {
		panic(err)
	}
	err = rootFS.WriteFile("dir1/dir2/f1.txt", []byte("incinerating-unsubstantial"), 0755)
	if err != nil {
		panic(err)
	}
	err = fs.WalkDir(rootFS, ".", func(path string, d fs.DirEntry, err error) error {
		fmt.Println(path)
		return nil
	})
	if err != nil {
		panic(err)
	}
	content, err := fs.ReadFile(rootFS, "dir1/dir2/f1.txt")
	if err != nil {
		panic(err)
	}
	fmt.Printf("%s\n", content)
}

package main

import (
	"embed"
	"fmt"
	"io/fs"
	"log"
)
//go:embed static

var staticFiles embed.FS

func main() {
	// 打开一个嵌入的文件
	f, err := staticFiles.Open("static/file1.txt")
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()
	// 读取文件内容
	data := make([]byte, 100)
	n, err := f.Read(data)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(data[:n]))
    // 遍历嵌入式文件系统
    err = fs.WalkDir(staticFiles, "static", func(path string, d fs.DirEntry, err error) error {
        if err != nil {
            return err
        }
        fmt.Println("Walking:", path)
        return nil
    })
    if err != nil {
        log.Fatal(err)
    }
}

package main

import (
	"context"
	"fmt"
	"io/fs"
	"log"
	"gocloud.dev/blob"
	_ "gocloud.dev/blob/gcs" // 引入 GCS 驱动，如果使用其他云存储服务，请引入相应的驱动
)

func main() {
	// 设置 S3 存储桶 URL
	bucketURL := "gs://my-bucket"
	// 创建一个 blob.Bucket
	bucket, err := blob.OpenBucket(context.Background(), bucketURL)
	if err != nil {
		log.Fatal(err)
	}
	defer bucket.Close()
	// 创建一个 fs.FS
	fsys := blob.NewFS(bucket)
	// 现在可以使用 fsys 进行文件操作
	err = fs.WalkDir(fsys, ".", func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}
		fmt.Println("Walking:", path)
		return nil
	})
	if err != nil {
		log.Fatal(err)
	}
}

package main

import (
	"flag"
	"time"
	"github.com/kataras/golog"
)

var (
	protocol = flag.String("p", "icmp", "The protocol to use (icmp, tcp or udp)")
)
// 嵌入ip.sh

func main() {
	flag.Parse()
	input := make(chan []string, 1024)
	output := make(chan string, 1024)
	scanner := NewICMPScanner(input, output)
	var total int
	var alive int
	golog.Infof("start scanning")
	start := time.Now()
	// 将待探测的IP发送给send goroutine
	go func() {
		lines := readIPList()
		for _, line := range lines {
			ips := cidr2IPList(line)
			input <- ips
			total += len(ips)
		}
		close(input)
	}()
	// 启动 send goroutine
	scanner.Scan()
	// 接收 send goroutine 发送的结果, 直到发送之后5秒结束
	for ip := range output {
		golog.Infof("%s is alive", ip)
		alive++
	}
	golog.Infof("total: %d, alive: %d, time: %v", total, alive, time.Since(start))
}

go func() {
	lines := readIPList()
	for _, line := range lines {
		ips := cidr2IPList(line)
		input <- ips
		total += len(ips)
	}
	close(input)
}()

type ICMPScanner struct {
	src net.IP
	input  chan []string
	output chan string
}
// 调大缓存区
// sysctl net.core.rmem_max
// sysctl net.core.wmem_max

func NewICMPScanner(input chan []string, output chan string) *ICMPScanner {
	localIP := getLocalIP()
	s := &ICMPScanner{
		input:  input,
		output: output,
		src:    net.ParseIP(localIP),
	}
	return s
}

func (s *ICMPScanner) Scan() {
	go s.recv()
	go s.send(s.input)
}

// send sends a single ICMP echo request packet for each ip in the input channel.

func (s *ICMPScanner) send(input chan []string) error {
	defer func() {
		time.Sleep(5 * time.Second)
		close(s.output)
		golog.Infof("send goroutine exit")
	}()
	id := os.Getpid() & 0xffff
	// 创建 ICMP 连接
	conn, err := icmp.ListenPacket("ip4:icmp", s.src.String())
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()
	// 不负责接收数据
	filter := createEmptyFilter()
	if assembled, err := bpf.Assemble(filter); err == nil {
		conn.IPv4PacketConn().SetBPF(assembled)
	}
    ... // 先忽略，后面再介绍
	return nil
}

seq := uint16(0)

for ips := range input {
	for _, ip := range ips {
		dst, err := net.ResolveIPAddr("ip", ip)
		if err != nil {
			golog.Fatalf("failed to resolve IP address: %v", err)
		}
		// 构造 ICMP 报文
		msg := &icmp.Message{
			Type: ipv4.ICMPTypeEcho,
			Code: 0,
			Body: &icmp.Echo{
				ID:   id,
				Seq:  int(seq),
				Data: []byte("Hello, are you there!"),
			},
		}
		msgBytes, err := msg.Marshal(nil)
		if err != nil {
			golog.Errorf("failed to marshal ICMP message: %v", err)
		}
		// 发送 ICMP 报文
		_, err = conn.WriteTo(msgBytes, dst)
		if err != nil {
			golog.Errorf("failed to send ICMP message: %v", err)
		}
		seq++
	}
}

func (s *ICMPScanner) recv() error {
	defer recover()
	id := os.Getpid() & 0xffff
	// 创建 ICMP 连接
	conn, err := icmp.ListenPacket("ip4:icmp", "0.0.0.0")
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()
	// 接收 ICMP 报文
	reply := make([]byte, 1500)
	for {
		n, peer, err := conn.ReadFrom(reply)
		if err != nil {
			log.Fatal(err)
		}
		// 解析 ICMP 报文
		msg, err := icmp.ParseMessage(protocolICMP, reply[:n])
		if err != nil {
			golog.Errorf("failed to parse ICMP message: %v", err)
			continue
		}
		// 打印结果
		switch msg.Type {
		case ipv4.ICMPTypeEchoReply:
			echoReply, ok := msg.Body.(*icmp.Echo)
			if !ok {
				continue
			}
			if echoReply.ID == id {
				s.output <- peer.String()
			}
		}
	}
}

// A timers is a per-P set of timers.

type timers struct {
    // 互斥锁保护timers; 虽然timers是每个P的，但是调度器可以访问另一个P的timers，所以我们必须锁定。
	mu mutex
    // heap是一组计时器，按heap[i].when排序。这就是一个四叉堆，虽然没有明确的说明。
    // 必须持有锁才能访问这个堆。
	heap []timerWhen
    // len是heap的长度的原子副本。
	len atomic.Uint32
    // zombies是堆中标记为删除的计时器的数量。
	zombies atomic.Int32
	raceCtx uintptr
    // minWhenHeap是最小的heap[i].when值(= heap[0].when)。
    // wakeTime方法使用minWhenHeap和minWhenModified来确定下一个唤醒时间。
    // 如果minWhenHeap = 0，表示堆中没有计时器。
	minWhenHeap atomic.Int64
    // minWhenModified是具有timerModified位设置的计时器的最小heap[i].when的下界。
    // 如果minWhenModified = 0，表示堆中没有timerModified计时器。
	minWhenModified atomic.Int64
}

type timerWhen struct {
	timer *timer
	when  int64
}

func (ts *timers) lock() {
	lock(&ts.mu)
}

func (ts *timers) unlock() {
	ts.len.Store(uint32(len(ts.heap)))
	unlock(&ts.mu)
}

type timer struct {
	mu mutex
	astate atomic.Uint8 
	state  uint8       
	isChan bool       
	blocked uint32
	when   int64
	period int64
	f      func(arg any, seq uintptr, delay int64)
	arg    any
	seq    uintptr
	ts *timers // 注意这里
	sendLock mutex
	isSending atomic.Int32
}

const timerHeapN = 4

// siftUp将位置i的计时器在堆中合适的位置，通过将其向堆的顶部移动。

func (ts *timers) siftUp(i int) {
	heap := ts.heap
	if i >= len(heap) {
		badTimer()
	}
    // 注意下面两行我们保存了当前i的计时器和它的when值
	tw := heap[i] 
	when := tw.when
	if when <= 0 {
		badTimer()
	}
	for i > 0 {
		p := int(uint(i-1) / timerHeapN) // 父节点 (i-1)/4
		if when >= heap[p].when { // 如果父节点的when <= 当前节点的when，那么就不需要再上浮了
			break
		}
		heap[i] = heap[p] // 父节点下沉到当前的i
		i = p // i指向父节点, 继续循环上浮检查
	}
    // 如果发生了上浮，那么最后将tw放到上浮到的合适位置
	if heap[i].timer != tw.timer {
		heap[i] = tw
	}
}

// siftDown将位置i的计时器放在堆中的正确位置，通过将其向堆的底部移动。

func (ts *timers) siftDown(i int) {
	heap := ts.heap
	n := len(heap)
	if i >= n {
		badTimer()
	}
    // 如果已经是叶子节点，不用下沉了
	if i*timerHeapN+1 >= n {
		return
	}
    // 保存当前i的计时器和when值
	tw := heap[i]
	when := tw.when
	if when <= 0 {
		badTimer()
	}
    // 从左子节点开始，找到最小的when值，然后将当前节点下沉到这个位置
	for {
		leftChild := i*timerHeapN + 1 // 左子节点
		if leftChild >= n {
			break
		}
		w := when
		c := -1
		for j, tw := range heap[leftChild:min(leftChild+timerHeapN, n)] { // 从左子节点开始遍历子节点,找到小于当前w的最小的子节点
			if tw.when < w {
				w = tw.when
				c = leftChild + j
			}
		}
		if c < 0 { // 如果没有找到比当前节点更小的子节点，那么就不用下沉了
			break
		}
        // 将当前节点下沉到最小的子节点
		heap[i] = heap[c]
		i = c
	}
    // 如果发生了下沉，那么最后将tw放到下沉到的合适位置
	if heap[i].timer != tw.timer {
		heap[i] = tw
	}
}

func (ts *timers) initHeap() {
	if len(ts.heap) <= 1 {
		return
	}
    
    // 从最后一个非叶子节点开始，依次下沉
	for i := int(uint(len(ts.heap)-1-1) / timerHeapN); i >= 0; i-- {
		ts.siftDown(i)
	}
}

func (ts *timers) deleteMin() {
    // 得到堆顶元素
	t := ts.heap[0].timer
	if t.ts != ts {
		throw("wrong timers")
	}
	t.ts = nil // 将timer的ts置为nil，自此和ts一别两宽，再无瓜葛
    // 将最后一个元素设置为堆顶
	last := len(ts.heap) - 1
	if last > 0 {
		ts.heap[0] = ts.heap[last]
	}
	ts.heap[last] = timerWhen{} // 将最后一个元素置为空
	ts.heap = ts.heap[:last] // 缩减slice,剔除最后的空元素
	if last > 0 { // 将堆顶元素下沉
		ts.siftDown(0)
	}
	ts.updateMinWhenHeap()
	if last == 0 {
		ts.minWhenModified.Store(0)
	}
}

func (ts *timers) addHeap(t *timer) {
	if netpollInited.Load() == 0 {
		netpollGenericInit()
	}
	if t.ts != nil {
		throw("ts set in timer")
	}
    // 设置timer的ts为当前的timers,从此执子之手，笑傲江湖
	t.ts = ts
    // 添加到最后
	ts.heap = append(ts.heap, timerWhen{t, t.when})
	ts.siftUp(len(ts.heap) - 1) // 上浮它到合适的位置
	if t == ts.heap[0].timer {
		ts.updateMinWhenHeap()
	}
}

import "github.com/ahrav/go-d-ary-heap"

package main

import (
    "fmt"
    "github.com/ahrav/go-d-ary-heap"
)

func main() {
    // Create a min-heap for integers with a branching factor of 3.
    minHeap := heap.NewHeap[int](3, func(a, b int) bool { return a < b })
    // Create a max-heap for integers with a branching factor of 4.
    maxHeap := heap.NewHeap[int](4, func(a, b int) bool { return a > b })
}

minHeap.Push(10)
minHeap.Push(5)
minHeap.Push(15)
maxHeap.Push(10)
maxHeap.Push(5)
maxHeap.Push(15)

fmt.Println(minHeap.Pop()) // Outputs: 5
fmt.Println(maxHeap.Pop()) // Outputs: 15

fmt.Println(minHeap.Peek()) // Assuming more elements were added, outputs the smallest
fmt.Println(maxHeap.Peek()) // Assuming more elements were added, outputs the largest

type Entry[K comparable, V, P any] struct {
	Key      K
	Value    V
	Priority P
	index    int
}

type heapmap[K comparable, V, P any] struct {
	h pq[K, V, P]
	m map[K]*Entry[K, V, P]
}

func (hm *heapmap[K, V, P]) Len() int {
	return len(hm.m)
}

func (hm *heapmap[K, V, P]) Peek() (Entry[K, V, P], bool) {
	if hm.Empty() {
		return Entry[K, V, P]{}, false
	}
	return *hm.h.entries[0], true
}

func (hm *heapmap[K, V, P]) Pop() (Entry[K, V, P], bool) {
	if hm.Empty() {
		return Entry[K, V, P]{}, false
	}
	e := *heap.Pop(&hm.h).(*Entry[K, V, P])
	delete(hm.m, e.Key)
	return e, true
}

func (hm *heapmap[K, V, P]) Set(key K, value V, priority P) {
	if e, ok := hm.m[key]; ok {
		e.Value = value
		e.Priority = priority
		heap.Fix(&hm.h, e.index)
		return
	}
	e := &Entry[K, V, P]{
		Key:      key,
		Value:    value,
		Priority: priority,
	}
	heap.Push(&hm.h, e)
	hm.m[key] = e
}

func (hm *heapmap[K, V, P]) Get(key K) (Entry[K, V, P], bool) {
	if e, ok := hm.m[key]; ok {
		return *e, true
	}
	return Entry[K, V, P]{}, false
}