min_hours -> Int4,

        med_hours -> Int4,

    pub min_hours: i32,

    pub med_hours: i32,

    /// Lowest observed time in raid per week (in seconds)
    async fn min_hours(&self) -> i32 {
        self.min_hours

    /// Median observed time in raid per week (in seconds)
    async fn med_hours(&self) -> i32 {
        self.med_hours

                ts::min_hours,

                ts::med_hours,

fn minmax_hours(data: &Vec<InternalRaidNight>) -> Option<(Duration, Duration)> {

fn medmax_hours(data: &Vec<InternalRaidNight>) -> Option<(Duration, Duration)> {

    Some((
        *hours.values().min().unwrap(),
        *hours.values().max().unwrap(),
    ))

    let hours = hours.values().map(|f| *f).collect::<Vec<_>>();
    Some((hours[hours.len() / 2], *hours.iter().max().unwrap()))

    let minmax = minmax_hours(&days);

    let medmax = medmax_hours(&days);

        Ok(minmax)

        Ok(medmax)

        let (_, max_hours) = minmax_hours(&rns).unwrap();

        let (med_hours, max_hours) = medmax_hours(&rns).unwrap();

        assert_eq!(Duration::hours(8), med_hours);

        min_hours: 0,

        med_hours: 0,

                ex!(ts::min_hours),

                ex!(ts::med_hours),

        let (min_hours, max_hours) = raid_nights::raid_night_analysis(

        let (med_hours, max_hours) = raid_nights::raid_night_analysis(

                ts::min_hours.eq(min_hours.num_seconds() as i32),

                ts::med_hours.eq(med_hours.num_seconds() as i32),

-- Your SQL goes here
alter table team_stats drop column min_hours;
alter table team_stats add column med_hours int not null default 0;

-- This file should undo anything in `up.sql`

use std::process::Command;
fn main() {
    let output = Command::new("pijul")
        .args(&["log", "--hash-only"])
        .output()
        .unwrap();
    let hashes = String::from_utf8(output.stdout).unwrap();
    let hash = hashes.lines().next().unwrap();
    println!("cargo:rustc-env=PIJUL_CHANGESET={}", hash);
}

      medHours,

}
function PrettyDuration({ secs }: { secs: number }) {
  const mins = secs / 60;
  return <>{`${Math.floor(mins / 60)}h ${Math.floor(mins % 60)}m`}</>;

    const mins = data.teamStats.maxHours / 60;

            {`${Math.floor(mins / 60)}h ${Math.floor(mins % 60)}m`}

            <PrettyDuration secs={data.teamStats.medHours} />
            { (data.teamStats.maxHours >= data.teamStats.medHours + 60 * 60) && <span> &mdash; <PrettyDuration secs={data.teamStats.maxHours} /></span>}

  {
    date: '2021-03-03T12:04-05:00',
    messages: ['Hours / Week now shows median by default. If the maximum observed weekly raid hours is at least 1 hour more than the median, then it shows "median — maximum".']
  },