github.com/sandwich-go/boost@v1.3.29/xmap/walk.go

// Code generated by tools. DO NOT EDIT.
package xmap

import "sort"

var _ sort.Interface

// WalkFloat32Float32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat32Float32MapDeterministic(in map[float32]float32, walkFunc func(k float32, v float32) bool) {
	var keys = make([]float32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat32Float64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat32Float64MapDeterministic(in map[float32]float64, walkFunc func(k float32, v float64) bool) {
	var keys = make([]float32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat32IntMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat32IntMapDeterministic(in map[float32]int, walkFunc func(k float32, v int) bool) {
	var keys = make([]float32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat32Int16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat32Int16MapDeterministic(in map[float32]int16, walkFunc func(k float32, v int16) bool) {
	var keys = make([]float32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat32Int32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat32Int32MapDeterministic(in map[float32]int32, walkFunc func(k float32, v int32) bool) {
	var keys = make([]float32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat32Int64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat32Int64MapDeterministic(in map[float32]int64, walkFunc func(k float32, v int64) bool) {
	var keys = make([]float32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat32Int8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat32Int8MapDeterministic(in map[float32]int8, walkFunc func(k float32, v int8) bool) {
	var keys = make([]float32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat32InterfaceMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat32InterfaceMapDeterministic(in map[float32]interface{}, walkFunc func(k float32, v interface{}) bool) {
	var keys = make([]float32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat32StringMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat32StringMapDeterministic(in map[float32]string, walkFunc func(k float32, v string) bool) {
	var keys = make([]float32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat32UintMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat32UintMapDeterministic(in map[float32]uint, walkFunc func(k float32, v uint) bool) {
	var keys = make([]float32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat32Uint16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat32Uint16MapDeterministic(in map[float32]uint16, walkFunc func(k float32, v uint16) bool) {
	var keys = make([]float32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat32Uint32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat32Uint32MapDeterministic(in map[float32]uint32, walkFunc func(k float32, v uint32) bool) {
	var keys = make([]float32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat32Uint64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat32Uint64MapDeterministic(in map[float32]uint64, walkFunc func(k float32, v uint64) bool) {
	var keys = make([]float32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat32Uint8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat32Uint8MapDeterministic(in map[float32]uint8, walkFunc func(k float32, v uint8) bool) {
	var keys = make([]float32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat64Float32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat64Float32MapDeterministic(in map[float64]float32, walkFunc func(k float64, v float32) bool) {
	var keys = make([]float64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat64Float64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat64Float64MapDeterministic(in map[float64]float64, walkFunc func(k float64, v float64) bool) {
	var keys = make([]float64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat64IntMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat64IntMapDeterministic(in map[float64]int, walkFunc func(k float64, v int) bool) {
	var keys = make([]float64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat64Int16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat64Int16MapDeterministic(in map[float64]int16, walkFunc func(k float64, v int16) bool) {
	var keys = make([]float64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat64Int32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat64Int32MapDeterministic(in map[float64]int32, walkFunc func(k float64, v int32) bool) {
	var keys = make([]float64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat64Int64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat64Int64MapDeterministic(in map[float64]int64, walkFunc func(k float64, v int64) bool) {
	var keys = make([]float64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat64Int8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat64Int8MapDeterministic(in map[float64]int8, walkFunc func(k float64, v int8) bool) {
	var keys = make([]float64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat64InterfaceMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat64InterfaceMapDeterministic(in map[float64]interface{}, walkFunc func(k float64, v interface{}) bool) {
	var keys = make([]float64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat64StringMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat64StringMapDeterministic(in map[float64]string, walkFunc func(k float64, v string) bool) {
	var keys = make([]float64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat64UintMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat64UintMapDeterministic(in map[float64]uint, walkFunc func(k float64, v uint) bool) {
	var keys = make([]float64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat64Uint16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat64Uint16MapDeterministic(in map[float64]uint16, walkFunc func(k float64, v uint16) bool) {
	var keys = make([]float64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat64Uint32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat64Uint32MapDeterministic(in map[float64]uint32, walkFunc func(k float64, v uint32) bool) {
	var keys = make([]float64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat64Uint64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat64Uint64MapDeterministic(in map[float64]uint64, walkFunc func(k float64, v uint64) bool) {
	var keys = make([]float64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkFloat64Uint8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkFloat64Uint8MapDeterministic(in map[float64]uint8, walkFunc func(k float64, v uint8) bool) {
	var keys = make([]float64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkIntFloat32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkIntFloat32MapDeterministic(in map[int]float32, walkFunc func(k int, v float32) bool) {
	var keys = make([]int, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Ints(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkIntFloat64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkIntFloat64MapDeterministic(in map[int]float64, walkFunc func(k int, v float64) bool) {
	var keys = make([]int, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Ints(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkIntIntMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkIntIntMapDeterministic(in map[int]int, walkFunc func(k int, v int) bool) {
	var keys = make([]int, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Ints(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkIntInt16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkIntInt16MapDeterministic(in map[int]int16, walkFunc func(k int, v int16) bool) {
	var keys = make([]int, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Ints(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkIntInt32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkIntInt32MapDeterministic(in map[int]int32, walkFunc func(k int, v int32) bool) {
	var keys = make([]int, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Ints(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkIntInt64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkIntInt64MapDeterministic(in map[int]int64, walkFunc func(k int, v int64) bool) {
	var keys = make([]int, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Ints(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkIntInt8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkIntInt8MapDeterministic(in map[int]int8, walkFunc func(k int, v int8) bool) {
	var keys = make([]int, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Ints(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkIntInterfaceMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkIntInterfaceMapDeterministic(in map[int]interface{}, walkFunc func(k int, v interface{}) bool) {
	var keys = make([]int, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Ints(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkIntStringMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkIntStringMapDeterministic(in map[int]string, walkFunc func(k int, v string) bool) {
	var keys = make([]int, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Ints(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkIntUintMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkIntUintMapDeterministic(in map[int]uint, walkFunc func(k int, v uint) bool) {
	var keys = make([]int, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Ints(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkIntUint16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkIntUint16MapDeterministic(in map[int]uint16, walkFunc func(k int, v uint16) bool) {
	var keys = make([]int, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Ints(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkIntUint32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkIntUint32MapDeterministic(in map[int]uint32, walkFunc func(k int, v uint32) bool) {
	var keys = make([]int, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Ints(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkIntUint64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkIntUint64MapDeterministic(in map[int]uint64, walkFunc func(k int, v uint64) bool) {
	var keys = make([]int, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Ints(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkIntUint8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkIntUint8MapDeterministic(in map[int]uint8, walkFunc func(k int, v uint8) bool) {
	var keys = make([]int, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Ints(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt16Float32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt16Float32MapDeterministic(in map[int16]float32, walkFunc func(k int16, v float32) bool) {
	var keys = make([]int16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt16Float64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt16Float64MapDeterministic(in map[int16]float64, walkFunc func(k int16, v float64) bool) {
	var keys = make([]int16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt16IntMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt16IntMapDeterministic(in map[int16]int, walkFunc func(k int16, v int) bool) {
	var keys = make([]int16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt16Int16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt16Int16MapDeterministic(in map[int16]int16, walkFunc func(k int16, v int16) bool) {
	var keys = make([]int16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt16Int32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt16Int32MapDeterministic(in map[int16]int32, walkFunc func(k int16, v int32) bool) {
	var keys = make([]int16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt16Int64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt16Int64MapDeterministic(in map[int16]int64, walkFunc func(k int16, v int64) bool) {
	var keys = make([]int16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt16Int8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt16Int8MapDeterministic(in map[int16]int8, walkFunc func(k int16, v int8) bool) {
	var keys = make([]int16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt16InterfaceMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt16InterfaceMapDeterministic(in map[int16]interface{}, walkFunc func(k int16, v interface{}) bool) {
	var keys = make([]int16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt16StringMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt16StringMapDeterministic(in map[int16]string, walkFunc func(k int16, v string) bool) {
	var keys = make([]int16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt16UintMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt16UintMapDeterministic(in map[int16]uint, walkFunc func(k int16, v uint) bool) {
	var keys = make([]int16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt16Uint16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt16Uint16MapDeterministic(in map[int16]uint16, walkFunc func(k int16, v uint16) bool) {
	var keys = make([]int16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt16Uint32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt16Uint32MapDeterministic(in map[int16]uint32, walkFunc func(k int16, v uint32) bool) {
	var keys = make([]int16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt16Uint64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt16Uint64MapDeterministic(in map[int16]uint64, walkFunc func(k int16, v uint64) bool) {
	var keys = make([]int16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt16Uint8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt16Uint8MapDeterministic(in map[int16]uint8, walkFunc func(k int16, v uint8) bool) {
	var keys = make([]int16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt32Float32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt32Float32MapDeterministic(in map[int32]float32, walkFunc func(k int32, v float32) bool) {
	var keys = make([]int32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt32Float64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt32Float64MapDeterministic(in map[int32]float64, walkFunc func(k int32, v float64) bool) {
	var keys = make([]int32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt32IntMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt32IntMapDeterministic(in map[int32]int, walkFunc func(k int32, v int) bool) {
	var keys = make([]int32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt32Int16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt32Int16MapDeterministic(in map[int32]int16, walkFunc func(k int32, v int16) bool) {
	var keys = make([]int32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt32Int32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt32Int32MapDeterministic(in map[int32]int32, walkFunc func(k int32, v int32) bool) {
	var keys = make([]int32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt32Int64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt32Int64MapDeterministic(in map[int32]int64, walkFunc func(k int32, v int64) bool) {
	var keys = make([]int32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt32Int8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt32Int8MapDeterministic(in map[int32]int8, walkFunc func(k int32, v int8) bool) {
	var keys = make([]int32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt32InterfaceMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt32InterfaceMapDeterministic(in map[int32]interface{}, walkFunc func(k int32, v interface{}) bool) {
	var keys = make([]int32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt32StringMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt32StringMapDeterministic(in map[int32]string, walkFunc func(k int32, v string) bool) {
	var keys = make([]int32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt32UintMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt32UintMapDeterministic(in map[int32]uint, walkFunc func(k int32, v uint) bool) {
	var keys = make([]int32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt32Uint16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt32Uint16MapDeterministic(in map[int32]uint16, walkFunc func(k int32, v uint16) bool) {
	var keys = make([]int32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt32Uint32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt32Uint32MapDeterministic(in map[int32]uint32, walkFunc func(k int32, v uint32) bool) {
	var keys = make([]int32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt32Uint64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt32Uint64MapDeterministic(in map[int32]uint64, walkFunc func(k int32, v uint64) bool) {
	var keys = make([]int32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt32Uint8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt32Uint8MapDeterministic(in map[int32]uint8, walkFunc func(k int32, v uint8) bool) {
	var keys = make([]int32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt64Float32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt64Float32MapDeterministic(in map[int64]float32, walkFunc func(k int64, v float32) bool) {
	var keys = make([]int64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt64Float64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt64Float64MapDeterministic(in map[int64]float64, walkFunc func(k int64, v float64) bool) {
	var keys = make([]int64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt64IntMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt64IntMapDeterministic(in map[int64]int, walkFunc func(k int64, v int) bool) {
	var keys = make([]int64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt64Int16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt64Int16MapDeterministic(in map[int64]int16, walkFunc func(k int64, v int16) bool) {
	var keys = make([]int64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt64Int32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt64Int32MapDeterministic(in map[int64]int32, walkFunc func(k int64, v int32) bool) {
	var keys = make([]int64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt64Int64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt64Int64MapDeterministic(in map[int64]int64, walkFunc func(k int64, v int64) bool) {
	var keys = make([]int64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt64Int8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt64Int8MapDeterministic(in map[int64]int8, walkFunc func(k int64, v int8) bool) {
	var keys = make([]int64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt64InterfaceMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt64InterfaceMapDeterministic(in map[int64]interface{}, walkFunc func(k int64, v interface{}) bool) {
	var keys = make([]int64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt64StringMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt64StringMapDeterministic(in map[int64]string, walkFunc func(k int64, v string) bool) {
	var keys = make([]int64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt64UintMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt64UintMapDeterministic(in map[int64]uint, walkFunc func(k int64, v uint) bool) {
	var keys = make([]int64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt64Uint16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt64Uint16MapDeterministic(in map[int64]uint16, walkFunc func(k int64, v uint16) bool) {
	var keys = make([]int64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt64Uint32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt64Uint32MapDeterministic(in map[int64]uint32, walkFunc func(k int64, v uint32) bool) {
	var keys = make([]int64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt64Uint64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt64Uint64MapDeterministic(in map[int64]uint64, walkFunc func(k int64, v uint64) bool) {
	var keys = make([]int64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt64Uint8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt64Uint8MapDeterministic(in map[int64]uint8, walkFunc func(k int64, v uint8) bool) {
	var keys = make([]int64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt8Float32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt8Float32MapDeterministic(in map[int8]float32, walkFunc func(k int8, v float32) bool) {
	var keys = make([]int8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt8Float64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt8Float64MapDeterministic(in map[int8]float64, walkFunc func(k int8, v float64) bool) {
	var keys = make([]int8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt8IntMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt8IntMapDeterministic(in map[int8]int, walkFunc func(k int8, v int) bool) {
	var keys = make([]int8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt8Int16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt8Int16MapDeterministic(in map[int8]int16, walkFunc func(k int8, v int16) bool) {
	var keys = make([]int8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt8Int32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt8Int32MapDeterministic(in map[int8]int32, walkFunc func(k int8, v int32) bool) {
	var keys = make([]int8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt8Int64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt8Int64MapDeterministic(in map[int8]int64, walkFunc func(k int8, v int64) bool) {
	var keys = make([]int8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt8Int8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt8Int8MapDeterministic(in map[int8]int8, walkFunc func(k int8, v int8) bool) {
	var keys = make([]int8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt8InterfaceMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt8InterfaceMapDeterministic(in map[int8]interface{}, walkFunc func(k int8, v interface{}) bool) {
	var keys = make([]int8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt8StringMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt8StringMapDeterministic(in map[int8]string, walkFunc func(k int8, v string) bool) {
	var keys = make([]int8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt8UintMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt8UintMapDeterministic(in map[int8]uint, walkFunc func(k int8, v uint) bool) {
	var keys = make([]int8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt8Uint16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt8Uint16MapDeterministic(in map[int8]uint16, walkFunc func(k int8, v uint16) bool) {
	var keys = make([]int8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt8Uint32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt8Uint32MapDeterministic(in map[int8]uint32, walkFunc func(k int8, v uint32) bool) {
	var keys = make([]int8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt8Uint64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt8Uint64MapDeterministic(in map[int8]uint64, walkFunc func(k int8, v uint64) bool) {
	var keys = make([]int8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkInt8Uint8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkInt8Uint8MapDeterministic(in map[int8]uint8, walkFunc func(k int8, v uint8) bool) {
	var keys = make([]int8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkStringFloat32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkStringFloat32MapDeterministic(in map[string]float32, walkFunc func(k string, v float32) bool) {
	var keys = make([]string, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkStringFloat64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkStringFloat64MapDeterministic(in map[string]float64, walkFunc func(k string, v float64) bool) {
	var keys = make([]string, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkStringIntMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkStringIntMapDeterministic(in map[string]int, walkFunc func(k string, v int) bool) {
	var keys = make([]string, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkStringInt16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkStringInt16MapDeterministic(in map[string]int16, walkFunc func(k string, v int16) bool) {
	var keys = make([]string, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkStringInt32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkStringInt32MapDeterministic(in map[string]int32, walkFunc func(k string, v int32) bool) {
	var keys = make([]string, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkStringInt64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkStringInt64MapDeterministic(in map[string]int64, walkFunc func(k string, v int64) bool) {
	var keys = make([]string, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkStringInt8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkStringInt8MapDeterministic(in map[string]int8, walkFunc func(k string, v int8) bool) {
	var keys = make([]string, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkStringInterfaceMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkStringInterfaceMapDeterministic(in map[string]interface{}, walkFunc func(k string, v interface{}) bool) {
	var keys = make([]string, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkStringStringMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkStringStringMapDeterministic(in map[string]string, walkFunc func(k string, v string) bool) {
	var keys = make([]string, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkStringUintMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkStringUintMapDeterministic(in map[string]uint, walkFunc func(k string, v uint) bool) {
	var keys = make([]string, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkStringUint16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkStringUint16MapDeterministic(in map[string]uint16, walkFunc func(k string, v uint16) bool) {
	var keys = make([]string, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkStringUint32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkStringUint32MapDeterministic(in map[string]uint32, walkFunc func(k string, v uint32) bool) {
	var keys = make([]string, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkStringUint64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkStringUint64MapDeterministic(in map[string]uint64, walkFunc func(k string, v uint64) bool) {
	var keys = make([]string, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkStringUint8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkStringUint8MapDeterministic(in map[string]uint8, walkFunc func(k string, v uint8) bool) {
	var keys = make([]string, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUintFloat32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUintFloat32MapDeterministic(in map[uint]float32, walkFunc func(k uint, v float32) bool) {
	var keys = make([]uint, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUintFloat64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUintFloat64MapDeterministic(in map[uint]float64, walkFunc func(k uint, v float64) bool) {
	var keys = make([]uint, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUintIntMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUintIntMapDeterministic(in map[uint]int, walkFunc func(k uint, v int) bool) {
	var keys = make([]uint, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUintInt16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUintInt16MapDeterministic(in map[uint]int16, walkFunc func(k uint, v int16) bool) {
	var keys = make([]uint, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUintInt32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUintInt32MapDeterministic(in map[uint]int32, walkFunc func(k uint, v int32) bool) {
	var keys = make([]uint, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUintInt64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUintInt64MapDeterministic(in map[uint]int64, walkFunc func(k uint, v int64) bool) {
	var keys = make([]uint, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUintInt8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUintInt8MapDeterministic(in map[uint]int8, walkFunc func(k uint, v int8) bool) {
	var keys = make([]uint, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUintInterfaceMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUintInterfaceMapDeterministic(in map[uint]interface{}, walkFunc func(k uint, v interface{}) bool) {
	var keys = make([]uint, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUintStringMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUintStringMapDeterministic(in map[uint]string, walkFunc func(k uint, v string) bool) {
	var keys = make([]uint, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUintUintMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUintUintMapDeterministic(in map[uint]uint, walkFunc func(k uint, v uint) bool) {
	var keys = make([]uint, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUintUint16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUintUint16MapDeterministic(in map[uint]uint16, walkFunc func(k uint, v uint16) bool) {
	var keys = make([]uint, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUintUint32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUintUint32MapDeterministic(in map[uint]uint32, walkFunc func(k uint, v uint32) bool) {
	var keys = make([]uint, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUintUint64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUintUint64MapDeterministic(in map[uint]uint64, walkFunc func(k uint, v uint64) bool) {
	var keys = make([]uint, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUintUint8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUintUint8MapDeterministic(in map[uint]uint8, walkFunc func(k uint, v uint8) bool) {
	var keys = make([]uint, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint16Float32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint16Float32MapDeterministic(in map[uint16]float32, walkFunc func(k uint16, v float32) bool) {
	var keys = make([]uint16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint16Float64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint16Float64MapDeterministic(in map[uint16]float64, walkFunc func(k uint16, v float64) bool) {
	var keys = make([]uint16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint16IntMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint16IntMapDeterministic(in map[uint16]int, walkFunc func(k uint16, v int) bool) {
	var keys = make([]uint16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint16Int16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint16Int16MapDeterministic(in map[uint16]int16, walkFunc func(k uint16, v int16) bool) {
	var keys = make([]uint16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint16Int32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint16Int32MapDeterministic(in map[uint16]int32, walkFunc func(k uint16, v int32) bool) {
	var keys = make([]uint16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint16Int64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint16Int64MapDeterministic(in map[uint16]int64, walkFunc func(k uint16, v int64) bool) {
	var keys = make([]uint16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint16Int8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint16Int8MapDeterministic(in map[uint16]int8, walkFunc func(k uint16, v int8) bool) {
	var keys = make([]uint16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint16InterfaceMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint16InterfaceMapDeterministic(in map[uint16]interface{}, walkFunc func(k uint16, v interface{}) bool) {
	var keys = make([]uint16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint16StringMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint16StringMapDeterministic(in map[uint16]string, walkFunc func(k uint16, v string) bool) {
	var keys = make([]uint16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint16UintMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint16UintMapDeterministic(in map[uint16]uint, walkFunc func(k uint16, v uint) bool) {
	var keys = make([]uint16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint16Uint16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint16Uint16MapDeterministic(in map[uint16]uint16, walkFunc func(k uint16, v uint16) bool) {
	var keys = make([]uint16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint16Uint32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint16Uint32MapDeterministic(in map[uint16]uint32, walkFunc func(k uint16, v uint32) bool) {
	var keys = make([]uint16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint16Uint64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint16Uint64MapDeterministic(in map[uint16]uint64, walkFunc func(k uint16, v uint64) bool) {
	var keys = make([]uint16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint16Uint8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint16Uint8MapDeterministic(in map[uint16]uint8, walkFunc func(k uint16, v uint8) bool) {
	var keys = make([]uint16, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint32Float32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint32Float32MapDeterministic(in map[uint32]float32, walkFunc func(k uint32, v float32) bool) {
	var keys = make([]uint32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint32Float64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint32Float64MapDeterministic(in map[uint32]float64, walkFunc func(k uint32, v float64) bool) {
	var keys = make([]uint32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint32IntMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint32IntMapDeterministic(in map[uint32]int, walkFunc func(k uint32, v int) bool) {
	var keys = make([]uint32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint32Int16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint32Int16MapDeterministic(in map[uint32]int16, walkFunc func(k uint32, v int16) bool) {
	var keys = make([]uint32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint32Int32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint32Int32MapDeterministic(in map[uint32]int32, walkFunc func(k uint32, v int32) bool) {
	var keys = make([]uint32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint32Int64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint32Int64MapDeterministic(in map[uint32]int64, walkFunc func(k uint32, v int64) bool) {
	var keys = make([]uint32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint32Int8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint32Int8MapDeterministic(in map[uint32]int8, walkFunc func(k uint32, v int8) bool) {
	var keys = make([]uint32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint32InterfaceMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint32InterfaceMapDeterministic(in map[uint32]interface{}, walkFunc func(k uint32, v interface{}) bool) {
	var keys = make([]uint32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint32StringMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint32StringMapDeterministic(in map[uint32]string, walkFunc func(k uint32, v string) bool) {
	var keys = make([]uint32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint32UintMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint32UintMapDeterministic(in map[uint32]uint, walkFunc func(k uint32, v uint) bool) {
	var keys = make([]uint32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint32Uint16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint32Uint16MapDeterministic(in map[uint32]uint16, walkFunc func(k uint32, v uint16) bool) {
	var keys = make([]uint32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint32Uint32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint32Uint32MapDeterministic(in map[uint32]uint32, walkFunc func(k uint32, v uint32) bool) {
	var keys = make([]uint32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint32Uint64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint32Uint64MapDeterministic(in map[uint32]uint64, walkFunc func(k uint32, v uint64) bool) {
	var keys = make([]uint32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint32Uint8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint32Uint8MapDeterministic(in map[uint32]uint8, walkFunc func(k uint32, v uint8) bool) {
	var keys = make([]uint32, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint64Float32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint64Float32MapDeterministic(in map[uint64]float32, walkFunc func(k uint64, v float32) bool) {
	var keys = make([]uint64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint64Float64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint64Float64MapDeterministic(in map[uint64]float64, walkFunc func(k uint64, v float64) bool) {
	var keys = make([]uint64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint64IntMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint64IntMapDeterministic(in map[uint64]int, walkFunc func(k uint64, v int) bool) {
	var keys = make([]uint64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint64Int16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint64Int16MapDeterministic(in map[uint64]int16, walkFunc func(k uint64, v int16) bool) {
	var keys = make([]uint64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint64Int32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint64Int32MapDeterministic(in map[uint64]int32, walkFunc func(k uint64, v int32) bool) {
	var keys = make([]uint64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint64Int64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint64Int64MapDeterministic(in map[uint64]int64, walkFunc func(k uint64, v int64) bool) {
	var keys = make([]uint64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint64Int8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint64Int8MapDeterministic(in map[uint64]int8, walkFunc func(k uint64, v int8) bool) {
	var keys = make([]uint64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint64InterfaceMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint64InterfaceMapDeterministic(in map[uint64]interface{}, walkFunc func(k uint64, v interface{}) bool) {
	var keys = make([]uint64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint64StringMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint64StringMapDeterministic(in map[uint64]string, walkFunc func(k uint64, v string) bool) {
	var keys = make([]uint64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint64UintMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint64UintMapDeterministic(in map[uint64]uint, walkFunc func(k uint64, v uint) bool) {
	var keys = make([]uint64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint64Uint16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint64Uint16MapDeterministic(in map[uint64]uint16, walkFunc func(k uint64, v uint16) bool) {
	var keys = make([]uint64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint64Uint32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint64Uint32MapDeterministic(in map[uint64]uint32, walkFunc func(k uint64, v uint32) bool) {
	var keys = make([]uint64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint64Uint64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint64Uint64MapDeterministic(in map[uint64]uint64, walkFunc func(k uint64, v uint64) bool) {
	var keys = make([]uint64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint64Uint8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint64Uint8MapDeterministic(in map[uint64]uint8, walkFunc func(k uint64, v uint8) bool) {
	var keys = make([]uint64, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint8Float32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint8Float32MapDeterministic(in map[uint8]float32, walkFunc func(k uint8, v float32) bool) {
	var keys = make([]uint8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint8Float64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint8Float64MapDeterministic(in map[uint8]float64, walkFunc func(k uint8, v float64) bool) {
	var keys = make([]uint8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint8IntMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint8IntMapDeterministic(in map[uint8]int, walkFunc func(k uint8, v int) bool) {
	var keys = make([]uint8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint8Int16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint8Int16MapDeterministic(in map[uint8]int16, walkFunc func(k uint8, v int16) bool) {
	var keys = make([]uint8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint8Int32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint8Int32MapDeterministic(in map[uint8]int32, walkFunc func(k uint8, v int32) bool) {
	var keys = make([]uint8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint8Int64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint8Int64MapDeterministic(in map[uint8]int64, walkFunc func(k uint8, v int64) bool) {
	var keys = make([]uint8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint8Int8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint8Int8MapDeterministic(in map[uint8]int8, walkFunc func(k uint8, v int8) bool) {
	var keys = make([]uint8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint8InterfaceMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint8InterfaceMapDeterministic(in map[uint8]interface{}, walkFunc func(k uint8, v interface{}) bool) {
	var keys = make([]uint8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint8StringMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint8StringMapDeterministic(in map[uint8]string, walkFunc func(k uint8, v string) bool) {
	var keys = make([]uint8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint8UintMapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint8UintMapDeterministic(in map[uint8]uint, walkFunc func(k uint8, v uint) bool) {
	var keys = make([]uint8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint8Uint16MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint8Uint16MapDeterministic(in map[uint8]uint16, walkFunc func(k uint8, v uint16) bool) {
	var keys = make([]uint8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint8Uint32MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint8Uint32MapDeterministic(in map[uint8]uint32, walkFunc func(k uint8, v uint32) bool) {
	var keys = make([]uint8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint8Uint64MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint8Uint64MapDeterministic(in map[uint8]uint64, walkFunc func(k uint8, v uint64) bool) {
	var keys = make([]uint8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}

// WalkUint8Uint8MapDeterministic 有序遍历map
// walkFunc 函数返回 false，停止遍历
func WalkUint8Uint8MapDeterministic(in map[uint8]uint8, walkFunc func(k uint8, v uint8) bool) {
	var keys = make([]uint8, 0, len(in))
	for k := range in {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		if walkFunc(k, in[k]) {
			continue
		}
		break
	}
}