// Verilated -*- C++ -*-
// DESCRIPTION: Verilator output: Design implementation internals
// See Vmod_add_sync.h for the primary calling header

#include "Vmod_add_sync__pch.h"

void Vmod_add_sync___024root___eval_triggers_vec__ico(Vmod_add_sync___024root* vlSelf) {
    VL_DEBUG_IF(VL_DBG_MSGF("+    Vmod_add_sync___024root___eval_triggers_vec__ico\n"); );
    Vmod_add_sync__Syms* const __restrict vlSymsp VL_ATTR_UNUSED = vlSelf->vlSymsp;
    auto& vlSelfRef = std::ref(*vlSelf).get();
    // Body
    vlSelfRef.__VicoTriggered[0U] = ((0xfffffffffffffffeULL 
                                      & vlSelfRef.__VicoTriggered[0U]) 
                                     | (IData)((IData)(vlSelfRef.__VicoFirstIteration)));
}

bool Vmod_add_sync___024root___trigger_anySet__ico(const VlUnpacked<QData/*63:0*/, 1> &in) {
    VL_DEBUG_IF(VL_DBG_MSGF("+    Vmod_add_sync___024root___trigger_anySet__ico\n"); );
    // Locals
    IData/*31:0*/ n;
    // Body
    n = 0U;
    do {
        if (in[n]) {
            return (1U);
        }
        n = ((IData)(1U) + n);
    } while ((1U > n));
    return (0U);
}

void Vmod_add_sync___024root___ico_sequent__TOP__0(Vmod_add_sync___024root* vlSelf) {
    VL_DEBUG_IF(VL_DBG_MSGF("+    Vmod_add_sync___024root___ico_sequent__TOP__0\n"); );
    Vmod_add_sync__Syms* const __restrict vlSymsp VL_ATTR_UNUSED = vlSelf->vlSymsp;
    auto& vlSelfRef = std::ref(*vlSelf).get();
    // Body
    vlSelfRef.mod_add_sync__DOT__add_raw = (0x00001fffU 
                                            & ((IData)(vlSelfRef.a) 
                                               + (IData)(vlSelfRef.b)));
    vlSelfRef.ready_o = (1U & ((~ (IData)(vlSelfRef.mod_add_sync__DOT__u_pipe__DOT__valid_r)) 
                               | (IData)(vlSelfRef.ready_i)));
}

void Vmod_add_sync___024root___eval_ico(Vmod_add_sync___024root* vlSelf) {
    VL_DEBUG_IF(VL_DBG_MSGF("+    Vmod_add_sync___024root___eval_ico\n"); );
    Vmod_add_sync__Syms* const __restrict vlSymsp VL_ATTR_UNUSED = vlSelf->vlSymsp;
    auto& vlSelfRef = std::ref(*vlSelf).get();
    // Body
    if ((1ULL & vlSelfRef.__VicoTriggered[0U])) {
        vlSelfRef.mod_add_sync__DOT__add_raw = (0x00001fffU 
                                                & ((IData)(vlSelfRef.a) 
                                                   + (IData)(vlSelfRef.b)));
        vlSelfRef.ready_o = (1U & ((~ (IData)(vlSelfRef.mod_add_sync__DOT__u_pipe__DOT__valid_r)) 
                                   | (IData)(vlSelfRef.ready_i)));
    }
}

#ifdef VL_DEBUG
VL_ATTR_COLD void Vmod_add_sync___024root___dump_triggers__ico(const VlUnpacked<QData/*63:0*/, 1> &triggers, const std::string &tag);
#endif  // VL_DEBUG

bool Vmod_add_sync___024root___eval_phase__ico(Vmod_add_sync___024root* vlSelf) {
    VL_DEBUG_IF(VL_DBG_MSGF("+    Vmod_add_sync___024root___eval_phase__ico\n"); );
    Vmod_add_sync__Syms* const __restrict vlSymsp VL_ATTR_UNUSED = vlSelf->vlSymsp;
    auto& vlSelfRef = std::ref(*vlSelf).get();
    // Locals
    CData/*0:0*/ __VicoExecute;
    // Body
    Vmod_add_sync___024root___eval_triggers_vec__ico(vlSelf);
#ifdef VL_DEBUG
    if (VL_UNLIKELY(vlSymsp->_vm_contextp__->debug())) {
        Vmod_add_sync___024root___dump_triggers__ico(vlSelfRef.__VicoTriggered, "ico"s);
    }
#endif
    __VicoExecute = Vmod_add_sync___024root___trigger_anySet__ico(vlSelfRef.__VicoTriggered);
    if (__VicoExecute) {
        Vmod_add_sync___024root___eval_ico(vlSelf);
    }
    return (__VicoExecute);
}

