use std::{cell::RefCell, rc::Rc, sync::mpsc::Sender};
mod generated {
    use rerust::rerust_gen;
    use std::cell::RefCell;
    use std::mem;
    use std::rc::Weak;
    use std::sync::mpsc::*;
    pub struct State {
        var_6: Option<usize>,
        var_5: Option<Vec<String>>,
        evt_1: Option<String>,
        var_0: Option<String>,
        group_2: Option<(String, String)>,
        map_3: Option<String>,
        fold_4: Option<Vec<String>>,
        group_7: Option<(Vec<String>, Vec<String>)>,
        map_8: Option<Vec<Vec<String>>>,
        group_9: Option<(Vec<Vec<String>>, usize)>,
        map_10: Option<Vec<String>>,
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::clone::Clone for State {
        #[inline]
        fn clone(&self) -> State {
            match *self {
                State {
                    var_6: ref __self_0_0,
                    var_5: ref __self_0_1,
                    evt_1: ref __self_0_2,
                    var_0: ref __self_0_3,
                    group_2: ref __self_0_4,
                    map_3: ref __self_0_5,
                    fold_4: ref __self_0_6,
                    group_7: ref __self_0_7,
                    map_8: ref __self_0_8,
                    group_9: ref __self_0_9,
                    map_10: ref __self_0_10,
                } => State {
                    var_6: ::core::clone::Clone::clone(&(*__self_0_0)),
                    var_5: ::core::clone::Clone::clone(&(*__self_0_1)),
                    evt_1: ::core::clone::Clone::clone(&(*__self_0_2)),
                    var_0: ::core::clone::Clone::clone(&(*__self_0_3)),
                    group_2: ::core::clone::Clone::clone(&(*__self_0_4)),
                    map_3: ::core::clone::Clone::clone(&(*__self_0_5)),
                    fold_4: ::core::clone::Clone::clone(&(*__self_0_6)),
                    group_7: ::core::clone::Clone::clone(&(*__self_0_7)),
                    map_8: ::core::clone::Clone::clone(&(*__self_0_8)),
                    group_9: ::core::clone::Clone::clone(&(*__self_0_9)),
                    map_10: ::core::clone::Clone::clone(&(*__self_0_10)),
                },
            }
        }
    }
    pub struct Change {
        var_6: bool,
        index: bool,
        var_5: bool,
        room2: bool,
        evt_1: bool,
        text: bool,
        var_0: bool,
        name: bool,
        group_2: bool,
        map_3: bool,
        message: bool,
        fold_4: bool,
        room1: bool,
        group_7: bool,
        map_8: bool,
        room_list: bool,
        group_9: bool,
        map_10: bool,
        selected_room: bool,
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::default::Default for Change {
        #[inline]
        fn default() -> Change {
            Change {
                var_6: ::core::default::Default::default(),
                index: ::core::default::Default::default(),
                var_5: ::core::default::Default::default(),
                room2: ::core::default::Default::default(),
                evt_1: ::core::default::Default::default(),
                text: ::core::default::Default::default(),
                var_0: ::core::default::Default::default(),
                name: ::core::default::Default::default(),
                group_2: ::core::default::Default::default(),
                map_3: ::core::default::Default::default(),
                message: ::core::default::Default::default(),
                fold_4: ::core::default::Default::default(),
                room1: ::core::default::Default::default(),
                group_7: ::core::default::Default::default(),
                map_8: ::core::default::Default::default(),
                room_list: ::core::default::Default::default(),
                group_9: ::core::default::Default::default(),
                map_10: ::core::default::Default::default(),
                selected_room: ::core::default::Default::default(),
            }
        }
    }
    pub struct Observers {
        index: Vec<Weak<RefCell<dyn FnMut(&usize)>>>,
        room2: Vec<Weak<RefCell<dyn FnMut(&Vec<String>)>>>,
        text: Vec<Weak<RefCell<dyn FnMut(&String)>>>,
        name: Vec<Weak<RefCell<dyn FnMut(&String)>>>,
        message: Vec<Weak<RefCell<dyn FnMut(&String)>>>,
        room1: Vec<Weak<RefCell<dyn FnMut(&Vec<String>)>>>,
        room_list: Vec<Weak<RefCell<dyn FnMut(&Vec<Vec<String>>)>>>,
        selected_room: Vec<Weak<RefCell<dyn FnMut(&Vec<String>)>>>,
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::default::Default for Observers {
        #[inline]
        fn default() -> Observers {
            Observers {
                index: ::core::default::Default::default(),
                room2: ::core::default::Default::default(),
                text: ::core::default::Default::default(),
                name: ::core::default::Default::default(),
                message: ::core::default::Default::default(),
                room1: ::core::default::Default::default(),
                room_list: ::core::default::Default::default(),
                selected_room: ::core::default::Default::default(),
            }
        }
    }
    pub struct Program {
        state: State,
        observers: Observers,
        receiver: Receiver<Input>,
        sink: Sink,
    }
    pub struct Input {
        var_6: Option<usize>,
        var_5: Option<Vec<String>>,
        evt_1: Option<String>,
        var_0: Option<String>,
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::default::Default for Input {
        #[inline]
        fn default() -> Input {
            Input {
                var_6: ::core::default::Default::default(),
                var_5: ::core::default::Default::default(),
                evt_1: ::core::default::Default::default(),
                var_0: ::core::default::Default::default(),
            }
        }
    }
    impl Input {
        pub fn set_index(&mut self, value: usize) {
            self.var_6 = Some(value);
        }
        pub fn set_room2(&mut self, value: Vec<String>) {
            self.var_5 = Some(value);
        }
        pub fn set_text(&mut self, value: String) {
            self.evt_1 = Some(value);
        }
        pub fn set_name(&mut self, value: String) {
            self.var_0 = Some(value);
        }
    }
    struct Phantom {}
    struct Slots {
        index: Option<Cardindex>,
        room2: Option<Cardroom2>,
        text: Option<Cardtext>,
        name: Option<Cardname>,
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::core::default::Default for Slots {
        #[inline]
        fn default() -> Slots {
            Slots {
                index: ::core::default::Default::default(),
                room2: ::core::default::Default::default(),
                text: ::core::default::Default::default(),
                name: ::core::default::Default::default(),
            }
        }
    }
    pub struct Sink {
        slots: Slots,
        channel_sender: Sender<Input>,
    }
    impl Clone for Sink {
        fn clone(&self) -> Self {
            Self {
                slots: Slots::default(),
                channel_sender: self.channel_sender.clone(),
            }
        }
    }
    impl Sink {
        pub fn push_index(&mut self, card: Cardindex) {
            self.slots.index = Some(card);
        }
        pub fn pull_index(&mut self) -> Option<Cardindex> {
            self.slots.index.take()
        }
        pub fn send_index(&mut self, value: usize) {
            let mut input = Input::default();
            input.set_index(value);
            self.send(input);
        }
        pub fn push_room2(&mut self, card: Cardroom2) {
            self.slots.room2 = Some(card);
        }
        pub fn pull_room2(&mut self) -> Option<Cardroom2> {
            self.slots.room2.take()
        }
        pub fn send_room2(&mut self, value: Vec<String>) {
            let mut input = Input::default();
            input.set_room2(value);
            self.send(input);
        }
        pub fn push_text(&mut self, card: Cardtext) {
            self.slots.text = Some(card);
        }
        pub fn pull_text(&mut self) -> Option<Cardtext> {
            self.slots.text.take()
        }
        pub fn send_text(&mut self, value: String) {
            let mut input = Input::default();
            input.set_text(value);
            self.send(input);
        }
        pub fn push_name(&mut self, card: Cardname) {
            self.slots.name = Some(card);
        }
        pub fn pull_name(&mut self) -> Option<Cardname> {
            self.slots.name.take()
        }
        pub fn send_name(&mut self, value: String) {
            let mut input = Input::default();
            input.set_name(value);
            self.send(input);
        }
        pub fn take_all(&mut self, other: &mut Self) {
            if other.slots.index.is_some() {
                mem::swap(&mut self.slots.index, &mut other.slots.index);
            }
            if other.slots.room2.is_some() {
                mem::swap(&mut self.slots.room2, &mut other.slots.room2);
            }
            if other.slots.text.is_some() {
                mem::swap(&mut self.slots.text, &mut other.slots.text);
            }
            if other.slots.name.is_some() {
                mem::swap(&mut self.slots.name, &mut other.slots.name);
            }
        }
        pub fn send(&mut self, input: Input) {
            if (false
                || self.slots.index.is_some()
                || input.var_6.is_none()
                || self.slots.room2.is_some()
                || input.var_5.is_none()
                || self.slots.text.is_some()
                || input.evt_1.is_none()
                || self.slots.name.is_some()
                || input.var_0.is_none())
            {
                self.channel_sender.send(input);
            } else {
                {
                    ::std::rt::begin_panic("Slot empty for one input")
                };
            }
        }
        pub fn new(sender: Sender<Input>) -> Self {
            Self {
                slots: Slots::default(),
                channel_sender: sender,
            }
        }
    }
    impl Program {
        fn update(state: &mut State, receiver: &mut Receiver<Input>) -> Change {
            let mut change = Change::default();
            let result = receiver.try_recv();
            if let Ok(inputs) = result {
                if inputs.var_6.is_some() {
                    state.var_6 = inputs.var_6;
                    change.var_6 = true;
                }
                if inputs.var_5.is_some() {
                    state.var_5 = inputs.var_5;
                    change.var_5 = true;
                }
                if inputs.evt_1.is_some() {
                    state.evt_1 = inputs.evt_1;
                    change.evt_1 = true;
                }
                if inputs.var_0.is_some() {
                    state.var_0 = inputs.var_0;
                    change.var_0 = true;
                }
                if !state.evt_1.is_none() && !state.var_0.is_none() {
                    if change.evt_1 || change.var_0 {
                        change.group_2 = true;
                    }
                    state.group_2 =
                        Some((state.evt_1.clone().unwrap(), state.var_0.clone().unwrap()));
                }
                if change.group_2 {
                    let val = state.group_2.clone().unwrap();
                    let result = Self::map_3(val);
                    if state.map_3.is_none() || result != *state.map_3.as_ref().unwrap() {
                        change.map_3 = true;
                        state.map_3 = Some(result);
                    }
                }
                if change.map_3 {
                    let val = state.map_3.clone().unwrap();
                    let result = Self::fold_4(state.fold_4.clone().unwrap(), val);
                    if result != *state.fold_4.as_ref().unwrap() {
                        change.fold_4 = true;
                        state.fold_4 = Some(result);
                    }
                }
                if !state.fold_4.is_none() && !state.var_5.is_none() {
                    if change.fold_4 || change.var_5 {
                        change.group_7 = true;
                    }
                    state.group_7 =
                        Some((state.fold_4.clone().unwrap(), state.var_5.clone().unwrap()));
                }
                if change.group_7 {
                    let val = state.group_7.clone().unwrap();
                    let result = Self::map_8(val);
                    if state.map_8.is_none() || result != *state.map_8.as_ref().unwrap() {
                        change.map_8 = true;
                        state.map_8 = Some(result);
                    }
                }
                if !state.map_8.is_none() && !state.var_6.is_none() {
                    if change.map_8 || change.var_6 {
                        change.group_9 = true;
                    }
                    state.group_9 =
                        Some((state.map_8.clone().unwrap(), state.var_6.clone().unwrap()));
                }
                if change.group_9 {
                    let val = state.group_9.clone().unwrap();
                    let result = Self::map_10(val);
                    if state.map_10.is_none() || result != *state.map_10.as_ref().unwrap() {
                        change.map_10 = true;
                        state.map_10 = Some(result);
                    }
                }
            }
            change
        }
        fn notify(observers: &mut Observers, changes: Change, state: &State) {
            if changes.var_6 {
                observers.index.retain(|lst| {
                    if let Some(cb) = Weak::upgrade(lst) {
                        if let Some(val) = &state.var_6 {
                            (&mut *cb.borrow_mut())(val);
                            true
                        } else {
                            {
                                ::core::panicking::panic("internal error: entered unreachable code")
                            }
                        }
                    } else {
                        false
                    }
                });
            }
            if changes.var_5 {
                observers.room2.retain(|lst| {
                    if let Some(cb) = Weak::upgrade(lst) {
                        if let Some(val) = &state.var_5 {
                            (&mut *cb.borrow_mut())(val);
                            true
                        } else {
                            {
                                ::core::panicking::panic("internal error: entered unreachable code")
                            }
                        }
                    } else {
                        false
                    }
                });
            }
            if changes.evt_1 {
                observers.text.retain(|lst| {
                    if let Some(cb) = Weak::upgrade(lst) {
                        if let Some(val) = &state.evt_1 {
                            (&mut *cb.borrow_mut())(val);
                            true
                        } else {
                            {
                                ::core::panicking::panic("internal error: entered unreachable code")
                            }
                        }
                    } else {
                        false
                    }
                });
            }
            if changes.var_0 {
                observers.name.retain(|lst| {
                    if let Some(cb) = Weak::upgrade(lst) {
                        if let Some(val) = &state.var_0 {
                            (&mut *cb.borrow_mut())(val);
                            true
                        } else {
                            {
                                ::core::panicking::panic("internal error: entered unreachable code")
                            }
                        }
                    } else {
                        false
                    }
                });
            }
            if changes.map_3 {
                observers.message.retain(|lst| {
                    if let Some(cb) = Weak::upgrade(lst) {
                        if let Some(val) = &state.map_3 {
                            (&mut *cb.borrow_mut())(val);
                            true
                        } else {
                            {
                                ::core::panicking::panic("internal error: entered unreachable code")
                            }
                        }
                    } else {
                        false
                    }
                });
            }
            if changes.fold_4 {
                observers.room1.retain(|lst| {
                    if let Some(cb) = Weak::upgrade(lst) {
                        if let Some(val) = &state.fold_4 {
                            (&mut *cb.borrow_mut())(val);
                            true
                        } else {
                            {
                                ::core::panicking::panic("internal error: entered unreachable code")
                            }
                        }
                    } else {
                        false
                    }
                });
            }
            if changes.map_8 {
                observers.room_list.retain(|lst| {
                    if let Some(cb) = Weak::upgrade(lst) {
                        if let Some(val) = &state.map_8 {
                            (&mut *cb.borrow_mut())(val);
                            true
                        } else {
                            {
                                ::core::panicking::panic("internal error: entered unreachable code")
                            }
                        }
                    } else {
                        false
                    }
                });
            }
            if changes.map_10 {
                observers.selected_room.retain(|lst| {
                    if let Some(cb) = Weak::upgrade(lst) {
                        if let Some(val) = &state.map_10 {
                            (&mut *cb.borrow_mut())(val);
                            true
                        } else {
                            {
                                ::core::panicking::panic("internal error: entered unreachable code")
                            }
                        }
                    } else {
                        false
                    }
                });
            }
        }
        pub fn run(&mut self) {
            let Program {
                state,
                observers,
                receiver,
                sink,
            } = self;
            let changes = Self::update(state, receiver);
            Self::notify(observers, changes, state);
        }
        pub fn new() -> Self {
            let (send, recv) = channel();
            Self {
                state: State::default(),
                observers: Observers::default(),
                receiver: recv,
                sink: Sink::new(send),
            }
        }
        pub fn sink(&mut self) -> &mut Sink {
            &mut self.sink
        }
        pub fn observe_index(&mut self, observer: Weak<RefCell<dyn FnMut(&usize)>>) {
            self.observers.index.push(observer);
        }
        pub fn observe_room2(&mut self, observer: Weak<RefCell<dyn FnMut(&Vec<String>)>>) {
            self.observers.room2.push(observer);
        }
        pub fn observe_text(&mut self, observer: Weak<RefCell<dyn FnMut(&String)>>) {
            self.observers.text.push(observer);
        }
        pub fn observe_name(&mut self, observer: Weak<RefCell<dyn FnMut(&String)>>) {
            self.observers.name.push(observer);
        }
        #[inline]
        fn map_3((t, n): (String, String)) -> String {
            {
                let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
                    &["", ": "],
                    &match (&n, &t) {
                        (arg0, arg1) => [
                            ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Display::fmt),
                            ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Display::fmt),
                        ],
                    },
                ));
                res
            }
        }
        pub fn observe_message(&mut self, observer: Weak<RefCell<dyn FnMut(&String)>>) {
            self.observers.message.push(observer);
        }
        #[inline]
        fn fold_4(mut vec: Vec<String>, msg: String) -> Vec<String> {
            vec.push(msg);
            vec
        }
        pub fn observe_room1(&mut self, observer: Weak<RefCell<dyn FnMut(&Vec<String>)>>) {
            self.observers.room1.push(observer);
        }
        #[inline]
        fn map_8((room1, room2): (Vec<String>, Vec<String>)) -> Vec<Vec<String>> {
            <[_]>::into_vec(box [room1, room2])
        }
        pub fn observe_room_list(&mut self, observer: Weak<RefCell<dyn FnMut(&Vec<Vec<String>>)>>) {
            self.observers.room_list.push(observer);
        }
        #[inline]
        fn map_10((room_list, index): (Vec<Vec<String>>, usize)) -> Vec<String> {
            room_list[index].clone()
        }
        pub fn observe_selected_room(&mut self, observer: Weak<RefCell<dyn FnMut(&Vec<String>)>>) {
            self.observers.selected_room.push(observer);
        }
    }
    impl Default for State {
        fn default() -> Self {
            Self {
                var_6: Some(0),
                var_5: Some(<[_]>::into_vec(box [String::from(
                    "Me: a constant message",
                )])),
                evt_1: None,
                var_0: Some(String::new()),
                group_2: None,
                map_3: None,
                fold_4: Some(Vec::new()),
                group_7: None,
                map_8: None,
                group_9: None,
                map_10: None,
            }
        }
    }
}

fn main() {}