///////////////////// DEFS /////////////////////

pub type ControllerId = u32;

pub type ChannelIndex = u32;

#[derive(Eq, PartialEq, Ord, PartialOrd, Hash, Copy, Clone)]

#[repr(C)]

pub struct Port(pub usize); // ports are COPY

#[derive(Eq, PartialEq, Copy, Clone, Debug)]

pub enum MainComponentErr {

    fn parse(pdl: &[u8]) -> Result<Self, String>;

    fn component_polarities(&self, identifier: &[u8]) -> Result<Vec<Polarity>, MainComponentErr>;

}

pub trait ComponentState: Sized + Clone {

pub enum PolyBlocker {

    Inconsistent,

    SyncBlockEnd,

}

pub trait MonoContext {

    type D: ProtocolDescription;

    type S: ComponentState<D = Self::D>;

    fn new_random(&mut self) -> u64;

}

pub trait PolyContext {

    type D: ProtocolDescription;

}

///////////////////// IMPL /////////////////////

        write!(f, "Port({})", self.0)

    }

}

    pub fn from_raw(raw: usize) -> Self {

        Self(raw)

    }

}

#[derive(Debug, Clone)]

impl Display for InputValue {

    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

}

#[derive(Debug, Clone)]

impl Display for OutputValue {

    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

primitive sync(in i, out o) {

    while(true) synchronous() if(fires(i)) put(o, get(i));

}

    while(true) {

    }

}

primitive replicator_2(in i, out l, out r) {

impl InputSource {

    // Constructors

        let mut vec = STD_LIB_PDL.to_vec();

        reader.read_to_end(&mut vec)?;

        Ok(InputSource {

        }

        Ok(result)

    }

        let mut args = Vec::new();

        for (&x, y) in ports.iter().zip(self.component_polarities(identifier).unwrap()) {

            match y {

                    // Not possible to create component in sync block

                    EvalContinuation::NewComponent(_, _) => unreachable!(),

                    EvalContinuation::BlockFires(port) => match port {

                        }

                        }

                        _ => unreachable!(),

                    },

                    EvalContinuation::BlockGet(port) => match port {

                        }

                        }

                        _ => unreachable!(),

                    },

                    EvalContinuation::Put(port, message) => {

                        match port {

                            }

                            }

                            _ => unreachable!(),

                        }

                            }

                            _ => unreachable!(),

                        }

                    }

                },

            }

    None,

}

impl EvalContext<'_> {

    fn new_component(&mut self, args: &[Value], init_state: ComponentStateImpl) -> () {

        match self {

            EvalContext::None => unreachable!(),

            EvalContext::Mono(context) => {

                for arg in args.iter() {

                    match arg {

                        }

                        }

                        _ => {}

                    }

                }

            }

            EvalContext::Poly(_) => unreachable!(),

        }

            EvalContext::None => unreachable!(),

            EvalContext::Mono(_) => unreachable!(),

            EvalContext::Poly(context) => match port {

                _ => unreachable!(),

            },

        }

            EvalContext::None => unreachable!(),

            EvalContext::Mono(_) => unreachable!(),

            EvalContext::Poly(context) => match port {

                }

                _ => unreachable!(),

            },

        }

#[derive(Debug, Clone)]

pub(crate) struct MonoN {

}

#[derive(Debug)]

pub(crate) struct PolyN {

    pub branches: HashMap<Predicate, BranchN>,

}

#[derive(Debug, Clone)]

pub(crate) struct BranchN {

    pub sync_batch_index: usize,

}

#[derive(Debug, Clone)]

pub struct MonoP {

    pub state: ProtocolS,

}

#[derive(Debug)]

pub(crate) struct PolyP {

    pub incomplete: HashMap<Predicate, BranchP>,

    pub complete: HashMap<Predicate, BranchP>,

}

#[derive(Debug, Clone)]

pub(crate) struct BranchP {

