package regalloc

import (
	
	
)

// NewRegSet returns a new RegSet with the given registers.
func ( ...RealReg) RegSet {
	var  RegSet
	for ,  := range  {
		 = .add()
	}
	return 
}

// RegSet represents a set of registers.
type RegSet uint64

func ( RegSet) ( *RegisterInfo) string { //nolint:unused
	var  []string
	for  := 0;  < 64; ++ {
		if &(1<<uint()) != 0 {
			 = append(, .RealRegName(RealReg()))
		}
	}
	return strings.Join(, ", ")
}

func ( RegSet) ( RealReg) bool {
	return &(1<<uint()) != 0
}

func ( RegSet) ( RealReg) RegSet {
	if  >= 64 {
		return 
	}
	return  | 1<<uint()
}

func ( RegSet) ( func( RealReg)) {
	for  := 0;  < 64; ++ {
		if &(1<<uint()) != 0 {
			(RealReg())
		}
	}
}

type regInUseSet[ Instr,  Block[],  Function[, ]] [64]*vrState[, , ]

func newRegInUseSet[ Instr,  Block[],  Function[, ]]() regInUseSet[, , ] {
	var  regInUseSet[, , ]
	.reset()
	return 
}

func ( *regInUseSet[, , ]) () {
	clear([:])
}

func ( *regInUseSet[, , ]) ( *RegisterInfo) string { //nolint:unused
	var  []string
	for ,  := range  {
		if  != nil {
			 = append(, fmt.Sprintf("(%s->v%d)", .RealRegName(RealReg()), .v.ID()))
		}
	}
	return strings.Join(, ", ")
}

func ( *regInUseSet[, , ]) ( RealReg) bool {
	return  < 64 && [] != nil
}

func ( *regInUseSet[, , ]) ( RealReg) *vrState[, , ] {
	return []
}

func ( *regInUseSet[, , ]) ( RealReg) {
	[] = nil
}

func ( *regInUseSet[, , ]) ( RealReg,  *vrState[, , ]) {
	if  >= 64 {
		return
	}
	[] = 
}

func ( *regInUseSet[, , ]) ( func( RealReg,  *vrState[, , ])) {
	for ,  := range  {
		if  != nil {
			(RealReg(), )
		}
	}
}