// unaryOpOctcps converts decimal octaves to cycles per second.
17903
func unaryOpOctcps(rate int8, in Input, numOutputs int) Input {
	CheckRate(rate)
	return NewInput(UnaryOpUgenName, rate, UnaryOpOctcps, numOutputs, in)
}
699616
func (_m *Auth) UnaryInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
	ret := _m.Called(ctx, req, info, handler)

	var r0 interface{}
	if rf, ok := ret.Get(0).(func(context.Context, interface{}, *grpc.UnaryServerInfo, grpc.UnaryHandler) interface{}); ok {
		r0 = rf(ctx, req, info, handler)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(interface{})
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, interface{}, *grpc.UnaryServerInfo, grpc.UnaryHandler) error); ok {
		r1 = rf(ctx, req, info, handler)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}
898344
func (r Network_Bandwidth_Version1_Allotment) UnassignServers(templateObjects []datatypes.Hardware) (resp bool, err error) {
	params := []interface{}{
		templateObjects,
	}
	err = r.Session.DoRequest("SoftLayer_Network_Bandwidth_Version1_Allotment", "unassignServers", params, &r.Options, &resp)
	return
}
1244974
func (*TLSProperties_CertificateProperties_SubjectAltName) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _TLSProperties_CertificateProperties_SubjectAltName_OneofMarshaler, _TLSProperties_CertificateProperties_SubjectAltName_OneofUnmarshaler, _TLSProperties_CertificateProperties_SubjectAltName_OneofSizer, []interface{}{
		(*TLSProperties_CertificateProperties_SubjectAltName_Uri)(nil),
		(*TLSProperties_CertificateProperties_SubjectAltName_Dns)(nil),
	}
}
555962
func (*Operand_ConstantOperand) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Operand_ConstantOperand_OneofMarshaler, _Operand_ConstantOperand_OneofUnmarshaler, _Operand_ConstantOperand_OneofSizer, []interface{}{
		(*Operand_ConstantOperand_StringValue)(nil),
		(*Operand_ConstantOperand_LongValue)(nil),
		(*Operand_ConstantOperand_BooleanValue)(nil),
		(*Operand_ConstantOperand_DoubleValue)(nil),
	}
}
859438
func unaryOpSqrt(rate int8, in Input, numOutputs int) Input {
	CheckRate(rate)
	return NewInput(UnaryOpUgenName, rate, UnaryOpSqrt, numOutputs, in)
}
1122911
func unaryOpFloor(rate int8, in Input, numOutputs int) Input {
	CheckRate(rate)
	return NewInput(UnaryOpUgenName, rate, UnaryOpFloor, numOutputs, in)
}
1177619
func unaryOpSoftClip(rate int8, in Input, numOutputs int) Input {
	CheckRate(rate)
	return NewInput(UnaryOpUgenName, rate, UnaryOpSoftClip, numOutputs, in)
}
820799
func seccomp(op, flags uintptr, uargs unsafe.Pointer) error {
	nr, _ := constants.GetSyscall("seccomp")
	_, _, e := syscall.Syscall(uintptr(nr), op, flags, uintptr(uargs))
	if e != 0 {
		return e
	}
	return nil
}
766339
func UnaryClientInterceptor(opts ...Option) grpc.UnaryClientInterceptor {
	o := evaluateOptions(opts)
	return func(parentCtx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
		if o.filterOutFunc != nil && !o.filterOutFunc(parentCtx, method) {
			return invoker(parentCtx, method, req, reply, cc, opts...)
		}
		newCtx, clientSpan := newClientSpanFromContext(parentCtx, o.tracer, method)
		err := invoker(newCtx, method, req, reply, cc, opts...)
		finishClientSpan(clientSpan, err)
		return err
	}
}
589309
func (g *GPG) DecryptionKeys() []openpgp.Key {
	return append(g.secring.DecryptionKeys(), g.pubring.DecryptionKeys()...)
}
441563
func (*CustomerClientLinkOperation) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _CustomerClientLinkOperation_OneofMarshaler, _CustomerClientLinkOperation_OneofUnmarshaler, _CustomerClientLinkOperation_OneofSizer, []interface{}{
		(*CustomerClientLinkOperation_Create)(nil),
		(*CustomerClientLinkOperation_Update)(nil),
	}
}
267251
func unaryOpTanh(rate int8, in Input, numOutputs int) Input {
	CheckRate(rate)
	return NewInput(UnaryOpUgenName, rate, UnaryOpTanh, numOutputs, in)
}
1125590
func (d *Domain) GetCPUStats(startCpu int, nCpus uint, flags uint32) ([]DomainCPUStats, error) {
	var err C.virError
	if nCpus == 0 {
		if startCpu == -1 {
			nCpus = 1
		} else {
			ret := C.virDomainGetCPUStatsWrapper(d.ptr, nil, 0, 0, 0, 0, &err)
			if ret == -1 {
				return []DomainCPUStats{}, makeError(&err)
			}
			nCpus = uint(ret)
		}
	}

	ret := C.virDomainGetCPUStatsWrapper(d.ptr, nil, 0, C.int(startCpu), C.uint(nCpus), 0, &err)
	if ret == -1 {
		return []DomainCPUStats{}, makeError(&err)
	}
	cnparams := C.int(ret)

	var cnallocparams C.int
	if startCpu == -1 {
		cnallocparams = cnparams
	} else {
		cnallocparams = cnparams * C.int(nCpus)
	}
	cparams := typedParamsNew(cnallocparams)
	defer C.virTypedParamsFree(cparams, cnallocparams)
	ret = C.virDomainGetCPUStatsWrapper(d.ptr, cparams, C.uint(cnparams), C.int(startCpu), C.uint(nCpus), C.uint(flags), &err)
	if ret == -1 {
		return []DomainCPUStats{}, makeError(&err)
	}

	stats := make([]DomainCPUStats, nCpus)
	for i := 0; i < int(nCpus); i++ {
		coffset := C.int(i) * cnparams
		info := getCPUStatsFieldInfo(&stats[i])
		var cparamscpu *C.virTypedParameter
		cparamscpu = (*C.virTypedParameter)(unsafe.Pointer(uintptr(unsafe.Pointer(cparams)) +
			(unsafe.Sizeof(*cparams) * uintptr(coffset))))
		_, gerr := typedParamsUnpack(cparamscpu, cnparams, info)
		if gerr != nil {
			return []DomainCPUStats{}, gerr
		}
	}
	return stats, nil
}
195396
func unaryOpSinh(rate int8, in Input, numOutputs int) Input {
	CheckRate(rate)
	return NewInput(UnaryOpUgenName, rate, UnaryOpSinh, numOutputs, in)
}
246902
func unaryOpCos(rate int8, in Input, numOutputs int) Input {
	CheckRate(rate)
	return NewInput(UnaryOpUgenName, rate, UnaryOpCos, numOutputs, in)
}
1088815
func GetFreeTCPPorts(n int, offset ...int) (PortList, error) {
	list := make(PortList, 0, n)
	start := PortStartingNumber
	if len(offset) != 0 {
		start = offset[0]
	}
	for i := start; i < start+n; i++ {
		list = append(list, strconv.Itoa(i))
	}
	return list, nil
}