// Gt determines if the current carbon is greater (after) than another
437206
func (c *Carbon) Gt(carb *Carbon) bool {
	return c.After(carb.Time)
}
493869
func (p *SampleQueryProperty) GreaterThanOrEqual(value interface{}) *SampleQueryBuilder {
	p.bldr.q = p.bldr.q.Filter(p.name+" >=", value)
	if p.bldr.plugin != nil {
		p.bldr.plugin.Filter(p.name, ">=", value)
	}
	return p.bldr
}
925463
func GT(m interface{}, value interface{}) (Predicate, error) {
	switch mapper := m.(type) {
	case RequestToInt:
		return intGT(mapper, value)
	case RequestToFloat64:
		return float64GT(mapper, value)
	}
	return nil, fmt.Errorf("unsupported argument: %T", m)
}
986582
func (m *LRUCacher) RunGC() {
	time.AfterFunc(m.GcInterval, func() {
		m.RunGC()
		m.GC()
	})
}
721423
func (s *DescribeDataSourcesInput) SetGT(v string) *DescribeDataSourcesInput {
	s.GT = &v
	return s
}
495782
func (v Vector) GreaterEqual(b Vector) bool {
	comp := v.Compare(b)
	return comp == Greater || comp == Equal
}
885476
func (i Int) Equal(other Argument) bool {
	if other.Typetag() != TypetagInt {
		return false
	}
	i2 := other.(Int)
	return i == i2
}
127910
func (c *Carbon) Between(before, after *Carbon) bool {
	return c.After(before.Time) && c.Before(after.Time)
}
293160
func Pair(g1 *G1, g2 *G2) *GT {
	return &GT{optimalAte(g2.p, g1.p, new(bnPool))}
}
451667
func GreaterThanOrEqualTo(version, otherVersion string) (bool, error) {
	firstMajor, firstMinor, firstMicro, err := ParseVersion(version)
	if err != nil {
		return false, err
	}

	secondMajor, secondMinor, secondMicro, err := ParseVersion(otherVersion)
	if err != nil {
		return false, err
	}

	if firstMajor > secondMajor {
		return true, nil
	} else if firstMajor == secondMajor {
		if firstMinor > secondMinor {
			return true, nil
		} else if firstMinor == secondMinor && firstMicro >= secondMicro {
			return true, nil
		}
	}
	return false, nil
}
28905
func Gt(column string) Cmp {
	return Cmp{
		op:     gt,
		column: column,
		value:  param(column),
	}
}
1208064
func GreaterTime(t1, t2 time.Time) time.Time {
	if IsGreaterThan(t1, t2, false) {
		return t1
	}
	return t2
}
1225013
func (a *Assertions) Greater(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Greater(a.t, e1, e2, msgAndArgs...)
}
97326
func (r *RemoveRangeOp) Gt(fieldName string, value interface{}) *RemoveRangeOp {
	r.appendOp(Gt, fieldName, value)
	return r
}
1301777
func (q *RangeQuery) Gte(from interface{}) *RangeQuery {
	q.from = from
	q.includeLower = true
	return q
}
40960
func (v *Validator) GreaterOrEqual(field string, value float64) *ValidationResult {
	return v.inequality(field, value, greaterOrEqual, "greater than or equal to")
}
1093355
func (c *Carbon) Max(carb *Carbon) *Carbon {
	if carb == nil {
		carb = nowIn(c.Location())
	}

	if c.Gt(carb) {
		return c
	}

	return carb
}