// try recv messages arriving through endpoints

            log!(cu.logger, "No decision yet. Let's recv an endpoint msg...");

            {

                        CommRecvOk::NewPayloadMsgs => continue 'undecided,

                        CommRecvOk::TimeoutWithoutNew => {

                            log!(cu.logger, "Reached user-defined deadling without decision...");

                log!(

                    cu.logger,

                    "Received from endpoint {} ctrl msg  {:?}",

                    &comm_ctrl_msg

                );

                match comm_ctrl_msg {

                    CommCtrlMsg::Suggest { suggestion } => {

                        // only accept this control msg through a child endpoint

                            match suggestion {

                                Decision::Success(predicate) => {

                                    // child solution contributes to local solution

                                    log!(cu.logger, "Child provided solution {:?}", &predicate);

                                    rctx.solution_storage.submit_and_digest_subtree_solution(

                                        &mut *cu.logger,

                                        subtree_id,

                                cu.logger,

                                "Discarding suggestion {:?} from non-child endpoint idx {:?}",

                                &suggestion,

                            );

                        }

                    }

                    CommCtrlMsg::Announce { decision } => {

                            // adopt this decision

                            return Ok(decision);

                        } else {

                                cu.logger,

                                "Discarding announcement {:?} from non-parent endpoint idx {:?}",

                                &decision,

                            );

                        }

                    }

                finished.insert(predicate, branch);

                continue;

            }

                    // this branch does not receive the message

                    log!(

                        cu.logger,

                    );

                    finished.insert(predicate, branch);

                }

                    // retain the existing predicate, but add this payload

                    feed_branch(&mut branch, &predicate);

                    log!(cu.logger, "branch pred covers it! Accept the msg");

                    finished.insert(predicate, branch);

                }

                    // fork branch, give fork the message and payload predicate. original branch untouched

                    let mut branch2 = branch.clone();

                    let predicate2 = send_payload_msg.predicate.clone();

                    finished.insert(predicate, branch);

                    finished.insert(predicate2, branch2);

                }

                    // fork branch, give fork the message and the new predicate. original branch untouched

                    let mut branch2 = branch.clone();

                    feed_branch(&mut branch2, &predicate2);

                blocked.insert(predicate, branch);

                continue;

            }

            log!(logger, "visiting branch with pred {:?}", &predicate);

                    // this branch does not receive the message

                    log!(logger, "skipping branch");

                    blocked.insert(predicate, branch);

                }

                    // retain the existing predicate, but add this payload

                    log!(logger, "feeding this branch without altering its predicate");

                    branch.feed_msg(getter, send_payload_msg.payload.clone());

                    unblocked.insert(predicate, branch);

                }

                    // fork branch, give fork the message and payload predicate. original branch untouched

                    log!(logger, "Forking this branch, giving it the predicate of the msg");

                    let mut branch2 = branch.clone();

                    blocked.insert(predicate, branch);

                    unblocked.insert(predicate2, branch2);

                }

                    // fork branch, give fork the message and the new predicate. original branch untouched

                    log!(logger, "Forking this branch with new predicate {:?}", &predicate2);

                    let mut branch2 = branch.clone();

                &mut self,

                logger: &mut dyn Logger,

                round_ctx: &mut impl RoundCtxTrait,

                msg: Msg,

                round_index: usize,

                some_message_enqueued: &mut bool,

                                comm_msg.round_index,

                                round_index,

                            );

                            return None;

                        }

                    },

                };

                match comm_msg_contents {

                    CommMsgContents::SendPayload(send_payload_msg) => {

                        round_ctx.getter_add(getter, send_payload_msg);

                        *some_message_enqueued = true;

                        None

        ///////////////////////////////////////////

        let mut some_message_enqueued = false;

        // try yield undelayed net message

                logger,

                round_ctx,

                msg,

                round_index,

                &mut some_message_enqueued,

            ) {

            }

        }

        loop {

            // try receive a net message

                    logger,

                    round_ctx,

                    msg,

                    round_index,

                    &mut some_message_enqueued,

                ) {

                }

            }

            // try receive a udp message

    payload: Payload,

}

#[derive(Debug, PartialEq)]

    FormerNotLatter,

    LatterNotFormer,

    Equivalent,

    to_put: HashMap<PortId, Payload>,

    to_get: HashSet<PortId>,

}

enum TokenTarget {

    NetEndpoint { index: usize },

    UdpEndpoint { index: usize },

enum CommRecvOk {

    TimeoutWithoutNew,

