// Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.
// Copyright 2022-2025 Advanced Micro Devices, Inc. All Rights Reserved.
// --------------------------------------------------------------------------------
// Tool Version: Vivado v.2025.1 (win64) Build 6140274 Thu May 22 00:12:29 MDT 2025
// Date        : Sun Jan  4 04:34:43 2026
// Host        : LAPTOP-L3CRKKNJ running 64-bit major release  (build 9200)
// Command     : write_verilog -force -mode funcsim
//               c:/Vivado_Debug/PLLXplore_FNPLL/FNPLL2.gen/sources_1/bd/FNPLL/ip/FNPLL_nn2_div_0_0/FNPLL_nn2_div_0_0_sim_netlist.v
// Design      : FNPLL_nn2_div_0_0
// Purpose     : This verilog netlist is a functional simulation representation of the design and should not be modified
//               or synthesized. This netlist cannot be used for SDF annotated simulation.
// Device      : xc7a35tcpg236-1
// --------------------------------------------------------------------------------
`timescale 1 ps / 1 ps

(* CHECK_LICENSE_TYPE = "FNPLL_nn2_div_0_0,nn2_div,{}" *) (* downgradeipidentifiedwarnings = "yes" *) (* ip_definition_source = "module_ref" *) 
(* x_core_info = "nn2_div,Vivado 2025.1" *) 
(* NotValidForBitStream *)
module FNPLL_nn2_div_0_0
   (vcoin,
    select_bit,
    count_val,
    out_pulse);
  input vcoin;
  input select_bit;
  input [7:0]count_val;
  output out_pulse;

  wire [7:0]count_val;
  wire out_pulse;
  wire select_bit;
  wire vcoin;

  FNPLL_nn2_div_0_0_nn2_div U0
       (.count_val(count_val),
        .out_pulse(out_pulse),
        .select_bit(select_bit),
        .vcoin(vcoin));
endmodule

(* ORIG_REF_NAME = "nn2_div" *) 
module FNPLL_nn2_div_0_0_nn2_div
   (out_pulse,
    count_val,
    vcoin,
    select_bit);
  output out_pulse;
  input [7:0]count_val;
  input vcoin;
  input select_bit;

  wire [7:0]count_val;
  wire \counter[1]_i_1_n_0 ;
  wire \counter[2]_i_1_n_0 ;
  wire \counter[3]_i_1_n_0 ;
  wire \counter[4]_i_1_n_0 ;
  wire \counter[5]_i_1_n_0 ;
  wire \counter[6]_i_1_n_0 ;
  wire \counter[7]_i_1_n_0 ;
  wire \counter[8]_i_1_n_0 ;
  wire \counter[9]_i_2_n_0 ;
  wire [9:0]counter_reg;
  wire [8:0]current_base_n;
  wire \current_base_n[1]_i_1_n_0 ;
  wire \current_base_n[2]_i_1_n_0 ;
  wire \current_base_n[3]_i_1_n_0 ;
  wire \current_base_n[4]_i_1_n_0 ;
  wire \current_base_n[5]_i_1_n_0 ;
  wire \current_base_n[6]_i_1_n_0 ;
  wire \current_base_n[7]_i_1_n_0 ;
  wire \current_base_n[8]_i_1_n_0 ;
  wire \current_base_n[8]_i_2_n_0 ;
  wire [9:2]current_limit;
  wire \current_limit[9]_i_2_n_0 ;
  wire \current_limit_reg_n_0_[0] ;
  wire \current_limit_reg_n_0_[1] ;
  wire \current_limit_reg_n_0_[2] ;
  wire \current_limit_reg_n_0_[3] ;
  wire \current_limit_reg_n_0_[4] ;
  wire \current_limit_reg_n_0_[5] ;
  wire \current_limit_reg_n_0_[6] ;
  wire \current_limit_reg_n_0_[7] ;
  wire \current_limit_reg_n_0_[8] ;
  wire \current_limit_reg_n_0_[9] ;
  wire current_mode;
  wire [0:0]minusOp;
  wire out_pulse;
  wire out_pulse0_carry_i_1_n_0;
  wire out_pulse0_carry_i_2_n_0;
  wire out_pulse0_carry_i_3_n_0;
  wire out_pulse0_carry_i_4_n_0;
  wire out_pulse0_carry_i_5_n_0;
  wire out_pulse0_carry_i_6_n_0;
  wire out_pulse0_carry_i_7_n_0;
  wire out_pulse0_carry_i_8_n_0;
  wire out_pulse0_carry_i_9_n_0;
  wire out_pulse0_carry_n_0;
  wire out_pulse0_carry_n_1;
  wire out_pulse0_carry_n_2;
  wire out_pulse0_carry_n_3;
  wire [9:9]plusOp;
  wire [0:0]plusOp__0;
  wire select_bit;
  wire toggle;
  wire toggle_i_1_n_0;
  wire vcoin;
  wire [3:0]NLW_out_pulse0_carry_O_UNCONNECTED;

  LUT1 #(
    .INIT(2'h1)) 
    \counter[0]_i_1 
       (.I0(counter_reg[0]),
        .O(plusOp__0));
  (* SOFT_HLUTNM = "soft_lutpair9" *) 
  LUT3 #(
    .INIT(8'h06)) 
    \counter[1]_i_1 
       (.I0(counter_reg[0]),
        .I1(counter_reg[1]),
        .I2(out_pulse0_carry_n_0),
        .O(\counter[1]_i_1_n_0 ));
  (* SOFT_HLUTNM = "soft_lutpair4" *) 
  LUT4 #(
    .INIT(16'h0078)) 
    \counter[2]_i_1 
       (.I0(counter_reg[0]),
        .I1(counter_reg[1]),
        .I2(counter_reg[2]),
        .I3(out_pulse0_carry_n_0),
        .O(\counter[2]_i_1_n_0 ));
  (* SOFT_HLUTNM = "soft_lutpair2" *) 
  LUT4 #(
    .INIT(16'h7F80)) 
    \counter[3]_i_1 
       (.I0(counter_reg[2]),
        .I1(counter_reg[0]),
        .I2(counter_reg[1]),
        .I3(counter_reg[3]),
        .O(\counter[3]_i_1_n_0 ));
  LUT6 #(
    .INIT(64'h000000007FFF8000)) 
    \counter[4]_i_1 
       (.I0(counter_reg[2]),
        .I1(counter_reg[0]),
        .I2(counter_reg[1]),
        .I3(counter_reg[3]),
        .I4(counter_reg[4]),
        .I5(out_pulse0_carry_n_0),
        .O(\counter[4]_i_1_n_0 ));
  (* SOFT_HLUTNM = "soft_lutpair8" *) 
  LUT3 #(
    .INIT(8'h09)) 
    \counter[5]_i_1 
       (.I0(\counter[9]_i_2_n_0 ),
        .I1(counter_reg[5]),
        .I2(out_pulse0_carry_n_0),
        .O(\counter[5]_i_1_n_0 ));
  LUT3 #(
    .INIT(8'hD2)) 
    \counter[6]_i_1 
       (.I0(counter_reg[5]),
        .I1(\counter[9]_i_2_n_0 ),
        .I2(counter_reg[6]),
        .O(\counter[6]_i_1_n_0 ));
  (* SOFT_HLUTNM = "soft_lutpair1" *) 
  LUT5 #(
    .INIT(32'h0000DF20)) 
    \counter[7]_i_1 
       (.I0(counter_reg[5]),
        .I1(\counter[9]_i_2_n_0 ),
        .I2(counter_reg[6]),
        .I3(counter_reg[7]),
        .I4(out_pulse0_carry_n_0),
        .O(\counter[7]_i_1_n_0 ));
  LUT6 #(
    .INIT(64'h00000000DFFF2000)) 
    \counter[8]_i_1 
       (.I0(counter_reg[6]),
        .I1(\counter[9]_i_2_n_0 ),
        .I2(counter_reg[5]),
        .I3(counter_reg[7]),
        .I4(counter_reg[8]),
        .I5(out_pulse0_carry_n_0),
        .O(\counter[8]_i_1_n_0 ));
  LUT6 #(
    .INIT(64'hF7FFFFFF08000000)) 
    \counter[9]_i_1 
       (.I0(counter_reg[8]),
        .I1(counter_reg[6]),
        .I2(\counter[9]_i_2_n_0 ),
        .I3(counter_reg[5]),
        .I4(counter_reg[7]),
        .I5(counter_reg[9]),
        .O(plusOp));
  (* SOFT_HLUTNM = "soft_lutpair2" *) 
  LUT5 #(
    .INIT(32'h7FFFFFFF)) 
    \counter[9]_i_2 
       (.I0(counter_reg[3]),
        .I1(counter_reg[1]),
        .I2(counter_reg[0]),
        .I3(counter_reg[2]),
        .I4(counter_reg[4]),
        .O(\counter[9]_i_2_n_0 ));
  FDRE #(
    .INIT(1'b0)) 
    \counter_reg[0] 
       (.C(vcoin),
        .CE(1'b1),
        .D(plusOp__0),
        .Q(counter_reg[0]),
        .R(out_pulse0_carry_n_0));
  FDRE #(
    .INIT(1'b0)) 
    \counter_reg[1] 
       (.C(vcoin),
        .CE(1'b1),
        .D(\counter[1]_i_1_n_0 ),
        .Q(counter_reg[1]),
        .R(1'b0));
  FDRE #(
    .INIT(1'b0)) 
    \counter_reg[2] 
       (.C(vcoin),
        .CE(1'b1),
        .D(\counter[2]_i_1_n_0 ),
        .Q(counter_reg[2]),
        .R(1'b0));
  FDRE #(
    .INIT(1'b0)) 
    \counter_reg[3] 
       (.C(vcoin),
        .CE(1'b1),
        .D(\counter[3]_i_1_n_0 ),
        .Q(counter_reg[3]),
        .R(out_pulse0_carry_n_0));
  FDRE #(
    .INIT(1'b0)) 
    \counter_reg[4] 
       (.C(vcoin),
        .CE(1'b1),
        .D(\counter[4]_i_1_n_0 ),
        .Q(counter_reg[4]),
        .R(1'b0));
  FDRE #(
    .INIT(1'b0)) 
    \counter_reg[5] 
       (.C(vcoin),
        .CE(1'b1),
        .D(\counter[5]_i_1_n_0 ),
        .Q(counter_reg[5]),
        .R(1'b0));
  FDRE #(
    .INIT(1'b0)) 
    \counter_reg[6] 
       (.C(vcoin),
        .CE(1'b1),
        .D(\counter[6]_i_1_n_0 ),
        .Q(counter_reg[6]),
        .R(out_pulse0_carry_n_0));
  FDRE #(
    .INIT(1'b0)) 
    \counter_reg[7] 
       (.C(vcoin),
        .CE(1'b1),
        .D(\counter[7]_i_1_n_0 ),
        .Q(counter_reg[7]),
        .R(1'b0));
  FDRE #(
    .INIT(1'b0)) 
    \counter_reg[8] 
       (.C(vcoin),
        .CE(1'b1),
        .D(\counter[8]_i_1_n_0 ),
        .Q(counter_reg[8]),
        .R(1'b0));
  FDRE #(
    .INIT(1'b0)) 
    \counter_reg[9] 
       (.C(vcoin),
        .CE(1'b1),
        .D(plusOp),
        .Q(counter_reg[9]),
        .R(out_pulse0_carry_n_0));
  LUT1 #(
    .INIT(2'h1)) 
    \current_base_n[0]_i_1 
       (.I0(count_val[0]),
        .O(minusOp));
  (* SOFT_HLUTNM = "soft_lutpair6" *) 
  LUT2 #(
    .INIT(4'h9)) 
    \current_base_n[1]_i_1 
       (.I0(count_val[0]),
        .I1(count_val[1]),
        .O(\current_base_n[1]_i_1_n_0 ));
  (* SOFT_HLUTNM = "soft_lutpair6" *) 
  LUT3 #(
    .INIT(8'hE1)) 
    \current_base_n[2]_i_1 
       (.I0(count_val[1]),
        .I1(count_val[0]),
        .I2(count_val[2]),
        .O(\current_base_n[2]_i_1_n_0 ));
  (* SOFT_HLUTNM = "soft_lutpair0" *) 
  LUT4 #(
    .INIT(16'hFE01)) 
    \current_base_n[3]_i_1 
       (.I0(count_val[2]),
        .I1(count_val[0]),
        .I2(count_val[1]),
        .I3(count_val[3]),
        .O(\current_base_n[3]_i_1_n_0 ));
  (* SOFT_HLUTNM = "soft_lutpair0" *) 
  LUT5 #(
    .INIT(32'hFFFE0001)) 
    \current_base_n[4]_i_1 
       (.I0(count_val[3]),
        .I1(count_val[1]),
        .I2(count_val[0]),
        .I3(count_val[2]),
        .I4(count_val[4]),
        .O(\current_base_n[4]_i_1_n_0 ));
  LUT6 #(
    .INIT(64'hFFFFFFFE00000001)) 
    \current_base_n[5]_i_1 
       (.I0(count_val[4]),
        .I1(count_val[2]),
        .I2(count_val[0]),
        .I3(count_val[1]),
        .I4(count_val[3]),
        .I5(count_val[5]),
        .O(\current_base_n[5]_i_1_n_0 ));
  LUT2 #(
    .INIT(4'h9)) 
    \current_base_n[6]_i_1 
       (.I0(\current_base_n[8]_i_2_n_0 ),
        .I1(count_val[6]),
        .O(\current_base_n[6]_i_1_n_0 ));
  (* SOFT_HLUTNM = "soft_lutpair7" *) 
  LUT3 #(
    .INIT(8'hE1)) 
    \current_base_n[7]_i_1 
       (.I0(count_val[6]),
        .I1(\current_base_n[8]_i_2_n_0 ),
        .I2(count_val[7]),
        .O(\current_base_n[7]_i_1_n_0 ));
  (* SOFT_HLUTNM = "soft_lutpair7" *) 
  LUT3 #(
    .INIT(8'h01)) 
    \current_base_n[8]_i_1 
       (.I0(count_val[6]),
        .I1(\current_base_n[8]_i_2_n_0 ),
        .I2(count_val[7]),
        .O(\current_base_n[8]_i_1_n_0 ));
  LUT6 #(
    .INIT(64'hFFFFFFFFFFFFFFFE)) 
    \current_base_n[8]_i_2 
       (.I0(count_val[4]),
        .I1(count_val[2]),
        .I2(count_val[0]),
        .I3(count_val[1]),
        .I4(count_val[3]),
        .I5(count_val[5]),
        .O(\current_base_n[8]_i_2_n_0 ));
  FDRE #(
    .INIT(1'b0)) 
    \current_base_n_reg[0] 
       (.C(vcoin),
        .CE(out_pulse0_carry_n_0),
        .D(minusOp),
        .Q(current_base_n[0]),
        .R(1'b0));
  FDRE #(
    .INIT(1'b0)) 
    \current_base_n_reg[1] 
       (.C(vcoin),
        .CE(out_pulse0_carry_n_0),
        .D(\current_base_n[1]_i_1_n_0 ),
        .Q(current_base_n[1]),
        .R(1'b0));
  FDRE #(
    .INIT(1'b0)) 
    \current_base_n_reg[2] 
       (.C(vcoin),
        .CE(out_pulse0_carry_n_0),
        .D(\current_base_n[2]_i_1_n_0 ),
        .Q(current_base_n[2]),
        .R(1'b0));
  FDRE #(
    .INIT(1'b0)) 
    \current_base_n_reg[3] 
       (.C(vcoin),
        .CE(out_pulse0_carry_n_0),
        .D(\current_base_n[3]_i_1_n_0 ),
        .Q(current_base_n[3]),
        .R(1'b0));
  FDRE #(
    .INIT(1'b0)) 
    \current_base_n_reg[4] 
       (.C(vcoin),
        .CE(out_pulse0_carry_n_0),
        .D(\current_base_n[4]_i_1_n_0 ),
        .Q(current_base_n[4]),
        .R(1'b0));
  FDRE #(
    .INIT(1'b0)) 
    \current_base_n_reg[5] 
       (.C(vcoin),
        .CE(out_pulse0_carry_n_0),
        .D(\current_base_n[5]_i_1_n_0 ),
        .Q(current_base_n[5]),
        .R(1'b0));
  FDRE #(
    .INIT(1'b0)) 
    \current_base_n_reg[6] 
       (.C(vcoin),
        .CE(out_pulse0_carry_n_0),
        .D(\current_base_n[6]_i_1_n_0 ),
        .Q(current_base_n[6]),
        .R(1'b0));
  FDRE #(
    .INIT(1'b0)) 
    \current_base_n_reg[7] 
       (.C(vcoin),
        .CE(out_pulse0_carry_n_0),
        .D(\current_base_n[7]_i_1_n_0 ),
        .Q(current_base_n[7]),
        .R(1'b0));
  FDRE #(
    .INIT(1'b0)) 
    \current_base_n_reg[8] 
       (.C(vcoin),
        .CE(out_pulse0_carry_n_0),
        .D(\current_base_n[8]_i_1_n_0 ),
        .Q(current_base_n[8]),
        .R(1'b0));
  LUT3 #(
    .INIT(8'h78)) 
    \current_limit[2]_i_1 
       (.I0(current_mode),
        .I1(toggle),
        .I2(current_base_n[2]),
        .O(current_limit[2]));
  (* SOFT_HLUTNM = "soft_lutpair3" *) 
  LUT4 #(
    .INIT(16'h7F80)) 
    \current_limit[3]_i_1 
       (.I0(current_base_n[2]),
        .I1(toggle),
        .I2(current_mode),
        .I3(current_base_n[3]),
        .O(current_limit[3]));
  (* SOFT_HLUTNM = "soft_lutpair3" *) 
  LUT5 #(
    .INIT(32'h7FFF8000)) 
    \current_limit[4]_i_1 
       (.I0(current_base_n[3]),
        .I1(current_mode),
        .I2(toggle),
        .I3(current_base_n[2]),
        .I4(current_base_n[4]),
        .O(current_limit[4]));
  LUT6 #(
    .INIT(64'h7FFFFFFF80000000)) 
    \current_limit[5]_i_1 
       (.I0(current_base_n[4]),
        .I1(current_base_n[2]),
        .I2(toggle),
        .I3(current_mode),
        .I4(current_base_n[3]),
        .I5(current_base_n[5]),
        .O(current_limit[5]));
  (* SOFT_HLUTNM = "soft_lutpair10" *) 
  LUT2 #(
    .INIT(4'h9)) 
    \current_limit[6]_i_1 
       (.I0(\current_limit[9]_i_2_n_0 ),
        .I1(current_base_n[6]),
        .O(current_limit[6]));
  (* SOFT_HLUTNM = "soft_lutpair10" *) 
  LUT3 #(
    .INIT(8'hD2)) 
    \current_limit[7]_i_1 
       (.I0(current_base_n[6]),
        .I1(\current_limit[9]_i_2_n_0 ),
        .I2(current_base_n[7]),
        .O(current_limit[7]));
  (* SOFT_HLUTNM = "soft_lutpair5" *) 
  LUT4 #(
    .INIT(16'hDF20)) 
    \current_limit[8]_i_1 
       (.I0(current_base_n[7]),
        .I1(\current_limit[9]_i_2_n_0 ),
        .I2(current_base_n[6]),
        .I3(current_base_n[8]),
        .O(current_limit[8]));
  (* SOFT_HLUTNM = "soft_lutpair5" *) 
  LUT4 #(
    .INIT(16'hDF00)) 
    \current_limit[9]_i_1 
       (.I0(current_base_n[7]),
        .I1(\current_limit[9]_i_2_n_0 ),
        .I2(current_base_n[6]),
        .I3(current_base_n[8]),
        .O(current_limit[9]));
  LUT6 #(
    .INIT(64'h7FFFFFFFFFFFFFFF)) 
    \current_limit[9]_i_2 
       (.I0(current_base_n[4]),
        .I1(current_base_n[2]),
        .I2(toggle),
        .I3(current_mode),
        .I4(current_base_n[3]),
        .I5(current_base_n[5]),
        .O(\current_limit[9]_i_2_n_0 ));
  FDRE \current_limit_reg[0] 
       (.C(vcoin),
        .CE(1'b1),
        .D(current_base_n[0]),
        .Q(\current_limit_reg_n_0_[0] ),
        .R(1'b0));
  FDRE \current_limit_reg[1] 
       (.C(vcoin),
        .CE(1'b1),
        .D(current_base_n[1]),
        .Q(\current_limit_reg_n_0_[1] ),
        .R(1'b0));
  FDRE \current_limit_reg[2] 
       (.C(vcoin),
        .CE(1'b1),
        .D(current_limit[2]),
        .Q(\current_limit_reg_n_0_[2] ),
        .R(1'b0));
  FDRE \current_limit_reg[3] 
       (.C(vcoin),
        .CE(1'b1),
        .D(current_limit[3]),
        .Q(\current_limit_reg_n_0_[3] ),
        .R(1'b0));
  FDRE \current_limit_reg[4] 
       (.C(vcoin),
        .CE(1'b1),
        .D(current_limit[4]),
        .Q(\current_limit_reg_n_0_[4] ),
        .R(1'b0));
  FDRE \current_limit_reg[5] 
       (.C(vcoin),
        .CE(1'b1),
        .D(current_limit[5]),
        .Q(\current_limit_reg_n_0_[5] ),
        .R(1'b0));
  FDRE \current_limit_reg[6] 
       (.C(vcoin),
        .CE(1'b1),
        .D(current_limit[6]),
        .Q(\current_limit_reg_n_0_[6] ),
        .R(1'b0));
  FDRE \current_limit_reg[7] 
       (.C(vcoin),
        .CE(1'b1),
        .D(current_limit[7]),
        .Q(\current_limit_reg_n_0_[7] ),
        .R(1'b0));
  FDRE \current_limit_reg[8] 
       (.C(vcoin),
        .CE(1'b1),
        .D(current_limit[8]),
        .Q(\current_limit_reg_n_0_[8] ),
        .R(1'b0));
  FDRE \current_limit_reg[9] 
       (.C(vcoin),
        .CE(1'b1),
        .D(current_limit[9]),
        .Q(\current_limit_reg_n_0_[9] ),
        .R(1'b0));
  FDRE #(
    .INIT(1'b0)) 
    current_mode_reg
       (.C(vcoin),
        .CE(out_pulse0_carry_n_0),
        .D(select_bit),
        .Q(current_mode),
        .R(1'b0));
  CARRY4 out_pulse0_carry
       (.CI(1'b0),
        .CO({out_pulse0_carry_n_0,out_pulse0_carry_n_1,out_pulse0_carry_n_2,out_pulse0_carry_n_3}),
        .CYINIT(1'b1),
        .DI({1'b0,1'b0,1'b0,1'b0}),
        .O(NLW_out_pulse0_carry_O_UNCONNECTED[3:0]),
        .S({out_pulse0_carry_i_1_n_0,out_pulse0_carry_i_2_n_0,out_pulse0_carry_i_3_n_0,out_pulse0_carry_i_4_n_0}));
  LUT4 #(
    .INIT(16'h9699)) 
    out_pulse0_carry_i_1
       (.I0(\current_limit_reg_n_0_[9] ),
        .I1(counter_reg[9]),
        .I2(out_pulse0_carry_i_5_n_0),
        .I3(counter_reg[8]),
        .O(out_pulse0_carry_i_1_n_0));
  LUT6 #(
    .INIT(64'h8200008200248200)) 
    out_pulse0_carry_i_2
       (.I0(out_pulse0_carry_i_6_n_0),
        .I1(counter_reg[7]),
        .I2(\current_limit_reg_n_0_[7] ),
        .I3(\current_limit_reg_n_0_[6] ),
        .I4(counter_reg[6]),
        .I5(out_pulse0_carry_i_7_n_0),
        .O(out_pulse0_carry_i_2_n_0));
  LUT6 #(
    .INIT(64'h8200008200248200)) 
    out_pulse0_carry_i_3
       (.I0(out_pulse0_carry_i_8_n_0),
        .I1(counter_reg[4]),
        .I2(\current_limit_reg_n_0_[4] ),
        .I3(\current_limit_reg_n_0_[3] ),
        .I4(counter_reg[3]),
        .I5(out_pulse0_carry_i_9_n_0),
        .O(out_pulse0_carry_i_3_n_0));
  LUT6 #(
    .INIT(64'h0920004000400920)) 
    out_pulse0_carry_i_4
       (.I0(\current_limit_reg_n_0_[1] ),
        .I1(counter_reg[1]),
        .I2(counter_reg[0]),
        .I3(\current_limit_reg_n_0_[0] ),
        .I4(\current_limit_reg_n_0_[2] ),
        .I5(counter_reg[2]),
        .O(out_pulse0_carry_i_4_n_0));
  (* SOFT_HLUTNM = "soft_lutpair1" *) 
  LUT4 #(
    .INIT(16'hDFFF)) 
    out_pulse0_carry_i_5
       (.I0(counter_reg[6]),
        .I1(\counter[9]_i_2_n_0 ),
        .I2(counter_reg[5]),
        .I3(counter_reg[7]),
        .O(out_pulse0_carry_i_5_n_0));
  LUT2 #(
    .INIT(4'h9)) 
    out_pulse0_carry_i_6
       (.I0(counter_reg[8]),
        .I1(\current_limit_reg_n_0_[8] ),
        .O(out_pulse0_carry_i_6_n_0));
  LUT6 #(
    .INIT(64'h7FFFFFFFFFFFFFFF)) 
    out_pulse0_carry_i_7
       (.I0(counter_reg[4]),
        .I1(counter_reg[2]),
        .I2(counter_reg[0]),
        .I3(counter_reg[1]),
        .I4(counter_reg[3]),
        .I5(counter_reg[5]),
        .O(out_pulse0_carry_i_7_n_0));
  (* SOFT_HLUTNM = "soft_lutpair8" *) 
  LUT2 #(
    .INIT(4'h9)) 
    out_pulse0_carry_i_8
       (.I0(counter_reg[5]),
        .I1(\current_limit_reg_n_0_[5] ),
        .O(out_pulse0_carry_i_8_n_0));
  (* SOFT_HLUTNM = "soft_lutpair4" *) 
  LUT3 #(
    .INIT(8'h7F)) 
    out_pulse0_carry_i_9
       (.I0(counter_reg[1]),
        .I1(counter_reg[0]),
        .I2(counter_reg[2]),
        .O(out_pulse0_carry_i_9_n_0));
  FDRE out_pulse_reg
       (.C(vcoin),
        .CE(1'b1),
        .D(out_pulse0_carry_n_0),
        .Q(out_pulse),
        .R(1'b0));
  (* SOFT_HLUTNM = "soft_lutpair9" *) 
  LUT3 #(
    .INIT(8'h78)) 
    toggle_i_1
       (.I0(current_mode),
        .I1(out_pulse0_carry_n_0),
        .I2(toggle),
        .O(toggle_i_1_n_0));
  FDRE #(
    .INIT(1'b0)) 
    toggle_reg
       (.C(vcoin),
        .CE(1'b1),
        .D(toggle_i_1_n_0),
        .Q(toggle),
        .R(1'b0));
endmodule
`ifndef GLBL
`define GLBL
`timescale  1 ps / 1 ps

