Differences

This shows you the differences between two versions of the page.

--- dt-vhdl-numeric-std-library [2010/12/23 09:01]
beckmanf created
+++ dt-vhdl-numeric-std-library [2024/04/07 20:49] (current)
beckmanf Remove Body - Rendering is too slow
@@ Line 1: / Line 1: @@
-=== VHDL Numeric Standard Library ===
+=== VHDL Numeric Standard Package ===
 Dieses Package definiert die Typen und Funktionen für arithmetische Operationen
@@ Line 858: / Line 858: @@
 end NUMERIC_STD;
---==============================================================================
---============================= Package Body ===================================
---==============================================================================
-  -- Synthesis Directives
-  -- Directives are in the form of the following two attributes :
---  attribute SYNTHESIS_RETURN : STRING ;
---  attribute IS_SIGNED : BOOLEAN ;
-  -- The SYNTHESIS_RETURN attribute is set on a return variable inside a function.
-  -- Quartus will recognize the attribute and replace the function body by a
-  -- built-in definition for synthesis.
-  -- The variable on which the attribute is set defines the return (index) range
-  -- of the function.
-  -- The IS_SIGNED attribute is set on array parameters of the function that
-  -- should be interpreted as 2-complement values.
-  -- MSB is always the left most bit in an array (both for parameters and for
-  -- return values).
-library altera;
-use altera.altera_internal_syn.all;
-package body NUMERIC_STD is
-  -- null range array constants
-  constant NAU: UNSIGNED(0 downto 1) := (others => '0');
-  constant NAS: SIGNED(0 downto 1) := (others => '0');
-  -- implementation controls
-  constant NO_WARNING: BOOLEAN := FALSE; -- default to emit warnings
-  --=========================Local Subprograms =================================
-  function MAX (LEFT, RIGHT: INTEGER) return INTEGER is
-  begin
-    if LEFT > RIGHT then return LEFT;
-    else return RIGHT;
-    end if;
-  end MAX;
-  function MIN (LEFT, RIGHT: INTEGER) return INTEGER is
-  begin
-    if LEFT < RIGHT then return LEFT;
-    else return RIGHT;
-    end if;
-  end MIN;
-  function SIGNED_NUM_BITS (ARG: INTEGER) return NATURAL is
-    variable NBITS: NATURAL;
-    variable N: NATURAL;
-  begin
-    if ARG >= 0 then
-      N := ARG;
-    else
-      N := -(ARG+1);
-    end if;
-    NBITS := 1;
-    while N > 0 loop
-      NBITS := NBITS+1;
-      N := N / 2;
-    end loop;
-    return NBITS;
-  end SIGNED_NUM_BITS;
-  function UNSIGNED_NUM_BITS (ARG: NATURAL) return NATURAL is
-    variable NBITS: NATURAL;
-    variable N: NATURAL;
-  begin
-    N := ARG;
-    NBITS := 1;
-    while N > 1 loop
-      NBITS := NBITS+1;
-      N := N / 2;
-    end loop;
-    return NBITS;
-  end UNSIGNED_NUM_BITS;
-  ------------------------------------------------------------------------
-  -- this internal function computes the addition of two UNSIGNED
-  -- with input CARRY
-  -- * the two arguments are of the same length
-  function ADD_UNSIGNED (L, R: UNSIGNED; C: STD_LOGIC) return UNSIGNED is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    alias XL: UNSIGNED(L_LEFT downto 0) is L;
-    alias XR: UNSIGNED(L_LEFT downto 0) is R;
-    variable RESULT: UNSIGNED(L_LEFT downto 0);
-    variable CBIT: STD_LOGIC := C;
-  begin
-    for I in 0 to L_LEFT loop
-      RESULT(I) := CBIT xor XL(I) xor XR(I);
-      CBIT := (CBIT and XL(I)) or (CBIT and XR(I)) or (XL(I) and XR(I));
-    end loop;
-    return RESULT;
-  end ADD_UNSIGNED;
-  -- this internal function computes the addition of two SIGNED
-  -- with input CARRY
-  -- * the two arguments are of the same length
-  function ADD_SIGNED (L, R: SIGNED; C: STD_LOGIC) return SIGNED is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    alias XL: SIGNED(L_LEFT downto 0) is L;
-    alias XR: SIGNED(L_LEFT downto 0) is R;
-    variable RESULT: SIGNED(L_LEFT downto 0);
-    variable CBIT: STD_LOGIC := C;
-  begin
-    for I in 0 to L_LEFT loop
-      RESULT(I) := CBIT xor XL(I) xor XR(I);
-      CBIT := (CBIT and XL(I)) or (CBIT and XR(I)) or (XL(I) and XR(I));
-    end loop;
-    return RESULT;
-  end ADD_SIGNED;
-  -----------------------------------------------------------------------------
-  -- this internal procedure computes UNSIGNED division
-  -- giving the quotient and remainder.
-  procedure DIVMOD (NUM, XDENOM: UNSIGNED; XQUOT, XREMAIN: out UNSIGNED) is
-    variable TEMP: UNSIGNED(NUM'LENGTH downto 0);
-    variable QUOT: UNSIGNED(MAX(NUM'LENGTH, XDENOM'LENGTH)-1 downto 0);
-    alias DENOM: UNSIGNED(XDENOM'LENGTH-1 downto 0) is XDENOM;
-    variable TOPBIT: INTEGER;
-  begin
-    TEMP := "0"&NUM;
-    QUOT := (others => '0');
-    TOPBIT := -1;
-    for J in DENOM'RANGE loop
-      if DENOM(J)='1' then
-        TOPBIT := J;
-        exit;
-      end if;
-    end loop;
-    assert TOPBIT >= 0 report "DIV, MOD, or REM by zero" severity ERROR;
-    for J in NUM'LENGTH-(TOPBIT+1) downto 0 loop
-      if TEMP(TOPBIT+J+1 downto J) >= "0"&DENOM(TOPBIT downto 0) then
-        TEMP(TOPBIT+J+1 downto J) := (TEMP(TOPBIT+J+1 downto J))
-            -("0"&DENOM(TOPBIT downto 0));
-        QUOT(J) := '1';
-      end if;
-      assert TEMP(TOPBIT+J+1)='0'
-          report "internal error in the division algorithm"
-          severity ERROR;
-    end loop;
-    XQUOT := RESIZE(QUOT, XQUOT'LENGTH);
-    XREMAIN := RESIZE(TEMP, XREMAIN'LENGTH);
-  end DIVMOD;
-  -----------------Local Subprograms - shift/rotate ops-------------------------
-  function XSLL (ARG: STD_LOGIC_VECTOR; COUNT: NATURAL) return STD_LOGIC_VECTOR
-      is
-    constant ARG_L: INTEGER := ARG'LENGTH-1;
-    alias XARG: STD_LOGIC_VECTOR(ARG_L downto 0) is ARG;
-    variable RESULT: STD_LOGIC_VECTOR(ARG_L downto 0) := (others => '0');
-    -- Synthesis directives :
-    attribute SYNTHESIS_RETURN of RESULT:variable is "SLL" ;
-  begin
-    if COUNT <= ARG_L then
-      RESULT(ARG_L downto COUNT) := XARG(ARG_L-COUNT downto 0);
-    end if;
-    return RESULT;
-  end XSLL;
-  function XSRL (ARG: STD_LOGIC_VECTOR; COUNT: NATURAL) return STD_LOGIC_VECTOR
-      is
-    constant ARG_L: INTEGER := ARG'LENGTH-1;
-    alias XARG: STD_LOGIC_VECTOR(ARG_L downto 0) is ARG;
-    variable RESULT: STD_LOGIC_VECTOR(ARG_L downto 0) := (others => '0');
-    -- Synthesis directives :
-    attribute SYNTHESIS_RETURN of RESULT:variable is "SRL" ;
-  begin
-    if COUNT <= ARG_L then
-      RESULT(ARG_L-COUNT downto 0) := XARG(ARG_L downto COUNT);
-    end if;
-    return RESULT;
-  end XSRL;
-  function XSRA (ARG: STD_LOGIC_VECTOR; COUNT: NATURAL) return STD_LOGIC_VECTOR
-      is
-    constant ARG_L: INTEGER := ARG'LENGTH-1;
-    alias XARG: STD_LOGIC_VECTOR(ARG_L downto 0) is ARG;
-    variable RESULT: STD_LOGIC_VECTOR(ARG_L downto 0);
-    variable XCOUNT: NATURAL := COUNT;
-    -- Synthesis directives :
-    attribute SYNTHESIS_RETURN of RESULT:variable is "SRA" ;
-  begin
-    if ((ARG'LENGTH <= 1) or (XCOUNT = 0)) then return ARG;
-    else
-      if (XCOUNT > ARG_L) then XCOUNT := ARG_L;
-      end if;
-      RESULT(ARG_L-XCOUNT downto 0) := XARG(ARG_L downto XCOUNT);
-      RESULT(ARG_L downto (ARG_L - XCOUNT + 1)) := (others => XARG(ARG_L));
-    end if;
-    return RESULT;
-  end XSRA;
-  function XROL (ARG: STD_LOGIC_VECTOR; COUNT: NATURAL) return STD_LOGIC_VECTOR
-      is
-    constant ARG_L: INTEGER := ARG'LENGTH-1;
-    alias XARG: STD_LOGIC_VECTOR(ARG_L downto 0) is ARG;
-    variable RESULT: STD_LOGIC_VECTOR(ARG_L downto 0) := XARG;
-    variable COUNTM: INTEGER;
-    -- Synthesis directives :
-    attribute SYNTHESIS_RETURN of RESULT:variable is "ROL" ;
-  begin
-    COUNTM := COUNT mod (ARG_L + 1);
-    if COUNTM /= 0 then
-      RESULT(ARG_L downto COUNTM) := XARG(ARG_L-COUNTM downto 0);
-      RESULT(COUNTM-1 downto 0) := XARG(ARG_L downto ARG_L-COUNTM+1);
-    end if;
-    return RESULT;
-  end XROL;
-  function XROR (ARG: STD_LOGIC_VECTOR; COUNT: NATURAL) return STD_LOGIC_VECTOR
-      is
-    constant ARG_L: INTEGER := ARG'LENGTH-1;
-    alias XARG: STD_LOGIC_VECTOR(ARG_L downto 0) is ARG;
-    variable RESULT: STD_LOGIC_VECTOR(ARG_L downto 0) := XARG;
-    variable COUNTM: INTEGER;
-    -- Synthesis directives :
-    attribute SYNTHESIS_RETURN of RESULT:variable is "ROR" ;
-  begin
-    COUNTM := COUNT mod (ARG_L + 1);
-    if COUNTM /= 0 then
-      RESULT(ARG_L-COUNTM downto 0) := XARG(ARG_L downto COUNTM);
-      RESULT(ARG_L downto ARG_L-COUNTM+1) := XARG(COUNTM-1 downto 0);
-    end if;
-    return RESULT;
-  end XROR;
-  -----------------Local Subprograms - Relational ops---------------------------
-  --
-  -- General "=" for UNSIGNED vectors, same length
-  --
-  function UNSIGNED_EQUAL (L, R: UNSIGNED) return BOOLEAN is
-  begin
-    return STD_LOGIC_VECTOR(L) = STD_LOGIC_VECTOR(R);
-  end UNSIGNED_EQUAL;
-  --
-  -- General "=" for SIGNED vectors, same length
-  --
-  function SIGNED_EQUAL (L, R: SIGNED) return BOOLEAN is
-  begin
-    return STD_LOGIC_VECTOR(L) = STD_LOGIC_VECTOR(R);
-  end SIGNED_EQUAL;
-  --
-  -- General "<" for UNSIGNED vectors, same length
-  --
-  function UNSIGNED_LESS (L, R: UNSIGNED) return BOOLEAN is
-  begin
-    return STD_LOGIC_VECTOR(L) < STD_LOGIC_VECTOR(R);
-  end UNSIGNED_LESS;
-  --
-  -- General "<" function for SIGNED vectors, same length
-  --
-  function SIGNED_LESS (L, R: SIGNED) return BOOLEAN is
-    variable INTERN_L: SIGNED(0 to L'LENGTH-1);
-    variable INTERN_R: SIGNED(0 to R'LENGTH-1);
-  begin
-    INTERN_L := L;
-    INTERN_R := R;
-    INTERN_L(0) := not INTERN_L(0);
-    INTERN_R(0) := not INTERN_R(0);
-    return STD_LOGIC_VECTOR(INTERN_L) < STD_LOGIC_VECTOR(INTERN_R);
-  end SIGNED_LESS;
-  --
-  -- General "<=" function for UNSIGNED vectors, same length
-  --
-  function UNSIGNED_LESS_OR_EQUAL (L, R: UNSIGNED) return BOOLEAN is
-  begin
-    return STD_LOGIC_VECTOR(L) <= STD_LOGIC_VECTOR(R);
-  end UNSIGNED_LESS_OR_EQUAL;
-  --
-  -- General "<=" function for SIGNED vectors, same length
-  --
-  function SIGNED_LESS_OR_EQUAL (L, R: SIGNED) return BOOLEAN is
-    -- Need aliases to assure index direction
-    variable INTERN_L: SIGNED(0 to L'LENGTH-1);
-    variable INTERN_R: SIGNED(0 to R'LENGTH-1);
-  begin
-    INTERN_L := L;
-    INTERN_R := R;
-    INTERN_L(0) := not INTERN_L(0);
-    INTERN_R(0) := not INTERN_R(0);
-    return STD_LOGIC_VECTOR(INTERN_L) <= STD_LOGIC_VECTOR(INTERN_R);
-  end SIGNED_LESS_OR_EQUAL;
-  --=========================Exported Functions ==========================
-  -- Id: A.1
-  function "abs" (ARG: SIGNED) return SIGNED is
-    constant ARG_LEFT: INTEGER := ARG'LENGTH-1;
-    alias XARG: SIGNED(ARG_LEFT downto 0) is ARG;
-    variable RESULT: SIGNED(ARG_LEFT downto 0);
-    -- Synthesis directives :
-    attribute IS_SIGNED of ARG:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "ABS" ;
-  begin
-    if ARG'LENGTH < 1 then return NAS;
-    end if;
-    RESULT := TO_01(XARG, 'X');
-    if (RESULT(RESULT'LEFT)='X') then return RESULT;
-    end if;
-    if RESULT(RESULT'LEFT) = '1' then
-      RESULT := -RESULT;
-    end if;
-    return RESULT;
-  end "abs";
-  -- Id: A.2
-  function "-" (ARG: SIGNED) return SIGNED is
-    constant ARG_LEFT: INTEGER := ARG'LENGTH-1;
-    alias XARG: SIGNED(ARG_LEFT downto 0) is ARG;
-    variable RESULT, XARG01 : SIGNED(ARG_LEFT downto 0);
-    variable CBIT: STD_LOGIC := '1';
-    -- Synthesis directives :
-    attribute IS_SIGNED of ARG:constant is TRUE ;
-    attribute IS_SIGNED of RESULT:variable is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "UMINUS" ;
-  begin
-    if ARG'LENGTH < 1 then return NAS;
-    end if;
-    XARG01 := TO_01(ARG, 'X');
-    if (XARG01(XARG01'LEFT)='X') then return XARG01;
-    end if;
-    for I in 0 to RESULT'LEFT loop
-      RESULT(I) := not(XARG01(I)) xor CBIT;
-      CBIT := CBIT and not(XARG01(I));
-    end loop;
-    return RESULT;
-  end "-";
-  --============================================================================
-  -- Id: A.3
-  function "+" (L, R: UNSIGNED) return UNSIGNED is
-    constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH);
-    variable L01 : UNSIGNED(SIZE-1 downto 0);
-    variable R01 : UNSIGNED(SIZE-1 downto 0);
-    -- Synthesis directives :
-    attribute SYNTHESIS_RETURN of L01:variable is "ADD" ;
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU;
-    end if;
-    L01 := TO_01(RESIZE(L, SIZE), 'X');
-    if (L01(L01'LEFT)='X') then return L01;
-    end if;
-    R01 := TO_01(RESIZE(R, SIZE), 'X');
-    if (R01(R01'LEFT)='X') then return R01;
-    end if;
-    return ADD_UNSIGNED(L01, R01, '0');
-  end "+";
-  -- Id: A.4
-  function "+" (L, R: SIGNED) return SIGNED is
-    constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH);
-    variable L01 : SIGNED(SIZE-1 downto 0);
-    variable R01 : SIGNED(SIZE-1 downto 0);
-    -- Synthesis directives :
-    attribute IS_SIGNED of L:constant is TRUE ;
-    attribute IS_SIGNED of R:constant is TRUE ;
-    attribute IS_SIGNED of L01:variable is TRUE ;
-    attribute SYNTHESIS_RETURN of L01:variable is "ADD" ;
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAS;
-    end if;
-    L01 := TO_01(RESIZE(L, SIZE), 'X');
-    if (L01(L01'LEFT)='X') then return L01;
-    end if;
-    R01 := TO_01(RESIZE(R, SIZE), 'X');
-    if (R01(R01'LEFT)='X') then return R01;
-    end if;
-    return ADD_SIGNED(L01, R01, '0');
-  end "+";
-  -- Id: A.5
-  function "+" (L: UNSIGNED; R: NATURAL) return UNSIGNED is
-  begin
-    return L + TO_UNSIGNED(R, L'LENGTH);
-  end "+";
-  -- Id: A.6
-  function "+" (L: NATURAL; R: UNSIGNED) return UNSIGNED is
-  begin
-    return TO_UNSIGNED(L, R'LENGTH) + R;
-  end "+";
-  -- Id: A.7
-  function "+" (L: SIGNED; R: INTEGER) return SIGNED is
-  begin
-    return L + TO_SIGNED(R, L'LENGTH);
-  end "+";
-  -- Id: A.8
-  function "+" (L: INTEGER; R: SIGNED) return SIGNED is
-  begin
-    return TO_SIGNED(L, R'LENGTH) + R;
-  end "+";
-  --============================================================================
-  -- Id: A.9
-  function "-" (L, R: UNSIGNED) return UNSIGNED is
-    constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH);
-    variable L01 : UNSIGNED(SIZE-1 downto 0);
-    variable R01 : UNSIGNED(SIZE-1 downto 0);
-    -- Synthesis directives :
-    attribute SYNTHESIS_RETURN of L01:variable is "SUB" ;
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU;
-    end if;
-    L01 := TO_01(RESIZE(L, SIZE), 'X');
-    if (L01(L01'LEFT)='X') then return L01;
-    end if;
-    R01 := TO_01(RESIZE(R, SIZE), 'X');
-    if (R01(R01'LEFT)='X') then return R01;
-    end if;
-    return ADD_UNSIGNED(L01, not(R01), '1');
-  end "-";
-  -- Id: A.10
-  function "-" (L, R: SIGNED) return SIGNED is
-    constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH);
-    variable L01 : SIGNED(SIZE-1 downto 0);
-    variable R01 : SIGNED(SIZE-1 downto 0);
-    -- Synthesis directives :
-    attribute IS_SIGNED of L:constant is TRUE ;
-    attribute IS_SIGNED of R:constant is TRUE ;
-    attribute IS_SIGNED of L01:variable is TRUE ;
-    attribute SYNTHESIS_RETURN of L01:variable is "SUB" ;
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAS;
-    end if;
-    L01 := TO_01(RESIZE(L, SIZE), 'X');
-    if (L01(L01'LEFT)='X') then return L01;
-    end if;
-    R01 := TO_01(RESIZE(R, SIZE), 'X');
-    if (R01(R01'LEFT)='X') then return R01;
-    end if;
-    return ADD_SIGNED(L01, not(R01), '1');
-  end "-";
-  -- Id: A.11
-  function "-" (L: UNSIGNED; R: NATURAL) return UNSIGNED is
-  begin
-    return L - TO_UNSIGNED(R, L'LENGTH);
-  end "-";
-  -- Id: A.12
-  function "-" (L: NATURAL; R: UNSIGNED) return UNSIGNED is
-  begin
-    return TO_UNSIGNED(L, R'LENGTH) - R;
-  end "-";
-  -- Id: A.13
-  function "-" (L: SIGNED; R: INTEGER) return SIGNED is
-  begin
-    return L - TO_SIGNED(R, L'LENGTH);
-  end "-";
-  -- Id: A.14
-  function "-" (L: INTEGER; R: SIGNED) return SIGNED is
-  begin
-    return TO_SIGNED(L, R'LENGTH) - R;
-  end "-";
-  --============================================================================
-  -- Id: A.15
-  function "*" (L, R: UNSIGNED) return UNSIGNED is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XXL: UNSIGNED(L_LEFT downto 0) is L;
-    alias XXR: UNSIGNED(R_LEFT downto 0) is R;
-    variable XL: UNSIGNED(L_LEFT downto 0);
-    variable XR: UNSIGNED(R_LEFT downto 0);
-    variable RESULT: UNSIGNED((L'LENGTH+R'LENGTH-1) downto 0) :=
-        (others => '0');
-    variable ADVAL: UNSIGNED((L'LENGTH+R'LENGTH-1) downto 0);
-    -- Synthesis directives :
-    attribute SYNTHESIS_RETURN of RESULT:variable is "MULT" ;
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU;
-    end if;
-    XL := TO_01(XXL, 'X');
-    XR := TO_01(XXR, 'X');
-    if ((XL(XL'LEFT)='X') or (XR(XR'LEFT)='X')) then
-      RESULT := (others => 'X');
-      return RESULT;
-    end if;
-    ADVAL := RESIZE(XR, RESULT'LENGTH);
-    for I in 0 to L_LEFT loop
-      if XL(I)='1' then RESULT := RESULT + ADVAL;
-      end if;
-      ADVAL := SHIFT_LEFT(ADVAL, 1);
-    end loop;
-    return RESULT;
-  end "*";
-  -- Id: A.16
-  function "*" (L, R: SIGNED) return SIGNED is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    variable XL: SIGNED(L_LEFT downto 0);
-    variable XR: SIGNED(R_LEFT downto 0);
-    variable RESULT: SIGNED((L_LEFT+R_LEFT+1) downto 0) := (others => '0');
-    variable ADVAL: SIGNED((L_LEFT+R_LEFT+1) downto 0);
-    -- Synthesis directives :
-    attribute IS_SIGNED of L:constant is TRUE ;
-    attribute IS_SIGNED of R:constant is TRUE ;
-    attribute IS_SIGNED of result:variable is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "MULT" ;
-  begin
-    if ((L_LEFT < 0) or (R_LEFT < 0)) then return NAS;
-    end if;
-    XL := TO_01(L, 'X');
-    XR := TO_01(R, 'X');
-    if ((XL(L_LEFT)='X') or (XR(R_LEFT)='X')) then
-      RESULT := (others => 'X');
-      return RESULT;
-    end if;
-    ADVAL := RESIZE(XR, RESULT'LENGTH);
-    for I in 0 to L_LEFT-1 loop
-      if XL(I)='1' then RESULT := RESULT + ADVAL;
-      end if;
-      ADVAL := SHIFT_LEFT(ADVAL, 1);
-    end loop;
-    if XL(L_LEFT)='1' then
-      RESULT := RESULT - ADVAL;
-    end if;
-    return RESULT;
-  end "*";
-  -- Id: A.17
-  function "*" (L: UNSIGNED; R: NATURAL) return UNSIGNED is
-  begin
-    return L * TO_UNSIGNED(R, L'LENGTH);
-  end "*";
-  -- Id: A.18
-  function "*" (L: NATURAL; R: UNSIGNED) return UNSIGNED is
-  begin
-    return TO_UNSIGNED(L, R'LENGTH) * R;
-  end "*";
-  -- Id: A.19
-  function "*" (L: SIGNED; R: INTEGER) return SIGNED is
-  begin
-    return L * TO_SIGNED(R, L'LENGTH);
-  end "*";
-  -- Id: A.20
-  function "*" (L: INTEGER; R: SIGNED) return SIGNED is
-  begin
-    return TO_SIGNED(L, R'LENGTH) * R;
-  end "*";
-  --============================================================================
-  -- Id: A.21
-  function "/" (L, R: UNSIGNED) return UNSIGNED is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XXL: UNSIGNED(L_LEFT downto 0) is L;
-    alias XXR: UNSIGNED(R_LEFT downto 0) is R;
-    variable XL: UNSIGNED(L_LEFT downto 0);
-    variable XR: UNSIGNED(R_LEFT downto 0);
-    variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0);
-    variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0);
-    -- Synthesis directives :
-    attribute SYNTHESIS_RETURN of FQUOT:variable is "DIV" ;
-    attribute SYNTHESIS_RESULT_SIZE of FQUOT : variable is "LEFT";
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU;
-    end if;
-    XL := TO_01(XXL, 'X');
-    XR := TO_01(XXR, 'X');
-    if ((XL(XL'LEFT)='X') or (XR(XR'LEFT)='X')) then
-      FQUOT := (others => 'X');
-      return FQUOT;
-    end if;
-    DIVMOD(XL, XR, FQUOT, FREMAIN);
-    return FQUOT;
-  end "/";
-  -- Id: A.22
-  function "/" (L, R: SIGNED) return SIGNED is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XXL: SIGNED(L_LEFT downto 0) is L;
-    alias XXR: SIGNED(R_LEFT downto 0) is R;
-    variable XL: SIGNED(L_LEFT downto 0);
-    variable XR: SIGNED(R_LEFT downto 0);
-    variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0);
-    variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0);
-    variable XNUM: UNSIGNED(L'LENGTH-1 downto 0);
-    variable XDENOM: UNSIGNED(R'LENGTH-1 downto 0);
-    variable QNEG: BOOLEAN := FALSE;
-    -- Synthesis directives :
-    attribute IS_SIGNED of L:constant is TRUE ;
-    attribute IS_SIGNED of R:constant is TRUE ;
-    attribute IS_SIGNED of FQUOT:variable is TRUE ;
-    attribute SYNTHESIS_RETURN of FQUOT:variable is "DIV" ;
-    attribute SYNTHESIS_RESULT_SIZE of FQUOT : variable is "LEFT";
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAS;
-    end if;
-    XL := TO_01(XXL, 'X');
-    XR := TO_01(XXR, 'X');
-    if ((XL(XL'LEFT)='X') or (XR(XR'LEFT)='X')) then
-      FQUOT := (others => 'X');
-      return SIGNED(FQUOT);
-    end if;
-    if XL(XL'LEFT)='1' then
-      XNUM := UNSIGNED(-XL);
-      QNEG := TRUE;
-    else
-      XNUM := UNSIGNED(XL);
-    end if;
-    if XR(XR'LEFT)='1' then
-      XDENOM := UNSIGNED(-XR);
-      QNEG := not QNEG;
-    else
-      XDENOM := UNSIGNED(XR);
-    end if;
-    DIVMOD(XNUM, XDENOM, FQUOT, FREMAIN);
-    if QNEG then FQUOT := "0"-FQUOT;
-    end if;
-    return SIGNED(FQUOT);
-  end "/";
-  -- Id: A.23
-  function "/" (L: UNSIGNED; R: NATURAL) return UNSIGNED is
-    constant R_LENGTH: NATURAL := MAX(L'LENGTH, UNSIGNED_NUM_BITS(R));
-    variable XR, QUOT: UNSIGNED(R_LENGTH-1 downto 0);
-    -- Synthesis directives :
-    variable RESULT : UNSIGNED (L'LENGTH-1 downto 0) ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "DIV" ;
-    attribute SYNTHESIS_RESULT_SIZE of RESULT : variable is "LEFT";
-  begin
-    if (L'LENGTH < 1) then return NAU;
-    end if;
-    if (R_LENGTH > L'LENGTH) then
-      QUOT := (others => '0');
-      return RESIZE(QUOT, L'LENGTH);
-    end if;
-    XR := TO_UNSIGNED(R, R_LENGTH);
-    QUOT := RESIZE((L / XR), QUOT'LENGTH);
-    return RESIZE(QUOT, L'LENGTH);
-  end "/";
-  -- Id: A.24
-  function "/" (L: NATURAL; R: UNSIGNED) return UNSIGNED is
-    constant L_LENGTH: NATURAL := MAX(UNSIGNED_NUM_BITS(L), R'LENGTH);
-    variable XL, QUOT: UNSIGNED(L_LENGTH-1 downto 0);
-    -- Synthesis directives :
-    variable RESULT : UNSIGNED (R'LENGTH-1 downto 0) ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "DIV" ;
-    attribute SYNTHESIS_RESULT_SIZE of RESULT : variable is "RIGHT";
-  begin
-    if (R'LENGTH < 1) then return NAU;
-    end if;
-    XL := TO_UNSIGNED(L, L_LENGTH);
-    QUOT := RESIZE((XL / R), QUOT'LENGTH);
-    if L_LENGTH > R'LENGTH and QUOT(0)/='X'
-        and QUOT(L_LENGTH-1 downto R'LENGTH)
-        /= (L_LENGTH-1 downto R'LENGTH => '0')
-        then
-      assert NO_WARNING report "NUMERIC_STD.""/"": Quotient Truncated"
-          severity WARNING;
-    end if;
-    return RESIZE(QUOT, R'LENGTH);
-  end "/";
-  -- Id: A.25
-  function "/" (L: SIGNED; R: INTEGER) return SIGNED is
-    constant R_LENGTH: NATURAL := MAX(L'LENGTH, SIGNED_NUM_BITS(R));
-    variable XR, QUOT: SIGNED(R_LENGTH-1 downto 0);
-    -- Synthesis directives :
-    variable RESULT : SIGNED (L'LENGTH-1 downto 0) ;
-    attribute IS_SIGNED of L:constant is TRUE ;
-    attribute IS_SIGNED of result:variable is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "DIV" ;
-    attribute SYNTHESIS_RESULT_SIZE of RESULT : variable is "LEFT";
-    attribute SIGNED_TRUNCATION of RESULT : variable is true;
-  begin
-    if (L'LENGTH < 1) then return NAS;
-    end if;
-    if (R_LENGTH > L'LENGTH) then
-      QUOT := (others => '0');
-      return RESIZE(QUOT, L'LENGTH);
-    end if;
-    XR := TO_SIGNED(R, R_LENGTH);
-    QUOT := RESIZE((L / XR), QUOT'LENGTH);
-    return RESIZE(QUOT, L'LENGTH);
-  end "/";
-  -- Id: A.26
-  function "/" (L: INTEGER; R: SIGNED) return SIGNED is
-    constant L_LENGTH: NATURAL := MAX(SIGNED_NUM_BITS(L), R'LENGTH);
-    variable XL, QUOT: SIGNED(L_LENGTH-1 downto 0);
-    -- Synthesis directives :
-    variable RESULT : SIGNED (R'LENGTH-1 downto 0) ;
-    attribute IS_SIGNED of R:constant is TRUE ;
-    attribute IS_SIGNED of result:variable is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "DIV" ;
-    attribute SYNTHESIS_RESULT_SIZE of RESULT : variable is "RIGHT";
-    attribute SIGNED_TRUNCATION of RESULT : variable is true;
-  begin
-    if (R'LENGTH < 1) then return NAS;
-    end if;
-    XL := TO_SIGNED(L, L_LENGTH);
-    QUOT := RESIZE((XL / R), QUOT'LENGTH);
-    if L_LENGTH > R'LENGTH and QUOT(0)/='X'
-        and QUOT(L_LENGTH-1 downto R'LENGTH)
-        /= (L_LENGTH-1 downto R'LENGTH => QUOT(R'LENGTH-1))
-        then
-      assert NO_WARNING report "NUMERIC_STD.""/"": Quotient Truncated"
-          severity WARNING;
-    end if;
-    return RESIZE(QUOT, R'LENGTH);
-  end "/";
-  --============================================================================
-  -- Id: A.27
-  function "rem" (L, R: UNSIGNED) return UNSIGNED is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XXL: UNSIGNED(L_LEFT downto 0) is L;
-    alias XXR: UNSIGNED(R_LEFT downto 0) is R;
-    variable XL: UNSIGNED(L_LEFT downto 0);
-    variable XR: UNSIGNED(R_LEFT downto 0);
-    variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0);
-    variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0);
-    -- Synthesis directives :
-    attribute SYNTHESIS_RETURN of FREMAIN:variable is "REM" ;
-    attribute SYNTHESIS_RESULT_SIZE of FREMAIN : variable is "RIGHT";
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU;
-    end if;
-    XL := TO_01(XXL, 'X');
-    XR := TO_01(XXR, 'X');
-    if ((XL(XL'LEFT)='X') or (XR(XR'LEFT)='X')) then
-      FREMAIN := (others => 'X');
-      return FREMAIN;
-    end if;
-    DIVMOD(XL, XR, FQUOT, FREMAIN);
-    return FREMAIN;
-  end "rem";
-  -- Id: A.28
-  function "rem" (L, R: SIGNED) return SIGNED is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XXL: SIGNED(L_LEFT downto 0) is L;
-    alias XXR: SIGNED(R_LEFT downto 0) is R;
-    variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0);
-    variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0);
-    variable XNUM: UNSIGNED(L'LENGTH-1 downto 0);
-    variable XDENOM: UNSIGNED(R'LENGTH-1 downto 0);
-    variable RNEG: BOOLEAN := FALSE;
-    -- Synthesis directives :
-    attribute IS_SIGNED of L:constant is TRUE ;
-    attribute IS_SIGNED of R:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of FREMAIN:variable is "REM" ;
-    attribute SYNTHESIS_RESULT_SIZE of FREMAIN : variable is "RIGHT";
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAS;
-    end if;
-    XNUM := UNSIGNED(TO_01(XXL, 'X'));
-    XDENOM := UNSIGNED(TO_01(XXR, 'X'));
-    if ((XNUM(XNUM'LEFT)='X') or (XDENOM(XDENOM'LEFT)='X')) then
-      FREMAIN := (others => 'X');
-      return SIGNED(FREMAIN);
-    end if;
-    if XNUM(XNUM'LEFT)='1' then
-      XNUM := UNSIGNED(-SIGNED(XNUM));
-      RNEG := TRUE;
-    else
-      XNUM := UNSIGNED(XNUM);
-    end if;
-    if XDENOM(XDENOM'LEFT)='1' then
-      XDENOM := UNSIGNED(-SIGNED(XDENOM));
-    else
-      XDENOM := UNSIGNED(XDENOM);
-    end if;
-    DIVMOD(XNUM, XDENOM, FQUOT, FREMAIN);
-    if RNEG then
-      FREMAIN := "0"-FREMAIN;
-    end if;
-    return SIGNED(FREMAIN);
-  end "rem";
-  -- Id: A.29
-  function "rem" (L: UNSIGNED; R: NATURAL) return UNSIGNED is
-    constant R_LENGTH: NATURAL := MAX(L'LENGTH, UNSIGNED_NUM_BITS(R));
-    variable XR, XREM: UNSIGNED(R_LENGTH-1 downto 0);
-    -- Synthesis directives :
-    variable RESULT : UNSIGNED (L'LENGTH-1 downto 0) ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "REM" ;
-    attribute SYNTHESIS_RESULT_SIZE of RESULT : variable is "LEFT";
-  begin
-    if (L'LENGTH < 1) then return NAU;
-    end if;
-    XR := TO_UNSIGNED(R, R_LENGTH);
-    XREM := L rem XR;
-    if R_LENGTH > L'LENGTH and XREM(0)/='X'
-        and XREM(R_LENGTH-1 downto L'LENGTH)
-        /= (R_LENGTH-1 downto L'LENGTH => '0')
-        then
-      assert NO_WARNING report "NUMERIC_STD.""rem"": Remainder Truncated"
-          severity WARNING;
-    end if;
-    return RESIZE(XREM, L'LENGTH);
-  end "rem";
-  -- Id: A.30
-  function "rem" (L: NATURAL; R: UNSIGNED) return UNSIGNED is
-    constant L_LENGTH: NATURAL := MAX(UNSIGNED_NUM_BITS(L), R'LENGTH);
-    variable XL, XREM: UNSIGNED(L_LENGTH-1 downto 0);
-    -- Synthesis directives :
-    variable RESULT : UNSIGNED (R'LENGTH-1 downto 0) ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "REM" ;
-    attribute SYNTHESIS_RESULT_SIZE of RESULT : variable is "RIGHT";
-  begin
-    XL := TO_UNSIGNED(L, L_LENGTH);
-    XREM := XL rem R;
-    if L_LENGTH > R'LENGTH and XREM(0)/='X'
-        and XREM(L_LENGTH-1 downto R'LENGTH)
-        /= (L_LENGTH-1 downto R'LENGTH => '0')
-        then
-      assert NO_WARNING report "NUMERIC_STD.""rem"": Remainder Truncated"
-          severity WARNING;
-    end if;
-    return RESIZE(XREM, R'LENGTH);
-  end "rem";
-  -- Id: A.31
-  function "rem" (L: SIGNED; R: INTEGER) return SIGNED is
-    constant R_LENGTH: NATURAL := MAX(L'LENGTH, SIGNED_NUM_BITS(R));
-    variable XR, XREM: SIGNED(R_LENGTH-1 downto 0);
-    -- Synthesis directives :
-    variable RESULT : SIGNED (L'LENGTH-1 downto 0) ;
-    attribute IS_SIGNED of L:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "REM" ;
-    attribute SYNTHESIS_RESULT_SIZE of RESULT : variable is "LEFT";
-    attribute SIGNED_TRUNCATION of RESULT : variable is true;
-  begin
-    if (L'LENGTH < 1) then return NAS;
-    end if;
-    XR := TO_SIGNED(R, R_LENGTH);
-    XREM := RESIZE((L rem XR), XREM'LENGTH);
-    if R_LENGTH > L'LENGTH and XREM(0)/='X'
-        and XREM(R_LENGTH-1 downto L'LENGTH)
-        /= (R_LENGTH-1 downto L'LENGTH => XREM(L'LENGTH-1))
-        then
-      assert NO_WARNING report "NUMERIC_STD.""rem"": Remainder Truncated"
-          severity WARNING;
-    end if;
-    return RESIZE(XREM, L'LENGTH);
-  end "rem";
-  -- Id: A.32
-  function "rem" (L: INTEGER; R: SIGNED) return SIGNED is
-    constant L_LENGTH: NATURAL := MAX(SIGNED_NUM_BITS(L), R'LENGTH);
-    variable XL, XREM: SIGNED(L_LENGTH-1 downto 0);
-    -- Synthesis directives :
-    variable RESULT : SIGNED (R'LENGTH-1 downto 0) ;
-    attribute IS_SIGNED of R:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "REM" ;
-    attribute SYNTHESIS_RESULT_SIZE of RESULT : variable is "RIGHT";
-    attribute SIGNED_TRUNCATION of RESULT : variable is true;
-  begin
-    if (R'LENGTH < 1) then return NAS;
-    end if;
-    XL := TO_SIGNED(L, L_LENGTH);
-    XREM := RESIZE((XL rem R), XREM'LENGTH);
-    if L_LENGTH > R'LENGTH and XREM(0)/='X'
-        and XREM(L_LENGTH-1 downto R'LENGTH)
-        /= (L_LENGTH-1 downto R'LENGTH => XREM(R'LENGTH-1))
-        then
-      assert NO_WARNING report "NUMERIC_STD.""rem"": Remainder Truncated"
-          severity WARNING;
-    end if;
-    return RESIZE(XREM, R'LENGTH);
-  end "rem";
-  --============================================================================
-  -- Id: A.33
-  function "mod" (L, R: UNSIGNED) return UNSIGNED is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XXL: UNSIGNED(L_LEFT downto 0) is L;
-    alias XXR: UNSIGNED(R_LEFT downto 0) is R;
-    variable XL: UNSIGNED(L_LEFT downto 0);
-    variable XR: UNSIGNED(R_LEFT downto 0);
-    variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0);
-    variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0);
-    -- Synthesis directives :
-    attribute SYNTHESIS_RETURN of FREMAIN:variable is "MOD" ;
-    attribute SYNTHESIS_RESULT_SIZE of FREMAIN : variable is "RIGHT";
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU;
-    end if;
-    XL := TO_01(XXL, 'X');
-    XR := TO_01(XXR, 'X');
-    if ((XL(XL'LEFT)='X') or (XR(XR'LEFT)='X')) then
-      FREMAIN := (others => 'X');
-      return FREMAIN;
-    end if;
-    DIVMOD(XL, XR, FQUOT, FREMAIN);
-    return FREMAIN;
-  end "mod";
-  -- Id: A.34
-  function "mod" (L, R: SIGNED) return SIGNED is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XXL: SIGNED(L_LEFT downto 0) is L;
-    alias XXR: SIGNED(R_LEFT downto 0) is R;
-    variable XL: SIGNED(L_LEFT downto 0);
-    variable XR: SIGNED(R_LEFT downto 0);
-    variable FQUOT: UNSIGNED(L'LENGTH-1 downto 0);
-    variable FREMAIN: UNSIGNED(R'LENGTH-1 downto 0);
-    variable XNUM: UNSIGNED(L'LENGTH-1 downto 0);
-    variable XDENOM: UNSIGNED(R'LENGTH-1 downto 0);
-    variable RNEG: BOOLEAN := FALSE;
-    -- Synthesis directives :
-    attribute IS_SIGNED of L:constant is TRUE ;
-    attribute IS_SIGNED of R:constant is TRUE ;
-    attribute IS_SIGNED of FREMAIN:variable is TRUE ;
-    attribute SYNTHESIS_RETURN of FREMAIN:variable is "MOD" ;
-    attribute SYNTHESIS_RESULT_SIZE of FREMAIN : variable is "RIGHT";
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAS;
-    end if;
-    XL := TO_01(XXL, 'X');
-    XR := TO_01(XXR, 'X');
-    if ((XL(XL'LEFT)='X') or (XR(XR'LEFT)='X')) then
-      FREMAIN := (others => 'X');
-      return SIGNED(FREMAIN);
-    end if;
-    if XL(XL'LEFT)='1' then
-      XNUM := UNSIGNED(-XL);
-    else
-      XNUM := UNSIGNED(XL);
-    end if;
-    if XR(XR'LEFT)='1' then
-      XDENOM := UNSIGNED(-XR);
-      RNEG := TRUE;
-    else
-      XDENOM := UNSIGNED(XR);
-    end if;
-    DIVMOD(XNUM, XDENOM, FQUOT, FREMAIN);
-    if RNEG and L(L'LEFT)='1' then
-      FREMAIN := "0"-FREMAIN;
-    elsif RNEG and FREMAIN/="0" then
-      FREMAIN := FREMAIN-XDENOM;
-    elsif L(L'LEFT)='1' and FREMAIN/="0" then
-      FREMAIN := XDENOM-FREMAIN;
-    end if;
-    return SIGNED(FREMAIN);
-  end "mod";
-  -- Id: A.35
-  function "mod" (L: UNSIGNED; R: NATURAL) return UNSIGNED is
-    constant R_LENGTH: NATURAL := MAX(L'LENGTH, UNSIGNED_NUM_BITS(R));
-    variable XR, XREM: UNSIGNED(R_LENGTH-1 downto 0);
-    -- Synthesis directives :
-    variable RESULT : UNSIGNED (L'LENGTH-1 downto 0) ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "MOD" ;
-    attribute SYNTHESIS_RESULT_SIZE of RESULT:variable is "LEFT" ;
-  begin
-    if (L'LENGTH < 1) then return NAU;
-    end if;
-    XR := TO_UNSIGNED(R, R_LENGTH);
-    XREM := RESIZE((L mod XR), XREM'LENGTH);
-    if R_LENGTH > L'LENGTH and XREM(0)/='X'
-        and XREM(R_LENGTH-1 downto L'LENGTH)
-        /= (R_LENGTH-1 downto L'LENGTH => '0')
-        then
-      assert NO_WARNING report "NUMERIC_STD.""mod"": Modulus Truncated"
-          severity WARNING;
-    end if;
-    return RESIZE(XREM, L'LENGTH);
-  end "mod";
-  -- Id: A.36
-  function "mod" (L: NATURAL; R: UNSIGNED) return UNSIGNED is
-    constant L_LENGTH: NATURAL := MAX(UNSIGNED_NUM_BITS(L), R'LENGTH);
-    variable XL, XREM: UNSIGNED(L_LENGTH-1 downto 0);
-    -- Synthesis directives :
-    variable RESULT : UNSIGNED (R'LENGTH-1 downto 0) ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "MOD" ;
-    attribute SYNTHESIS_RESULT_SIZE of RESULT:variable is "RIGHT" ;
-  begin
-    if (R'LENGTH < 1) then return NAU;
-    end if;
-    XL := TO_UNSIGNED(L, L_LENGTH);
-    XREM := RESIZE((XL mod R), XREM'LENGTH);
-    if L_LENGTH > R'LENGTH and XREM(0)/='X'
-        and XREM(L_LENGTH-1 downto R'LENGTH)
-        /= (L_LENGTH-1 downto R'LENGTH => '0')
-        then
-      assert NO_WARNING report "NUMERIC_STD.""mod"": Modulus Truncated"
-          severity WARNING;
-    end if;
-    return RESIZE(XREM, R'LENGTH);
-  end "mod";
-  -- Id: A.37
-  function "mod" (L: SIGNED; R: INTEGER) return SIGNED is
-    constant R_LENGTH: NATURAL := MAX(L'LENGTH, SIGNED_NUM_BITS(R));
-    variable XR, XREM: SIGNED(R_LENGTH-1 downto 0);
-    -- Synthesis directives :
-    variable RESULT : SIGNED (L'LENGTH-1 downto 0) ;
-    attribute IS_SIGNED of L:constant is TRUE ;
-    attribute IS_SIGNED of result:variable is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "MOD" ;
-    attribute SYNTHESIS_RESULT_SIZE of RESULT:variable is "LEFT" ;
-    attribute SIGNED_TRUNCATION of RESULT : variable is true;
-  begin
-    if (L'LENGTH < 1) then return NAS;
-    end if;
-    XR := TO_SIGNED(R, R_LENGTH);
-    XREM := RESIZE((L mod XR), XREM'LENGTH);
-    if R_LENGTH > L'LENGTH and XREM(0)/='X'
-        and XREM(R_LENGTH-1 downto L'LENGTH)
-        /= (R_LENGTH-1 downto L'LENGTH => XREM(L'LENGTH-1))
-        then
-      assert NO_WARNING report "NUMERIC_STD.""mod"": Modulus Truncated"
-          severity WARNING;
-    end if;
-    return RESIZE(XREM, L'LENGTH);
-  end "mod";
-  -- Id: A.38
-  function "mod" (L: INTEGER; R: SIGNED) return SIGNED is
-    constant L_LENGTH: NATURAL := MAX(SIGNED_NUM_BITS(L), R'LENGTH);
-    variable XL, XREM: SIGNED(L_LENGTH-1 downto 0);
-    -- Synthesis directives :
-    variable RESULT : SIGNED (R'LENGTH-1 downto 0) ;
-    attribute IS_SIGNED of R:constant is TRUE ;
-    attribute IS_SIGNED of result:variable is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "MOD" ;
-    attribute SYNTHESIS_RESULT_SIZE of RESULT:variable is "RIGHT" ;
-    attribute SIGNED_TRUNCATION of RESULT : variable is true;
-  begin
-    if (R'LENGTH < 1) then return NAS;
-    end if;
-    XL := TO_SIGNED(L, L_LENGTH);
-    XREM := RESIZE((XL mod R), XREM'LENGTH);
-    if L_LENGTH > R'LENGTH and XREM(0)/='X'
-        and XREM(L_LENGTH-1 downto R'LENGTH)
-        /= (L_LENGTH-1 downto R'LENGTH => XREM(R'LENGTH-1))
-        then
-      assert NO_WARNING report "NUMERIC_STD.""mod"": Modulus Truncated"
-          severity WARNING;
-    end if;
-    return RESIZE(XREM, R'LENGTH);
-  end "mod";
-  --============================================================================
-  -- Id: C.1
-  function ">" (L, R: UNSIGNED) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XL: UNSIGNED(L_LEFT downto 0) is L;
-    alias XR: UNSIGNED(R_LEFT downto 0) is R;
-    constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH);
-    variable L01 : UNSIGNED(L_LEFT downto 0);
-    variable R01 : UNSIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "GT" ;
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then
-      assert NO_WARNING
-          report "NUMERIC_STD."">"": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    R01 := TO_01(XR, 'X');
-    if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then
-      assert NO_WARNING
-          report "NUMERIC_STD."">"": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    return not UNSIGNED_LESS_OR_EQUAL(RESIZE(L01, SIZE), RESIZE(R01, SIZE));
-  end ">";
-  -- Id: C.2
-  function ">" (L, R: SIGNED) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XL: SIGNED(L_LEFT downto 0) is L;
-    alias XR: SIGNED(R_LEFT downto 0) is R;
-    constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH);
-    variable L01 : SIGNED(L_LEFT downto 0);
-    variable R01 : SIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute IS_SIGNED of L:constant is TRUE ;
-    attribute IS_SIGNED of R:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "GT" ;
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then
-      assert NO_WARNING
-          report "NUMERIC_STD."">"": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    R01 := TO_01(XR, 'X');
-    if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then
-      assert NO_WARNING
-          report "NUMERIC_STD."">"": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    return not SIGNED_LESS_OR_EQUAL(RESIZE(L01, SIZE), RESIZE(R01, SIZE));
-  end ">";
-  -- Id: C.3
-  function ">" (L: NATURAL; R: UNSIGNED) return BOOLEAN is
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XR: UNSIGNED(R_LEFT downto 0) is R;
-    variable R01 : UNSIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "GT" ;
-  begin
-    if (R'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD."">"": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    R01 := TO_01(XR, 'X');
-    if (R01(R01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD."">"": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if UNSIGNED_NUM_BITS(L) > R'LENGTH then return TRUE;
-    end if;
-    return not UNSIGNED_LESS_OR_EQUAL(TO_UNSIGNED(L, R01'LENGTH), R01);
-  end ">";
-  -- Id: C.4
-  function ">" (L: INTEGER; R: SIGNED) return BOOLEAN is
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XR: SIGNED(R_LEFT downto 0) is R;
-    variable R01 : SIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute IS_SIGNED of R:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "GT" ;
-  begin
-    if (R'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD."">"": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    R01 := TO_01(XR, 'X');
-    if (R01(R01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD."">"": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if SIGNED_NUM_BITS(L) > R'LENGTH then return L > 0;
-    end if;
-    return not SIGNED_LESS_OR_EQUAL(TO_SIGNED(L, R01'LENGTH), R01);
-  end ">";
-  -- Id: C.5
-  function ">" (L: UNSIGNED; R: NATURAL) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    alias XL: UNSIGNED(L_LEFT downto 0) is L;
-    variable L01 : UNSIGNED(L_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "GT" ;
-  begin
-    if (L'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD."">"": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    if (L01(L01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD."">"": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if UNSIGNED_NUM_BITS(R) > L'LENGTH then return FALSE;
-    end if;
-    return not UNSIGNED_LESS_OR_EQUAL(L01, TO_UNSIGNED(R, L01'LENGTH));
-  end ">";
-  -- Id: C.6
-  function ">" (L: SIGNED; R: INTEGER) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    alias XL: SIGNED(L_LEFT downto 0) is L;
-    variable L01 : SIGNED(L_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute IS_SIGNED of L:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "GT" ;
-  begin
-    if (L'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD."">"": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    if (L01(L01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD."">"": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if SIGNED_NUM_BITS(R) > L'LENGTH then return 0 > R;
-    end if;
-    return not SIGNED_LESS_OR_EQUAL(L01, TO_SIGNED(R, L01'LENGTH));
-  end ">";
-  --============================================================================
-  -- Id: C.7
-  function "<" (L, R: UNSIGNED) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XL: UNSIGNED(L_LEFT downto 0) is L;
-    alias XR: UNSIGNED(R_LEFT downto 0) is R;
-    constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH);
-    variable L01 : UNSIGNED(L_LEFT downto 0);
-    variable R01 : UNSIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "LT" ;
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<"": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    R01 := TO_01(XR, 'X');
-    if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<"": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    return UNSIGNED_LESS(RESIZE(L01, SIZE), RESIZE(R01, SIZE));
-  end "<";
-  -- Id: C.8
-  function "<" (L, R: SIGNED) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XL: SIGNED(L_LEFT downto 0) is L;
-    alias XR: SIGNED(R_LEFT downto 0) is R;
-    constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH);
-    variable L01 : SIGNED(L_LEFT downto 0);
-    variable R01 : SIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute IS_SIGNED of L:constant is TRUE ;
-    attribute IS_SIGNED of R:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "LT" ;
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<"": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    R01 := TO_01(XR, 'X');
-    if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<"": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    return SIGNED_LESS(RESIZE(L01, SIZE), RESIZE(R01, SIZE));
-  end "<";
-  -- Id: C.9
-  function "<" (L: NATURAL; R: UNSIGNED) return BOOLEAN is
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XR: UNSIGNED(R_LEFT downto 0) is R;
-    variable R01 : UNSIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "LT" ;
-  begin
-    if (R'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<"": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    R01 := TO_01(XR, 'X');
-    if (R01(R01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<"": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if UNSIGNED_NUM_BITS(L) > R'LENGTH then return L < 0;
-    end if;
-    return UNSIGNED_LESS(TO_UNSIGNED(L, R01'LENGTH), R01);
-  end "<";
-  -- Id: C.10
-  function "<" (L: INTEGER; R: SIGNED) return BOOLEAN is
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XR: SIGNED(R_LEFT downto 0) is R;
-    variable R01 : SIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute IS_SIGNED of R:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "LT" ;
-  begin
-    if (R'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<"": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    R01 := TO_01(XR, 'X');
-    if (R01(R01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<"": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if SIGNED_NUM_BITS(L) > R'LENGTH then return L < 0;
-    end if;
-    return SIGNED_LESS(TO_SIGNED(L, R01'LENGTH), R01);
-  end "<";
-  -- Id: C.11
-  function "<" (L: UNSIGNED; R: NATURAL) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    alias XL: UNSIGNED(L_LEFT downto 0) is L;
-    variable L01 : UNSIGNED(L_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "LT" ;
-  begin
-    if (L'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<"": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    if (L01(L01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<"": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if UNSIGNED_NUM_BITS(R) > L'LENGTH then return 0 < R;
-    end if;
-    return UNSIGNED_LESS(L01, TO_UNSIGNED(R, L01'LENGTH));
-  end "<";
-  -- Id: C.12
-  function "<" (L: SIGNED; R: INTEGER) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    alias XL: SIGNED(L_LEFT downto 0) is L;
-    variable L01 : SIGNED(L_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute IS_SIGNED of L:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "LT" ;
-  begin
-    if (L'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<"": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    if (L01(L01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<"": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if SIGNED_NUM_BITS(R) > L'LENGTH then return 0 < R;
-    end if;
-    return SIGNED_LESS(L01, TO_SIGNED(R, L01'LENGTH));
-  end "<";
-  --============================================================================
-  -- Id: C.13
-  function "<=" (L, R: UNSIGNED) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XL: UNSIGNED(L_LEFT downto 0) is L;
-    alias XR: UNSIGNED(R_LEFT downto 0) is R;
-    constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH);
-    variable L01 : UNSIGNED(L_LEFT downto 0);
-    variable R01 : UNSIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "LTE" ;
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<="": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    R01 := TO_01(XR, 'X');
-    if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<="": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    return UNSIGNED_LESS_OR_EQUAL(RESIZE(L01, SIZE), RESIZE(R01, SIZE));
-  end "<=";
-  -- Id: C.14
-  function "<=" (L, R: SIGNED) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XL: SIGNED(L_LEFT downto 0) is L;
-    alias XR: SIGNED(R_LEFT downto 0) is R;
-    constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH);
-    variable L01 : SIGNED(L_LEFT downto 0);
-    variable R01 : SIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute IS_SIGNED of L:constant is TRUE ;
-    attribute IS_SIGNED of R:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "LTE" ;
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<="": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    R01 := TO_01(XR, 'X');
-    if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<="": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    return SIGNED_LESS_OR_EQUAL(RESIZE(L01, SIZE), RESIZE(R01, SIZE));
-  end "<=";
-  -- Id: C.15
-  function "<=" (L: NATURAL; R: UNSIGNED) return BOOLEAN is
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XR: UNSIGNED(R_LEFT downto 0) is R;
-    variable R01 : UNSIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "LTE" ;
-  begin
-    if (R'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<="": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    R01 := TO_01(XR, 'X');
-    if (R01(R01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<="": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if UNSIGNED_NUM_BITS(L) > R'LENGTH then return L < 0;
-    end if;
-    return UNSIGNED_LESS_OR_EQUAL(TO_UNSIGNED(L, R01'LENGTH), R01);
-  end "<=";
-  -- Id: C.16
-  function "<=" (L: INTEGER; R: SIGNED) return BOOLEAN is
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XR: SIGNED(R_LEFT downto 0) is R;
-    variable R01 : SIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute IS_SIGNED of R:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "LTE" ;
-  begin
-    if (R'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<="": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    R01 := TO_01(XR, 'X');
-    if (R01(R01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<="": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if SIGNED_NUM_BITS(L) > R'LENGTH then return L < 0;
-    end if;
-    return SIGNED_LESS_OR_EQUAL(TO_SIGNED(L, R01'LENGTH), R01);
-  end "<=";
-  -- Id: C.17
-  function "<=" (L: UNSIGNED; R: NATURAL) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    alias XL: UNSIGNED(L_LEFT downto 0) is L;
-    variable L01 : UNSIGNED(L_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "LTE" ;
-  begin
-    if (L_LEFT < 0) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<="": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    if (L01(L01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<="": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if UNSIGNED_NUM_BITS(R) > L'LENGTH then return 0 < R;
-    end if;
-    return UNSIGNED_LESS_OR_EQUAL(L01, TO_UNSIGNED(R, L01'LENGTH));
-  end "<=";
-  -- Id: C.18
-  function "<=" (L: SIGNED; R: INTEGER) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    alias XL: SIGNED(L_LEFT downto 0) is L;
-    variable L01 : SIGNED(L_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute IS_SIGNED of L:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "LTE" ;
-  begin
-    if (L_LEFT < 0) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<="": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    if (L01(L01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD.""<="": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if SIGNED_NUM_BITS(R) > L'LENGTH then return 0 < R;
-    end if;
-    return SIGNED_LESS_OR_EQUAL(L01, TO_SIGNED(R, L01'LENGTH));
-  end "<=";
-  --============================================================================
-  -- Id: C.19
-  function ">=" (L, R: UNSIGNED) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XL: UNSIGNED(L_LEFT downto 0) is L;
-    alias XR: UNSIGNED(R_LEFT downto 0) is R;
-    constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH);
-    variable L01 : UNSIGNED(L_LEFT downto 0);
-    variable R01 : UNSIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "GTE" ;
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then
-      assert NO_WARNING
-          report "NUMERIC_STD."">="": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    R01 := TO_01(XR, 'X');
-    if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then
-      assert NO_WARNING
-          report "NUMERIC_STD."">="": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    return not UNSIGNED_LESS(RESIZE(L01, SIZE), RESIZE(R01, SIZE));
-  end ">=";
-  -- Id: C.20
-  function ">=" (L, R: SIGNED) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XL: SIGNED(L_LEFT downto 0) is L;
-    alias XR: SIGNED(R_LEFT downto 0) is R;
-    constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH);
-    variable L01 : SIGNED(L_LEFT downto 0);
-    variable R01 : SIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute IS_SIGNED of L:constant is TRUE ;
-    attribute IS_SIGNED of R:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "GTE" ;
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then
-      assert NO_WARNING
-          report "NUMERIC_STD."">="": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    R01 := TO_01(XR, 'X');
-    if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then
-      assert NO_WARNING
-          report "NUMERIC_STD."">="": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    return not SIGNED_LESS(RESIZE(L01, SIZE), RESIZE(R01, SIZE));
-  end ">=";
-  -- Id: C.21
-  function ">=" (L: NATURAL; R: UNSIGNED) return BOOLEAN is
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XR: UNSIGNED(R_LEFT downto 0) is R;
-    variable R01 : UNSIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "GTE" ;
-  begin
-    if (R'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD."">="": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    R01 := TO_01(XR, 'X');
-    if (R01(R01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD."">="": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if UNSIGNED_NUM_BITS(L) > R'LENGTH then return L > 0;
-    end if;
-    return not UNSIGNED_LESS(TO_UNSIGNED(L, R01'LENGTH), R01);
-  end ">=";
-  -- Id: C.22
-  function ">=" (L: INTEGER; R: SIGNED) return BOOLEAN is
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XR: SIGNED(R_LEFT downto 0) is R;
-    variable R01 : SIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute IS_SIGNED of R:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "GTE" ;
-  begin
-    if (R'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD."">="": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    R01 := TO_01(XR, 'X');
-    if (R01(R01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD."">="": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if SIGNED_NUM_BITS(L) > R'LENGTH then return L > 0;
-    end if;
-    return not SIGNED_LESS(TO_SIGNED(L, R01'LENGTH), R01);
-  end ">=";
-  -- Id: C.23
-  function ">=" (L: UNSIGNED; R: NATURAL) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    alias XL: UNSIGNED(L_LEFT downto 0) is L;
-    variable L01 : UNSIGNED(L_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "GTE" ;
-  begin
-    if (L'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD."">="": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    if (L01(L01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD."">="": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if UNSIGNED_NUM_BITS(R) > L'LENGTH then return 0 > R;
-    end if;
-    return not UNSIGNED_LESS(L01, TO_UNSIGNED(R, L01'LENGTH));
-  end ">=";
-  -- Id: C.24
-  function ">=" (L: SIGNED; R: INTEGER) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    alias XL: SIGNED(L_LEFT downto 0) is L;
-    variable L01 : SIGNED(L_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute IS_SIGNED of L:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "GTE" ;
-  begin
-    if (L'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD."">="": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    if (L01(L01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD."">="": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if SIGNED_NUM_BITS(R) > L'LENGTH then return 0 > R;
-    end if;
-    return not SIGNED_LESS(L01, TO_SIGNED(R, L01'LENGTH));
-  end ">=";
-  --============================================================================
-  -- Id: C.25
-  function "=" (L, R: UNSIGNED) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XL: UNSIGNED(L_LEFT downto 0) is L;
-    alias XR: UNSIGNED(R_LEFT downto 0) is R;
-    constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH);
-    variable L01 : UNSIGNED(L_LEFT downto 0);
-    variable R01 : UNSIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "EQ" ;
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""="": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    R01 := TO_01(XR, 'X');
-    if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""="": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    return UNSIGNED_EQUAL(RESIZE(L01, SIZE), RESIZE(R01, SIZE));
-  end "=";
-  -- Id: C.26
-  function "=" (L, R: SIGNED) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XL: SIGNED(L_LEFT downto 0) is L;
-    alias XR: SIGNED(R_LEFT downto 0) is R;
-    constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH);
-    variable L01 : SIGNED(L_LEFT downto 0);
-    variable R01 : SIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute IS_SIGNED of L:constant is TRUE ;
-    attribute IS_SIGNED of R:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "EQ" ;
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""="": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    R01 := TO_01(XR, 'X');
-    if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""="": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    return SIGNED_EQUAL(RESIZE(L01, SIZE), RESIZE(R01, SIZE));
-  end "=";
-  -- Id: C.27
-  function "=" (L: NATURAL; R: UNSIGNED) return BOOLEAN is
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XR: UNSIGNED(R_LEFT downto 0) is R;
-    variable R01 : UNSIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "EQ" ;
-  begin
-    if (R'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""="": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    R01 := TO_01(XR, 'X');
-    if (R01(R01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD.""="": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if UNSIGNED_NUM_BITS(L) > R'LENGTH then return FALSE;
-    end if;
-    return UNSIGNED_EQUAL(TO_UNSIGNED(L, R01'LENGTH), R01);
-  end "=";
-  -- Id: C.28
-  function "=" (L: INTEGER; R: SIGNED) return BOOLEAN is
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XR: SIGNED(R_LEFT downto 0) is R;
-    variable R01 : SIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute IS_SIGNED of R:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "EQ" ;
-  begin
-    if (R'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""="": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    R01 := TO_01(XR, 'X');
-    if (R01(R01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD.""="": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if SIGNED_NUM_BITS(L) > R'LENGTH then return FALSE;
-    end if;
-    return SIGNED_EQUAL(TO_SIGNED(L, R01'LENGTH), R01);
-  end "=";
-  -- Id: C.29
-  function "=" (L: UNSIGNED; R: NATURAL) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    alias XL: UNSIGNED(L_LEFT downto 0) is L;
-    variable L01 : UNSIGNED(L_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "EQ" ;
-  begin
-    if (L'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""="": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    if (L01(L01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD.""="": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if UNSIGNED_NUM_BITS(R) > L'LENGTH then return FALSE;
-    end if;
-    return UNSIGNED_EQUAL(L01, TO_UNSIGNED(R, L01'LENGTH));
-  end "=";
-  -- Id: C.30
-  function "=" (L: SIGNED; R: INTEGER) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    alias XL: SIGNED(L_LEFT downto 0) is L;
-    variable L01 : SIGNED(L_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute IS_SIGNED of L:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "EQ" ;
-  begin
-    if (L'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""="": null argument detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    if (L01(L01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD.""="": metavalue detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if SIGNED_NUM_BITS(R) > L'LENGTH then return FALSE;
-    end if;
-    return SIGNED_EQUAL(L01, TO_SIGNED(R, L01'LENGTH));
-  end "=";
-  --============================================================================
-  -- Id: C.31
-  function "/=" (L, R: UNSIGNED) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XL: UNSIGNED(L_LEFT downto 0) is L;
-    alias XR: UNSIGNED(R_LEFT downto 0) is R;
-    constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH);
-    variable L01 : UNSIGNED(L_LEFT downto 0);
-    variable R01 : UNSIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "NEQ" ;
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""/="": null argument detected, returning TRUE"
-          severity WARNING;
-      return TRUE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    R01 := TO_01(XR, 'X');
-    if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""/="": metavalue detected, returning TRUE"
-          severity WARNING;
-      return TRUE;
-    end if;
-    return not(UNSIGNED_EQUAL(RESIZE(L01, SIZE), RESIZE(R01, SIZE)));
-  end "/=";
-  -- Id: C.32
-  function "/=" (L, R: SIGNED) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XL: SIGNED(L_LEFT downto 0) is L;
-    alias XR: SIGNED(R_LEFT downto 0) is R;
-    constant SIZE: NATURAL := MAX(L'LENGTH, R'LENGTH);
-    variable L01 : SIGNED(L_LEFT downto 0);
-    variable R01 : SIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute IS_SIGNED of L:constant is TRUE ;
-    attribute IS_SIGNED of R:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "NEQ" ;
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""/="": null argument detected, returning TRUE"
-          severity WARNING;
-      return TRUE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    R01 := TO_01(XR, 'X');
-    if ((L01(L01'LEFT)='X') or (R01(R01'LEFT)='X')) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""/="": metavalue detected, returning TRUE"
-          severity WARNING;
-      return TRUE;
-    end if;
-    return not(SIGNED_EQUAL(RESIZE(L01, SIZE), RESIZE(R01, SIZE)));
-  end "/=";
-  -- Id: C.33
-  function "/=" (L: NATURAL; R: UNSIGNED) return BOOLEAN is
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XR: UNSIGNED(R_LEFT downto 0) is R;
-    variable R01 : UNSIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "NEQ" ;
-  begin
-    if (R'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""/="": null argument detected, returning TRUE"
-          severity WARNING;
-      return TRUE;
-    end if;
-    R01 := TO_01(XR, 'X');
-    if (R01(R01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD.""/="": metavalue detected, returning TRUE"
-          severity WARNING;
-      return TRUE;
-    end if;
-    if UNSIGNED_NUM_BITS(L) > R'LENGTH then return TRUE;
-    end if;
-    return not(UNSIGNED_EQUAL(TO_UNSIGNED(L, R01'LENGTH), R01));
-  end "/=";
-  -- Id: C.34
-  function "/=" (L: INTEGER; R: SIGNED) return BOOLEAN is
-    constant R_LEFT: INTEGER := R'LENGTH-1;
-    alias XR: SIGNED(R_LEFT downto 0) is R;
-    variable R01 : SIGNED(R_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute IS_SIGNED of R:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "NEQ" ;
-  begin
-    if (R'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""/="": null argument detected, returning TRUE"
-          severity WARNING;
-      return TRUE;
-    end if;
-    R01 := TO_01(XR, 'X');
-    if (R01(R01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD.""/="": metavalue detected, returning TRUE"
-          severity WARNING;
-      return TRUE;
-    end if;
-    if SIGNED_NUM_BITS(L) > R'LENGTH then return TRUE;
-    end if;
-    return not(SIGNED_EQUAL(TO_SIGNED(L, R01'LENGTH), R01));
-  end "/=";
-  -- Id: C.35
-  function "/=" (L: UNSIGNED; R: NATURAL) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    alias XL: UNSIGNED(L_LEFT downto 0) is L;
-    variable L01 : UNSIGNED(L_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "NEQ" ;
-  begin
-    if (L'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""/="": null argument detected, returning TRUE"
-          severity WARNING;
-      return TRUE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    if (L01(L01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD.""/="": metavalue detected, returning TRUE"
-          severity WARNING;
-      return TRUE;
-    end if;
-    if UNSIGNED_NUM_BITS(R) > L'LENGTH then return TRUE;
-    end if;
-    return not(UNSIGNED_EQUAL(L01, TO_UNSIGNED(R, L01'LENGTH)));
-  end "/=";
-  -- Id: C.36
-  function "/=" (L: SIGNED; R: INTEGER) return BOOLEAN is
-    constant L_LEFT: INTEGER := L'LENGTH-1;
-    alias XL: SIGNED(L_LEFT downto 0) is L;
-    variable L01 : SIGNED(L_LEFT downto 0);
-    -- Synthesis directives :
-    variable RESULT : BOOLEAN ;
-    attribute IS_SIGNED of L:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "NEQ" ;
-  begin
-    if (L'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD.""/="": null argument detected, returning TRUE"
-          severity WARNING;
-      return TRUE;
-    end if;
-    L01 := TO_01(XL, 'X');
-    if (L01(L01'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD.""/="": metavalue detected, returning TRUE"
-          severity WARNING;
-      return TRUE;
-    end if;
-    if SIGNED_NUM_BITS(R) > L'LENGTH then return TRUE;
-    end if;
-    return not(SIGNED_EQUAL(L01, TO_SIGNED(R, L01'LENGTH)));
-  end "/=";
-  --============================================================================
-  -- Id: S.1
-  function SHIFT_LEFT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED is
-    -- Synthesis directives are in XSLL
-  begin
-    if (ARG'LENGTH < 1) then return NAU;
-    end if;
-    return UNSIGNED(XSLL(STD_LOGIC_VECTOR(ARG), COUNT));
-  end SHIFT_LEFT;
-  -- Id: S.2
-  function SHIFT_RIGHT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED is
-    -- Synthesis directives are in XSRL
-  begin
-    if (ARG'LENGTH < 1) then return NAU;
-    end if;
-    return UNSIGNED(XSRL(STD_LOGIC_VECTOR(ARG), COUNT));
-  end SHIFT_RIGHT;
-  -- Id: S.3
-  function SHIFT_LEFT (ARG: SIGNED; COUNT: NATURAL) return SIGNED is
-    -- Synthesis directives are in XSLL
-  begin
-    if (ARG'LENGTH < 1) then return NAS;
-    end if;
-    return SIGNED(XSLL(STD_LOGIC_VECTOR(ARG), COUNT));
-  end SHIFT_LEFT;
-  -- Id: S.4
-  function SHIFT_RIGHT (ARG: SIGNED; COUNT: NATURAL) return SIGNED is
-    -- Synthesis directives are in XSRA
-  begin
-    if (ARG'LENGTH < 1) then return NAS;
-    end if;
-    return SIGNED(XSRA(STD_LOGIC_VECTOR(ARG), COUNT));
-  end SHIFT_RIGHT;
-  --============================================================================
-  -- Id: S.5
-  function ROTATE_LEFT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED is
-    -- Synthesis directives are in XROL
-  begin
-    if (ARG'LENGTH < 1) then return NAU;
-    end if;
-    return UNSIGNED(XROL(STD_LOGIC_VECTOR(ARG), COUNT));
-  end ROTATE_LEFT;
-  -- Id: S.6
-  function ROTATE_RIGHT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED is
-    -- Synthesis directives are in XROR
-  begin
-    if (ARG'LENGTH < 1) then return NAU;
-    end if;
-    return UNSIGNED(XROR(STD_LOGIC_VECTOR(ARG), COUNT));
-  end ROTATE_RIGHT;
-  -- Id: S.7
-  function ROTATE_LEFT (ARG: SIGNED; COUNT: NATURAL) return SIGNED is
-    -- Synthesis directives are in XROL
-  begin
-    if (ARG'LENGTH < 1) then return NAS;
-    end if;
-    return SIGNED(XROL(STD_LOGIC_VECTOR(ARG), COUNT));
-  end ROTATE_LEFT;
-  -- Id: S.8
-  function ROTATE_RIGHT (ARG: SIGNED; COUNT: NATURAL) return SIGNED is
-    -- Synthesis directives are in XROR
-  begin
-    if (ARG'LENGTH < 1) then return NAS;
-    end if;
-    return SIGNED(XROR(STD_LOGIC_VECTOR(ARG), COUNT));
-  end ROTATE_RIGHT;
-  --============================================================================
-  ------------------------------------------------------------------------------
-  -- Note : Function S.9 is not compatible with VHDL 1076-1987. Comment
-  -- out the function (declaration and body) for VHDL 1076-1987 compatibility.
-  ------------------------------------------------------------------------------
-  -- Id: S.9
-  function "sll" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED is
-    -- Synthesis directives :
-    variable RESULT : UNSIGNED (ARG'LENGTH-1 downto 0) ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "SLL" ;
-  begin
-    if (COUNT >= 0) then
-      return SHIFT_LEFT(ARG, COUNT);
-    else
-      return SHIFT_RIGHT(ARG, -COUNT);
-    end if;
-  end "sll";
-  ------------------------------------------------------------------------------
-  --   Note : Function S.10 is not compatible with VHDL 1076-1987. Comment
-  --   out the function (declaration and body) for VHDL 1076-1987 compatibility.
-  ------------------------------------------------------------------------------
-  -- Id: S.10
-  function "sll" (ARG: SIGNED; COUNT: INTEGER) return SIGNED is
-    -- Synthesis directives :
-    variable RESULT : SIGNED (ARG'LENGTH-1 downto 0) ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "SLL" ;
-  begin
-    if (COUNT >= 0) then
-      return SHIFT_LEFT(ARG, COUNT);
-    else
-      return SIGNED(SHIFT_RIGHT(UNSIGNED(ARG), -COUNT));
-    end if;
-  end "sll";
-  ------------------------------------------------------------------------------
-  --   Note : Function S.11 is not compatible with VHDL 1076-1987. Comment
-  --   out the function (declaration and body) for VHDL 1076-1987 compatibility.
-  ------------------------------------------------------------------------------
-  -- Id: S.11
-  function "srl" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED is
-    -- Synthesis directives :
-    variable RESULT : UNSIGNED (ARG'LENGTH-1 downto 0) ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "SRL" ;
-  begin
-    if (COUNT >= 0) then
-      return SHIFT_RIGHT(ARG, COUNT);
-    else
-      return SHIFT_LEFT(ARG, -COUNT);
-    end if;
-  end "srl";
-  ------------------------------------------------------------------------------
-  --   Note : Function S.12 is not compatible with VHDL 1076-1987. Comment
-  -- out the function (declaration and body) for VHDL 1076-1987 compatibility.
-  ------------------------------------------------------------------------------
-  -- Id: S.12
-  function "srl" (ARG: SIGNED; COUNT: INTEGER) return SIGNED is
-    -- Synthesis directives :
-    variable RESULT : SIGNED (ARG'LENGTH-1 downto 0) ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "SRL" ;
-  begin
-    if (COUNT >= 0) then
-      return SIGNED(SHIFT_RIGHT(UNSIGNED(ARG), COUNT));
-    else
-      return SHIFT_LEFT(ARG, -COUNT);
-    end if;
-  end "srl";
-  ------------------------------------------------------------------------------
-  -- Note : Function S.13 is not compatible with VHDL 1076-1987. Comment
-  --   out the function (declaration and body) for VHDL 1076-1987 compatibility.
-  ------------------------------------------------------------------------------
-  -- Id: S.13
-  function "rol" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED is
-    -- Synthesis directives :
-    variable RESULT : UNSIGNED (ARG'LENGTH-1 downto 0) ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "ROL" ;
-  begin
-    if (COUNT >= 0) then
-      return ROTATE_LEFT(ARG, COUNT);
-    else
-      return ROTATE_RIGHT(ARG, -COUNT);
-    end if;
-  end "rol";
-  ------------------------------------------------------------------------------
-  --   Note : Function S.14 is not compatible with VHDL 1076-1987. Comment
-  -- out the function (declaration and body) for VHDL 1076-1987 compatibility.
-  ------------------------------------------------------------------------------
-  -- Id: S.14
-  function "rol" (ARG: SIGNED; COUNT: INTEGER) return SIGNED is
-    -- Synthesis directives :
-    variable RESULT : SIGNED (ARG'LENGTH-1 downto 0) ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "ROL" ;
-  begin
-    if (COUNT >= 0) then
-      return ROTATE_LEFT(ARG, COUNT);
-    else
-      return ROTATE_RIGHT(ARG, -COUNT);
-    end if;
-  end "rol";
-  ------------------------------------------------------------------------------
-  --   Note : Function S.15 is not compatible with VHDL 1076-1987. Comment
-  -- out the function (declaration and body) for VHDL 1076-1987 compatibility.
-  ------------------------------------------------------------------------------
-  -- Id: S.15
-  function "ror" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED is
-    -- Synthesis directives :
-    variable RESULT : UNSIGNED (ARG'LENGTH-1 downto 0) ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "ROR" ;
-  begin
-    if (COUNT >= 0) then
-      return ROTATE_RIGHT(ARG, COUNT);
-    else
-      return ROTATE_LEFT(ARG, -COUNT);
-    end if;
-  end "ror";
-  ------------------------------------------------------------------------------
-  -- Note : Function S.16 is not compatible with VHDL 1076-1987. Comment
-  -- out the function (declaration and body) for VHDL 1076-1987 compatibility.
-  ------------------------------------------------------------------------------
-  -- Id: S.16
-  function "ror" (ARG: SIGNED; COUNT: INTEGER) return SIGNED is
-    -- Synthesis directives :
-    variable RESULT : SIGNED (ARG'LENGTH-1 downto 0) ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "ROR" ;
-  begin
-    if (COUNT >= 0) then
-      return ROTATE_RIGHT(ARG, COUNT);
-    else
-      return ROTATE_LEFT(ARG, -COUNT);
-    end if;
-  end "ror";
-  --============================================================================
-  -- Id: D.1
-  function TO_INTEGER (ARG: UNSIGNED) return NATURAL is
-    constant ARG_LEFT: INTEGER := ARG'LENGTH-1;
-    alias XXARG: UNSIGNED(ARG_LEFT downto 0) is ARG;
-    variable XARG: UNSIGNED(ARG_LEFT downto 0);
-    variable RESULT: NATURAL := 0;
-    -- Synthesis directives :
-    attribute SYNTHESIS_RETURN of RESULT:variable is "FEED_THROUGH" ;
-  begin
-    if (ARG'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD.TO_INTEGER: null detected, returning 0"
-          severity WARNING;
-      return 0;
-    end if;
-    XARG := TO_01(XXARG, 'X');
-    if (XARG(XARG'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD.TO_INTEGER: metavalue detected, returning 0"
-          severity WARNING;
-      return 0;
-    end if;
-    for I in XARG'RANGE loop
-      RESULT := RESULT+RESULT;
-      if XARG(I) = '1' then
-        RESULT := RESULT + 1;
-      end if;
-    end loop;
-    return RESULT;
-  end TO_INTEGER;
-  -- Id: D.2
-  function TO_INTEGER (ARG: SIGNED) return INTEGER is
-    variable XARG: SIGNED(ARG'LENGTH-1 downto 0);
-    -- Synthesis directives :
-    variable RESULT : INTEGER ;
-    attribute IS_SIGNED of ARG:constant is TRUE ;
-    attribute SYNTHESIS_RETURN of RESULT:variable is "FEED_THROUGH" ;
-  begin
-    if (ARG'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD.TO_INTEGER: null detected, returning 0"
-          severity WARNING;
-      return 0;
-    end if;
-    XARG := TO_01(ARG, 'X');
-    if (XARG(XARG'LEFT)='X') then
-      assert NO_WARNING
-          report "NUMERIC_STD.TO_INTEGER: metavalue detected, returning 0"
-          severity WARNING;
-      return 0;
-    end if;
-    if XARG(XARG'LEFT) = '0' then
-      return TO_INTEGER(UNSIGNED(XARG));
-    else
-      return (- (TO_INTEGER(UNSIGNED(- (XARG + 1)))) -1);
-    end if;
-  end TO_INTEGER;
-  -- Id: D.3
-  function TO_UNSIGNED (ARG, SIZE: NATURAL) return UNSIGNED is
-    variable RESULT: UNSIGNED(SIZE-1 downto 0);
-    variable I_VAL: NATURAL := ARG;
-    -- Synthesis directives :
-    attribute SYNTHESIS_RETURN of RESULT:variable is "FEED_THROUGH" ;
-  begin
-    if (SIZE < 1) then return NAU;
-    end if;
-    for I in 0 to RESULT'LEFT loop
-      if (I_VAL mod 2) = 0 then
-        RESULT(I) := '0';
-      else RESULT(I) := '1';
-      end if;
-      I_VAL := I_VAL/2;
-    end loop;
-    if not(I_VAL =0) then
-      assert NO_WARNING
-          report "NUMERIC_STD.TO_UNSIGNED: vector truncated"
-          severity WARNING;
-    end if;
-    return RESULT;
-  end TO_UNSIGNED;
-  -- Id: D.4
-  function TO_SIGNED (ARG: INTEGER; SIZE: NATURAL) return SIGNED is
-    variable RESULT: SIGNED(SIZE-1 downto 0);
-    variable B_VAL: STD_LOGIC := '0';
-    variable I_VAL: INTEGER := ARG;
-    -- Synthesis directives :
-    attribute SYNTHESIS_RETURN of RESULT:variable is "FEED_THROUGH" ;
-  begin
-    if (SIZE < 1) then return NAS;
-    end if;
-    if (ARG < 0) then
-      B_VAL := '1';
-      I_VAL := -(ARG+1);
-    end if;
-    for I in 0 to RESULT'LEFT loop
-      if (I_VAL mod 2) = 0 then
-        RESULT(I) := B_VAL;
-      else
-        RESULT(I) := not B_VAL;
-      end if;
-      I_VAL := I_VAL/2;
-    end loop;
-    if ((I_VAL/=0) or (B_VAL/=RESULT(RESULT'LEFT))) then
-      assert NO_WARNING
-          report "NUMERIC_STD.TO_SIGNED: vector truncated"
-          severity WARNING;
-    end if;
-    return RESULT;
-  end TO_SIGNED;
-  --============================================================================
-  -- Id: R.1
-  function RESIZE (ARG: SIGNED; NEW_SIZE: NATURAL) return SIGNED is
-    alias INVEC: SIGNED(ARG'LENGTH-1 downto 0) is ARG;
-    variable RESULT: SIGNED(NEW_SIZE-1 downto 0) := (others => '0');
-    constant BOUND: INTEGER := MIN(ARG'LENGTH, RESULT'LENGTH)-2;
-    -- VERIFIC: The RESIZE() function for signed does NOT behave the same as the FEEDTHROUGH pragma does. It does truncation a bit different. Cannot use pragma. Issue 2044
-    -- attribute IS_SIGNED of ARG:constant is TRUE ;
-    ---attribute SYNTHESIS_RETURN of RESULT:variable is "FEED_THROUGH" ;
-  begin
-    if (NEW_SIZE < 1) then return NAS;
-    end if;
-    if (ARG'LENGTH = 0) then return RESULT;
-    end if;
-    RESULT := (others => ARG(ARG'LEFT));
-    if BOUND >= 0 then
-      RESULT(BOUND downto 0) := INVEC(BOUND downto 0);
-    end if;
-    return RESULT;
-  end RESIZE;
-  -- Id: R.2
-  function RESIZE (ARG: UNSIGNED; NEW_SIZE: NATURAL) return UNSIGNED is
-    constant ARG_LEFT: INTEGER := ARG'LENGTH-1;
-    alias XARG: UNSIGNED(ARG_LEFT downto 0) is ARG;
-    variable RESULT: UNSIGNED(NEW_SIZE-1 downto 0) := (others => '0');
-    -- Synthesis directives :
-    attribute SYNTHESIS_RETURN of RESULT:variable is "FEED_THROUGH" ;
-  begin
-    if (NEW_SIZE < 1) then return NAU;
-    end if;
-    if XARG'LENGTH =0 then return RESULT;
-    end if;
-    if (RESULT'LENGTH < ARG'LENGTH) then
-      RESULT(RESULT'LEFT downto 0) := XARG(RESULT'LEFT downto 0);
-    else
-      RESULT(RESULT'LEFT downto XARG'LEFT+1) := (others => '0');
-      RESULT(XARG'LEFT downto 0) := XARG;
-    end if;
-    return RESULT;
-  end RESIZE;
-  --============================================================================
-  -- Id: L.1
-  function "not" (L: UNSIGNED) return UNSIGNED is
-    variable RESULT: UNSIGNED(L'LENGTH-1 downto 0);
-  begin
-    RESULT := UNSIGNED(not(STD_LOGIC_VECTOR(L)));
-    return RESULT;
-  end "not";
-  -- Id: L.2
-  function "and" (L, R: UNSIGNED) return UNSIGNED is
-    variable RESULT: UNSIGNED(L'LENGTH-1 downto 0);
-  begin
-    RESULT := UNSIGNED(STD_LOGIC_VECTOR(L) and STD_LOGIC_VECTOR(R));
-    return RESULT;
-  end "and";
-  -- Id: L.3
-  function "or" (L, R: UNSIGNED) return UNSIGNED is
-    variable RESULT: UNSIGNED(L'LENGTH-1 downto 0);
-  begin
-    RESULT := UNSIGNED(STD_LOGIC_VECTOR(L) or STD_LOGIC_VECTOR(R));
-    return RESULT;
-  end "or";
-  -- Id: L.4
-  function "nand" (L, R: UNSIGNED) return UNSIGNED is
-    variable RESULT: UNSIGNED(L'LENGTH-1 downto 0);
-  begin
-    RESULT := UNSIGNED(STD_LOGIC_VECTOR(L) nand STD_LOGIC_VECTOR(R));
-    return RESULT;
-  end "nand";
-  -- Id: L.5
-  function "nor" (L, R: UNSIGNED) return UNSIGNED is
-    variable RESULT: UNSIGNED(L'LENGTH-1 downto 0);
-  begin
-    RESULT := UNSIGNED(STD_LOGIC_VECTOR(L) nor STD_LOGIC_VECTOR(R));
-    return RESULT;
-  end "nor";
-  -- Id: L.6
-  function "xor" (L, R: UNSIGNED) return UNSIGNED is
-    variable RESULT: UNSIGNED(L'LENGTH-1 downto 0);
-  begin
-    RESULT := UNSIGNED(STD_LOGIC_VECTOR(L) xor STD_LOGIC_VECTOR(R));
-    return RESULT;
-  end "xor";
-  ------------------------------------------------------------------------------
-  -- Note : Function L.7 is not compatible with VHDL 1076-1987. Comment
-  -- out the function (declaration and body) for VHDL 1076-1987 compatibility.
-  ------------------------------------------------------------------------------
-  -- Id: L.7
-  function "xnor" (L, R: UNSIGNED) return UNSIGNED is
-    variable RESULT: UNSIGNED(L'LENGTH-1 downto 0);
-  begin
-    RESULT := UNSIGNED(STD_LOGIC_VECTOR(L) xnor STD_LOGIC_VECTOR(R));
-    return RESULT;
-  end "xnor";
-  -- Id: L.8
-  function "not" (L: SIGNED) return SIGNED is
-    variable RESULT: SIGNED(L'LENGTH-1 downto 0);
-  begin
-    RESULT := SIGNED(not(STD_LOGIC_VECTOR(L)));
-    return RESULT;
-  end "not";
-  -- Id: L.9
-  function "and" (L, R: SIGNED) return SIGNED is
-    variable RESULT: SIGNED(L'LENGTH-1 downto 0);
-  begin
-    RESULT := SIGNED(STD_LOGIC_VECTOR(L) and STD_LOGIC_VECTOR(R));
-    return RESULT;
-  end "and";
-  -- Id: L.10
-  function "or" (L, R: SIGNED) return SIGNED is
-    variable RESULT: SIGNED(L'LENGTH-1 downto 0);
-  begin
-    RESULT := SIGNED(STD_LOGIC_VECTOR(L) or STD_LOGIC_VECTOR(R));
-    return RESULT;
-  end "or";
-  -- Id: L.11
-  function "nand" (L, R: SIGNED) return SIGNED is
-    variable RESULT: SIGNED(L'LENGTH-1 downto 0);
-  begin
-    RESULT := SIGNED(STD_LOGIC_VECTOR(L) nand STD_LOGIC_VECTOR(R));
-    return RESULT;
-  end "nand";
-  -- Id: L.12
-  function "nor" (L, R: SIGNED) return SIGNED is
-    variable RESULT: SIGNED(L'LENGTH-1 downto 0);
-  begin
-    RESULT := SIGNED(STD_LOGIC_VECTOR(L) nor STD_LOGIC_VECTOR(R));
-    return RESULT;
-  end "nor";
-  -- Id: L.13
-  function "xor" (L, R: SIGNED) return SIGNED is
-    variable RESULT: SIGNED(L'LENGTH-1 downto 0);
-  begin
-    RESULT := SIGNED(STD_LOGIC_VECTOR(L) xor STD_LOGIC_VECTOR(R));
-    return RESULT;
-  end "xor";
-  ------------------------------------------------------------------------------
-  -- Note : Function L.14 is not compatible with VHDL 1076-1987. Comment
-  --   out the function (declaration and body) for VHDL 1076-1987 compatibility.
-  ------------------------------------------------------------------------------
-  -- Id: L.14
-  function "xnor" (L, R: SIGNED) return SIGNED is
-    variable RESULT: SIGNED(L'LENGTH-1 downto 0);
-  begin
-    RESULT := SIGNED(STD_LOGIC_VECTOR(L) xnor STD_LOGIC_VECTOR(R));
-    return RESULT;
-  end "xnor";
-  --============================================================================
-  -- support constants for STD_MATCH:
-  type BOOLEAN_TABLE is array(STD_ULOGIC, STD_ULOGIC) of BOOLEAN;
-  constant MATCH_TABLE: BOOLEAN_TABLE := (
-      --------------------------------------------------------------------------
-      -- U      X      0      1      Z      W      L      H      -
-      --------------------------------------------------------------------------
-      (FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,  TRUE), -- | U |
-      (FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,  TRUE), -- | X |
-      (FALSE, FALSE,  TRUE, FALSE, FALSE, FALSE,  TRUE, FALSE,  TRUE), -- | 0 |
-      (FALSE, FALSE, FALSE,  TRUE, FALSE, FALSE, FALSE,  TRUE,  TRUE), -- | 1 |
-      (FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,  TRUE), -- | Z |
-      (FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,  TRUE), -- | W |
-      (FALSE, FALSE,  TRUE, FALSE, FALSE, FALSE,  TRUE, FALSE,  TRUE), -- | L |
-      (FALSE, FALSE, FALSE,  TRUE, FALSE, FALSE, FALSE,  TRUE,  TRUE), -- | H |
-      ( TRUE,  TRUE,  TRUE,  TRUE,  TRUE,  TRUE,  TRUE,  TRUE,  TRUE)  -- | - |
-      );
-  -- Id: M.1
-  function STD_MATCH (L, R: STD_ULOGIC) return BOOLEAN is
-    variable VALUE: STD_ULOGIC;
-  begin
-    return MATCH_TABLE(L, R);
-  end STD_MATCH;
-  -- Id: M.2
-  function STD_MATCH (L, R: UNSIGNED) return BOOLEAN is
-    alias LV: UNSIGNED(1 to L'LENGTH) is L;
-    alias RV: UNSIGNED(1 to R'LENGTH) is R;
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then
-      assert NO_WARNING
-          report "NUMERIC_STD.STD_MATCH: null detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if LV'LENGTH /= RV'LENGTH then
-      assert NO_WARNING
-          report "NUMERIC_STD.STD_MATCH: L'LENGTH /= R'LENGTH, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    else
-      for I in LV'LOW to LV'HIGH loop
-        if not (MATCH_TABLE(LV(I), RV(I))) then
-          return FALSE;
-        end if;
-      end loop;
-      return TRUE;
-    end if;
-  end STD_MATCH;
-  -- Id: M.3
-  function STD_MATCH (L, R: SIGNED) return BOOLEAN is
-    alias LV: SIGNED(1 to L'LENGTH) is L;
-    alias RV: SIGNED(1 to R'LENGTH) is R;
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then
-      assert NO_WARNING
-          report "NUMERIC_STD.STD_MATCH: null detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if LV'LENGTH /= RV'LENGTH then
-      assert NO_WARNING
-          report "NUMERIC_STD.STD_MATCH: L'LENGTH /= R'LENGTH, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    else
-      for I in LV'LOW to LV'HIGH loop
-        if not (MATCH_TABLE(LV(I), RV(I))) then
-          return FALSE;
-        end if;
-      end loop;
-      return TRUE;
-    end if;
-  end STD_MATCH;
-  -- Id: M.4
-  function STD_MATCH (L, R: STD_LOGIC_VECTOR) return BOOLEAN is
-    alias LV: STD_LOGIC_VECTOR(1 to L'LENGTH) is L;
-    alias RV: STD_LOGIC_VECTOR(1 to R'LENGTH) is R;
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then
-      assert NO_WARNING
-          report "NUMERIC_STD.STD_MATCH: null detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if LV'LENGTH /= RV'LENGTH then
-      assert NO_WARNING
-          report "NUMERIC_STD.STD_MATCH: L'LENGTH /= R'LENGTH, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    else
-      for I in LV'LOW to LV'HIGH loop
-        if not (MATCH_TABLE(LV(I), RV(I))) then
-          return FALSE;
-        end if;
-      end loop;
-      return TRUE;
-    end if;
-  end STD_MATCH;
-  -- Id: M.5
-  function STD_MATCH (L, R: STD_ULOGIC_VECTOR) return BOOLEAN is
-    alias LV: STD_ULOGIC_VECTOR(1 to L'LENGTH) is L;
-    alias RV: STD_ULOGIC_VECTOR(1 to R'LENGTH) is R;
-  begin
-    if ((L'LENGTH < 1) or (R'LENGTH < 1)) then
-      assert NO_WARNING
-          report "NUMERIC_STD.STD_MATCH: null detected, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    end if;
-    if LV'LENGTH /= RV'LENGTH then
-      assert NO_WARNING
-          report "NUMERIC_STD.STD_MATCH: L'LENGTH /= R'LENGTH, returning FALSE"
-          severity WARNING;
-      return FALSE;
-    else
-      for I in LV'LOW to LV'HIGH loop
-        if not (MATCH_TABLE(LV(I), RV(I))) then
-          return FALSE;
-        end if;
-      end loop;
-      return TRUE;
-    end if;
-  end STD_MATCH;
-  --============================================================================
-  -- function TO_01 is used to convert vectors to the
-  --          correct form for exported functions,
-  --          and to report if there is an element which
-  --          is not in (0, 1, H, L).
-  -- Id: T.1
-  function TO_01 (S: UNSIGNED; XMAP: STD_LOGIC := '0') return UNSIGNED is
-    variable RESULT: UNSIGNED(S'LENGTH-1 downto 0);
-    variable BAD_ELEMENT: BOOLEAN := FALSE;
-    alias XS: UNSIGNED(S'LENGTH-1 downto 0) is S;
-    -- Synthesis directives :
-    attribute SYNTHESIS_RETURN of RESULT:variable is "FEED_THROUGH" ;
-  begin
-    if (S'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD.TO_01: null detected, returning NAU"
-          severity WARNING;
-      return NAU;
-    end if;
-    for I in RESULT'RANGE loop
-      case XS(I) is
-        when '0' | 'L' => RESULT(I) := '0';
-        when '1' | 'H' => RESULT(I) := '1';
-        when others => BAD_ELEMENT := TRUE;
-      end case;
-    end loop;
-    if BAD_ELEMENT then
-      for I in RESULT'RANGE loop
-        RESULT(I) := XMAP; -- standard fixup
-      end loop;
-    end if;
-    return RESULT;
-  end TO_01;
-  -- Id: T.2
-  function TO_01 (S: SIGNED; XMAP: STD_LOGIC := '0') return SIGNED is
-    variable RESULT: SIGNED(S'LENGTH-1 downto 0);
-    variable BAD_ELEMENT: BOOLEAN := FALSE;
-    alias XS: SIGNED(S'LENGTH-1 downto 0) is S;
-    -- Synthesis directives :
-    attribute SYNTHESIS_RETURN of RESULT:variable is "FEED_THROUGH" ;
-  begin
-    if (S'LENGTH < 1) then
-      assert NO_WARNING
-          report "NUMERIC_STD.TO_01: null detected, returning NAS"
-          severity WARNING;
-      return NAS;
-    end if;
-    for I in RESULT'RANGE loop
-      case XS(I) is
-        when '0' | 'L' => RESULT(I) := '0';
-        when '1' | 'H' => RESULT(I) := '1';
-        when others => BAD_ELEMENT := TRUE;
-      end case;
-    end loop;
-    if BAD_ELEMENT then
-      for I in RESULT'RANGE loop
-        RESULT(I) := XMAP; -- standard fixup
-      end loop;
-    end if;
-    return RESULT;
-  end TO_01;
-  --============================================================================
-end NUMERIC_STD;
 </code>