use std::{
    cell::RefCell,
    cmp::Ordering,
    collections::HashSet,
    fmt::{self, Display},
    hash::Hash,
    ops::{DerefMut, SubAssign},
};
use itertools::Itertools;
use owo_colors::OwoColorize;
use rand::{seq::SliceRandom, Rng};
use rand_pcg::Pcg64Mcg;
thread_local! {
    static RNG: RefCell<Pcg64Mcg> = RefCell::new(Pcg64Mcg::new(0xcafef00dd15ea5e5));
}
/// One card of a Set game.
///
/// This struct represents one card of a Set game.
/// To model set games with a different number of
/// attributes than 4, the const generic DIM can be changed.
#[derive(PartialEq, Eq, Debug, Clone, Copy, Hash, Ord)]
pub struct Card<const DIM: usize = 4>([u8; DIM]);
impl<const DIM: usize> Card<DIM> {
    /// Constructs a new card.
    pub fn new(value: [u8; DIM]) -> Self {
        if DIM == 0 {
            panic!("the game needs one dimension");
        }
        if value.iter().any(|v| *v > 2) {
            panic!("card values have to be 0, 1 or 2");
        }
        Self(value)
    }
    /// Returns an iterator going over all cards
    pub fn all() -> impl Iterator<Item = Self> {
        (0..DIM)
            .map(|_| 0..3)
            .multi_cartesian_product()
            .map(TryInto::<[u8; DIM]>::try_into)
            .map(Result::unwrap)
            .map(Self::new)
    }
    /// Given two [Cards](Card), returns the third [Card] needed to form a [Set].
    pub fn missing_for_set(a: Self, b: Self) -> Self {
        let mut result = [0; DIM];
        for i in 0..DIM {
            if a.0[i] == b.0[i] {
                result[i] = a.0[i];
            } else {
                result[i] = 3 - (a.0[i] + b.0[i]);
            }
        }
        Self(result)
    }
    /// Given a [CardSelection], finds all [Sets](Set) that can be built from self and two cards
    /// from the selection.
    pub fn sets_with(self, cards: &CardSelection<DIM>) -> impl Iterator<Item = Set<DIM>> + '_ {
        cards
            .iter()
            .copied()
            .map(move |card| [self, card, Self::missing_for_set(self, card)])
            .filter(move |maybe_set| cards.contains(&maybe_set[2]))
            .map(Set::new)
            .unique()
    }
    /// Checks whether a set can be constructed from self and two cards from the provided
    /// [CardSelection].
    pub fn has_sets_with(self, cards: &CardSelection<DIM>) -> bool {
        self.sets_with(cards).next().is_some()
    }
}
impl<const DIM: usize> PartialOrd for Card<DIM> {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        for i in (0..DIM).rev() {
            let res = self.0[i].cmp(&other.0[i]);
            if res != Ordering::Equal {
                return Some(res);
            }
        }
        Some(Ordering::Equal)
    }
}
impl<const DIM: usize> Display for Card<DIM> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let symbols = [
            [["○", "◇", "□"], ["◍", "◈", "▥"], ["●", "◆", "■"]],
            [["○○", "◇◇", "□□"], ["◍◍", "◈◈", "▥▥"], ["●●", "◆◆", "■■"]],
            [
                ["○○○", "◇◇◇", "□□□"],
                ["◍◍◍", "◈◈◈", "▥▥▥"],
                ["●●●", "◆◆◆", "■■■"],
            ],
        ];
        if DIM == 0 {
            panic!("the game needs one dimension")
        }
        let amount = self.0[0] as usize;
        let shape = if DIM >= 2 { self.0[1] } else { 0 } as usize;
        let fill = if DIM >= 3 { self.0[2] } else { 0 } as usize;
        let symbol = symbols[amount][fill][shape];
        if DIM < 4 {
            f.write_str(symbol)
        } else {
            f.write_str(&match self.0[3] {
                0 => symbol.red().to_string(),
                1 => symbol.green().to_string(),
                2 => symbol.blue().to_string(),
                _ => panic!("value cannot be more than 3"),
            })
        }
    }
}
/// A selection of [Cards](Card).
///
/// Stores any set of [Cards](Card). Can also be empty.
/// Not named Set to avoid confusion with [Sets](Set).
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CardSelection<const DIM: usize>(HashSet<Card<DIM>>);
impl<const DIM: usize> CardSelection<DIM> {
    /// Returns an empty [CardSelection].
    pub fn new() -> Self {
        Self(HashSet::new())
    }
    /// Returns `true`, iff no new card could be inserted to this [CardSelection] without forming
    /// a new [Set].
    ///
    /// This does not check if there already are [Sets](Set) within this [CardSelection], use
    /// [CardSelection::has_sets] to check if needed.
    pub fn no_sets_is_maximal(&self) -> bool {
        Self::no_sets_possible_extensions(self).is_empty()
    }
    /// Returns all cards that could be added to this selection without forming new sets.
    pub fn no_sets_possible_extensions(&self) -> CardSelection<DIM> {
        CardSelection(
            Card::all()
                .filter(|card| !self.clone().contains(card))
                .filter(|card| !card.has_sets_with(self))
                .collect::<HashSet<Card<DIM>>>(),
        )
    }
    /// Returns a random card from the selection.
    pub fn pick_random(&self) -> Option<Card<DIM>> {
        if self.is_empty() {
            return None;
        }
        let index = RNG.with(|rng| rng.borrow_mut().gen_range(0..self.len()));
        self.iter().nth(index).copied()
    }
    /// Returns a sorted iterator over the contained cards.
    pub fn sorted(&self) -> impl Iterator<Item = Card<DIM>> {
        let mut vec = self.0.iter().copied().collect_vec();
        vec.sort_unstable();
        vec.into_iter()
    }
    /// Find all sets in this selection.
    pub fn sets(&self) -> impl Iterator<Item = Set<DIM>> + '_ {
        self.iter()
            .copied()
            .combinations(2)
            .map(|pair| [pair[0], pair[1], Card::missing_for_set(pair[0], pair[1])])
            .filter(move |maybe_set| self.contains(&maybe_set[2]))
            .map(Set::new)
            .unique()
    }
    /// Check if this selection has any sets.
    pub fn has_sets(&self) -> bool {
        self.sets().next().is_some()
    }
    /// Check if this selection contains some card.
    pub fn contains(&self, value: &Card<DIM>) -> bool {
        self.0.contains(value)
    }
    /// Returns the amount of cards in this selection.
    pub fn len(&self) -> usize {
        self.0.len()
    }
    /// Removes a card from this selection.
    pub fn remove(&mut self, value: &Card<DIM>) -> bool {
        self.0.remove(value)
    }
    /// Inserts a card to this selection.
    ///
    /// Returns true if the card was already contained.
    pub fn insert(&mut self, value: Card<DIM>) -> bool {
        self.0.insert(value)
    }
    pub fn iter(&self) -> impl Iterator<Item = &Card<DIM>> {
        self.0.iter()
    }
    /// Check if the selection is empty.
    pub fn is_empty(&self) -> bool {
        self.0.is_empty()
    }
}
impl<const DIM: usize> Extend<Card<DIM>> for CardSelection<DIM> {
    fn extend<T: IntoIterator<Item = Card<DIM>>>(&mut self, iter: T) {
        for card in iter.into_iter() {
            self.insert(card);
        }
    }
}
impl<'a, const DIM: usize> Extend<&'a Card<DIM>> for CardSelection<DIM> {
    fn extend<T: IntoIterator<Item = &'a Card<DIM>>>(&mut self, iter: T) {
        for card in iter.into_iter() {
            self.insert(*card);
        }
    }
}
impl<const DIM: usize> FromIterator<Card<DIM>> for CardSelection<DIM> {
    fn from_iter<T: IntoIterator<Item = Card<DIM>>>(iter: T) -> Self {
        Self(iter.into_iter().collect())
    }
}
impl<const DIM: usize> SubAssign<Set<DIM>> for CardSelection<DIM> {
    fn sub_assign(&mut self, rhs: Set<DIM>) {
        self.remove(&rhs.0[0]);
        self.remove(&rhs.0[1]);
        self.remove(&rhs.0[2]);
    }
}
impl<const DIM: usize> Display for CardSelection<DIM> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(
            &self
                .0
                .iter()
                .map(Card::to_string)
                .reduce(|a, b| a + " " + &b)
                .unwrap(),
        )
    }
}
#[derive(Debug, Clone)]
pub struct Deck<const DIM: usize = 4>(Vec<Card<DIM>>);
impl<const DIM: usize> Deck<DIM> {
    pub fn new() -> Self {
        let mut deck = Self(Card::all().collect());
        RNG.with(|rng| deck.0.shuffle(rng.borrow_mut().deref_mut()));
        deck
    }
    pub fn draw(&mut self, amount: usize) -> impl Iterator<Item = Card<DIM>> + '_ {
        if amount == 0 {
            panic!("cannot draw 0 cards");
        }
        let start = self.0.len()
            - if amount < self.len() {
                amount
            } else {
                self.len()
            };
        let end = if amount == 0 { start } else { self.0.len() };
        self.0.drain(start..end)
    }
    pub fn reshuffle(&mut self, cards: &CardSelection<DIM>) {
        for card in cards.iter().copied() {
            self.0.push(card);
        }
        RNG.with(|rng| self.0.shuffle(rng.borrow_mut().deref_mut()));
    }
    pub fn has_sets(&self) -> bool {
        self.0
            .iter()
            .copied()
            .collect::<CardSelection<DIM>>()
            .has_sets()
    }
    pub fn len(&self) -> usize {
        self.0.len()
    }
}
impl<const DIM: usize> AsRef<[Card<DIM>]> for Deck<DIM> {
    fn as_ref(&self) -> &[Card<DIM>] {
        &self.0
    }
}
/// A set according to set rules.
#[derive(Debug, PartialEq, Eq, Clone, Hash)]
pub struct Set<const DIM: usize>([Card<DIM>; 3]);
impl<const DIM: usize> Set<DIM> {
    fn new(mut cards: [Card<DIM>; 3]) -> Self {
        cards.sort_unstable();
        Self(cards)
    }
    /// Count the number of attributes that are the same across the cards in this set
    pub fn same_count(&self) -> u8 {
        self.0[0]
            .0
            .iter()
            .zip(self.0[1].0.iter())
            .map(|(a, b)| (*a == *b) as u8)
            .sum()
    }
}
impl<const DIM: usize> Display for Set<DIM> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_fmt(format_args!(
            "{{ {} {} {} }}",
            self.0[0], self.0[1], self.0[2]
        ))
    }
}
#[cfg(test)]
mod test {
    use std::collections::HashSet;
    use itertools::Itertools;
    use crate::{Card, CardSelection, Set};
    #[test]
    fn same_count() {
        let set = Set::new([Card([0, 0, 0, 0]), Card([0, 0, 1, 2]), Card([0, 0, 2, 1])]);
        assert_eq!(set.same_count(), 2);
    }
    #[test]
    fn sets() {
        let sets = [
            Set([Card([0, 1, 0, 2]), Card([1, 1, 0, 2]), Card([2, 1, 0, 2])]),
            Set([Card([0, 1, 0, 0]), Card([1, 1, 2, 1]), Card([2, 1, 1, 2])]),
            Set([Card([0, 1, 0, 0]), Card([1, 1, 2, 1]), Card([2, 1, 1, 2])]),
            Set([Card([0, 1, 2, 0]), Card([2, 0, 0, 1]), Card([1, 2, 1, 2])]),
            Set([Card([1, 2, 0, 0]), Card([0, 2, 0, 1]), Card([2, 2, 0, 2])]),
            Set([Card([2, 0, 2, 0]), Card([0, 2, 0, 1]), Card([1, 1, 1, 2])]),
            Set([Card([2, 0, 0, 0]), Card([0, 0, 1, 1]), Card([1, 0, 2, 2])]),
            Set([Card([2, 0, 0, 0]), Card([0, 0, 1, 1]), Card([1, 0, 2, 2])]),
        ];
        let unique = vec![
            Set([Card([0, 1, 0, 2]), Card([1, 1, 0, 2]), Card([2, 1, 0, 2])]),
            Set([Card([0, 1, 0, 0]), Card([1, 1, 2, 1]), Card([2, 1, 1, 2])]),
            Set([Card([0, 1, 2, 0]), Card([2, 0, 0, 1]), Card([1, 2, 1, 2])]),
            Set([Card([1, 2, 0, 0]), Card([0, 2, 0, 1]), Card([2, 2, 0, 2])]),
            Set([Card([2, 0, 2, 0]), Card([0, 2, 0, 1]), Card([1, 1, 1, 2])]),
            Set([Card([2, 0, 0, 0]), Card([0, 0, 1, 1]), Card([1, 0, 2, 2])]),
        ];
        assert_eq!(unique, sets.into_iter().unique().collect_vec());
    }
    #[test]
    fn test_missing_for_set() {
        let a = Card([0, 0, 0]);
        let b = Card([2, 1, 2]);
        assert_eq!(Card::missing_for_set(a, b), Card([1, 2, 1]));
        let a = Card([0, 0, 0]);
        let b = Card([0, 0, 1]);
        assert_eq!(Card::missing_for_set(a, b), Card([0, 0, 2]));
        let a = Card([2, 1, 1]);
        let b = Card([0, 2, 1]);
        assert_eq!(Card::missing_for_set(a, b), Card([1, 0, 1]));
    }
    #[test]
    fn find_sets() {
        let selection = CardSelection(HashSet::from([
            Card([0, 0, 0]),
            Card([0, 1, 2]),
            Card([1, 2, 0]),
            Card([1, 1, 1]),
            Card([1, 0, 1]),
            Card([0, 2, 1]),
        ]));
        let sets = vec![Set::new([
            Card([0, 0, 0]),
            Card([0, 1, 2]),
            Card([0, 2, 1]),
        ])];
        assert_eq!(sets, selection.sets().collect::<Vec<Set<3>>>());
    }
    #[test]
    fn find_sets_with() {
        let card = Card([0, 0, 0]);
        let selection = CardSelection(HashSet::from([
            Card([0, 1, 2]),
            Card([1, 2, 0]),
            Card([1, 1, 1]),
            Card([1, 0, 1]),
            Card([0, 2, 1]),
        ]));
        let sets = vec![Set::new([
            Card([0, 0, 0]),
            Card([0, 1, 2]),
            Card([0, 2, 1]),
        ])];
        assert_eq!(sets, card.sets_with(&selection).collect::<Vec<Set<3>>>());
    }
    #[test]
    fn has_sets() {
        let selection = CardSelection(HashSet::from([
            Card([0, 0, 0]),
            Card([0, 1, 2]),
            Card([1, 2, 0]),
            Card([1, 1, 1]),
            Card([1, 0, 1]),
            Card([0, 2, 1]),
        ]));
        assert!(selection.has_sets());
    }
    #[test]
    fn has_sets_with() {
        let card = Card([0, 0, 0]);
        let selection = CardSelection(HashSet::from([
            Card([0, 1, 2]),
            Card([1, 2, 0]),
            Card([1, 1, 1]),
            Card([1, 0, 1]),
            Card([0, 2, 1]),
        ]));
        assert!(card.has_sets_with(&selection));
        let card = Card([0, 1, 2, 1]);
        let selection = CardSelection(HashSet::from([
            Card([0, 0, 1, 2]),
            Card([1, 1, 2, 2]),
            Card([0, 0, 1, 1]),
            Card([2, 2, 2, 2]),
            Card([1, 2, 2, 2]),
            Card([0, 0, 0, 0]),
            Card([0, 0, 0, 1]),
            Card([0, 1, 1, 2]),
            Card([0, 1, 1, 1]),
            Card([0, 1, 2, 2]),
        ]));
        assert!(!card.has_sets_with(&selection));
    }
    #[test]
    fn is_maximal() {
        let selection = CardSelection(HashSet::from([
            Card([0, 0, 1, 2]),
            Card([1, 1, 2, 2]),
            Card([0, 0, 1, 1]),
            Card([2, 2, 2, 2]),
            Card([1, 2, 2, 2]),
            Card([0, 0, 0, 0]),
            Card([0, 0, 0, 2]),
            Card([0, 1, 1, 2]),
            Card([0, 1, 1, 1]),
            Card([0, 1, 2, 2]),
        ]));
        assert!(!selection.no_sets_is_maximal());
    }
    #[test]
    fn all() {
        let all_cards = CardSelection(HashSet::from([
            Card([0, 0]),
            Card([0, 1]),
            Card([0, 2]),
            Card([1, 0]),
            Card([1, 1]),
            Card([1, 2]),
            Card([2, 0]),
            Card([2, 1]),
            Card([2, 2]),
        ]));
        assert_eq!(all_cards, Card::<2>::all().collect());
    }
}