    pub state: ProtocolS,

}

        'to_run_loop: while let Some((mut predicate, mut branch)) = to_run.pop() {

            let mut r_ctx = BranchPContext {

                m_ctx: m_ctx.reborrow(),

                predicate: &predicate,

                inbox: &branch.inbox,

            };

            );

            match blocker {

                Sb::Inconsistent => {} // DROP

                    let channel_id =

                    log!(

                        &mut r_ctx.m_ctx.inner.logger,

                        "~ ... {:?} couldnt read msg for port {:?}. has inbox {:?}",

                        // don't rerun now. Rerun at next `sync_run`

                        log!(&mut m_ctx.inner.logger, "~ ... Delay {:?}", m_ctx.my_subtree_id,);

                        self.incomplete.insert(predicate, branch);

                    } else {

                        log!(&mut m_ctx.inner.logger, "~ ... Drop {:?}", m_ctx.my_subtree_id,);

                    }

                    // ELSE DROP

                }

                    let channel_id =

                    // split the branch!

                    let branch_f = branch.clone();

                    let mut predicate_f = predicate.clone();

                    );

                    // come up with the predicate for this local solution

                        let fired =

                        match predicate.query(channel_id) {

                            Some(true) => {

                                if !fired {

                                    println!(

                                        "pred {:#?} in {:#?} out {:#?}",

                                        &predicate,

                                    );

                                    panic!("channel_id {:?} fired (based on outbox/inbox) but the predicate had Some(false)!" ,channel_id)

                                }

                                    println!(

                                        "pred {:#?} in {:#?} out {:#?}",

                                        &predicate,

                                    );

                                    panic!("channel_id {:?} fired (based on outbox/inbox) but the predicate had None!" ,channel_id)

                                }

                    );

                    self.complete.insert(predicate, branch);

                }

                    let EndpointExt { info, endpoint } =

                    if predicate.replace_assignment(info.channel_id, true) != Some(false) {

                        let msg = CommMsgContents::SendPayload {

                            payload_predicate: predicate.clone(),

                            payload,

                            &mut m_ctx.inner.logger,

                            "~ ... ... PolyP sending msg {:?} to {:?} ({:?}) now!",

                            &msg,

                            (info.channel_id.controller_id, info.channel_id.channel_index),

                        );

                        endpoint.send(msg)?;

        &mut self,

        m_ctx: PolyPContext,

        protocol_description: &ProtocolD,

        payload_predicate: Predicate,

        payload: Payload,

    ) -> Result<SyncRunResult, EndpointErr> {

                "... poly_recv_run matched running machine exactly! pred is {:?}",

                &payload_predicate

            );

                branch.blocking_on = None;

                vec![(payload_predicate, branch)]

            } else {

                            );

                            // old_predicate COVERS the assumptions of payload_predicate

                                // Incorrect to receive two distinct messages in same branch!

                                assert_eq!(prev_payload, &payload);

                            }

                                // run.

                                branch.blocking_on = None;

                                Some((old_predicate, branch))

                            );

                            // payload_predicate has new assumptions. FORK!

                            let mut payload_branch = branch.clone();

                                // Incorrect to receive two distinct messages in same branch!

                                assert_eq!(prev_payload, &payload);

                            }

                            // put the original back untouched

                            incomplete2.insert(old_predicate, branch);

                                // run the fork

                                payload_branch.blocking_on = None;

                                Some((new, payload_branch))

                            );

                            // payload_predicate has new assumptions. FORK!

                            let mut payload_branch = branch.clone();

                                // Incorrect to receive two distinct messages in same branch!

                                assert_eq!(prev_payload, &payload);

                            }

                            // put the original back untouched

                            incomplete2.insert(old_predicate.clone(), branch);

                                // run the fork

                                payload_branch.blocking_on = None;

                                Some((payload_predicate.clone(), payload_branch))

        self.complete

            .iter()

            .find(|(p, _)| decision.satisfies(p))

    }

}

impl PolyN {

    pub fn sync_recv(

        &mut self,

        logger: &mut String,

        payload: Payload,

        payload_predicate: Predicate,

                Csr::Nonexistant => { /* skip branch */ }

                Csr::LatterNotFormer | Csr::Equivalent => {

                    // Feed the message to this branch in-place. no need to modify pred.

                        report_if_solution(&branch, &old_predicate, logger);

                    }

                }

                Csr::FormerNotLatter => {

                    // create a new branch with the payload_predicate.

                    let mut forked = branch.clone();

                        report_if_solution(&forked, &payload_predicate, logger);

                        branches2.insert(payload_predicate.clone(), forked);

                    }

                Csr::New(new) => {

                    // create a new branch with the newly-created predicate

                    let mut forked = branch.clone();

                        report_if_solution(&forked, &new, logger);

                        branches2.insert(new.clone(), forked);

                    }

            .find(|(p, branch)| branch.to_get.is_empty() && decision.satisfies(p))

