True if then is later or equal to that
429123
def later_than(after, before):
    
    if isinstance(after, str):
        after = str_to_time(after)
    elif isinstance(after, int):
        after = time.gmtime(after)

    if isinstance(before, str):
        before = str_to_time(before)
    elif isinstance(before, int):
        before = time.gmtime(before)

    return after >= before
925266
def p_if_statement_2(self, p):
        """"""
        p[0] = ast.If(predicate=p[3], consequent=p[5], alternative=p[7])
274756
private int calcFuByWait(MentsuComp comp, Tile last) {
        if (comp.isKanchan(last) || comp.isPenchan(last) || comp.isTanki(last)) {
            return 2;
        }

        return 0;
    }
1170658
function(d) {
    return d.wmStart || (d.wmStart = later.date.next(
      later.Y.val(d),
      later.M.val(d),
      Math.max(later.D.val(d) - later.dw.val(d) + 1, 1)));
  }
1073963
public boolean before (final TimeOfDay timeOfDay)
  {
    if (timeOfDay.m_nHour > m_nHour)
      return true;
    if (timeOfDay.m_nHour < m_nHour)
      return false;

    if (timeOfDay.m_nMinute > m_nMinute)
      return true;
    if (timeOfDay.m_nMinute < m_nMinute)
      return false;

    if (timeOfDay.m_nSecond > m_nSecond)
      return true;
    if (timeOfDay.m_nSecond < m_nSecond)
      return false;

    return false; // must be equal...
  }
190414
def time_afterwards_preceding(
            self, when: datetime.datetime) -> Optional[datetime.timedelta]:
        
        if self.is_empty():
            return None
        end_time = self.end_datetime()
        if when <= end_time:
            return datetime.timedelta()
        else:
            return when - end_time
1003650
def _equal(self, row1, row2):
        
        for key in row1.keys():
            if key not in [self._key_start_date, self._key_end_date]:
                if row1[key] != row2[key]:
                    return False

        return True
195365
def contains(self, time: datetime.datetime,
                 inclusive: bool = True) -> bool:
        
        if inclusive:
            return self.start <= time <= self.end
        else:
            return self.start < time < self.end
751689
static boolean isAfter(Date a, Date b) {
        return a == null || (b != null && b.after(a));
    }
1268586
function icaltime_compare(other) {
      var a = this.toUnixTime();
      var b = other.toUnixTime();

      if (a > b) return 1;
      if (b > a) return -1;
      return 0;
    }
1149917
private static int isTodayOrTomorrow(Resources r, long dayMillis,
                                         long currentMillis, long localGmtOffset) {
        int startDay = Time.getJulianDay(dayMillis, localGmtOffset);
        int currentDay = Time.getJulianDay(currentMillis, localGmtOffset);

        int days = startDay - currentDay;
        if (days == 1) {
            return TOMORROW;
        } else if (days == 0) {
            return TODAY;
        } else {
            return NONE;
        }
    }
1121539
function equal(actual, expected, message) {
    if (actual == expected) {
      this.pass(message);
    }
    else {
      this.fail({
        actual: actual,
        expected: expected,
        message: message,
        operator: "=="
      });
    }
  }
842982
public static function compareInstancesByStartTime($a, $b) {
		$start_a = $a->getStartTimestamp();
		$start_b = $b->getStartTimestamp();
		if ($start_a == $start_b) {
			return 0;
		}
		return ($start_a < $start_b) ? -1 : 1;
	}
1283976
function isBetween (dt1, dt2) {
  dt1 = Miment(dt1).valueOf()
  dt2 = Miment(dt2).valueOf()
  let dt = this.valueOf()
  return (dt1 > dt && dt2 < dt) || (dt1 < dt && dt2 > dt)
}
1340417
public static boolean compare(Time aValue, Time bValue, CompareWay compareWay) {
        String value = Formatter.datetimeToCustomString(aValue, TIME_FORMAT);
        int result = value.compareTo(Formatter.datetimeToCustomString(bValue, TIME_FORMAT));
        switch (compareWay) {
            case EQ:
                return result == 0;
            case GT:
                return result > 0;
            default:
                return result < 0;
        }
    }
536679
function hasPrecedence(op1, op2) {
    invariant(PRECEDENCE[op1] && PRECEDENCE[op2], `Missing precedence number for
            ${JSON.stringify(op1)} or ${JSON.stringify(op2)}.
            See ${JSON.stringify(PRECEDENCE)}`);

    return PRECEDENCE[op1] < PRECEDENCE[op2];
}
436738
function compare(a, b, n) {
	var n2 = n,
		then = Date.now()
	while (n2--) {
		a === b
	}
	return (Date.now() - then) * 1e6 / n
}