// this is where the interesting stuff happens..
516667
func main() {

	var inputbytes, utf8bytes, outputbytes []byte

	flag.Parse()

	// print help/version/list/usage...
	someSortOfHelp()

	// read input from stdin or file
	inputbytes = getInputBytes()

	// convert inputformat to UTF-8 (decode)
	utf8bytes = getUtf8FromInput(inputbytes)

	// convert UTF-8 to output format (encode)
	outputbytes = convertToDesired(utf8bytes)

	// write output to stdout or file
	writeOutput(outputbytes)

}
467410
func (l *Logger) Info(format string, v ...interface{}) {
	l.output(LInfo, format, v...)
}
1031756
func (r *PropResult) And(other *PropResult) *PropResult {
	switch {
	case r.Status == PropError:
		return r
	case other.Status == PropError:
		return other
	case r.Status == PropFalse:
		return r
	case other.Status == PropFalse:
		return other
	case r.Status == PropUndecided:
		return r
	case other.Status == PropUndecided:
		return other
	case r.Status == PropProof:
		return r.mergeWith(other, other.Status)
	case other.Status == PropProof:
		return r.mergeWith(other, r.Status)
	case r.Status == PropTrue && other.Status == PropTrue:
		return r.mergeWith(other, PropTrue)
	default:
		return r
	}
}
819576
func (vis *GenericVisitor) Visit(x interface{}) Visitor {
	if vis.f(x) {
		return nil
	}
	return vis
}
1362639
func main() {
	Tables := []interface{}{
		&promotion.Discount{},
		&promotion.Rule{},
		&promotion.Benefit{},
		&promotion.Coupon{},
		&promotion.BenefitRecord{},
		&enterprise.QorMicroSite{},
	}

	TruncateTables(Tables...)
	createPromotion()
	createMicroSite()
}
962663
func (a *EventCounter) Events(now time.Time, count int64) int64 {
	for {
		nsSince := now.Sub(a.startingTime).Nanoseconds()
		prevNsSinceStart := atomic.LoadInt64(&a.nsSinceStart)
		if nsSince-prevNsSinceStart >= a.eventDuration.Nanoseconds() {
			//		 Note: There is an accepted race here when we transition states that could cause us to
			//		       rarely miss an event that crosses the threshold.  This is an accepted aspect of
			//		       having a very fast non threshold event
			if atomic.CompareAndSwapInt64(&a.nsSinceStart, prevNsSinceStart, nsSince) {
				atomic.StoreInt64(&a.eventsThisPeriod, 0)
				break
			}
		} else {
			break
		}
	}
	return atomic.AddInt64(&a.eventsThisPeriod, count)
}
571794
func Intersect(its ...Postings) Postings {
	if len(its) == 0 {
		return EmptyPostings()
	}
	if len(its) == 1 {
		return its[0]
	}

	l := len(its) / 2
	a := Intersect(its[:l]...)
	b := Intersect(its[l:]...)

	if a == EmptyPostings() || b == EmptyPostings() {
		return EmptyPostings()
	}
	return newIntersectPostings(a, b)
}
1204684
func (s *XormLogger) Info(v ...interface{}) {
	if s.level <= glog.LvlInfo {
		s.grafanaLog.Info(fmt.Sprint(v...))
	}
}
441239
func (a *Application) AddTopic(topic Topic) {
	a.Topics = append(a.Topics, topic)
}
763737
func errorSeemsInteresting(err error) bool {
	boringSubstrs := []string{"connection refused", "connection reset by peer", "no such host", "transport endpoint is not connected", "no route to host"}
	errS := err.Error()
	for _, boringS := range boringSubstrs {
		if strings.Contains(errS, boringS) {
			return false
		}
	}
	return true
}
1026289
func (user *User) Interests() (interests []string) {
	Db().Model(Interest{}).Where(Interest{From: user.ID()}).Pluck(`"value"`, &interests)
	return
}
360779
func (e *Entry) Info(msg string) {
	e.Logger.log(InfoLevel, e, msg)
}
1125751
func main() {
	args := map[string]string{}
	gp := geopattern.Base64String(args)
	fmt.Println(gp)
}
320059
func (node *Select) AddHaving(expr Expr) {
	if _, ok := expr.(*OrExpr); ok {
		expr = &ParenExpr{Expr: expr}
	}
	if node.Having == nil {
		node.Having = &Where{
			Type: HavingStr,
			Expr: expr,
		}
		return
	}
	node.Having.Expr = &AndExpr{
		Left:  node.Having.Expr,
		Right: expr,
	}
}
1252128
func (t *Tree) enter(n Node) {
	for _, v := range t.Visitors {
		v.Enter(n)
	}
}
1296990
func (topic *RelatedTopic) Show(prefix string) {
	topic.fshow(os.Stdout, prefix)
}
505289
func main() {
	args := map[string]string{}
	gp := geopattern.Generate(args)
	fmt.Println(gp)
}