*/

macro_rules! log {

    (@ENDPT, $logger:expr, $($arg:tt)*) => {{

        // if let Some(w) = $logger.line_writer() {

        //     let _ = writeln!(w, $($arg)*);

        use SyncError as Se;

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

        // Create separate storages for ports and components stored in `cu`,

        // while kicking off the branching of components until the set of

        // components entering their synchronous block is finalized in `branching_proto_components`.

            "All {} proto components are now done with Nonsync phase",

            branching_proto_components.len(),

        );

        // Create temporary structures needed for the synchronous phase of the round

        let mut rctx = RoundCtx {

            deadline: timeout.map(|to| Instant::now() + to),

        };

        log!(cu.logger(), "Round context structure initialized");

        // Prepare the branching native component, involving the conversion

        // of its synchronous batches (user provided) into speculative branches eagerly.

        // Call to another big method; keep running this round

        // until a distributed decision is reached!

        log!(cu.logger(), "Searching for decision...");

        let decision = Self::sync_reach_decision(

            cu,

            comm,

            &mut branching_proto_components,

            &mut rctx,

        )?;

        log!(cu.logger(), "Committing to decision {:?}!", &decision);

        comm.endpoint_manager.udp_endpoints_round_end(&mut *cu.logger(), &decision)?;

        // propagate the decision to children

            &msg,

            &comm.neighborhood.children

        );

        for &child in comm.neighborhood.children.iter() {

            comm.endpoint_manager.send_to_comms(child, &msg)?;

        }

            }

        };

        log!(cu.logger(), "Sync round ending! Cleaning up");

        ret

    }

        rctx: &mut RoundCtx,

    ) -> Result<Decision, UnrecoverableSyncError> {

        // The round is in progress, and now its just a matter of arriving at a decision.

        let mut already_requested_failure = false;

        if branching_native.branches.is_empty() {

            // An unsatisfiable native is the easiest way to detect failure

            // handle all buffered messages, sending them through endpoints / feeding them to components

            log!(cu.logger(), "Decision loop! have {} messages to recv", rctx.payload_inbox.len());

            while let Some((getter, send_payload_msg)) = rctx.getter_pop() {

                let getter_info = rctx.ips.port_info.map.get(&getter).unwrap();

                let cid = getter_info.owner; // the id of the component owning `getter` port

                assert_eq!(Getter, getter_info.polarity); // sanity check

                    }

                    Route::NetEndpoint { index } => {

                        // this is a message sent over the network as a control message

                        let msg = Msg::CommMsg(CommMsg {

                            round_index: comm.round_index,

                            contents: CommMsgContents::SendPayload(send_payload_msg),

            log!(cu.logger(), "Check if we have any local decisions...");

            for solution in rctx.solution_storage.iter_new_local_make_old() {

                log!(cu.logger(), "New local decision with solution {:?}...", &solution);

                match comm.neighborhood.parent {

                    Some(parent) => {

                        // Always forward connector-local solutions to my parent