--------------------------------------------------------------------------

--                                                                      --

-- Copyright (c) 1990,1991,1992 by Synopsys, Inc.  All rights reserved. --

--                                                                      --

-- This source file may be used and distributed without restriction     --

-- provided that this copyright statement is not removed from the file  --

-- and that any derivative work contains this copyright notice.         --

--                                                                      --

--     Package name: STD_LOGIC_ARITH                                 --

--                                                            --

--     Purpose:                                               --

--     A set of arithemtic, conversion, and comparison functions    --

--     for SIGNED, UNSIGNED, SMALL_INT, INTEGER,                    --

--     STD_ULOGIC, STD_LOGIC, and STD_LOGIC_VECTOR.                 --

--                                                            --

--------------------------------------------------------------------------

 

---------------------------------------------------

-- Attributes added to invoke MTI builtin functions

---------------------------------------------------

 

library IEEE;

use IEEE.std_logic_1164.all;

 

package std_logic_arith is

 

    type UNSIGNED is array (NATURAL range <>) of STD_LOGIC;

    type SIGNED is array (NATURAL range <>) of STD_LOGIC;

    subtype SMALL_INT is INTEGER range 0 to 1;

 

    attribute builtin_subprogram: string;

 

    function "+"(L: UNSIGNED; R: UNSIGNED) return UNSIGNED;

    attribute builtin_subprogram of

        "+"[UNSIGNED, UNSIGNED return UNSIGNED]: function is "stdarith_plus_uuu";

 

    function "+"(L: SIGNED; R: SIGNED) return SIGNED;

    attribute builtin_subprogram of

        "+"[SIGNED, SIGNED return SIGNED]: function is "stdarith_plus_sss";

 

    function "+"(L: UNSIGNED; R: SIGNED) return SIGNED;

    attribute builtin_subprogram of

        "+"[UNSIGNED, SIGNED return SIGNED]: function is "stdarith_plus_uss";

 

    function "+"(L: SIGNED; R: UNSIGNED) return SIGNED;

    attribute builtin_subprogram of

        "+"[SIGNED, UNSIGNED return SIGNED]: function is "stdarith_plus_sus";

 

    function "+"(L: UNSIGNED; R: INTEGER) return UNSIGNED;

    attribute builtin_subprogram of

        "+"[UNSIGNED, INTEGER return UNSIGNED]: function is "stdarith_plus_uiu";

 

    function "+"(L: INTEGER; R: UNSIGNED) return UNSIGNED;

    attribute builtin_subprogram of

        "+"[INTEGER, UNSIGNED return UNSIGNED]: function is "stdarith_plus_iuu";

 

    function "+"(L: SIGNED; R: INTEGER) return SIGNED;

    attribute builtin_subprogram of

        "+"[SIGNED, INTEGER return SIGNED]: function is "stdarith_plus_sis";

 

    function "+"(L: INTEGER; R: SIGNED) return SIGNED;

    attribute builtin_subprogram of

        "+"[INTEGER, SIGNED return SIGNED]: function is "stdarith_plus_iss";

 

    function "+"(L: UNSIGNED; R: STD_ULOGIC) return UNSIGNED;

    attribute builtin_subprogram of

        "+"[UNSIGNED, STD_ULOGIC return UNSIGNED]: function is "stdarith_plus_uxu";

 

    function "+"(L: STD_ULOGIC; R: UNSIGNED) return UNSIGNED;

    attribute builtin_subprogram of

        "+"[STD_ULOGIC, UNSIGNED return UNSIGNED]: function is "stdarith_plus_xuu";

 

    function "+"(L: SIGNED; R: STD_ULOGIC) return SIGNED;

    attribute builtin_subprogram of

        "+"[SIGNED, STD_ULOGIC return SIGNED]: function is "stdarith_plus_sxs";

 

    function "+"(L: STD_ULOGIC; R: SIGNED) return SIGNED;

    attribute builtin_subprogram of

        "+"[STD_ULOGIC, SIGNED return SIGNED]: function is "stdarith_plus_xss";

 

    function "+"(L: UNSIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "+"[UNSIGNED, UNSIGNED return STD_LOGIC_VECTOR]: function is "stdarith_plus_uuu";

 

    function "+"(L: SIGNED; R: SIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "+"[SIGNED, SIGNED return STD_LOGIC_VECTOR]: function is "stdarith_plus_sss";

 

    function "+"(L: UNSIGNED; R: SIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "+"[UNSIGNED, SIGNED return STD_LOGIC_VECTOR]: function is "stdarith_plus_uss";

 

    function "+"(L: SIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "+"[SIGNED, UNSIGNED return STD_LOGIC_VECTOR]: function is "stdarith_plus_sus";

 

    function "+"(L: UNSIGNED; R: INTEGER) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "+"[UNSIGNED, INTEGER return STD_LOGIC_VECTOR]: function is "stdarith_plus_uiu";

 

    function "+"(L: INTEGER; R: UNSIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "+"[INTEGER, UNSIGNED return STD_LOGIC_VECTOR]: function is "stdarith_plus_iuu";

 

    function "+"(L: SIGNED; R: INTEGER) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "+"[SIGNED, INTEGER return STD_LOGIC_VECTOR]: function is "stdarith_plus_sis";

 

    function "+"(L: INTEGER; R: SIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "+"[INTEGER, SIGNED return STD_LOGIC_VECTOR]: function is "stdarith_plus_iss";

 

    function "+"(L: UNSIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "+"[UNSIGNED, STD_ULOGIC return STD_LOGIC_VECTOR]: function is "stdarith_plus_uxu";

 

    function "+"(L: STD_ULOGIC; R: UNSIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "+"[STD_ULOGIC, UNSIGNED return STD_LOGIC_VECTOR]: function is "stdarith_plus_xuu";

 

    function "+"(L: SIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "+"[SIGNED, STD_ULOGIC return STD_LOGIC_VECTOR]: function is "stdarith_plus_sxs";

 

    function "+"(L: STD_ULOGIC; R: SIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "+"[STD_ULOGIC, SIGNED return STD_LOGIC_VECTOR]: function is "stdarith_plus_xss";

 

 

    function "-"(L: UNSIGNED; R: UNSIGNED) return UNSIGNED;

    attribute builtin_subprogram of

        "-"[UNSIGNED, UNSIGNED return UNSIGNED]: function is "stdarith_minus_uuu";

 

    function "-"(L: SIGNED; R: SIGNED) return SIGNED;

    attribute builtin_subprogram of

        "-"[SIGNED, SIGNED return SIGNED]: function is "stdarith_minus_sss";

 

    function "-"(L: UNSIGNED; R: SIGNED) return SIGNED;

    attribute builtin_subprogram of

        "-"[UNSIGNED, SIGNED return SIGNED]: function is "stdarith_minus_uss";

 

    function "-"(L: SIGNED; R: UNSIGNED) return SIGNED;

    attribute builtin_subprogram of

        "-"[SIGNED, UNSIGNED return SIGNED]: function is "stdarith_minus_sus";

 

    function "-"(L: UNSIGNED; R: INTEGER) return UNSIGNED;

    attribute builtin_subprogram of

        "-"[UNSIGNED, INTEGER return UNSIGNED]: function is "stdarith_minus_uiu";

 

    function "-"(L: INTEGER; R: UNSIGNED) return UNSIGNED;

    attribute builtin_subprogram of

        "-"[INTEGER, UNSIGNED return UNSIGNED]: function is "stdarith_minus_iuu";

 

    function "-"(L: SIGNED; R: INTEGER) return SIGNED;

    attribute builtin_subprogram of

        "-"[SIGNED, INTEGER return SIGNED]: function is "stdarith_minus_sis";

 

    function "-"(L: INTEGER; R: SIGNED) return SIGNED;

    attribute builtin_subprogram of

        "-"[INTEGER, SIGNED return SIGNED]: function is "stdarith_minus_iss";

 

    function "-"(L: UNSIGNED; R: STD_ULOGIC) return UNSIGNED;

    attribute builtin_subprogram of

        "-"[UNSIGNED, STD_ULOGIC return UNSIGNED]: function is "stdarith_minus_uxu";

 

    function "-"(L: STD_ULOGIC; R: UNSIGNED) return UNSIGNED;

    attribute builtin_subprogram of

        "-"[STD_ULOGIC, UNSIGNED return UNSIGNED]: function is "stdarith_minus_xuu";

 

    function "-"(L: SIGNED; R: STD_ULOGIC) return SIGNED;

    attribute builtin_subprogram of

        "-"[SIGNED, STD_ULOGIC return SIGNED]: function is "stdarith_minus_sxs";

 

    function "-"(L: STD_ULOGIC; R: SIGNED) return SIGNED;

    attribute builtin_subprogram of

        "-"[STD_ULOGIC, SIGNED return SIGNED]: function is "stdarith_minus_xss";

 

    function "-"(L: UNSIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "-"[UNSIGNED, UNSIGNED return STD_LOGIC_VECTOR]: function is "stdarith_minus_uuu";

 

    function "-"(L: SIGNED; R: SIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "-"[SIGNED, SIGNED return STD_LOGIC_VECTOR]: function is "stdarith_minus_sss";

 

    function "-"(L: UNSIGNED; R: SIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "-"[UNSIGNED, SIGNED return STD_LOGIC_VECTOR]: function is "stdarith_minus_uss";

 

    function "-"(L: SIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "-"[SIGNED, UNSIGNED return STD_LOGIC_VECTOR]: function is "stdarith_minus_sus";

 

    function "-"(L: UNSIGNED; R: INTEGER) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "-"[UNSIGNED, INTEGER return STD_LOGIC_VECTOR]: function is "stdarith_minus_uiu";

 

    function "-"(L: INTEGER; R: UNSIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "-"[INTEGER, UNSIGNED return STD_LOGIC_VECTOR]: function is "stdarith_minus_iuu";

 

    function "-"(L: SIGNED; R: INTEGER) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "-"[SIGNED, INTEGER return STD_LOGIC_VECTOR]: function is "stdarith_minus_sis";

 

    function "-"(L: INTEGER; R: SIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "-"[INTEGER, SIGNED return STD_LOGIC_VECTOR]: function is "stdarith_minus_iss";

 

    function "-"(L: UNSIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "-"[UNSIGNED, STD_ULOGIC return STD_LOGIC_VECTOR]: function is "stdarith_minus_uxu";

 

    function "-"(L: STD_ULOGIC; R: UNSIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "-"[STD_ULOGIC, UNSIGNED return STD_LOGIC_VECTOR]: function is "stdarith_minus_xuu";

 

    function "-"(L: SIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "-"[SIGNED, STD_ULOGIC return STD_LOGIC_VECTOR]: function is "stdarith_minus_sxs";

 

    function "-"(L: STD_ULOGIC; R: SIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "-"[STD_ULOGIC, SIGNED return STD_LOGIC_VECTOR]: function is "stdarith_minus_xss";

 

    function "+"(L: UNSIGNED) return UNSIGNED;

    attribute builtin_subprogram of

        "+"[UNSIGNED return UNSIGNED]: function is "stdarith_unary_plus_uu";

 

    function "+"(L: SIGNED) return SIGNED;

    attribute builtin_subprogram of

        "+"[SIGNED return SIGNED]: function is "stdarith_unary_plus_ss";

 

    function "-"(L: SIGNED) return SIGNED;

    attribute builtin_subprogram of

        "-"[SIGNED return SIGNED]: function is "stdarith_unary_minus_ss";

 

    function "ABS"(L: SIGNED) return SIGNED;

    attribute builtin_subprogram of

        "ABS"[SIGNED return SIGNED]: function is "stdarith_abs_ss";

 

 

    function "+"(L: UNSIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "+"[UNSIGNED return STD_LOGIC_VECTOR]: function is "stdarith_unary_plus_uu";

 

    function "+"(L: SIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "+"[SIGNED return STD_LOGIC_VECTOR]: function is "stdarith_unary_plus_ss";

 

    function "-"(L: SIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "-"[SIGNED return STD_LOGIC_VECTOR]: function is "stdarith_unary_minus_ss";

 

    function "ABS"(L: SIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "ABS"[SIGNED return STD_LOGIC_VECTOR]: function is "stdarith_abs_ss";

 

    function "*"(L: UNSIGNED; R: UNSIGNED) return UNSIGNED;

    attribute builtin_subprogram of

        "*"[UNSIGNED, UNSIGNED return UNSIGNED]: function is "stdarith_mult_uuu";

 

    function "*"(L: SIGNED; R: SIGNED) return SIGNED;

    attribute builtin_subprogram of

        "*"[SIGNED, SIGNED return SIGNED]: function is "stdarith_mult_sss";

 

    function "*"(L: SIGNED; R: UNSIGNED) return SIGNED;

    attribute builtin_subprogram of

        "*"[SIGNED, UNSIGNED return SIGNED]: function is "stdarith_mult_sus";

 

    function "*"(L: UNSIGNED; R: SIGNED) return SIGNED;

    attribute builtin_subprogram of

        "*"[UNSIGNED, SIGNED return SIGNED]: function is "stdarith_mult_uss";

 

 

    function "*"(L: UNSIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "*"[UNSIGNED, UNSIGNED return STD_LOGIC_VECTOR]: function is "stdarith_mult_uuu";

 

    function "*"(L: SIGNED; R: SIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "*"[SIGNED, SIGNED return STD_LOGIC_VECTOR]: function is "stdarith_mult_sss";

 

    function "*"(L: SIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "*"[SIGNED, UNSIGNED return STD_LOGIC_VECTOR]: function is "stdarith_mult_sus";

 

    function "*"(L: UNSIGNED; R: SIGNED) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        "*"[UNSIGNED, SIGNED return STD_LOGIC_VECTOR]: function is "stdarith_mult_uss";

 

 

    function "<"(L: UNSIGNED; R: UNSIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "<"[UNSIGNED, UNSIGNED return BOOLEAN]: function is "stdarith_lt_uu";

 

    function "<"(L: SIGNED; R: SIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "<"[SIGNED, SIGNED return BOOLEAN]: function is "stdarith_lt_ss";

 

    function "<"(L: UNSIGNED; R: SIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "<"[UNSIGNED, SIGNED return BOOLEAN]: function is "stdarith_lt_us";

 

    function "<"(L: SIGNED; R: UNSIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "<"[SIGNED, UNSIGNED return BOOLEAN]: function is "stdarith_lt_su";

 

    function "<"(L: UNSIGNED; R: INTEGER) return BOOLEAN;

    attribute builtin_subprogram of

        "<"[UNSIGNED, INTEGER return BOOLEAN]: function is "stdarith_lt_ui";

 

    function "<"(L: INTEGER; R: UNSIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "<"[INTEGER, UNSIGNED return BOOLEAN]: function is "stdarith_lt_iu";

 

    function "<"(L: SIGNED; R: INTEGER) return BOOLEAN;

    attribute builtin_subprogram of

        "<"[SIGNED, INTEGER return BOOLEAN]: function is "stdarith_lt_si";

 

    function "<"(L: INTEGER; R: SIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "<"[INTEGER, SIGNED return BOOLEAN]: function is "stdarith_lt_is";

 

    function "<="(L: UNSIGNED; R: UNSIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "<="[UNSIGNED, UNSIGNED return BOOLEAN]: function is "stdarith_lte_uu";

 

    function "<="(L: SIGNED; R: SIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "<="[SIGNED, SIGNED return BOOLEAN]: function is "stdarith_lte_ss";

 

    function "<="(L: UNSIGNED; R: SIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "<="[UNSIGNED, SIGNED return BOOLEAN]: function is "stdarith_lte_us";

 

    function "<="(L: SIGNED; R: UNSIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "<="[SIGNED, UNSIGNED return BOOLEAN]: function is "stdarith_lte_su";

 

    function "<="(L: UNSIGNED; R: INTEGER) return BOOLEAN;

    attribute builtin_subprogram of

        "<="[UNSIGNED, INTEGER return BOOLEAN]: function is "stdarith_lte_ui";

 

    function "<="(L: INTEGER; R: UNSIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "<="[INTEGER, UNSIGNED return BOOLEAN]: function is "stdarith_lte_iu";

 

    function "<="(L: SIGNED; R: INTEGER) return BOOLEAN;

    attribute builtin_subprogram of

        "<="[SIGNED, INTEGER return BOOLEAN]: function is "stdarith_lte_si";

 

    function "<="(L: INTEGER; R: SIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "<="[INTEGER, SIGNED return BOOLEAN]: function is "stdarith_lte_is";

 

 

    function ">"(L: UNSIGNED; R: UNSIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        ">"[UNSIGNED, UNSIGNED return BOOLEAN]: function is "stdarith_gt_uu";

 

    function ">"(L: SIGNED; R: SIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        ">"[SIGNED, SIGNED return BOOLEAN]: function is "stdarith_gt_ss";

 

    function ">"(L: UNSIGNED; R: SIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        ">"[UNSIGNED, SIGNED return BOOLEAN]: function is "stdarith_gt_us";

 

    function ">"(L: SIGNED; R: UNSIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        ">"[SIGNED, UNSIGNED return BOOLEAN]: function is "stdarith_gt_su";

 

    function ">"(L: UNSIGNED; R: INTEGER) return BOOLEAN;

    attribute builtin_subprogram of

        ">"[UNSIGNED, INTEGER return BOOLEAN]: function is "stdarith_gt_ui";

 

    function ">"(L: INTEGER; R: UNSIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        ">"[INTEGER, UNSIGNED return BOOLEAN]: function is "stdarith_gt_iu";

 

    function ">"(L: SIGNED; R: INTEGER) return BOOLEAN;

    attribute builtin_subprogram of

        ">"[SIGNED, INTEGER return BOOLEAN]: function is "stdarith_gt_si";

 

    function ">"(L: INTEGER; R: SIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        ">"[INTEGER, SIGNED return BOOLEAN]: function is "stdarith_gt_is";

 

 

    function ">="(L: UNSIGNED; R: UNSIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        ">="[UNSIGNED, UNSIGNED return BOOLEAN]: function is "stdarith_gte_uu";

 

    function ">="(L: SIGNED; R: SIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        ">="[SIGNED, SIGNED return BOOLEAN]: function is "stdarith_gte_ss";

 

    function ">="(L: UNSIGNED; R: SIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        ">="[UNSIGNED, SIGNED return BOOLEAN]: function is "stdarith_gte_us";

 

    function ">="(L: SIGNED; R: UNSIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        ">="[SIGNED, UNSIGNED return BOOLEAN]: function is "stdarith_gte_su";

 

    function ">="(L: UNSIGNED; R: INTEGER) return BOOLEAN;

    attribute builtin_subprogram of

        ">="[UNSIGNED, INTEGER return BOOLEAN]: function is "stdarith_gte_ui";

 

    function ">="(L: INTEGER; R: UNSIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        ">="[INTEGER, UNSIGNED return BOOLEAN]: function is "stdarith_gte_iu";

 

    function ">="(L: SIGNED; R: INTEGER) return BOOLEAN;

    attribute builtin_subprogram of

        ">="[SIGNED, INTEGER return BOOLEAN]: function is "stdarith_gte_si";

 

    function ">="(L: INTEGER; R: SIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        ">="[INTEGER, SIGNED return BOOLEAN]: function is "stdarith_gte_is";

 

 

    function "="(L: UNSIGNED; R: UNSIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "="[UNSIGNED, UNSIGNED return BOOLEAN]: function is "stdarith_eq_uu";

 

    function "="(L: SIGNED; R: SIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "="[SIGNED, SIGNED return BOOLEAN]: function is "stdarith_eq_ss";

 

    function "="(L: UNSIGNED; R: SIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "="[UNSIGNED, SIGNED return BOOLEAN]: function is "stdarith_eq_us";

 

    function "="(L: SIGNED; R: UNSIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "="[SIGNED, UNSIGNED return BOOLEAN]: function is "stdarith_eq_su";

 

    function "="(L: UNSIGNED; R: INTEGER) return BOOLEAN;

    attribute builtin_subprogram of

        "="[UNSIGNED, INTEGER return BOOLEAN]: function is "stdarith_eq_ui";

 

    function "="(L: INTEGER; R: UNSIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "="[INTEGER, UNSIGNED return BOOLEAN]: function is "stdarith_eq_iu";

 

    function "="(L: SIGNED; R: INTEGER) return BOOLEAN;

    attribute builtin_subprogram of

        "="[SIGNED, INTEGER return BOOLEAN]: function is "stdarith_eq_si";

 

    function "="(L: INTEGER; R: SIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "="[INTEGER, SIGNED return BOOLEAN]: function is "stdarith_eq_is";

 

 

    function "/="(L: UNSIGNED; R: UNSIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "/="[UNSIGNED, UNSIGNED return BOOLEAN]: function is "stdarith_neq_uu";

 

    function "/="(L: SIGNED; R: SIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "/="[SIGNED, SIGNED return BOOLEAN]: function is "stdarith_neq_ss";

 

    function "/="(L: UNSIGNED; R: SIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "/="[UNSIGNED, SIGNED return BOOLEAN]: function is "stdarith_neq_us";

 

    function "/="(L: SIGNED; R: UNSIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "/="[SIGNED, UNSIGNED return BOOLEAN]: function is "stdarith_neq_su";

 

    function "/="(L: UNSIGNED; R: INTEGER) return BOOLEAN;

    attribute builtin_subprogram of

        "/="[UNSIGNED, INTEGER return BOOLEAN]: function is "stdarith_neq_ui";

 

    function "/="(L: INTEGER; R: UNSIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "/="[INTEGER, UNSIGNED return BOOLEAN]: function is "stdarith_neq_iu";

 

    function "/="(L: SIGNED; R: INTEGER) return BOOLEAN;

    attribute builtin_subprogram of

        "/="[SIGNED, INTEGER return BOOLEAN]: function is "stdarith_neq_si";

 

    function "/="(L: INTEGER; R: SIGNED) return BOOLEAN;

    attribute builtin_subprogram of

        "/="[INTEGER, SIGNED return BOOLEAN]: function is "stdarith_neq_is";

 

 

    function SHL(ARG: UNSIGNED; COUNT: UNSIGNED) return UNSIGNED;

    attribute builtin_subprogram of

        SHL[UNSIGNED, UNSIGNED return UNSIGNED]: function is "stdarith_shl_uuu";

 

    function SHL(ARG: SIGNED; COUNT: UNSIGNED) return SIGNED;

    attribute builtin_subprogram of

        SHL[SIGNED, UNSIGNED return SIGNED]: function is "stdarith_shl_sus";

 

    function SHR(ARG: UNSIGNED; COUNT: UNSIGNED) return UNSIGNED;

    attribute builtin_subprogram of

        SHR[UNSIGNED, UNSIGNED return UNSIGNED]: function is "stdarith_shr_uuu";

 

    function SHR(ARG: SIGNED; COUNT: UNSIGNED) return SIGNED;

    attribute builtin_subprogram of

        SHR[SIGNED, UNSIGNED return SIGNED]: function is "stdarith_shr_sus";

 

 

    function CONV_INTEGER(ARG: INTEGER) return INTEGER;

    attribute builtin_subprogram of

        CONV_INTEGER[INTEGER return INTEGER]: function is "stdarith_conv_integer_ii";

 

    function CONV_INTEGER(ARG: UNSIGNED) return INTEGER;

    attribute builtin_subprogram of

        CONV_INTEGER[UNSIGNED return INTEGER]: function is "stdarith_conv_integer_ui2";

------------------------------------------------------------------------------------------

--  If desired, you may select an optional implementation for CONV_INTEGER(UNSIGNED)

--  by changing the value of the attribute:

--      stdarith_conv_integer_ui implements the original CONV_INTEGER(UNSIGNED) VHDL which

--          generates an error if the argument is larger than 31 bits.

--      stdarith_conv_integer_ui2 allows 32 bits. It generates a warning if the

--          argument is 32 bits and the MSB is not zero.

--      The default is stdarith_conv_integer_ui2.

--

--    attribute builtin_subprogram of

--        CONV_INTEGER[UNSIGNED return INTEGER]: function is "stdarith_conv_integer_ui";

------------------------------------------------------------------------------------------

 

    function CONV_INTEGER(ARG: SIGNED) return INTEGER;

    attribute builtin_subprogram of

        CONV_INTEGER[SIGNED return INTEGER]: function is "stdarith_conv_integer_si";

 

    function CONV_INTEGER(ARG: STD_ULOGIC) return SMALL_INT;

    attribute builtin_subprogram of

        CONV_INTEGER[STD_ULOGIC return SMALL_INT]: function is "stdarith_conv_integer_xz";

 

 

    function CONV_UNSIGNED(ARG: INTEGER; SIZE: INTEGER) return UNSIGNED;

    attribute builtin_subprogram of

        CONV_UNSIGNED [INTEGER, INTEGER return UNSIGNED]: function is "stdarith_conv_unsigned_iu";

 

    function CONV_UNSIGNED(ARG: UNSIGNED; SIZE: INTEGER) return UNSIGNED;

    attribute builtin_subprogram of

        CONV_UNSIGNED [UNSIGNED, INTEGER return UNSIGNED]: function is "stdarith_conv_unsigned_uu";

 

    function CONV_UNSIGNED(ARG: SIGNED; SIZE: INTEGER) return UNSIGNED;

    attribute builtin_subprogram of

        CONV_UNSIGNED [SIGNED, INTEGER return UNSIGNED]: function is "stdarith_conv_unsigned_su";

 

    function CONV_UNSIGNED(ARG: STD_ULOGIC; SIZE: INTEGER) return UNSIGNED;

    attribute builtin_subprogram of

        CONV_UNSIGNED [STD_ULOGIC, INTEGER return UNSIGNED]: function is "stdarith_conv_unsigned_xu";

 

 

    function CONV_SIGNED(ARG: INTEGER; SIZE: INTEGER) return SIGNED;

    attribute builtin_subprogram of

        CONV_SIGNED [INTEGER, INTEGER return SIGNED]: function is "stdarith_conv_signed_is";

 

    function CONV_SIGNED(ARG: UNSIGNED; SIZE: INTEGER) return SIGNED;

    attribute builtin_subprogram of

        CONV_SIGNED [UNSIGNED, INTEGER return SIGNED]: function is "stdarith_conv_signed_us";

 

    function CONV_SIGNED(ARG: SIGNED; SIZE: INTEGER) return SIGNED;

    attribute builtin_subprogram of

        CONV_SIGNED [SIGNED, INTEGER return SIGNED]: function is "stdarith_conv_signed_ss";

 

    function CONV_SIGNED(ARG: STD_ULOGIC; SIZE: INTEGER) return SIGNED;

    attribute builtin_subprogram of

        CONV_SIGNED [STD_ULOGIC, INTEGER return SIGNED]: function is "stdarith_conv_signed_xs";

 

 

 

    function CONV_STD_LOGIC_VECTOR(ARG: INTEGER; SIZE: INTEGER)

                                                return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        CONV_STD_LOGIC_VECTOR [INTEGER, INTEGER return STD_LOGIC_VECTOR]: function is

            "stdarith_conv_slv_iv";

 

    function CONV_STD_LOGIC_VECTOR(ARG: UNSIGNED; SIZE: INTEGER)

                                                return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        CONV_STD_LOGIC_VECTOR [UNSIGNED, INTEGER return STD_LOGIC_VECTOR]: function is

            "stdarith_conv_slv_uv";

 

    function CONV_STD_LOGIC_VECTOR(ARG: SIGNED; SIZE: INTEGER)

                                                return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        CONV_STD_LOGIC_VECTOR [SIGNED, INTEGER return STD_LOGIC_VECTOR]: function is

            "stdarith_conv_slv_sv";

 

    function CONV_STD_LOGIC_VECTOR(ARG: STD_ULOGIC; SIZE: INTEGER)

                                                return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        CONV_STD_LOGIC_VECTOR [STD_ULOGIC, INTEGER return STD_LOGIC_VECTOR]: function is

            "stdarith_conv_slv_xv";

 

    -- zero extend STD_LOGIC_VECTOR (ARG) to SIZE,

    -- SIZE < 0 is same as SIZE = 0

    -- returns STD_LOGIC_VECTOR(SIZE-1 downto 0)

    function EXT(ARG: STD_LOGIC_VECTOR; SIZE: INTEGER) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        EXT [STD_LOGIC_VECTOR, INTEGER return STD_LOGIC_VECTOR]: function is

            "stdarith_zeroextend_vv";

 

 

    -- sign extend STD_LOGIC_VECTOR (ARG) to SIZE,

    -- SIZE < 0 is same as SIZE = 0

    -- return STD_LOGIC_VECTOR(SIZE-1 downto 0)

    function SXT(ARG: STD_LOGIC_VECTOR; SIZE: INTEGER) return STD_LOGIC_VECTOR;

    attribute builtin_subprogram of

        SXT [STD_LOGIC_VECTOR, INTEGER return STD_LOGIC_VECTOR]: function is

            "stdarith_signextend_vv";

 

 

end Std_logic_arith;

 

 

 

library IEEE;

use IEEE.std_logic_1164.all;

 

package body std_logic_arith is

 

    function max(L, R: INTEGER) return INTEGER is

    begin

       if L > R then

           return L;

       else

           return R;

       end if;

    end;

 

 

    function min(L, R: INTEGER) return INTEGER is

    begin

       if L < R then

           return L;

       else

           return R;

       end if;

    end;

 

    -- synopsys synthesis_off

    type tbl_type is array (STD_ULOGIC) of STD_ULOGIC;

    constant tbl_BINARY : tbl_type :=

       ('X', 'X', '0', '1', 'X', 'X', '0', '1', 'X');

    -- synopsys synthesis_on

 

    -- synopsys synthesis_off

    type tbl_mvl9_boolean is array (STD_ULOGIC) of boolean;

    constant IS_X : tbl_mvl9_boolean :=

        (true, true, false, false, true, true, false, false, true);

    -- synopsys synthesis_on

 

 

 

    function MAKE_BINARY(A : STD_ULOGIC) return STD_ULOGIC is

       -- synopsys built_in SYN_FEED_THRU

    begin

       -- synopsys synthesis_off

           if (IS_X(A)) then

              assert false

              report "There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, the result will be 'X'(es)."

              severity warning;

               return ('X');

           end if;

           return tbl_BINARY(A);

       -- synopsys synthesis_on

    end;

 

    function MAKE_BINARY(A : UNSIGNED) return UNSIGNED is

       -- synopsys built_in SYN_FEED_THRU

       variable one_bit : STD_ULOGIC;

       variable result : UNSIGNED (A'range);

    begin

       -- synopsys synthesis_off

           for i in A'range loop

               if (IS_X(A(i))) then

                  assert false

                  report "There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, the result will be 'X'(es)."

                  severity warning;

                  result := (others => 'X');

                   return result;

               end if;

              result(i) := tbl_BINARY(A(i));

           end loop;

           return result;

       -- synopsys synthesis_on

    end;

 

    function MAKE_BINARY(A : UNSIGNED) return SIGNED is

       -- synopsys built_in SYN_FEED_THRU

       variable one_bit : STD_ULOGIC;

       variable result : SIGNED (A'range);

    begin

       -- synopsys synthesis_off

           for i in A'range loop

               if (IS_X(A(i))) then

                  assert false

                  report "There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, the result will be 'X'(es)."

                  severity warning;

                  result := (others => 'X');

                   return result;

               end if;

              result(i) := tbl_BINARY(A(i));

           end loop;

           return result;

       -- synopsys synthesis_on

    end;

 

    function MAKE_BINARY(A : SIGNED) return UNSIGNED is

       -- synopsys built_in SYN_FEED_THRU

       variable one_bit : STD_ULOGIC;

       variable result : UNSIGNED (A'range);

    begin

       -- synopsys synthesis_off

           for i in A'range loop

               if (IS_X(A(i))) then

                  assert false

                  report "There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, the result will be 'X'(es)."

                  severity warning;

                  result := (others => 'X');

                   return result;

               end if;

              result(i) := tbl_BINARY(A(i));

           end loop;

           return result;

       -- synopsys synthesis_on

    end;

 

    function MAKE_BINARY(A : SIGNED) return SIGNED is

       -- synopsys built_in SYN_FEED_THRU

       variable one_bit : STD_ULOGIC;

       variable result : SIGNED (A'range);

    begin

       -- synopsys synthesis_off

           for i in A'range loop

               if (IS_X(A(i))) then

                  assert false

                  report "There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, the result will be 'X'(es)."

                  severity warning;

                  result := (others => 'X');

                   return result;

               end if;

              result(i) := tbl_BINARY(A(i));

           end loop;

           return result;

       -- synopsys synthesis_on

    end;

 

    function MAKE_BINARY(A : STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR is

       -- synopsys built_in SYN_FEED_THRU

       variable one_bit : STD_ULOGIC;

       variable result : STD_LOGIC_VECTOR (A'range);

    begin

       -- synopsys synthesis_off

           for i in A'range loop

               if (IS_X(A(i))) then

                  assert false

                  report "There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, the result will be 'X'(es)."

                  severity warning;

                  result := (others => 'X');

                   return result;

               end if;

              result(i) := tbl_BINARY(A(i));

           end loop;

           return result;

       -- synopsys synthesis_on

    end;

 

    function MAKE_BINARY(A : UNSIGNED) return STD_LOGIC_VECTOR is

       -- synopsys built_in SYN_FEED_THRU

       variable one_bit : STD_ULOGIC;

       variable result : STD_LOGIC_VECTOR (A'range);

    begin

       -- synopsys synthesis_off

           for i in A'range loop

               if (IS_X(A(i))) then

                  assert false

                  report "There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, the result will be 'X'(es)."

                  severity warning;

                  result := (others => 'X');

                   return result;

               end if;

              result(i) := tbl_BINARY(A(i));

           end loop;

           return result;

       -- synopsys synthesis_on

    end;

 

    function MAKE_BINARY(A : SIGNED) return STD_LOGIC_VECTOR is

       -- synopsys built_in SYN_FEED_THRU

       variable one_bit : STD_ULOGIC;

       variable result : STD_LOGIC_VECTOR (A'range);

    begin

       -- synopsys synthesis_off

           for i in A'range loop

               if (IS_X(A(i))) then

                  assert false

                  report "There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, the result will be 'X'(es)."

                  severity warning;

                  result := (others => 'X');

                   return result;

               end if;

              result(i) := tbl_BINARY(A(i));

           end loop;

           return result;

       -- synopsys synthesis_on

    end;

 

 

 

    -- Type propagation function which returns a signed type with the

    -- size of the left arg.

    function LEFT_SIGNED_ARG(A,B: SIGNED) return SIGNED is

      variable Z: SIGNED (A'left downto 0);

      -- pragma return_port_name Z

    begin

      return(Z);

    end;

      

    -- Type propagation function which returns an unsigned type with the

    -- size of the left arg.

    function LEFT_UNSIGNED_ARG(A,B: UNSIGNED) return UNSIGNED is

      variable Z: UNSIGNED (A'left downto 0);

      -- pragma return_port_name Z

    begin

      return(Z);

    end;

      

    -- Type propagation function which returns a signed type with the

    -- size of the result of a signed multiplication

    function MULT_SIGNED_ARG(A,B: SIGNED) return SIGNED is

      variable Z: SIGNED ((A'length+B'length-1) downto 0);

      -- pragma return_port_name Z

    begin

      return(Z);

    end;

      

    -- Type propagation function which returns an unsigned type with the

    -- size of the result of a unsigned multiplication

    function MULT_UNSIGNED_ARG(A,B: UNSIGNED) return UNSIGNED is

      variable Z: UNSIGNED ((A'length+B'length-1) downto 0);

      -- pragma return_port_name Z

    begin

      return(Z);

    end;

 

 

 

    function mult(A,B: SIGNED) return SIGNED is

 

      variable BA: SIGNED((A'length+B'length-1) downto 0);

      variable PA: SIGNED((A'length+B'length-1) downto 0);

      variable AA: SIGNED(A'length downto 0);

      variable neg: STD_ULOGIC;

      constant one : UNSIGNED(1 downto 0) := "01";

     

      -- pragma map_to_operator MULT_TC_OP

      -- pragma type_function MULT_SIGNED_ARG

      -- pragma return_port_name Z

 

      begin

       if (A(A'left) = 'X' or B(B'left) = 'X') then

            PA := (others => 'X');

            return(PA);

       end if;

        PA := (others => '0');

        neg := B(B'left) xor A(A'left);

        BA := CONV_SIGNED(('0' & ABS(B)),(A'length+B'length));

        AA := '0' & ABS(A);

        for i in 0 to A'length-1 loop

          if AA(i) = '1' then

            PA := PA+BA;

          end if;

          BA := SHL(BA,one);

        end loop;

        if (neg= '1') then

          return(-PA);

        else

          return(PA);

        end if;

      end;

 

    function mult(A,B: UNSIGNED) return UNSIGNED is

 

      variable BA: UNSIGNED((A'length+B'length-1) downto 0);

      variable PA: UNSIGNED((A'length+B'length-1) downto 0);

      constant one : UNSIGNED(1 downto 0) := "01";

     

      -- pragma map_to_operator MULT_UNS_OP

      -- pragma type_function MULT_UNSIGNED_ARG

      -- pragma return_port_name Z

 

      begin

       if (A(A'left) = 'X' or B(B'left) = 'X') then

            PA := (others => 'X');

            return(PA);

       end if;

        PA := (others => '0');

        BA := CONV_UNSIGNED(B,(A'length+B'length));

        for i in 0 to A'length-1 loop

          if A(i) = '1' then

            PA := PA+BA;

          end if;

          BA := SHL(BA,one);

        end loop;

        return(PA);

      end;

 

    -- subtract two signed numbers of the same length

    -- both arrays must have range (msb downto 0)

    function minus(A, B: SIGNED) return SIGNED is

       variable carry: STD_ULOGIC;

       variable BV: STD_ULOGIC_VECTOR (A'left downto 0);

       variable sum: SIGNED (A'left downto 0);

 

       -- pragma map_to_operator SUB_TC_OP

 

       -- pragma type_function LEFT_SIGNED_ARG

        -- pragma return_port_name Z

 

    begin

       if (A(A'left) = 'X' or B(B'left) = 'X') then

            sum := (others => 'X');

            return(sum);

       end if;

       carry := '1';

       BV := not STD_ULOGIC_VECTOR(B);

 

       for i in 0 to A'left loop

           sum(i) := A(i) xor BV(i) xor carry;

           carry := (A(i) and BV(i)) or

                  (A(i) and carry) or

                  (carry and BV(i));

       end loop;

       return sum;

    end;

 

    -- add two signed numbers of the same length

    -- both arrays must have range (msb downto 0)

    function plus(A, B: SIGNED) return SIGNED is

       variable carry: STD_ULOGIC;

       variable BV, sum: SIGNED (A'left downto 0);

 

       -- pragma map_to_operator ADD_TC_OP

       -- pragma type_function LEFT_SIGNED_ARG

        -- pragma return_port_name Z

 

    begin

       if (A(A'left) = 'X' or B(B'left) = 'X') then

            sum := (others => 'X');

            return(sum);

       end if;

       carry := '0';

       BV := B;

 

       for i in 0 to A'left loop

           sum(i) := A(i) xor BV(i) xor carry;

           carry := (A(i) and BV(i)) or

                  (A(i) and carry) or

                  (carry and BV(i));

       end loop;

       return sum;

    end;

 

 

    -- subtract two unsigned numbers of the same length

    -- both arrays must have range (msb downto 0)

    function unsigned_minus(A, B: UNSIGNED) return UNSIGNED is

       variable carry: STD_ULOGIC;

       variable BV: STD_ULOGIC_VECTOR (A'left downto 0);

       variable sum: UNSIGNED (A'left downto 0);

 

       -- pragma map_to_operator SUB_UNS_OP

       -- pragma type_function LEFT_UNSIGNED_ARG

        -- pragma return_port_name Z

 

    begin

       if (A(A'left) = 'X' or B(B'left) = 'X') then

            sum := (others => 'X');

            return(sum);

       end if;

       carry := '1';

       BV := not STD_ULOGIC_VECTOR(B);

 

       for i in 0 to A'left loop

           sum(i) := A(i) xor BV(i) xor carry;

           carry := (A(i) and BV(i)) or

                  (A(i) and carry) or

                  (carry and BV(i));

       end loop;

       return sum;

    end;

 

    -- add two unsigned numbers of the same length

    -- both arrays must have range (msb downto 0)

    function unsigned_plus(A, B: UNSIGNED) return UNSIGNED is

       variable carry: STD_ULOGIC;

       variable BV, sum: UNSIGNED (A'left downto 0);

 

       -- pragma map_to_operator ADD_UNS_OP

       -- pragma type_function LEFT_UNSIGNED_ARG

        -- pragma return_port_name Z

 

    begin

       if (A(A'left) = 'X' or B(B'left) = 'X') then

            sum := (others => 'X');

            return(sum);

       end if;

       carry := '0';

       BV := B;

 

       for i in 0 to A'left loop

           sum(i) := A(i) xor BV(i) xor carry;

           carry := (A(i) and BV(i)) or

                  (A(i) and carry) or

                  (carry and BV(i));

       end loop;

       return sum;

    end;

 

 

 

    function "*"(L: SIGNED; R: SIGNED) return SIGNED is

       -- pragma label_applies_to mult

       -- synopsys subpgm_id 296

    begin

          return     mult(CONV_SIGNED(L, L'length),

                        CONV_SIGNED(R, R'length)); -- pragma label mult

    end;

     

    function "*"(L: UNSIGNED; R: UNSIGNED) return UNSIGNED is

       -- pragma label_applies_to mult

       -- synopsys subpgm_id 295

    begin

          return   mult(CONV_UNSIGNED(L, L'length),

                        CONV_UNSIGNED(R, R'length)); -- pragma label mult

    end;

       

    function "*"(L: UNSIGNED; R: SIGNED) return SIGNED is

       -- pragma label_applies_to mult

       -- synopsys subpgm_id 297

    begin

       return       mult(CONV_SIGNED(L, L'length+1),

                        CONV_SIGNED(R, R'length)); -- pragma label mult

    end;

 

    function "*"(L: SIGNED; R: UNSIGNED) return SIGNED is

       -- pragma label_applies_to mult

       -- synopsys subpgm_id 298

    begin

       return      mult(CONV_SIGNED(L, L'length),

                       CONV_SIGNED(R, R'length+1)); -- pragma label mult

    end;

 

 

    function "*"(L: SIGNED; R: SIGNED) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to mult

       -- synopsys subpgm_id 301

    begin

          return STD_LOGIC_VECTOR (

              mult(-- pragma label mult

              CONV_SIGNED(L, L'length), CONV_SIGNED(R, R'length)));

    end;

     

    function "*"(L: UNSIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to mult

       -- synopsys subpgm_id 300

    begin

          return STD_LOGIC_VECTOR (

              mult(-- pragma label mult

              CONV_UNSIGNED(L, L'length), CONV_UNSIGNED(R, R'length)));

    end;

       

    function "*"(L: UNSIGNED; R: SIGNED) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to mult

       -- synopsys subpgm_id 302

    begin

       return STD_LOGIC_VECTOR (

              mult(-- pragma label mult

              CONV_SIGNED(L, L'length+1), CONV_SIGNED(R, R'length)));

    end;

 

    function "*"(L: SIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to mult

       -- synopsys subpgm_id 303

    begin

       return STD_LOGIC_VECTOR (

              mult(-- pragma label mult

              CONV_SIGNED(L, L'length), CONV_SIGNED(R, R'length+1)));

    end;

 

 

    function "+"(L: UNSIGNED; R: UNSIGNED) return UNSIGNED is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 236

       constant length: INTEGER := max(L'length, R'length);

    begin

       return unsigned_plus(CONV_UNSIGNED(L, length),

                          CONV_UNSIGNED(R, length)); -- pragma label plus

    end;

 

 

    function "+"(L: SIGNED; R: SIGNED) return SIGNED is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 237

       constant length: INTEGER := max(L'length, R'length);

    begin

       return plus(CONV_SIGNED(L, length),

                  CONV_SIGNED(R, length)); -- pragma label plus

    end;

 

 

    function "+"(L: UNSIGNED; R: SIGNED) return SIGNED is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 238

       constant length: INTEGER := max(L'length + 1, R'length);

    begin

       return plus(CONV_SIGNED(L, length),

                  CONV_SIGNED(R, length)); -- pragma label plus

    end;

 

 

    function "+"(L: SIGNED; R: UNSIGNED) return SIGNED is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 239

       constant length: INTEGER := max(L'length, R'length + 1);

    begin

       return plus(CONV_SIGNED(L, length),

                  CONV_SIGNED(R, length)); -- pragma label plus

    end;

 

 

    function "+"(L: UNSIGNED; R: INTEGER) return UNSIGNED is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 240

       constant length: INTEGER := L'length + 1;

    begin

       return CONV_UNSIGNED(

              plus( -- pragma label plus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1);

    end;

 

 

    function "+"(L: INTEGER; R: UNSIGNED) return UNSIGNED is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 241

       constant length: INTEGER := R'length + 1;

    begin

       return CONV_UNSIGNED(

              plus( -- pragma label plus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1);

    end;

 

 

    function "+"(L: SIGNED; R: INTEGER) return SIGNED is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 242

       constant length: INTEGER := L'length;

    begin

       return plus(CONV_SIGNED(L, length),

                  CONV_SIGNED(R, length)); -- pragma label plus

    end;

 

 

    function "+"(L: INTEGER; R: SIGNED) return SIGNED is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 243

       constant length: INTEGER := R'length;

    begin

       return plus(CONV_SIGNED(L, length),

                  CONV_SIGNED(R, length)); -- pragma label plus

    end;

 

 

    function "+"(L: UNSIGNED; R: STD_ULOGIC) return UNSIGNED is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 244

       constant length: INTEGER := L'length;

    begin

       return unsigned_plus(CONV_UNSIGNED(L, length),

                   CONV_UNSIGNED(R, length)) ; -- pragma label plus

    end;

 

 

    function "+"(L: STD_ULOGIC; R: UNSIGNED) return UNSIGNED is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 245

       constant length: INTEGER := R'length;

    begin

       return unsigned_plus(CONV_UNSIGNED(L, length),

                   CONV_UNSIGNED(R, length)); -- pragma label plus

    end;

 

 

    function "+"(L: SIGNED; R: STD_ULOGIC) return SIGNED is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 246

       constant length: INTEGER := L'length;

    begin

       return plus(CONV_SIGNED(L, length),

                  CONV_SIGNED(R, length)); -- pragma label plus

    end;

 

 

    function "+"(L: STD_ULOGIC; R: SIGNED) return SIGNED is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 247

       constant length: INTEGER := R'length;

    begin

       return plus(CONV_SIGNED(L, length),

                  CONV_SIGNED(R, length)); -- pragma label plus

    end;

 

 

 

    function "+"(L: UNSIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 260

       constant length: INTEGER := max(L'length, R'length);

    begin

       return STD_LOGIC_VECTOR (

              unsigned_plus(-- pragma label plus

              CONV_UNSIGNED(L, length), CONV_UNSIGNED(R, length)));

    end;

 

 

    function "+"(L: SIGNED; R: SIGNED) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 261

       constant length: INTEGER := max(L'length, R'length);

    begin

       return STD_LOGIC_VECTOR (

              plus(-- pragma label plus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)));

    end;

 

 

    function "+"(L: UNSIGNED; R: SIGNED) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 262

       constant length: INTEGER := max(L'length + 1, R'length);

    begin

       return STD_LOGIC_VECTOR (

              plus(-- pragma label plus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)));

    end;

 

 

    function "+"(L: SIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 263

       constant length: INTEGER := max(L'length, R'length + 1);

    begin

       return STD_LOGIC_VECTOR (

              plus(-- pragma label plus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)));

    end;

 

 

    function "+"(L: UNSIGNED; R: INTEGER) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 264

       constant length: INTEGER := L'length + 1;

    begin

       return STD_LOGIC_VECTOR (CONV_UNSIGNED(

              plus( -- pragma label plus

               CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1));

    end;

 

 

    function "+"(L: INTEGER; R: UNSIGNED) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 265

       constant length: INTEGER := R'length + 1;

    begin

       return STD_LOGIC_VECTOR (CONV_UNSIGNED(

              plus( -- pragma label plus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1));

    end;

 

 

    function "+"(L: SIGNED; R: INTEGER) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 266

       constant length: INTEGER := L'length;

    begin

       return STD_LOGIC_VECTOR (

              plus(-- pragma label plus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)));

    end;

 

 

    function "+"(L: INTEGER; R: SIGNED) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 267

       constant length: INTEGER := R'length;

    begin

       return STD_LOGIC_VECTOR (

              plus(-- pragma label plus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)));

    end;

 

 

    function "+"(L: UNSIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 268

       constant length: INTEGER := L'length;

    begin

       return STD_LOGIC_VECTOR (

              unsigned_plus(-- pragma label plus

              CONV_UNSIGNED(L, length), CONV_UNSIGNED(R, length))) ;

    end;

 

 

    function "+"(L: STD_ULOGIC; R: UNSIGNED) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 269

       constant length: INTEGER := R'length;

    begin

       return STD_LOGIC_VECTOR (

              unsigned_plus(-- pragma label plus

              CONV_UNSIGNED(L, length), CONV_UNSIGNED(R, length)));

    end;

 

 

    function "+"(L: SIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 270

       constant length: INTEGER := L'length;

    begin

       return STD_LOGIC_VECTOR (

              plus(-- pragma label plus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)));

    end;

 

 

    function "+"(L: STD_ULOGIC; R: SIGNED) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to plus

       -- synopsys subpgm_id 271

       constant length: INTEGER := R'length;

    begin

       return STD_LOGIC_VECTOR (

              plus(-- pragma label plus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)));

    end;

 

 

 

    function "-"(L: UNSIGNED; R: UNSIGNED) return UNSIGNED is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 248

       constant length: INTEGER := max(L'length, R'length);

    begin

       return unsigned_minus(CONV_UNSIGNED(L, length),

                          CONV_UNSIGNED(R, length)); -- pragma label minus

    end;

 

 

    function "-"(L: SIGNED; R: SIGNED) return SIGNED is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 249

       constant length: INTEGER := max(L'length, R'length);

    begin

       return minus(CONV_SIGNED(L, length),

                   CONV_SIGNED(R, length)); -- pragma label minus

    end;

 

 

    function "-"(L: UNSIGNED; R: SIGNED) return SIGNED is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 250

       constant length: INTEGER := max(L'length + 1, R'length);

    begin

       return minus(CONV_SIGNED(L, length),

                   CONV_SIGNED(R, length)); -- pragma label minus

    end;

 

 

    function "-"(L: SIGNED; R: UNSIGNED) return SIGNED is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 251

       constant length: INTEGER := max(L'length, R'length + 1);

    begin

       return minus(CONV_SIGNED(L, length),

                   CONV_SIGNED(R, length)); -- pragma label minus

    end;

 

 

    function "-"(L: UNSIGNED; R: INTEGER) return UNSIGNED is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 252

       constant length: INTEGER := L'length + 1;

    begin

       return CONV_UNSIGNED(

              minus( -- pragma label minus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1);

    end;

 

 

    function "-"(L: INTEGER; R: UNSIGNED) return UNSIGNED is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 253

       constant length: INTEGER := R'length + 1;

    begin

       return CONV_UNSIGNED(

              minus( -- pragma label minus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1);

    end;

 

 

    function "-"(L: SIGNED; R: INTEGER) return SIGNED is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 254

       constant length: INTEGER := L'length;

    begin

       return minus(CONV_SIGNED(L, length),

                   CONV_SIGNED(R, length)); -- pragma label minus

    end;

 

 

    function "-"(L: INTEGER; R: SIGNED) return SIGNED is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 255

       constant length: INTEGER := R'length;

    begin

       return minus(CONV_SIGNED(L, length),

                   CONV_SIGNED(R, length)); -- pragma label minus

    end;

 

 

    function "-"(L: UNSIGNED; R: STD_ULOGIC) return UNSIGNED is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 256

       constant length: INTEGER := L'length + 1;

    begin

       return CONV_UNSIGNED(

              minus( -- pragma label minus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1);

    end;

 

 

    function "-"(L: STD_ULOGIC; R: UNSIGNED) return UNSIGNED is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 257

       constant length: INTEGER := R'length + 1;

    begin

       return CONV_UNSIGNED(

              minus( -- pragma label minus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1);

    end;

 

 

    function "-"(L: SIGNED; R: STD_ULOGIC) return SIGNED is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 258

       constant length: INTEGER := L'length;

    begin

       return minus(CONV_SIGNED(L, length),

                   CONV_SIGNED(R, length)); -- pragma label minus

    end;

 

 

    function "-"(L: STD_ULOGIC; R: SIGNED) return SIGNED is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 259

       constant length: INTEGER := R'length;

    begin

       return minus(CONV_SIGNED(L, length),

                   CONV_SIGNED(R, length)); -- pragma label minus

    end;

 

 

 

 

    function "-"(L: UNSIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 272

       constant length: INTEGER := max(L'length, R'length);

    begin

       return STD_LOGIC_VECTOR (

              unsigned_minus(-- pragma label minus

              CONV_UNSIGNED(L, length), CONV_UNSIGNED(R, length)));

    end;

 

 

    function "-"(L: SIGNED; R: SIGNED) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 273

       constant length: INTEGER := max(L'length, R'length);

    begin

       return STD_LOGIC_VECTOR (

              minus(-- pragma label minus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)));

    end;

 

 

    function "-"(L: UNSIGNED; R: SIGNED) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 274

       constant length: INTEGER := max(L'length + 1, R'length);

    begin

       return STD_LOGIC_VECTOR (

              minus(-- pragma label minus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)));

    end;

 

 

    function "-"(L: SIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 275

       constant length: INTEGER := max(L'length, R'length + 1);

    begin

       return STD_LOGIC_VECTOR (

              minus(-- pragma label minus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)));

    end;

 

 

    function "-"(L: UNSIGNED; R: INTEGER) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 276

       constant length: INTEGER := L'length + 1;

    begin

       return STD_LOGIC_VECTOR (CONV_UNSIGNED(

              minus( -- pragma label minus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1));

    end;

 

 

    function "-"(L: INTEGER; R: UNSIGNED) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 277

       constant length: INTEGER := R'length + 1;

    begin

       return STD_LOGIC_VECTOR (CONV_UNSIGNED(

              minus( -- pragma label minus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1));

    end;

 

 

    function "-"(L: SIGNED; R: INTEGER) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 278

       constant length: INTEGER := L'length;

    begin

       return STD_LOGIC_VECTOR (

              minus(-- pragma label minus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)));

    end;

 

 

    function "-"(L: INTEGER; R: SIGNED) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 279

       constant length: INTEGER := R'length;

    begin

       return STD_LOGIC_VECTOR (

              minus(-- pragma label minus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)));

    end;

 

 

    function "-"(L: UNSIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 280

       constant length: INTEGER := L'length + 1;

    begin

       return STD_LOGIC_VECTOR (CONV_UNSIGNED(

              minus( -- pragma label minus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1));

    end;

 

 

    function "-"(L: STD_ULOGIC; R: UNSIGNED) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 281

       constant length: INTEGER := R'length + 1;

    begin

       return STD_LOGIC_VECTOR (CONV_UNSIGNED(

              minus( -- pragma label minus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1));

    end;

 

 

    function "-"(L: SIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 282

       constant length: INTEGER := L'length;

    begin

       return STD_LOGIC_VECTOR (

              minus(-- pragma label minus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)));

    end;

 

 

    function "-"(L: STD_ULOGIC; R: SIGNED) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 283

       constant length: INTEGER := R'length;

    begin

       return STD_LOGIC_VECTOR (

              minus(-- pragma label minus

              CONV_SIGNED(L, length), CONV_SIGNED(R, length)));

    end;

 

 

 

 

    function "+"(L: UNSIGNED) return UNSIGNED is

       -- synopsys subpgm_id 284

    begin

       return L;

    end;

 

 

    function "+"(L: SIGNED) return SIGNED is

       -- synopsys subpgm_id 285

    begin

       return L;

    end;

 

 

    function "-"(L: SIGNED) return SIGNED is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 286

    begin

       return 0 - L; -- pragma label minus

    end;

 

 

    function "ABS"(L: SIGNED) return SIGNED is

       -- synopsys subpgm_id 287

    begin

       if (L(L'left) = '0' or L(L'left) = 'L') then

           return L;

       else

           return 0 - L;

       end if;

    end;

 

 

    function "+"(L: UNSIGNED) return STD_LOGIC_VECTOR is

       -- synopsys subpgm_id 289

    begin

       return STD_LOGIC_VECTOR (L);

    end;

 

 

    function "+"(L: SIGNED) return STD_LOGIC_VECTOR is

       -- synopsys subpgm_id 290

    begin

       return STD_LOGIC_VECTOR (L);

    end;

 

 

    function "-"(L: SIGNED) return STD_LOGIC_VECTOR is

       -- pragma label_applies_to minus

       -- synopsys subpgm_id 292

       variable tmp: SIGNED(L'length-1 downto 0);

    begin

       tmp := 0 - L;  -- pragma label minus

       return STD_LOGIC_VECTOR (tmp);

    end;

 

 

    function "ABS"(L: SIGNED) return STD_LOGIC_VECTOR is

       -- synopsys subpgm_id 294

       variable tmp: SIGNED(L'length-1 downto 0);

    begin

       if (L(L'left) = '0' or L(L'left) = 'L') then

           return STD_LOGIC_VECTOR (L);

       else

           tmp := 0 - L;

           return STD_LOGIC_VECTOR (tmp);

       end if;

    end;

 

 

    -- Type propagation function which returns the type BOOLEAN

    function UNSIGNED_RETURN_BOOLEAN(A,B: UNSIGNED) return BOOLEAN is

      variable Z: BOOLEAN;

      -- pragma return_port_name Z

    begin

      return(Z);

    end;

      

    -- Type propagation function which returns the type BOOLEAN

    function SIGNED_RETURN_BOOLEAN(A,B: SIGNED) return BOOLEAN is

      variable Z: BOOLEAN;

      -- pragma return_port_name Z

    begin

      return(Z);

    end;

      

 

    -- compare two signed numbers of the same length

    -- both arrays must have range (msb downto 0)

    function is_less(A, B: SIGNED) return BOOLEAN is

       constant sign: INTEGER := A'left;

       variable a_is_0, b_is_1, result : boolean;

 

       -- pragma map_to_operator LT_TC_OP

       -- pragma type_function SIGNED_RETURN_BOOLEAN

        -- pragma return_port_name Z

 

    begin

       if A(sign) /= B(sign) then

           result := A(sign) = '1';

       else

           result := FALSE;

           for i in 0 to sign-1 loop

              a_is_0 := A(i) = '0';

              b_is_1 := B(i) = '1';

              result := (a_is_0 and b_is_1) or

                       (a_is_0 and result) or

                       (b_is_1 and result);

           end loop;

       end if;

       return result;

    end;

 

 

    -- compare two signed numbers of the same length

    -- both arrays must have range (msb downto 0)

    function is_less_or_equal(A, B: SIGNED) return BOOLEAN is

       constant sign: INTEGER := A'left;

       variable a_is_0, b_is_1, result : boolean;

 

       -- pragma map_to_operator LEQ_TC_OP

       -- pragma type_function SIGNED_RETURN_BOOLEAN

        -- pragma return_port_name Z

 

    begin

       if A(sign) /= B(sign) then

           result := A(sign) = '1';

       else

           result := TRUE;

           for i in 0 to sign-1 loop

              a_is_0 := A(i) = '0';

              b_is_1 := B(i) = '1';

              result := (a_is_0 and b_is_1) or

                       (a_is_0 and result) or

                       (b_is_1 and result);

           end loop;

       end if;

       return result;

    end;

 

 

 

    -- compare two unsigned numbers of the same length

    -- both arrays must have range (msb downto 0)

    function unsigned_is_less(A, B: UNSIGNED) return BOOLEAN is

       constant sign: INTEGER := A'left;

       variable a_is_0, b_is_1, result : boolean;

 

       -- pragma map_to_operator LT_UNS_OP

       -- pragma type_function UNSIGNED_RETURN_BOOLEAN

        -- pragma return_port_name Z

 

    begin

       result := FALSE;

       for i in 0 to sign loop

           a_is_0 := A(i) = '0';

           b_is_1 := B(i) = '1';

           result := (a_is_0 and b_is_1) or

                    (a_is_0 and result) or

                    (b_is_1 and result);

       end loop;

       return result;

    end;

 

 

    -- compare two unsigned numbers of the same length

    -- both arrays must have range (msb downto 0)

    function unsigned_is_less_or_equal(A, B: UNSIGNED) return BOOLEAN is

       constant sign: INTEGER := A'left;

       variable a_is_0, b_is_1, result : boolean;

 

       -- pragma map_to_operator LEQ_UNS_OP

       -- pragma type_function UNSIGNED_RETURN_BOOLEAN

        -- pragma return_port_name Z

 

    begin

       result := TRUE;

       for i in 0 to sign loop

           a_is_0 := A(i) = '0';

           b_is_1 := B(i) = '1';

           result := (a_is_0 and b_is_1) or

                    (a_is_0 and result) or

                    (b_is_1 and result);

       end loop;

       return result;

    end;

 

 

 

 

    function "<"(L: UNSIGNED; R: UNSIGNED) return BOOLEAN is

       -- pragma label_applies_to lt

       -- synopsys subpgm_id 305

       constant length: INTEGER := max(L'length, R'length);

    begin

       return unsigned_is_less(CONV_UNSIGNED(L, length),

                           CONV_UNSIGNED(R, length)); -- pragma label lt

    end;

 

 

    function "<"(L: SIGNED; R: SIGNED) return BOOLEAN is

       -- pragma label_applies_to lt

       -- synopsys subpgm_id 306

       constant length: INTEGER := max(L'length, R'length);

    begin

       return is_less(CONV_SIGNED(L, length),

                     CONV_SIGNED(R, length)); -- pragma label lt

    end;

 

 

    function "<"(L: UNSIGNED; R: SIGNED) return BOOLEAN is

       -- pragma label_applies_to lt

       -- synopsys subpgm_id 307

       constant length: INTEGER := max(L'length + 1, R'length);

    begin

       return is_less(CONV_SIGNED(L, length),

                     CONV_SIGNED(R, length)); -- pragma label lt

    end;

 

 

    function "<"(L: SIGNED; R: UNSIGNED) return BOOLEAN is

       -- pragma label_applies_to lt

       -- synopsys subpgm_id 308

       constant length: INTEGER := max(L'length, R'length + 1);

    begin

       return is_less(CONV_SIGNED(L, length),

                     CONV_SIGNED(R, length)); -- pragma label lt

    end;

 

 

    function "<"(L: UNSIGNED; R: INTEGER) return BOOLEAN is

       -- pragma label_applies_to lt

       -- synopsys subpgm_id 309

       constant length: INTEGER := L'length + 1;

    begin

       return is_less(CONV_SIGNED(L, length),

                     CONV_SIGNED(R, length)); -- pragma label lt

    end;

 

 

    function "<"(L: INTEGER; R: UNSIGNED) return BOOLEAN is

       -- pragma label_applies_to lt

       -- synopsys subpgm_id 310

       constant length: INTEGER := R'length + 1;

    begin

       return is_less(CONV_SIGNED(L, length),

                     CONV_SIGNED(R, length)); -- pragma label lt

    end;

 

 

    function "<"(L: SIGNED; R: INTEGER) return BOOLEAN is

       -- pragma label_applies_to lt

       -- synopsys subpgm_id 311

       constant length: INTEGER := L'length;

    begin

       return is_less(CONV_SIGNED(L, length),

                     CONV_SIGNED(R, length)); -- pragma label lt

    end;

 

 

    function "<"(L: INTEGER; R: SIGNED) return BOOLEAN is

       -- pragma label_applies_to lt

       -- synopsys subpgm_id 312

       constant length: INTEGER := R'length;

    begin

       return is_less(CONV_SIGNED(L, length),

                     CONV_SIGNED(R, length)); -- pragma label lt

    end;

 

 

 

 

    function "<="(L: UNSIGNED; R: UNSIGNED) return BOOLEAN is

       -- pragma label_applies_to leq

       -- synopsys subpgm_id 314

       constant length: INTEGER := max(L'length, R'length);

    begin

       return unsigned_is_less_or_equal(CONV_UNSIGNED(L, length),

                          CONV_UNSIGNED(R, length)); -- pragma label leq

    end;

 

 

    function "<="(L: SIGNED; R: SIGNED) return BOOLEAN is

       -- pragma label_applies_to leq

       -- synopsys subpgm_id 315

       constant length: INTEGER := max(L'length, R'length);

    begin

       return is_less_or_equal(CONV_SIGNED(L, length),

                           CONV_SIGNED(R, length)); -- pragma label leq

    end;

 

 

    function "<="(L: UNSIGNED; R: SIGNED) return BOOLEAN is

       -- pragma label_applies_to leq

       -- synopsys subpgm_id 316

       constant length: INTEGER := max(L'length + 1, R'length);

    begin

       return is_less_or_equal(CONV_SIGNED(L, length),

                           CONV_SIGNED(R, length)); -- pragma label leq

    end;

 

 

    function "<="(L: SIGNED; R: UNSIGNED) return BOOLEAN is

       -- pragma label_applies_to leq

       -- synopsys subpgm_id 317

       constant length: INTEGER := max(L'length, R'length + 1);

    begin

       return is_less_or_equal(CONV_SIGNED(L, length),

                           CONV_SIGNED(R, length)); -- pragma label leq

    end;

 

 

    function "<="(L: UNSIGNED; R: INTEGER) return BOOLEAN is

       -- pragma label_applies_to leq

       -- synopsys subpgm_id 318

       constant length: INTEGER := L'length + 1;

    begin

       return is_less_or_equal(CONV_SIGNED(L, length),

                            CONV_SIGNED(R, length)); -- pragma label leq

    end;

 

 

    function "<="(L: INTEGER; R: UNSIGNED) return BOOLEAN is

       -- pragma label_applies_to leq

       -- synopsys subpgm_id 319

       constant length: INTEGER := R'length + 1;

    begin

       return is_less_or_equal(CONV_SIGNED(L, length),

                           CONV_SIGNED(R, length)); -- pragma label leq

    end;

 

 

    function "<="(L: SIGNED; R: INTEGER) return BOOLEAN is

       -- pragma label_applies_to leq

       -- synopsys subpgm_id 320

       constant length: INTEGER := L'length;

    begin

       return is_less_or_equal(CONV_SIGNED(L, length),

                           CONV_SIGNED(R, length)); -- pragma label leq

    end;

 

 

    function "<="(L: INTEGER; R: SIGNED) return BOOLEAN is

       -- pragma label_applies_to leq

       -- synopsys subpgm_id 321

       constant length: INTEGER := R'length;

    begin

       return is_less_or_equal(CONV_SIGNED(L, length),

                           CONV_SIGNED(R, length)); -- pragma label leq

    end;

 

 

 

 

    function ">"(L: UNSIGNED; R: UNSIGNED) return BOOLEAN is

       -- pragma label_applies_to gt

       -- synopsys subpgm_id 323

       constant length: INTEGER := max(L'length, R'length);

    begin

       return unsigned_is_less(CONV_UNSIGNED(R, length),

                           CONV_UNSIGNED(L, length)); -- pragma label gt

    end;

 

 

    function ">"(L: SIGNED; R: SIGNED) return BOOLEAN is

       -- pragma label_applies_to gt

       -- synopsys subpgm_id 324

       constant length: INTEGER := max(L'length, R'length);

    begin

       return is_less(CONV_SIGNED(R, length),

                     CONV_SIGNED(L, length)); -- pragma label gt

    end;

 

 

    function ">"(L: UNSIGNED; R: SIGNED) return BOOLEAN is

       -- pragma label_applies_to gt

       -- synopsys subpgm_id 325

       constant length: INTEGER := max(L'length + 1, R'length);

    begin

       return is_less(CONV_SIGNED(R, length),

                     CONV_SIGNED(L, length)); -- pragma label gt

    end;

 

 

    function ">"(L: SIGNED; R: UNSIGNED) return BOOLEAN is

       -- pragma label_applies_to gt

       -- synopsys subpgm_id 326

       constant length: INTEGER := max(L'length, R'length + 1);

    begin

       return is_less(CONV_SIGNED(R, length),

                     CONV_SIGNED(L, length)); -- pragma label gt

    end;

 

 

    function ">"(L: UNSIGNED; R: INTEGER) return BOOLEAN is

       -- pragma label_applies_to gt

       -- synopsys subpgm_id 327

       constant length: INTEGER := L'length + 1;

    begin

       return is_less(CONV_SIGNED(R, length),

                     CONV_SIGNED(L, length)); -- pragma label gt

    end;

 

 

    function ">"(L: INTEGER; R: UNSIGNED) return BOOLEAN is

       -- pragma label_applies_to gt

       -- synopsys subpgm_id 328

       constant length: INTEGER := R'length + 1;

    begin

       return is_less(CONV_SIGNED(R, length),

                     CONV_SIGNED(L, length)); -- pragma label gt

    end;

 

 

    function ">"(L: SIGNED; R: INTEGER) return BOOLEAN is

       -- pragma label_applies_to gt

       -- synopsys subpgm_id 329

       constant length: INTEGER := L'length;

    begin

       return is_less(CONV_SIGNED(R, length),

                     CONV_SIGNED(L, length)); -- pragma label gt

    end;

 

 

    function ">"(L: INTEGER; R: SIGNED) return BOOLEAN is

       -- pragma label_applies_to gt

       -- synopsys subpgm_id 330

       constant length: INTEGER := R'length;

    begin

       return is_less(CONV_SIGNED(R, length),

                     CONV_SIGNED(L, length)); -- pragma label gt

    end;

 

 

 

 

    function ">="(L: UNSIGNED; R: UNSIGNED) return BOOLEAN is

       -- pragma label_applies_to geq

       -- synopsys subpgm_id 332

       constant length: INTEGER := max(L'length, R'length);

    begin

       return unsigned_is_less_or_equal(CONV_UNSIGNED(R, length),

                     CONV_UNSIGNED(L, length)); -- pragma label geq

    end;

 

 

    function ">="(L: SIGNED; R: SIGNED) return BOOLEAN is

       -- pragma label_applies_to geq

       -- synopsys subpgm_id 333

       constant length: INTEGER := max(L'length, R'length);

    begin

       return is_less_or_equal(CONV_SIGNED(R, length),

                     CONV_SIGNED(L, length)); -- pragma label geq

    end;

 

 

    function ">="(L: UNSIGNED; R: SIGNED) return BOOLEAN is

       -- pragma label_applies_to geq

       -- synopsys subpgm_id 334

       constant length: INTEGER := max(L'length + 1, R'length);

    begin

       return is_less_or_equal(CONV_SIGNED(R, length),

                     CONV_SIGNED(L, length)); -- pragma label geq

    end;

 

 

    function ">="(L: SIGNED; R: UNSIGNED) return BOOLEAN is

       -- pragma label_applies_to geq

       -- synopsys subpgm_id 335

       constant length: INTEGER := max(L'length, R'length + 1);

    begin

       return is_less_or_equal(CONV_SIGNED(R, length),

                     CONV_SIGNED(L, length)); -- pragma label geq

    end;

 

 

    function ">="(L: UNSIGNED; R: INTEGER) return BOOLEAN is

       -- pragma label_applies_to geq

       -- synopsys subpgm_id 336

       constant length: INTEGER := L'length + 1;

    begin

       return is_less_or_equal(CONV_SIGNED(R, length),

                            CONV_SIGNED(L, length)); -- pragma label geq

    end;

 

 

    function ">="(L: INTEGER; R: UNSIGNED) return BOOLEAN is

       -- pragma label_applies_to geq

       -- synopsys subpgm_id 337

       constant length: INTEGER := R'length + 1;

    begin

       return is_less_or_equal(CONV_SIGNED(R, length),

                           CONV_SIGNED(L, length)); -- pragma label geq

    end;

 

 

    function ">="(L: SIGNED; R: INTEGER) return BOOLEAN is

       -- pragma label_applies_to geq

       -- synopsys subpgm_id 338

       constant length: INTEGER := L'length;

    begin

       return is_less_or_equal(CONV_SIGNED(R, length),

                           CONV_SIGNED(L, length)); -- pragma label geq

    end;

 

 

    function