void Vmod_add_sync___024root___eval_triggers_vec__act(Vmod_add_sync___024root* vlSelf) {
    VL_DEBUG_IF(VL_DBG_MSGF("+    Vmod_add_sync___024root___eval_triggers_vec__act\n"); );
    Vmod_add_sync__Syms* const __restrict vlSymsp VL_ATTR_UNUSED = vlSelf->vlSymsp;
    auto& vlSelfRef = std::ref(*vlSelf).get();
    // Body
    vlSelfRef.__VactTriggered[0U] = (QData)((IData)(
                                                    ((((~ (IData)(vlSelfRef.rst_n)) 
                                                       & (IData)(vlSelfRef.__Vtrigprevexpr___TOP__rst_n__0)) 
                                                      << 1U) 
                                                     | ((IData)(vlSelfRef.clk) 
                                                        & (~ (IData)(vlSelfRef.__Vtrigprevexpr___TOP__clk__0))))));
    vlSelfRef.__Vtrigprevexpr___TOP__clk__0 = vlSelfRef.clk;
    vlSelfRef.__Vtrigprevexpr___TOP__rst_n__0 = vlSelfRef.rst_n;
}

bool Vmod_add_sync___024root___trigger_anySet__act(const VlUnpacked<QData/*63:0*/, 1> &in) {
    VL_DEBUG_IF(VL_DBG_MSGF("+    Vmod_add_sync___024root___trigger_anySet__act\n"); );
    // Locals
    IData/*31:0*/ n;
    // Body
    n = 0U;
    do {
        if (in[n]) {
            return (1U);
        }
        n = ((IData)(1U) + n);
    } while ((1U > n));
    return (0U);
}

void Vmod_add_sync___024root___nba_sequent__TOP__0(Vmod_add_sync___024root* vlSelf) {
    VL_DEBUG_IF(VL_DBG_MSGF("+    Vmod_add_sync___024root___nba_sequent__TOP__0\n"); );
    Vmod_add_sync__Syms* const __restrict vlSymsp VL_ATTR_UNUSED = vlSelf->vlSymsp;
    auto& vlSelfRef = std::ref(*vlSelf).get();
    // Body
    if (vlSelfRef.rst_n) {
        if (((IData)(vlSelfRef.mod_add_sync__DOT__u_pipe__DOT__valid_r) 
             & (IData)(vlSelfRef.ready_i))) {
            vlSelfRef.mod_add_sync__DOT__u_pipe__DOT__valid_r = 0U;
        }
        if (((IData)(vlSelfRef.valid_i) & (IData)(vlSelfRef.ready_o))) {
            vlSelfRef.mod_add_sync__DOT__u_pipe__DOT__valid_r = 1U;
            vlSelfRef.mod_add_sync__DOT__u_pipe__DOT__data_r 
                = (0x00000fffU & ((0x0d01U > (IData)(vlSelfRef.mod_add_sync__DOT__add_raw))
                                   ? (IData)(vlSelfRef.mod_add_sync__DOT__add_raw)
                                   : ((IData)(vlSelfRef.mod_add_sync__DOT__add_raw) 
                                      - (IData)(0x0d01U))));
        }
    } else {
        vlSelfRef.mod_add_sync__DOT__u_pipe__DOT__valid_r = 0U;
        vlSelfRef.mod_add_sync__DOT__u_pipe__DOT__data_r = 0U;
    }
    vlSelfRef.valid_o = vlSelfRef.mod_add_sync__DOT__u_pipe__DOT__valid_r;
    vlSelfRef.ready_o = (1U & ((~ (IData)(vlSelfRef.mod_add_sync__DOT__u_pipe__DOT__valid_r)) 
                               | (IData)(vlSelfRef.ready_i)));
    vlSelfRef.sum = vlSelfRef.mod_add_sync__DOT__u_pipe__DOT__data_r;
}

