func FilterMapInt64Uint32PtrErr(fFilter func(*int64) (bool, error), fMap func(*int64) (*uint32, error), list []*int64) ([]*uint32, error) {
	if fFilter == nil || fMap == nil {
		return []*uint32{}, nil
	}
	var newList []*uint32
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
FilterMapInt64Uint32PtrErr filters given list, then apply function(2nd argument) on each item in the list and returns a new list, error
Takes 3 inputs
1. Function: takes one input type - *int64 and returns (bool, error).
2. Function: takes *int64 as argument and returns (*uint32, error)
3. List of type *int64

Returns:
New List of type *uint32, error
Empty list if all there parameters are nil or either of parameter is nil
package fp
func FilterMapIntInt64PtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*int64, error), list []*int) ([]*int64, error) {
	if fFilter == nil || fMap == nil {
		return []*int64{}, nil
	}
	var newList []*int64
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntInt32PtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*int32, error), list []*int) ([]*int32, error) {
	if fFilter == nil || fMap == nil {
		return []*int32{}, nil
	}
	var newList []*int32
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntInt16PtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*int16, error), list []*int) ([]*int16, error) {
	if fFilter == nil || fMap == nil {
		return []*int16{}, nil
	}
	var newList []*int16
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntInt8PtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*int8, error), list []*int) ([]*int8, error) {
	if fFilter == nil || fMap == nil {
		return []*int8{}, nil
	}
	var newList []*int8
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntUintPtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*uint, error), list []*int) ([]*uint, error) {
	if fFilter == nil || fMap == nil {
		return []*uint{}, nil
	}
	var newList []*uint
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntUint64PtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*uint64, error), list []*int) ([]*uint64, error) {
	if fFilter == nil || fMap == nil {
		return []*uint64{}, nil
	}
	var newList []*uint64
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntUint32PtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*uint32, error), list []*int) ([]*uint32, error) {
	if fFilter == nil || fMap == nil {
		return []*uint32{}, nil
	}
	var newList []*uint32
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntUint16PtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*uint16, error), list []*int) ([]*uint16, error) {
	if fFilter == nil || fMap == nil {
		return []*uint16{}, nil
	}
	var newList []*uint16
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntUint8PtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*uint8, error), list []*int) ([]*uint8, error) {
	if fFilter == nil || fMap == nil {
		return []*uint8{}, nil
	}
	var newList []*uint8
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntStrPtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*string, error), list []*int) ([]*string, error) {
	if fFilter == nil || fMap == nil {
		return []*string{}, nil
	}
	var newList []*string
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntBoolPtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*bool, error), list []*int) ([]*bool, error) {
	if fFilter == nil || fMap == nil {
		return []*bool{}, nil
	}
	var newList []*bool
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntFloat32PtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*float32, error), list []*int) ([]*float32, error) {
	if fFilter == nil || fMap == nil {
		return []*float32{}, nil
	}
	var newList []*float32
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapIntFloat64PtrErr(fFilter func(*int) (bool, error), fMap func(*int) (*float64, error), list []*int) ([]*float64, error) {
	if fFilter == nil || fMap == nil {
		return []*float64{}, nil
	}
	var newList []*float64
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt64IntPtrErr(fFilter func(*int64) (bool, error), fMap func(*int64) (*int, error), list []*int64) ([]*int, error) {
	if fFilter == nil || fMap == nil {
		return []*int{}, nil
	}
	var newList []*int
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt64Int32PtrErr(fFilter func(*int64) (bool, error), fMap func(*int64) (*int32, error), list []*int64) ([]*int32, error) {
	if fFilter == nil || fMap == nil {
		return []*int32{}, nil
	}
	var newList []*int32
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt64Int16PtrErr(fFilter func(*int64) (bool, error), fMap func(*int64) (*int16, error), list []*int64) ([]*int16, error) {
	if fFilter == nil || fMap == nil {
		return []*int16{}, nil
	}
	var newList []*int16
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt64Int8PtrErr(fFilter func(*int64) (bool, error), fMap func(*int64) (*int8, error), list []*int64) ([]*int8, error) {
	if fFilter == nil || fMap == nil {
		return []*int8{}, nil
	}
	var newList []*int8
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt64UintPtrErr(fFilter func(*int64) (bool, error), fMap func(*int64) (*uint, error), list []*int64) ([]*uint, error) {
	if fFilter == nil || fMap == nil {
		return []*uint{}, nil
	}
	var newList []*uint
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}
func FilterMapInt64Uint64PtrErr(fFilter func(*int64) (bool, error), fMap func(*int64) (*uint64, error), list []*int64) ([]*uint64, error) {
	if fFilter == nil || fMap == nil {
		return []*uint64{}, nil
	}
	var newList []*uint64
	for _, v := range list {
		r, err := fFilter(v)
		if err != nil {
			return nil, err
		}
		if r {
			r, err := fMap(v)
			if err != nil {
				return nil, err
			}
			newList = append(newList, r)
		}
	}
	return newList, nil
}