    NewPayloadMsgs,

}

////////////////

fn would_block(err: &std::io::Error) -> bool {

        for (var, val) in self.assigned.iter() {

            match maybe_superset.assigned.get(var) {

                Some(val2) if val2 == val => {}

            }

        }

        true

    }

    // returns true IFF self.unify would return Equivalent OR FormerNotLatter

        // iterators over assignments of both predicates. Rely on SORTED ordering of BTreeMap's keys.

        let [mut s_it, mut o_it] = [self.assigned.iter(), other.assigned.iter()];

        let [mut s, mut o] = [s_it.next(), o_it.next()];

                    } else if sb != ob {

                        assert_eq!(sid, oid);

                        // both predicates assign the variable but differ on the value

                    } else {

                        // both predicates assign the variable to the same value

                        s = s_it.next();

        }

        // Observed zero inconsistencies. A unified predicate exists...

        match [s_not_o.is_empty(), o_not_s.is_empty()] {

            [false, false] => {

                // ... which is the union of the predicates' assignments but

                //     is equivalent to neither self nor other.

                for (&id, &b) in o_not_s {

                    new.assigned.insert(id, b);

                }

            }

        }

    }

                let mut endpoint_manager = new_endpoint_manager(

                    &mut *cu.logger,

                    &setup.net_endpoint_setups,

                    &mut cu.port_info,

                    &deadline,

                )?;

}

fn new_endpoint_manager(

    logger: &mut dyn Logger,

    port_info: &mut PortInfo,

    deadline: &Option<Instant>,

) -> Result<EndpointManager, ConnectError> {

        sent_local_port: bool,          // true <-> I've sent my local port

        recv_peer_port: Option<PortId>, // Some(..) <-> I've received my peer's port

    }

    enum TodoEndpoint {

        Accepting(TcpListener),

        NetEndpoint(NetEndpoint),

    }

    ////////////////////////////////////////////

    // 1. Start to construct EndpointManager

    let mut waker_state: Option<Arc<WakerState>> = None;

    let mut poll = Poll::new().map_err(|_| Ce::PollInitFailed)?;

    let mut net_polled_undrained = VecSet::default();

    let udp_polled_undrained = VecSet::default();

    let mut delayed_messages = vec![];

    // 2. create a registered (TcpListener/Endpoint) for passive / active respectively

        .iter()

        .enumerate()

        .map(|(index, (local_port, endpoint_setup))| {

        })

        .collect::<Result<Vec<Todo>, ConnectError>>()?;

    // 3. Using poll to drive progress:

    //    - accept an incoming connection for each TcpListener (turning them into endpoints too)

    // all in connect_failed are NOT registered with Poll

    let mut connect_failed: HashSet<usize> = Default::default();

    while !setup_incomplete.is_empty() {

        let remaining = if let Some(deadline) = deadline {

            Some(deadline.checked_duration_since(Instant::now()).ok_or(Ce::Timeout)?)

        for event in events.iter() {

            let token = event.token();

            let token_target = TokenTarget::from(token);

            match token_target {

                TokenTarget::Waker => {

                    log!(

                        connect_failed.iter()

                    );

                    assert!(waker_state.is_some());

                        log!(

                            logger,

                            "Restarting connection with endpoint {:?} {:?}",

                            todo.endpoint_setup.sock_addr

                        );

                        match &mut todo.todo_endpoint {

                                    TcpStream::connect(todo.endpoint_setup.sock_addr)

                                        .expect("mio::TcpStream connect should not fail!");

                                std::mem::swap(&mut endpoint.stream, &mut new_stream);

                                poll.registry()

                                    .register(&mut endpoint.stream, token, BOTH)

                                    .unwrap();

                        }

                    }

                }

                TokenTarget::NetEndpoint { index } => {

                    let todo: &mut Todo = &mut todos[index];

                    if let TodoEndpoint::Accepting(listener) = &mut todo.todo_endpoint {

                            // spurious wakeup

                            continue;

                        }

                        let local_polarity = *port_info.polarities.get(&todo.local_port).unwrap();

                        if event.is_writable() && !todo.sent_local_port {

                            // can write and didn't send setup msg yet? Do so!

                        // is the setup for this net_endpoint now complete?

                        if todo.sent_local_port && todo.recv_peer_port.is_some() {

                            // yes! connected, sent my info and received peer's info

                            log!(logger, "endpoint[{}] is finished!", index);

                        }

                    }

        arc.continue_signal.store(false, std::sync::atomic::Ordering::SeqCst);

        // TODO leave the waker registered?

    }

    let net_endpoint_exts = todos

        .into_iter()

            getter_for_incoming: local_port,

        })

        .collect();

    Ok(EndpointManager {

        poll,

        events,

    .unwrap();

}