void Vmod_add_sync___024root___eval_nba(Vmod_add_sync___024root* vlSelf) {
    VL_DEBUG_IF(VL_DBG_MSGF("+    Vmod_add_sync___024root___eval_nba\n"); );
    Vmod_add_sync__Syms* const __restrict vlSymsp VL_ATTR_UNUSED = vlSelf->vlSymsp;
    auto& vlSelfRef = std::ref(*vlSelf).get();
    // Body
    if ((3ULL & vlSelfRef.__VnbaTriggered[0U])) {
        if (vlSelfRef.rst_n) {
            if (((IData)(vlSelfRef.mod_add_sync__DOT__u_pipe__DOT__valid_r) 
                 & (IData)(vlSelfRef.ready_i))) {
                vlSelfRef.mod_add_sync__DOT__u_pipe__DOT__valid_r = 0U;
            }
            if (((IData)(vlSelfRef.valid_i) & (IData)(vlSelfRef.ready_o))) {
                vlSelfRef.mod_add_sync__DOT__u_pipe__DOT__valid_r = 1U;
                vlSelfRef.mod_add_sync__DOT__u_pipe__DOT__data_r 
                    = (0x00000fffU & ((0x0d01U > (IData)(vlSelfRef.mod_add_sync__DOT__add_raw))
                                       ? (IData)(vlSelfRef.mod_add_sync__DOT__add_raw)
                                       : ((IData)(vlSelfRef.mod_add_sync__DOT__add_raw) 
                                          - (IData)(0x0d01U))));
            }
        } else {
            vlSelfRef.mod_add_sync__DOT__u_pipe__DOT__valid_r = 0U;
            vlSelfRef.mod_add_sync__DOT__u_pipe__DOT__data_r = 0U;
        }
        vlSelfRef.valid_o = vlSelfRef.mod_add_sync__DOT__u_pipe__DOT__valid_r;
        vlSelfRef.ready_o = (1U & ((~ (IData)(vlSelfRef.mod_add_sync__DOT__u_pipe__DOT__valid_r)) 
                                   | (IData)(vlSelfRef.ready_i)));
        vlSelfRef.sum = vlSelfRef.mod_add_sync__DOT__u_pipe__DOT__data_r;
    }
}

void Vmod_add_sync___024root___trigger_orInto__act_vec_vec(VlUnpacked<QData/*63:0*/, 1> &out, const VlUnpacked<QData/*63:0*/, 1> &in) {
    VL_DEBUG_IF(VL_DBG_MSGF("+    Vmod_add_sync___024root___trigger_orInto__act_vec_vec\n"); );
    // Locals
    IData/*31:0*/ n;
    // Body
    n = 0U;
    do {
        out[n] = (out[n] | in[n]);
        n = ((IData)(1U) + n);
    } while ((0U >= n));
}

#ifdef VL_DEBUG
VL_ATTR_COLD void Vmod_add_sync___024root___dump_triggers__act(const VlUnpacked<QData/*63:0*/, 1> &triggers, const std::string &tag);
#endif  // VL_DEBUG

bool Vmod_add_sync___024root___eval_phase__act(Vmod_add_sync___024root* vlSelf) {
    VL_DEBUG_IF(VL_DBG_MSGF("+    Vmod_add_sync___024root___eval_phase__act\n"); );
    Vmod_add_sync__Syms* const __restrict vlSymsp VL_ATTR_UNUSED = vlSelf->vlSymsp;
    auto& vlSelfRef = std::ref(*vlSelf).get();
    // Body
    Vmod_add_sync___024root___eval_triggers_vec__act(vlSelf);
#ifdef VL_DEBUG
    if (VL_UNLIKELY(vlSymsp->_vm_contextp__->debug())) {
        Vmod_add_sync___024root___dump_triggers__act(vlSelfRef.__VactTriggered, "act"s);
    }
#endif
    Vmod_add_sync___024root___trigger_orInto__act_vec_vec(vlSelfRef.__VnbaTriggered, vlSelfRef.__VactTriggered);
    return (0U);
}

void Vmod_add_sync___024root___trigger_clear__act(VlUnpacked<QData/*63:0*/, 1> &out) {
    VL_DEBUG_IF(VL_DBG_MSGF("+    Vmod_add_sync___024root___trigger_clear__act\n"); );
    // Locals
    IData/*31:0*/ n;
    // Body
    n = 0U;
    do {
        out[n] = 0ULL;
        n = ((IData)(1U) + n);
    } while ((1U > n));
}

bool Vmod_add_sync___024root___eval_phase__nba(Vmod_add_sync___024root* vlSelf) {
    VL_DEBUG_IF(VL_DBG_MSGF("+    Vmod_add_sync___024root___eval_phase__nba\n"); );
    Vmod_add_sync__Syms* const __restrict vlSymsp VL_ATTR_UNUSED = vlSelf->vlSymsp;
    auto& vlSelfRef = std::ref(*vlSelf).get();
    // Locals
    CData/*0:0*/ __VnbaExecute;
    // Body
    __VnbaExecute = Vmod_add_sync___024root___trigger_anySet__act(vlSelfRef.__VnbaTriggered);
    if (__VnbaExecute) {
        Vmod_add_sync___024root___eval_nba(vlSelf);
        Vmod_add_sync___024root___trigger_clear__act(vlSelfRef.__VnbaTriggered);
    }
    return (__VnbaExecute);
}

