None,

            None,

                    None,

                    let last_modified = last_modified(&txn, &channel.borrow());

                        Some(last_modified),

                        None,

                        None,

}
fn last_modified<T: ChannelTxnT>(_: &T, channel: &T::Channel) -> std::time::SystemTime {
    std::time::SystemTime::UNIX_EPOCH + std::time::Duration::from_secs(T::last_modified(channel))

                None,

                None,

            None,

use std::collections::HashMap;

use std::collections::{HashMap, HashSet};

use libpijul::{MutTxnT, MutTxnTExt, TxnT};

use libpijul::{DepsTxnT, GraphTxnT, MutTxnT, MutTxnTExt, TxnT};

        txn.output_repository_no_pending(
            &mut repo.working_copy,
            &repo.changes,
            &mut channel,
            &mut HashMap::new(),
            "",
            true,
        )?;

        let mut touched = HashSet::new();
        for d in hashes.iter() {
            if let Some(int) = txn.get_internal(*d)? {
                for inode in txn.iter_rev_touched(int)? {
                    let (int_, inode) = inode?;
                    if int_ < int {
                        continue;
                    } else if int_ > int {
                        break;
                    }
                    touched.insert(inode);
                }
            }
        }
        let mut done = HashMap::new();
        for i in touched {
            let (path, _) =
                libpijul::fs::find_path(&repo.changes, &txn, &channel.borrow(), false, i)?;
            txn.output_repository_no_pending(
                &mut repo.working_copy,
                &repo.changes,
                &mut channel,
                &mut done,
                &path,
                true,
                None,
            )?;
        }

    if_modified_since: Option<std::time::SystemTime>,

        if_modified_since,

    if_modified_after: Option<std::time::SystemTime>,

                    repo.write_file(&path, |w: &mut dyn std::io::Write| {
                        output_file::<_, _, R>(
                            txn,
                            channel,
                            changes,
                            &output_item,
                            &mut conflicts,
                            w,
                        )
                    })
                    .map_err(OutputError::from)?

                    let output = if let Some(m) = if_modified_after {
                        if let Ok(last) = repo.modified_time(&path) {
                            last >= m
                        } else {
                            true
                        }
                    } else {
                        true
                    };
                    if output {
                        repo.write_file(&path, |w: &mut dyn std::io::Write| {
                            output_file::<_, _, R>(
                                txn,
                                channel,
                                changes,
                                &output_item,
                                &mut conflicts,
                                w,
                            )
                        })
                            .map_err(OutputError::from)?
                    }

        if_modified_since: Option<std::time::SystemTime>

            if_modified_since,