#![allow(unused)]
use std::{cell::RefCell, ops::DerefMut};
use itertools::Itertools;
use rand::seq::SliceRandom;
use rand_pcg::Pcg64Mcg;
use settheory::{CardSelection, Deck, Set};
const DIM: usize = 4;
const RUNS: usize = 10000;
thread_local! {
    static RNG: RefCell<Pcg64Mcg> = RefCell::new(Pcg64Mcg::new(0xcafef00dd15ea5e5));
}
fn main() {
    let mut avg = 0;
    let mut min = usize::MAX;
    let mut max = usize::MIN;
    let mut dist = [0; 7];
    let mut avg_sets_in_sel = 0;
    let mut selection_count = 0;
    let mut max_sets_in_sel = usize::MIN;
    let mut max_sets_sel = CardSelection::new();
    let mut sets_in_sel_dist = [0; 16];
    let mut avg_same_count = 0;
    let mut no_same_count = 0;
    let mut games_no_same_set = 0;
    'runs: for _ in 0..RUNS {
        let mut deck = Deck::new();
        let mut selection: CardSelection<DIM> = deck.draw(12).collect();
        let mut no_same_set = false;
        loop {
            let mut sets = selection.sets().collect_vec();
            if sets.is_empty() {
                deck.reshuffle(&selection);
                if !deck.has_sets() {
                    avg += deck.len();
                    min = usize::min(min, deck.len());
                    max = usize::max(max, deck.len());
                    dist[deck.len() / 3] += 1;
                    games_no_same_set += if no_same_set { 1 } else { 0 };
                    continue 'runs;
                }
                selection = deck.draw(12).collect();
                continue;
            }
            avg_sets_in_sel += sets.len();
            selection_count += 1;
            if max_sets_in_sel < sets.len() {
                max_sets_in_sel = sets.len();
                max_sets_sel = selection.clone();
            }
            sets_in_sel_dist[sets.len()] += 1;
            // let set_found = RNG
            //     .with(|rng| sets.choose(rng.borrow_mut().deref_mut()))
            //     .unwrap()
            //     .clone();
            sets.sort_unstable_by_key(Set::same_count);
            let set_found = sets.pop().unwrap();
            // let set_found = sets[0].clone();
            avg_same_count += set_found.same_count() as u64;
            if set_found.same_count() == 0 {
                no_same_count += 1;
                no_same_set = true;
            }
            selection -= set_found;
        }
    }
    println!(
        "The average number of cards left at the end was {:.3}",
        avg as f32 / RUNS as f32
    );
    println!("The minimum number was {min}");
    println!("The maximum number was {max}");
    println!(
        "Distribution:\n{}\n{}\n{}",
        (0..7)
            .map(|i| format!("{:6}", i))
            .reduce(|a, b| a + "  |" + &b)
            .unwrap(),
        dist.into_iter()
            .map(|i| format!("{:6}", i))
            .reduce(|a, b| a + "  |" + &b)
            .unwrap(),
        dist.into_iter()
            .map(|i| format!("{:6.1}%", i as f32 * 100.0 / RUNS as f32))
            .reduce(|a, b| a + " |" + &b)
            .unwrap(),
    );
    println!(
        "The average number of sets in a selection with sets was {:.3}",
        avg_sets_in_sel as f32 / selection_count as f32
    );
    println!("The maximum number of sets in one selection was {max_sets_in_sel}");
    println!("Selection: {max_sets_sel}");
    println!(
        "Distribution:\n{}\n{}\n{}",
        (0..16)
            .map(|i| format!("{:6}", i))
            .reduce(|a, b| a + "  |" + &b)
            .unwrap(),
        sets_in_sel_dist
            .into_iter()
            .map(|i| format!("{:6}", i))
            .reduce(|a, b| a + "  |" + &b)
            .unwrap(),
        sets_in_sel_dist
            .into_iter()
            .map(|i| format!(
                "{:6.1}%",
                i as f32 * 100.0 / sets_in_sel_dist.iter().sum::<usize>() as f32
            ))
            .reduce(|a, b| a + " |" + &b)
            .unwrap(),
    );
    println!(
        "The average same count was {:.2}",
        avg_same_count as f32 / selection_count as f32
    );
    println!(
        "The average amount of times per game with only sets without same attributes was {}",
        no_same_count as f32 / RUNS as f32
    );
    println!(
        "The percentage of games with sets with no shared attributes was {:.2}%",
        games_no_same_set as f32 * 100.0 / RUNS as f32
    );
}