void Vmod_add_sync___024root___eval(Vmod_add_sync___024root* vlSelf) {
    VL_DEBUG_IF(VL_DBG_MSGF("+    Vmod_add_sync___024root___eval\n"); );
    Vmod_add_sync__Syms* const __restrict vlSymsp VL_ATTR_UNUSED = vlSelf->vlSymsp;
    auto& vlSelfRef = std::ref(*vlSelf).get();
    // Locals
    IData/*31:0*/ __VicoIterCount;
    IData/*31:0*/ __VnbaIterCount;
    // Body
    __VicoIterCount = 0U;
    vlSelfRef.__VicoFirstIteration = 1U;
    do {
        if (VL_UNLIKELY(((0x00000064U < __VicoIterCount)))) {
#ifdef VL_DEBUG
            Vmod_add_sync___024root___dump_triggers__ico(vlSelfRef.__VicoTriggered, "ico"s);
#endif
            VL_FATAL_MT("sync_rtl/mod_add/mod_add_sync.v", 14, "", "DIDNOTCONVERGE: Input combinational region did not converge after '--converge-limit' of 100 tries");
        }
        __VicoIterCount = ((IData)(1U) + __VicoIterCount);
        vlSelfRef.__VicoPhaseResult = Vmod_add_sync___024root___eval_phase__ico(vlSelf);
        vlSelfRef.__VicoFirstIteration = 0U;
    } while (vlSelfRef.__VicoPhaseResult);
    __VnbaIterCount = 0U;
    do {
        if (VL_UNLIKELY(((0x00000064U < __VnbaIterCount)))) {
#ifdef VL_DEBUG
            Vmod_add_sync___024root___dump_triggers__act(vlSelfRef.__VnbaTriggered, "nba"s);
#endif
            VL_FATAL_MT("sync_rtl/mod_add/mod_add_sync.v", 14, "", "DIDNOTCONVERGE: NBA region did not converge after '--converge-limit' of 100 tries");
        }
        __VnbaIterCount = ((IData)(1U) + __VnbaIterCount);
        vlSelfRef.__VactIterCount = 0U;
        do {
            if (VL_UNLIKELY(((0x00000064U < vlSelfRef.__VactIterCount)))) {
#ifdef VL_DEBUG
                Vmod_add_sync___024root___dump_triggers__act(vlSelfRef.__VactTriggered, "act"s);
#endif
                VL_FATAL_MT("sync_rtl/mod_add/mod_add_sync.v", 14, "", "DIDNOTCONVERGE: Active region did not converge after '--converge-limit' of 100 tries");
            }
            vlSelfRef.__VactIterCount = ((IData)(1U) 
                                         + vlSelfRef.__VactIterCount);
            vlSelfRef.__VactPhaseResult = Vmod_add_sync___024root___eval_phase__act(vlSelf);
        } while (vlSelfRef.__VactPhaseResult);
        vlSelfRef.__VnbaPhaseResult = Vmod_add_sync___024root___eval_phase__nba(vlSelf);
    } while (vlSelfRef.__VnbaPhaseResult);
}

#ifdef VL_DEBUG
void Vmod_add_sync___024root___eval_debug_assertions(Vmod_add_sync___024root* vlSelf) {
    VL_DEBUG_IF(VL_DBG_MSGF("+    Vmod_add_sync___024root___eval_debug_assertions\n"); );
    Vmod_add_sync__Syms* const __restrict vlSymsp VL_ATTR_UNUSED = vlSelf->vlSymsp;
    auto& vlSelfRef = std::ref(*vlSelf).get();
    // Body
    if (VL_UNLIKELY(((vlSelfRef.clk & 0xfeU)))) {
        Verilated::overWidthError("clk");
    }
    if (VL_UNLIKELY(((vlSelfRef.rst_n & 0xfeU)))) {
        Verilated::overWidthError("rst_n");
    }
    if (VL_UNLIKELY(((vlSelfRef.a & 0xf000U)))) {
        Verilated::overWidthError("a");
    }
    if (VL_UNLIKELY(((vlSelfRef.b & 0xf000U)))) {
        Verilated::overWidthError("b");
    }
    if (VL_UNLIKELY(((vlSelfRef.valid_i & 0xfeU)))) {
        Verilated::overWidthError("valid_i");
    }
    if (VL_UNLIKELY(((vlSelfRef.ready_i & 0xfeU)))) {
        Verilated::overWidthError("ready_i");
    }
}
#endif  // VL_DEBUG