num_cpus::get(),

    let num_cpus = num_cpus::get();

        let result = working_copy.record_prefix(txn, channel, changes, &mut state, repo_path, p);

        let result =
            working_copy.record_prefix(txn, channel, changes, &mut state, repo_path, p, num_cpus);

        let threads = num_cpus::get();

                        .add_prefix_rec(&mut txn, &repo.path, &full, &prefix)?

                        .add_prefix_rec(&mut txn, &repo.path, &full, &prefix, threads)?

                num_cpus::get(),

num_cpus = "1.13"

        threads: usize,

            self.record_prefix(txn, channel, changes, state, repo_path, prefix.as_ref())?

            self.record_prefix(
                txn,
                channel,
                changes,
                state,
                repo_path,
                prefix.as_ref(),
                threads,
            )?

            self.record_prefix(txn, channel, changes, state, repo_path, Path::new(""))?

            self.record_prefix(
                txn,
                channel,
                changes,
                state,
                repo_path,
                Path::new(""),
                threads,
            )?

        threads: usize,

        if let Ok(meta) = meta {
            if meta.is_dir() {
                let mut walk = WalkBuilder::new(&full);
                walk.standard_filters(true);
                let walk = walk.build();
                for entry in walk {
                    let entry = entry?;
                    let p = entry.path();
                    if let Some(p) = p.file_name() {
                        if let Some(p) = p.to_str() {
                            if p.ends_with("~") || (p.starts_with("#") && p.ends_with("#")) {
                                continue;

        let (sender, receiver) = std::sync::mpsc::sync_channel(100);
        let full = full.to_path_buf();
        let t = std::thread::spawn(move || -> Result<(), AddError<T::Error>> {
            if let Ok(meta) = meta {
                if meta.is_dir() {
                    let mut walk = WalkBuilder::new(&full);
                    walk.standard_filters(true);
                    walk.threads(threads - 1);
                    walk.build_parallel().run(|| {
                        Box::new(|entry| {
                            let entry: ignore::DirEntry = if let Ok(entry) = entry {
                                entry
                            } else {
                                return ignore::WalkState::Quit;
                            };
                            let p = entry.path();
                            if let Some(p) = p.file_name() {
                                if let Some(p) = p.to_str() {
                                    if p.ends_with("~") || (p.starts_with("#") && p.ends_with("#"))
                                    {
                                        return ignore::WalkState::Skip;
                                    }
                                }
                            }
                            debug!("entry path = {:?} {:?}", entry.path(), repo_path_);
                            if let Ok(path) = entry.path().strip_prefix(&repo_path_) {
                                let is_dir = entry.file_type().unwrap().is_dir();
                                sender.send((path.to_path_buf(), is_dir)).unwrap();
                            } else {
                                debug!("entry = {:?}", entry.path());

                        }
                    }
                    debug!("entry path = {:?} {:?}", entry.path(), repo_path);
                    if let Ok(path) = entry.path().strip_prefix(&repo_path_) {
                        let path_str = path.to_str().unwrap();
                        if !txn.is_tracked(&path_str) {
                            info!("Adding {:?}", path);
                            txn.add(path_str, entry.file_type().unwrap().is_dir())?
                        } else {
                            debug!("already tracked {:?}", path_str)
                        }
                    } else {
                        debug!("entry = {:?}", entry.path());
                    }

                            ignore::WalkState::Continue
                        })
                    })
                } else if let Ok(path) = full.strip_prefix(&repo_path_) {
                    sender.send((path.to_path_buf(), false)).unwrap();

            } else if let Ok(path) = full.strip_prefix(&repo_path_) {
                let path_str = path.to_str().unwrap();
                if !txn.is_tracked(&path_str) {
                    info!("Adding file {:?}", path);
                    txn.add(path_str, false)?
                }

            Ok(())
        });
        while let Ok((path, is_dir)) = receiver.recv() {
            info!("Adding {:?}", path);
            let path_str = path.to_str().unwrap();
            txn.add(path_str, is_dir)?
        }
        if let Ok(t) = t.join() {
            t?

        threads: usize,

            self.add_prefix_rec(txn, repo_path, &full, &prefix)?;

            self.add_prefix_rec(txn, repo_path, &full, &prefix, threads)?;

// org id iBTHhIzBVluJ4gTIZXlBR1WgC/C6Zw4cKuVCh++X60Y=

// org id husqv+oHDFDeBrRtm5ymelT1H84bAvU87dV7ig64UFo=

        fileid.basename = SmallString::from_str(c);

        fileid.basename.clone_from_str(c);

                id.cmp(&fileid)

                id > fileid

            if !found {
                fileid.parent_inode = inode;
            }

            fileid.parent_inode = inode;
            break;

            current_inode = make_new_child(txn, current_inode, c, true, None)?

            current_inode = make_new_child(txn, current_inode, c, true, None)?;