use settheory::CardSelection;
const DIM: usize = 4;
const RUNS: usize = 1000000;
fn main() {
    let mut selection: CardSelection<DIM>;
    let mut avg = 0;
    let mut min = usize::MAX;
    let mut min_cards = CardSelection::new();
    let mut max = usize::MIN;
    let mut max_cards = CardSelection::new();
    'runs: for i in 0..RUNS {
        if i % 500 == 0 {
            print!("{i:5} of {RUNS} iterations\r");
        }
        selection = CardSelection::new();
        loop {
            let Some(card) = selection.no_sets_possible_extensions().pick_random()
            else {
                avg += selection.len();
                if selection.len() < min {
                    min = selection.len();
                    min_cards = selection.clone();
                }
                if selection.len() > max {
                    max = selection.len();
                    max_cards = selection.clone();
                }
                continue 'runs; 
            };
            selection.insert(card);
        }
    }
    println!("Average card amount needed: {}", avg as f64 / RUNS as f64);
    println!("Minimum card amount needed: {min}");
    println!("Cards: {}", min_cards.sorted().map(|card| card.to_string()).reduce(|a, b| a + " " + &b).unwrap_or_default());
    println!("Maximum card amount possible: {max}");
    println!("Cards: {}", max_cards.sorted().map(|card| card.to_string()).reduce(|a, b| a + " " + &b).unwrap_or_default());
}

