fn draw_board(val: [[u8; 9]; 9]) {
	let mut board: [[u8; 9]; 9] = [[0; 9]; 9];
	for (i, v) in val.iter().enumerate() {
		for j in v {
			board[(*j as usize)/9][(*j as usize)%9] = 1+i as u8;
		}
	}
	println!("___________________\n|{} {} {}|{} {} {}|{} {} {}|\n|{} {} {}|{} {} {}|{} {} {}|\n|{} {} {}|{} {} {}|{} {} {}|\n-------------------\n|{} {} {}|{} {} {}|{} {} {}|\n|{} {} {}|{} {} {}|{} {} {}|\n|{} {} {}|{} {} {}|{} {} {}|\n-------------------\n|{} {} {}|{} {} {}|{} {} {}|\n|{} {} {}|{} {} {}|{} {} {}|\n|{} {} {}|{} {} {}|{} {} {}|\n¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯\n", 
	board[0][0], board[0][1], board[0][2], board[0][3], board[0][4], board[0][5], board[0][6], board[0][7], board[0][8],
	board[1][0], board[1][1], board[1][2], board[1][3], board[1][4], board[1][5], board[1][6], board[1][7], board[1][8],
	board[2][0], board[2][1], board[2][2], board[2][3], board[2][4], board[2][5], board[2][6], board[2][7], board[2][8],
	board[3][0], board[3][1], board[3][2], board[3][3], board[3][4], board[3][5], board[3][6], board[3][7], board[3][8],
	board[4][0], board[4][1], board[4][2], board[4][3], board[4][4], board[4][5], board[4][6], board[4][7], board[4][8],
	board[5][0], board[5][1], board[5][2], board[5][3], board[5][4], board[5][5], board[5][6], board[5][7], board[5][8],
	board[6][0], board[6][1], board[6][2], board[6][3], board[6][4], board[6][5], board[6][6], board[6][7], board[6][8],
	board[7][0], board[7][1], board[7][2], board[7][3], board[7][4], board[7][5], board[7][6], board[7][7], board[7][8],
	board[8][0], board[8][1], board[8][2], board[8][3], board[8][4], board[8][5], board[8][6], board[8][7], board[8][8]);
}

fn layer(squares: &Vec<Vec<u8>>) -> impl Iterator<Item = [u8; 9]> { 
    let a = {
    let s0 = squares[0].iter();
    s0.flat_map(move |&o| {
        let s1 = squares[1].iter().filter(move |&&d| d / 3 != o / 3 + 1);
        s1.flat_map(move |&tw| {
            let s2 = squares[2].iter().filter(move |&&d| (d / 3 != o / 3 + 2) & (d / 3 != tw / 3 + 1));
            s2.flat_map(move |&th| {
                let s3 = squares[3].iter().filter(move |&&d| d % 3 != o % 3);
                s3.flat_map(move |&fo| {
                    let s4 = squares[4].iter().filter(move |&&d| (d % 3 != tw % 3) & (d / 3 != fo / 3 + 1));
                    s4.flat_map(move |&fi| {
                        let s5 = squares[5].iter().filter(move |&&d| (d % 3 != th % 3) & (d / 3 != fo / 3 + 2) & (d / 3 != fi / 3 + 1));
                        s5.flat_map(move |&si| {
                            let s6 = squares[6].iter().filter(move |&&d| (d % 3 != o % 3) & (d % 3 != fo % 3));
                            s6.flat_map(move |&se| {
                                let s7 = squares[7].iter().filter(move |&&d| (d % 3 != tw % 3) & (d % 3 != fi % 3) & (d / 3 != se / 3 + 1));
                                s7.flat_map(move |&e| {
                                    let s8 = squares[8].iter().filter(move |&&d| (d % 3 != th % 3) & (d % 3 != si % 3) & (d / 3 != se / 3 + 2) & (d / 3 != e / 3 + 1));
                                    s8.map(move |&n| [o, tw, th, fo, fi, si, se, e, n])
                                })
                            })
                        })
                    })
                })
            })
        })
    })};
    a
}