module glbl ();

    parameter ROC_WIDTH = 100000;
    parameter TOC_WIDTH = 0;
    parameter GRES_WIDTH = 10000;
    parameter GRES_START = 10000;

//--------   STARTUP Globals --------------
    wire GSR;
    wire GTS;
    wire GWE;
    wire PRLD;
    wire GRESTORE;
    tri1 p_up_tmp;
    tri (weak1, strong0) PLL_LOCKG = p_up_tmp;

    wire PROGB_GLBL;
    wire CCLKO_GLBL;
    wire FCSBO_GLBL;
    wire [3:0] DO_GLBL;
    wire [3:0] DI_GLBL;
   
    reg GSR_int;
    reg GTS_int;
    reg PRLD_int;
    reg GRESTORE_int;

//--------   JTAG Globals --------------
    wire JTAG_TDO_GLBL;
    wire JTAG_TCK_GLBL;
    wire JTAG_TDI_GLBL;
    wire JTAG_TMS_GLBL;
    wire JTAG_TRST_GLBL;

    reg JTAG_CAPTURE_GLBL;
    reg JTAG_RESET_GLBL;
    reg JTAG_SHIFT_GLBL;
    reg JTAG_UPDATE_GLBL;
    reg JTAG_RUNTEST_GLBL;

    reg JTAG_SEL1_GLBL = 0;
    reg JTAG_SEL2_GLBL = 0 ;
    reg JTAG_SEL3_GLBL = 0;
    reg JTAG_SEL4_GLBL = 0;

    reg JTAG_USER_TDO1_GLBL = 1'bz;
    reg JTAG_USER_TDO2_GLBL = 1'bz;
    reg JTAG_USER_TDO3_GLBL = 1'bz;
    reg JTAG_USER_TDO4_GLBL = 1'bz;

    assign (strong1, weak0) GSR = GSR_int;
    assign (strong1, weak0) GTS = GTS_int;
    assign (weak1, weak0) PRLD = PRLD_int;
    assign (strong1, weak0) GRESTORE = GRESTORE_int;

    initial begin
	GSR_int = 1'b1;
	PRLD_int = 1'b1;
	#(ROC_WIDTH)
	GSR_int = 1'b0;
	PRLD_int = 1'b0;
    end

    initial begin
	GTS_int = 1'b1;
	#(TOC_WIDTH)
	GTS_int = 1'b0;
    end

    initial begin 
	GRESTORE_int = 1'b0;
	#(GRES_START);
	GRESTORE_int = 1'b1;
	#(GRES_WIDTH);
	GRESTORE_int = 1'b0;
    end

endmodule
`endif