[package]
name = "settheory"
version = "0.1.0"
edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
itertools = "0.10.5"
owo-colors = "3.5.0"
rand = "0.8.5"
rand_pcg = "0.3.1"

# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 3
[[package]]
name = "cfg-if"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
[[package]]
name = "either"
version = "1.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91"
[[package]]
name = "getrandom"
version = "0.2.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
dependencies = [
 "cfg-if",
 "libc",
 "wasi",
]
[[package]]
name = "itertools"
version = "0.10.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
dependencies = [
 "either",
]
[[package]]
name = "libc"
version = "0.2.141"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3304a64d199bb964be99741b7a14d26972741915b3649639149b2479bb46f4b5"
[[package]]
name = "owo-colors"
version = "3.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c1b04fb49957986fdce4d6ee7a65027d55d4b6d2265e5848bbb507b58ccfdb6f"
[[package]]
name = "ppv-lite86"
version = "0.2.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
[[package]]
name = "rand"
version = "0.8.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
dependencies = [
 "libc",
 "rand_chacha",
 "rand_core",
]
[[package]]
name = "rand_chacha"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
dependencies = [
 "ppv-lite86",
 "rand_core",
]
[[package]]
name = "rand_core"
version = "0.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
dependencies = [
 "getrandom",
]
[[package]]
name = "rand_pcg"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "59cad018caf63deb318e5a4586d99a24424a364f40f1e5778c29aca23f4fc73e"
dependencies = [
 "rand_core",
]
[[package]]
name = "settheory"
version = "0.1.0"
dependencies = [
 "itertools",
 "owo-colors",
 "rand",
 "rand_pcg",
]
[[package]]
name = "wasi"
version = "0.11.0+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"

.git
.DS_Store
# Added by cargo
/target