fn all() {
    let squares = vec![
        vec![0, 1, 2, 9, 10, 11, 18, 19, 20],
        vec![3, 4, 5, 12, 13, 14, 21, 22, 23],
        vec![6, 7, 8, 15, 16, 17, 24, 25, 26],
        vec![27, 28, 29, 36, 37, 38, 45, 46, 47],
        vec![30, 31, 32, 39, 40, 41, 48, 49, 50],
        vec![33, 34, 35, 42, 43, 44, 51, 52, 53],
        vec![54, 55, 56, 63, 64, 65, 72, 73, 74],
        vec![57, 58, 59, 66, 67, 68, 75, 76, 77],
        vec![60, 61, 62, 69, 70, 71, 78, 79, 80],
    ];
    
    let mut a = layer(&squares);
    let mut count: usize = 0;
    loop {
        let _ = match a.next() {
        None => break,
        Some(val) => {
            let mut squares2 = squares.clone();
			for i in 0..9 {
			let index = squares2[i].iter().position(|x| *x == val[i]).unwrap();
			squares2[i].remove(index);
			}
			let mut b = layer(&squares2);
			loop {
			let _ = match b.next() {
			None => break,
			Some(val2) => {
				let mut squares3 = squares2.clone();
				for i in 0..9 {
				let index = squares3[i].iter().position(|x| *x == val2[i]).unwrap();
				squares3[i].remove(index);
				}
				let mut c = layer(&squares3);
				loop {
				let _ = match c.next() {
				None => break,
				Some(val3) => {
					let mut squares4 = squares3.clone();
					for i in 0..9 {
					let index = squares4[i].iter().position(|x| *x == val3[i]).unwrap();
					squares4[i].remove(index);
					}
					let mut d = layer(&squares4);
					loop {
					let _ = match d.next() {
					None => break,
					Some(val4) => {
						println!("{}", count);
						let mut squares5 = squares4.clone();
						for i in 0..9 {
						let index = squares5[i].iter().position(|x| *x==val4[i]).unwrap();
						squares5[i].remove(index);
						}
						let mut e = layer(&squares5);
						loop {
						let _ = match e.next() {
						None => break,
						Some(val5) => {
							let mut squares6 = squares5.clone();
							for i in 0..9 {
							let index = squares6[i].iter().position(|x| *x==val5[i]).unwrap();
							squares6[i].remove(index);
							}
							let mut f = layer(&squares6);
							loop {
							let _ = match f.next() {
							None => break,
							Some(val6) => {
								let mut squares7 = squares6.clone();
								for i in 0..9 {
								let index = squares7[i].iter().position(|x| *x==val6[i]).unwrap();
								squares7[i].remove(index);
								}
								let mut g = layer(&squares7);
								loop {
								let _ = match g.next() {
								None => break,
								Some(val7) => {
									let mut squares8 = squares7.clone();
									for i in 0..9 {
									let index = squares8[i].iter().position(|x| *x==val7[i]).unwrap();
									squares8[i].remove(index);
									}
									let mut h = layer(&squares8);
									loop {
									let _ = match h.next() {
									None => break,
									Some(val8) => {
										let mut squares9 = squares8.clone();
										let mut val9: [u8; 9] = [0; 9];
										for i in 0..9 {
										let index = squares9[i].iter().position(|x| *x==val8[i]).unwrap();
										squares9[i].remove(index);
										val9[i] = squares9[i][0];
										}
										count +=1;
										//println!("{:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}", val,val2,val3,val4,val5,val6,val7,val8,val9);
										//draw_board([val, val2, val3, val4, val5, val6, val7, val8, val9]);
										}};};}};};}};};}};};}};};}};};}};};}};};
	println!("{}", count);
}

fn main() {
	all();
}