            .map(|(_, branch)| {

                let BranchN { gotten, sync_batch_index, .. } = branch.clone();

            })

    }

}

            Decision::Failure => Err(SyncErr::Timeout),

        };

        let announcement = CommMsgContents::Announce { decision }.into_msg(self.inner.round_index);

            log!(

                &mut self.inner.logger,

                &announcement,

            );

            self.inner

                .endpoint_exts

                .expect("eefef")

                .endpoint

                .send(announcement.clone())?;

    // Drain self.ephemeral.solution_storage and handle the new locals. Return decision if one is found

    fn handle_locals_maybe_decide(&mut self) -> Result<bool, SyncErr> {

            // I have a parent -> I'm not the leader

            let parent_endpoint =

            for partial_oracle in self.ephemeral.solution_storage.iter_new_local_make_old() {

                let msg =

                    CommMsgContents::Elaborate { partial_oracle }.into_msg(self.inner.round_index);

                parent_endpoint.send(msg)?;

            }

            Ok(false)

        } else {

            // I have no parent -> I'm the leader

            let maybe_predicate = self.ephemeral.solution_storage.iter_new_local_make_old().next();

            Ok(if let Some(predicate) = maybe_predicate {

                let decision = Decision::Success(predicate);

        &mut self,

        sync_batches: impl Iterator<Item = SyncBatch>,

    ) -> Result<PolyN, EndpointErr> {

        let Self { inner: ControllerInner { endpoint_exts, round_index, .. }, .. } = self;

        let mut branches = HashMap::<_, _>::default();

        for (sync_batch_index, SyncBatch { puts, gets }) in sync_batches.enumerate() {

            let mut predicate = Predicate::new_trivial();

            // assign TRUE for puts and gets

            predicate.batch_assign_nones(true_channel_ids, true);

            // assign FALSE for all in interface not assigned true

                )

            }

            let branch = BranchN { to_get: gets, gotten: Default::default(), sync_batch_index };

                log!(

                    &mut self.inner.logger,

                    "... ... Initial native put msg {:?} pred {:?} batch {:?}",

                let msg =

                    CommMsgContents::SendPayload { payload_predicate: predicate.clone(), payload }

                        .into_msg(*round_index);

            }

            log!(

                &mut self.inner.logger,

            }

            branches.insert(predicate, branch);

        }

    }

    pub fn sync_round(

        &mut self,

        log!(&mut self.inner.logger, "Got {} MonoP's to run!", self.ephemeral.mono_ps.len());

        while let Some(mut mono_p) = self.ephemeral.mono_ps.pop() {

            let mut m_ctx = MonoPContext {

                mono_ps: &mut self.ephemeral.mono_ps,

                inner: &mut self.inner,

            };

            self.ephemeral.poly_ps.len()

        );

        //    this is needed during the event loop to determine which actor

        //    should receive the incoming message.

        //    TODO: store and update this mapping rather than rebuilding it each round.

            use PolyId::*;

            let p = self

                .ephemeral

                .poly_ps

                .iter()

                .enumerate()

            n.chain(p).collect()

        };

        log!(

            &mut self.inner.logger,

        );

        // 4. Create the solution storage. it tracks the solutions of "subtrees"

            let c = self

                .inner

                .family

                .iter()

            let subtree_id_iter = n.chain(m).chain(c);

            log!(

                &mut self.inner.logger,

                        // timed out! send a FAILURE message to the sink,

                        // and henceforth don't time out on polling.

                        deadline = None;

                            None => {

                                // I am the sink! announce failure and return.

                                return self.end_round_with_decision(Decision::Failure);

                            }

                                // I am not the sink! send a failure message.

                                let announcement = Msg::CommMsg(CommMsg {

                                    round_index: self.inner.round_index,

                                });

                                log!(

                                    &mut self.inner.logger,

                                    &announcement,

                                );

                                self.inner

                                    .endpoint_exts

                                    .expect("ss")

                                    .endpoint

                                    .send(announcement.clone())?;

                Msg::CommMsg(CommMsg { contents, round_index }) => {

                    log!(

                        &mut self.inner.logger,

                        received.recipient

                    );

                    assert_eq!(round_index, self.inner.round_index);

                }

            };

            match current_content {

                        let announcement = Msg::CommMsg(CommMsg {

                            round_index: self.inner.round_index,

                            contents: CommMsgContents::Failure,

                        });

                        log!(

                            &mut self.inner.logger,

                            &announcement,

                        );

                        self.inner

                            .endpoint_exts

                            .expect("ss")

                            .endpoint

                            .send(announcement.clone())?;

                },

                CommMsgContents::Elaborate { partial_oracle } => {

                    // Child controller submitted a subtree solution.

                        return Err(SyncErr::ElaborateFromNonChild);

                    }

                    log!(

                        &mut self.inner.logger,

                        "Received elaboration from child for subtree {:?}: {:?}",

                    }

                }

                CommMsgContents::Announce { decision } => {

                        return Err(SyncErr::AnnounceFromNonParent);

                    }

                    log!(

                    // message for some actor. Feed it to the appropriate actor

                    // and then give them another chance to run.

                    log!(

                        &mut self.inner.logger,

                        "Received SendPayload for subtree {:?} with pred {:?} and payload {:?}",

            && self.poly_n.is_none()

            && self.poly_ps.is_empty()

            && self.mono_ps.is_empty()

    }

    fn clear(&mut self) {

        self.solution_storage.clear();

        self.poly_n.take();

        self.poly_ps.clear();

    }

}

impl Into<PolyP> for MonoP {

                    blocking_on: None,

                }

            },

        }

    }

}

impl MonoContext for MonoPContext<'_> {

    type D = ProtocolD;

    type S = ProtocolS;

        log!(

            &mut self.inner.logger,

        );

        } else {

        }

    }

        let [a, b] = Endpoint::new_memory_pair();

        let channel_id = self.inner.channel_id_stream.next();

        let mut clos = |endpoint, polarity| {

            let endpoint_ext =

                EndpointExt { info: EndpointInfo { polarity, channel_id }, endpoint };

            self.inner

                .messenger_state

                .poll

                .register(endpoint, token, Ready::readable(), PollOpt::edge())

                .expect("AAGAGGGGG");

        };

        let [kp, kg] = [clos(a, Putter), clos(b, Getter)];