// NewProve makes a new Prove Engine given an RPC-friendly ProveArg.
421678
func NewProve(g *libkb.GlobalContext, arg *keybase1.StartProofArg) *Prove {
	if arg.SigVersion == nil || libkb.SigVersion(*arg.SigVersion) == libkb.KeybaseNullSigVersion {
		tmp := keybase1.SigVersion(libkb.GetDefaultSigVersion(g))
		arg.SigVersion = &tmp
	}
	return &Prove{
		arg:          arg,
		Contextified: libkb.NewContextified(g),
	}
}
146993
func NewVserverEntry(port uint16, proto seesaw.IPProto) *VserverEntry {
	return &VserverEntry{
		Port:         port,
		Proto:        proto,
		Healthchecks: make(map[string]*Healthcheck),
	}
}
21960
func NewProfiler() (prof *Profiler) {
	prof = &Profiler{}
	prof.SysFSSystemPath(joefriday.SysFSSystem)
	return prof
}
424540
func NewProduct(parent *Products) *Product {
	product := &Product{parent: parent}
	product.Init()

	return product
}
948195
func NewArg(logLevel int, pprof bool) Arg {
	return Arg{
		LogLevel:            log.Level(logLevel),
		PingTimeoutDuration: PingTimeoutDurationDefault,
		Pprof:               pprof,
	}
}
1111173
func NewProfiler() (prof *Profiler, err error) {
	p, err := info.NewProfiler()
	if err != nil {
		return nil, err
	}
	return &Profiler{Profiler: p}, nil
}
26593
func newProofTerm(i keybase1.UserOrTeamID, s keybase1.SignatureMetadata, lm linkMapT) proofTerm {
	return proofTerm{leafID: i, sigMeta: s, linkMap: lm}
}
565374
func NewPropArg(genResult *GenResult, shrinks int, value, origValue interface{}) *PropArg {
	return &PropArg{
		Label:   strings.Join(genResult.Labels, ", "),
		Arg:     value,
		OrigArg: origValue,
		Shrinks: shrinks,
	}
}
980869
func NewPairVerify(context hap.Context, database db.Database) *PairVerify {
	endpoint := PairVerify{
		context:  context,
		database: database,
	}

	return &endpoint
}
1333183
func NewProbabilisticCounter(cardinality int) *ProbabilisticCounter {
	return &ProbabilisticCounter{
		cardinality: cardinality,
		bitset:      newBitSetForCardinality(cardinality),
	}
}
952190
func New(sessionKey string) *InProgressRegistration {
	return &InProgressRegistration{
		CreatedAt:  time.Now(),
		SessionKey: sessionKey,
	}
}
488759
func (proxier *Proxier) precomputeProbabilities(numberOfPrecomputed int) {
	if len(proxier.precomputedProbabilities) == 0 {
		proxier.precomputedProbabilities = append(proxier.precomputedProbabilities, "<bad value>")
	}
	for i := len(proxier.precomputedProbabilities); i <= numberOfPrecomputed; i++ {
		proxier.precomputedProbabilities = append(proxier.precomputedProbabilities, computeProbability(i))
	}
}
544615
func NewProfiler() *Profiler {
	prof := cpux.NewProfiler()
	return &Profiler{Profiler: prof, Builder: fb.NewBuilder(0)}
}
1358748
func NewProjectFromEnv(c *check.C) *Project {
	client, err := client.NewEnvClient()
	c.Assert(err, check.IsNil, check.Commentf("Error while getting a docker client from env"))
	return NewProject(client)
}
912345
func NewProgressWriter(w io.Writer, size int64) (*ProgressWriter, <-chan Progress) {
	if w == nil {
		return nil, nil
	}
	wc, ok := w.(io.WriteCloser)
	if !ok {
		wc = getNopWriteCloser(w)
	}
	ret := &ProgressWriter{wc, *mkIoProgress(size)}
	return ret, ret.ch
}
724930
func NewProfiler() (prof *Profiler, err error) {
	p, err := u.NewProfiler()
	if err != nil {
		return nil, err
	}
	return &Profiler{Profiler: p}, nil
}
346025
func NewProvider(datafile string) (isp.Provider, error) {
	prov := &provider{
		yfast.New(uint32(0)), // 32 bit universe size for 32 bit IPv4
	}
	return prov, prov.init(datafile)
}