diff --git a/third_party/g7221/common/common.c b/third_party/g7221/common/common.c
index 66e32ad..94bcf79 100644
--- a/third_party/g7221/common/common.c
+++ b/third_party/g7221/common/common.c
@@ -94,7 +94,7 @@
     {
         number_of_available_bits = sub(number_of_available_bits,frame_size);
         number_of_available_bits = extract_l(L_mult0(number_of_available_bits,5));
-        number_of_available_bits = shr(number_of_available_bits,3);
+        number_of_available_bits = shr_nocheck(number_of_available_bits,3);
         number_of_available_bits = add(number_of_available_bits,frame_size);
     }
 
@@ -207,7 +207,7 @@
     for (j=0; j<num_categorization_control_possibilities-1; j++) 
     {
         min_plus_max = add(max,min);
-        two_x_number_of_available_bits = shl(number_of_available_bits,1);
+        two_x_number_of_available_bits = shl_nocheck(number_of_available_bits,1);
         
         temp = sub(min_plus_max,two_x_number_of_available_bits);
         test();
@@ -222,7 +222,7 @@
                 test();
                 if (max_rate_categories[region] > 0) 
                 {
-                    itemp0 = shl(max_rate_categories[region],1);
+                    itemp0 = shl_nocheck(max_rate_categories[region],1);
                     itemp1 = sub(offset,rms_index[region]);
                     itemp0 = sub(itemp1,itemp0);
                     
@@ -258,7 +258,7 @@
                 test();
                 if (temp < 0)
                 {
-                    itemp0 = shl(min_rate_categories[region],1);
+                    itemp0 = shl_nocheck(min_rate_categories[region],1);
                     itemp1 = sub(offset,rms_index[region]);
                     itemp0 = sub(itemp1,itemp0);
                     
@@ -356,7 +356,7 @@
         for (region=0; region<number_of_regions; region++) 
         {
             j = sub(test_offset,rms_index[region]);
-            j = shr(j,1);
+            j = shr_nocheck(j,1);
             
             /* Ensure j is between 0 and NUM_CAT-1 */
             test();
@@ -391,7 +391,7 @@
             answer = test_offset;
             move16();
         }
-        delta = shr(delta,1);
+        delta = shr_nocheck(delta,1);
         test(); /* for the while loop */
     } while (delta > 0);
 
@@ -440,7 +440,7 @@
     for (region=0; region<number_of_regions; region++) 
     {
         j = sub(offset,rms_index[region]);
-        j = shr(j,1);
+        j = shr_nocheck(j,1);
         
         /* make sure j is between 0 and NUM_CAT-1 */
         test();
diff --git a/third_party/g7221/common/stl-files/basop32.c b/third_party/g7221/common/stl-files/basop32.c
index 9eb4f38..efd5c20 100644
--- a/third_party/g7221/common/stl-files/basop32.c
+++ b/third_party/g7221/common/stl-files/basop32.c
@@ -79,86 +79,29 @@
 
 /*___________________________________________________________________________
  |                                                                           |
- |   Local Functions                                                         |
- |___________________________________________________________________________|
-*/
-Word16 saturate (Word32 L_var1);
-
-/*___________________________________________________________________________
- |                                                                           |
  |   Constants and Globals                                                   |
  |___________________________________________________________________________|
 */
-Flag Overflow = 0;
-Flag Carry = 0;
+#if INCLUDE_UNSAFE
+Flag g7221_Overflow = 0;
+Flag g7221_Carry = 0;
+#endif
 
 /*___________________________________________________________________________
  |                                                                           |
  |   Functions                                                               |
  |___________________________________________________________________________|
 */
-
 /*___________________________________________________________________________
  |                                                                           |
- |   Function Name : saturate                                                |
+ |   Function Name : shr                                                     |
  |                                                                           |
  |   Purpose :                                                               |
  |                                                                           |
- |    Limit the 32 bit input to the range of a 16 bit word.                  |
- |                                                                           |
- |   Inputs :                                                                |
- |                                                                           |
- |    L_var1                                                                 |
- |             32 bit long signed integer (Word32) whose value falls in the  |
- |             range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.                 |
- |                                                                           |
- |   Outputs :                                                               |
- |                                                                           |
- |    none                                                                   |
- |                                                                           |
- |   Return Value :                                                          |
- |                                                                           |
- |    var_out                                                                |
- |             16 bit short signed integer (Word16) whose value falls in the |
- |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
- |___________________________________________________________________________|
-*/
-Word16 saturate (Word32 L_var1)
-{
-    Word16 var_out;
-
-    if (L_var1 > 0X00007fffL)
-    {
-        Overflow = 1;
-        var_out = MAX_16;
-    }
-    else if (L_var1 < (Word32) 0xffff8000L)
-    {
-        Overflow = 1;
-        var_out = MIN_16;
-    }
-    else
-    {
-        var_out = extract_l (L_var1);
-#if (WMOPS)
-        multiCounter[currCounter].extract_l--;
-#endif
-    }
-
-    return (var_out);
-}
-/* ------------------------- End of saturate() ------------------------- */
-
-
-/*___________________________________________________________________________
- |                                                                           |
- |   Function Name : add                                                     |
- |                                                                           |
- |   Purpose :                                                               |
- |                                                                           |
- |    Performs the addition (var1+var2) with overflow control and saturation;|
- |    the 16 bit result is set at +32767 when overflow occurs or at -32768   |
- |    when underflow occurs.                                                 |
+ |   Arithmetically shift the 16 bit input var1 right var2 positions with    |
+ |   sign extension. If var2 is negative, arithmetically shift var1 left by  |
+ |   -var2 with sign extension. Saturate the result in case of underflows or |
+ |   overflows.                                                              |
  |                                                                           |
  |   Complexity weight : 1                                                   |
  |                                                                           |
@@ -183,121 +126,20 @@
  |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
  |___________________________________________________________________________|
 */
-Word16 add (Word16 var1, Word16 var2)
+Word16 shr (Word16 var1, Word16 var2)
 {
-    Word16 var_out;
-    Word32 L_sum;
-
-    L_sum = (Word32) var1 + var2;
-    var_out = saturate (L_sum);
-#if (WMOPS)
-    multiCounter[currCounter].add++;
-#endif
-    return (var_out);
-}
-/* ------------------------- End of add() ------------------------- */
-
-
-/*___________________________________________________________________________
- |                                                                           |
- |   Function Name : sub                                                     |
- |                                                                           |
- |   Purpose :                                                               |
- |                                                                           |
- |    Performs the subtraction (var1+var2) with overflow control and satu-   |
- |    ration; the 16 bit result is set at +32767 when overflow occurs or at  |
- |    -32768 when underflow occurs.                                          |
- |                                                                           |
- |   Complexity weight : 1                                                   |
- |                                                                           |
- |   Inputs :                                                                |
- |                                                                           |
- |    var1                                                                   |
- |             16 bit short signed integer (Word16) whose value falls in the |
- |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
- |                                                                           |
- |    var2                                                                   |
- |             16 bit short signed integer (Word16) whose value falls in the |
- |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
- |                                                                           |
- |   Outputs :                                                               |
- |                                                                           |
- |    none                                                                   |
- |                                                                           |
- |   Return Value :                                                          |
- |                                                                           |
- |    var_out                                                                |
- |             16 bit short signed integer (Word16) whose value falls in the |
- |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
- |___________________________________________________________________________|
-*/
-Word16 sub (Word16 var1, Word16 var2)
-{
-    Word16 var_out;
-    Word32 L_diff;
-
-    L_diff = (Word32) var1 - var2;
-    var_out = saturate (L_diff);
-#if (WMOPS)
-    multiCounter[currCounter].sub++;
-#endif
-    return (var_out);
-}
-/* ------------------------- End of sub() ------------------------- */
-
-
-/*___________________________________________________________________________
- |                                                                           |
- |   Function Name : abs_s                                                   |
- |                                                                           |
- |   Purpose :                                                               |
- |                                                                           |
- |    Absolute value of var1; abs_s(-32768) = 32767.                         |
- |                                                                           |
- |   Complexity weight : 1                                                   |
- |                                                                           |
- |   Inputs :                                                                |
- |                                                                           |
- |    var1                                                                   |
- |             16 bit short signed integer (Word16) whose value falls in the |
- |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
- |                                                                           |
- |   Outputs :                                                               |
- |                                                                           |
- |    none                                                                   |
- |                                                                           |
- |   Return Value :                                                          |
- |                                                                           |
- |    var_out                                                                |
- |             16 bit short signed integer (Word16) whose value falls in the |
- |             range : 0x0000 0000 <= var_out <= 0x0000 7fff.                |
- |___________________________________________________________________________|
-*/
-Word16 abs_s (Word16 var1)
-{
-    Word16 var_out;
-
-    if (var1 == (Word16) 0X8000)
+    if (var2 < 0)
     {
-        var_out = MAX_16;
+        if (var2 < -16)
+            var2 = -16;
+        return shl_nocheck(var1, (Word16) -var2);
     }
     else
     {
-        if (var1 < 0)
-        {
-            var_out = -var1;
-        }
-        else
-        {
-            var_out = var1;
-        }
+        return shr_nocheck(var1, var2);
     }
-#if (WMOPS)
-    multiCounter[currCounter].abs_s++;
-#endif
-    return (var_out);
 }
-/* ------------------------- End of abs_s() ------------------------- */
+/* ------------------------- End of shr() ------------------------- */
 
 
 /*___________________________________________________________________________
@@ -336,116 +178,18 @@
 */
 Word16 shl (Word16 var1, Word16 var2)
 {
-    Word16 var_out;
-    Word32 result;
-
     if (var2 < 0)
     {
-        if (var2 < -16)
-            var2 = -16;
-        var_out = shr (var1, (Word16) -var2);
-#if (WMOPS)
-        multiCounter[currCounter].shr--;
-#endif
+        return shr_nocheck(var1, (Word16) -var2);
     }
     else
     {
-        result = (Word32) var1 *((Word32) 1 << var2);
-
-        if ((var2 > 15 && var1 != 0) || (result != (Word32) ((Word16) result)))
-        {
-            Overflow = 1;
-            var_out = (var1 > 0) ? MAX_16 : MIN_16;
-        }
-        else
-        {
-            var_out = extract_l (result);
-#if (WMOPS)
-            multiCounter[currCounter].extract_l--;
-#endif
-        }
+        return shl_nocheck(var1, var2);
     }
-#if (WMOPS)
-    multiCounter[currCounter].shl++;
-#endif
-    return (var_out);
 }
 /* ------------------------- End of shl() ------------------------- */
 
 
-/*___________________________________________________________________________
- |                                                                           |
- |   Function Name : shr                                                     |
- |                                                                           |
- |   Purpose :                                                               |
- |                                                                           |
- |   Arithmetically shift the 16 bit input var1 right var2 positions with    |
- |   sign extension. If var2 is negative, arithmetically shift var1 left by  |
- |   -var2 with sign extension. Saturate the result in case of underflows or |
- |   overflows.                                                              |
- |                                                                           |
- |   Complexity weight : 1                                                   |
- |                                                                           |
- |   Inputs :                                                                |
- |                                                                           |
- |    var1                                                                   |
- |             16 bit short signed integer (Word16) whose value falls in the |
- |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
- |                                                                           |
- |    var2                                                                   |
- |             16 bit short signed integer (Word16) whose value falls in the |
- |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
- |                                                                           |
- |   Outputs :                                                               |
- |                                                                           |
- |    none                                                                   |
- |                                                                           |
- |   Return Value :                                                          |
- |                                                                           |
- |    var_out                                                                |
- |             16 bit short signed integer (Word16) whose value falls in the |
- |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
- |___________________________________________________________________________|
-*/
-Word16 shr (Word16 var1, Word16 var2)
-{
-    Word16 var_out;
-
-    if (var2 < 0)
-    {
-        if (var2 < -16)
-            var2 = -16;
-        var_out = shl (var1, (Word16) -var2);
-#if (WMOPS)
-        multiCounter[currCounter].shl--;
-#endif
-    }
-    else
-    {
-        if (var2 >= 15)
-        {
-            var_out = (var1 < 0) ? -1 : 0;
-        }
-        else
-        {
-            if (var1 < 0)
-            {
-                var_out = ~((~var1) >> var2);
-            }
-            else
-            {
-                var_out = var1 >> var2;
-            }
-        }
-    }
-
-#if (WMOPS)
-    multiCounter[currCounter].shr++;
-#endif
-    return (var_out);
-}
-/* ------------------------- End of shr() ------------------------- */
-
 
 /*___________________________________________________________________________
  |                                                                           |
@@ -504,289 +248,6 @@
 
 /*___________________________________________________________________________
  |                                                                           |
- |   Function Name : L_mult                                                  |
- |                                                                           |
- |   Purpose :                                                               |
- |                                                                           |
- |   L_mult is the 32 bit result of the multiplication of var1 times var2    |
- |   with one shift left i.e.:                                               |
- |        L_mult(var1,var2) = L_shl((var1 times var2),1) and                 |
- |        L_mult(-32768,-32768) = 2147483647.                                |
- |                                                                           |
- |   Complexity weight : 1                                                   |
- |                                                                           |
- |   Inputs :                                                                |
- |                                                                           |
- |    var1                                                                   |
- |             16 bit short signed integer (Word16) whose value falls in the |
- |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
- |                                                                           |
- |    var2                                                                   |
- |             16 bit short signed integer (Word16) whose value falls in the |
- |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
- |                                                                           |
- |   Outputs :                                                               |
- |                                                                           |
- |    none                                                                   |
- |                                                                           |
- |   Return Value :                                                          |
- |                                                                           |
- |    L_var_out                                                              |
- |             32 bit long signed integer (Word32) whose value falls in the  |
- |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
- |___________________________________________________________________________|
-*/
-Word32 L_mult (Word16 var1, Word16 var2)
-{
-    Word32 L_var_out;
-
-    L_var_out = (Word32) var1 *(Word32) var2;
-
-    if (L_var_out != (Word32) 0x40000000L)
-    {
-        L_var_out *= 2;
-    }
-    else
-    {
-        Overflow = 1;
-        L_var_out = MAX_32;
-    }
-
-#if (WMOPS)
-    multiCounter[currCounter].L_mult++;
-#endif
-    return (L_var_out);
-}
-/* ------------------------- End of L_mult() ------------------------- */
-
-
-/*___________________________________________________________________________
- |                                                                           |
- |   Function Name : negate                                                  |
- |                                                                           |
- |   Purpose :                                                               |
- |                                                                           |
- |   Negate var1 with saturation, saturate in the case where input is -32768:|
- |                negate(var1) = sub(0,var1).                                |
- |                                                                           |
- |   Complexity weight : 1                                                   |
- |                                                                           |
- |   Inputs :                                                                |
- |                                                                           |
- |    var1                                                                   |
- |             16 bit short signed integer (Word16) whose value falls in the |
- |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
- |                                                                           |
- |   Outputs :                                                               |
- |                                                                           |
- |    none                                                                   |
- |                                                                           |
- |   Return Value :                                                          |
- |                                                                           |
- |    var_out                                                                |
- |             16 bit short signed integer (Word16) whose value falls in the |
- |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
- |___________________________________________________________________________|
-*/
-Word16 negate (Word16 var1)
-{
-    Word16 var_out;
-
-    var_out = (var1 == MIN_16) ? MAX_16 : -var1;
-#if (WMOPS)
-    multiCounter[currCounter].negate++;
-#endif
-    return (var_out);
-}
-/* ------------------------- End of negate() ------------------------- */
-
-
-/*___________________________________________________________________________
- |                                                                           |
- |   Function Name : extract_h                                               |
- |                                                                           |
- |   Purpose :                                                               |
- |                                                                           |
- |   Return the 16 MSB of L_var1.                                            |
- |                                                                           |
- |   Complexity weight : 1                                                   |
- |                                                                           |
- |   Inputs :                                                                |
- |                                                                           |
- |    L_var1                                                                 |
- |             32 bit long signed integer (Word32 ) whose value falls in the |
- |             range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.                 |
- |                                                                           |
- |   Outputs :                                                               |
- |                                                                           |
- |    none                                                                   |
- |                                                                           |
- |   Return Value :                                                          |
- |                                                                           |
- |    var_out                                                                |
- |             16 bit short signed integer (Word16) whose value falls in the |
- |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
- |___________________________________________________________________________|
-*/
-Word16 extract_h (Word32 L_var1)
-{
-    Word16 var_out;
-
-    var_out = (Word16) (L_var1 >> 16);
-#if (WMOPS)
-    multiCounter[currCounter].extract_h++;
-#endif
-    return (var_out);
-}
-/* ------------------------- End of extract_h() ------------------------- */
-
-
-/*___________________________________________________________________________
- |                                                                           |
- |   Function Name : extract_l                                               |
- |                                                                           |
- |   Purpose :                                                               |
- |                                                                           |
- |   Return the 16 LSB of L_var1.                                            |
- |                                                                           |
- |   Complexity weight : 1                                                   |
- |                                                                           |
- |   Inputs :                                                                |
- |                                                                           |
- |    L_var1                                                                 |
- |             32 bit long signed integer (Word32 ) whose value falls in the |
- |             range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.                 |
- |                                                                           |
- |   Outputs :                                                               |
- |                                                                           |
- |    none                                                                   |
- |                                                                           |
- |   Return Value :                                                          |
- |                                                                           |
- |    var_out                                                                |
- |             16 bit short signed integer (Word16) whose value falls in the |
- |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
- |___________________________________________________________________________|
-*/
-Word16 extract_l (Word32 L_var1)
-{
-    Word16 var_out;
-
-    var_out = (Word16) L_var1;
-#if (WMOPS)
-    multiCounter[currCounter].extract_l++;
-#endif
-    return (var_out);
-}
-/* ------------------------- End of extract_l() ------------------------- */
-
-
-/*___________________________________________________________________________
- |                                                                           |
- |   Function Name : round                                                   |
- |                                                                           |
- |   Purpose :                                                               |
- |                                                                           |
- |   Round the lower 16 bits of the 32 bit input number into the MS 16 bits  |
- |   with saturation. Shift the resulting bits right by 16 and return the 16 |
- |   bit number:                                                             |
- |               round(L_var1) = extract_h(L_add(L_var1,32768))              |
- |                                                                           |
- |   Complexity weight : 1                                                   |
- |                                                                           |
- |   Inputs :                                                                |
- |                                                                           |
- |    L_var1                                                                 |
- |             32 bit long signed integer (Word32 ) whose value falls in the |
- |             range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.                 |
- |                                                                           |
- |   Outputs :                                                               |
- |                                                                           |
- |    none                                                                   |
- |                                                                           |
- |   Return Value :                                                          |
- |                                                                           |
- |    var_out                                                                |
- |             16 bit short signed integer (Word16) whose value falls in the |
- |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
- |___________________________________________________________________________|
-*/
-Word16 itu_round (Word32 L_var1)
-{
-    Word16 var_out;
-    Word32 L_rounded;
-
-    L_rounded = L_add (L_var1, (Word32) 0x00008000L);
-#if (WMOPS)
-    multiCounter[currCounter].L_add--;
-#endif
-    var_out = extract_h (L_rounded);
-#if (WMOPS)
-    multiCounter[currCounter].extract_h--;
-    multiCounter[currCounter].round++;
-#endif
-    return (var_out);
-}
-/* ------------------------- End of round() ------------------------- */
-
-
-/*___________________________________________________________________________
- |                                                                           |
- |   Function Name : L_mac                                                   |
- |                                                                           |
- |   Purpose :                                                               |
- |                                                                           |
- |   Multiply var1 by var2 and shift the result left by 1. Add the 32 bit    |
- |   result to L_var3 with saturation, return a 32 bit result:               |
- |        L_mac(L_var3,var1,var2) = L_add(L_var3,L_mult(var1,var2)).         |
- |                                                                           |
- |   Complexity weight : 1                                                   |
- |                                                                           |
- |   Inputs :                                                                |
- |                                                                           |
- |    L_var3   32 bit long signed integer (Word32) whose value falls in the  |
- |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
- |                                                                           |
- |    var1                                                                   |
- |             16 bit short signed integer (Word16) whose value falls in the |
- |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
- |                                                                           |
- |    var2                                                                   |
- |             16 bit short signed integer (Word16) whose value falls in the |
- |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
- |                                                                           |
- |   Outputs :                                                               |
- |                                                                           |
- |    none                                                                   |
- |                                                                           |
- |   Return Value :                                                          |
- |                                                                           |
- |    L_var_out                                                              |
- |             32 bit long signed integer (Word32) whose value falls in the  |
- |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
- |___________________________________________________________________________|
-*/
-Word32 L_mac (Word32 L_var3, Word16 var1, Word16 var2)
-{
-    Word32 L_var_out;
-    Word32 L_product;
-
-    L_product = L_mult (var1, var2);
-#if (WMOPS)
-    multiCounter[currCounter].L_mult--;
-#endif
-    L_var_out = L_add (L_var3, L_product);
-#if (WMOPS)
-    multiCounter[currCounter].L_add--;
-    multiCounter[currCounter].L_mac++;
-#endif
-    return (L_var_out);
-}
-/* ------------------------- End of L_mac() ------------------------- */
-
-
-/*___________________________________________________________________________
- |                                                                           |
  |   Function Name : L_msu                                                   |
  |                                                                           |
  |   Purpose :                                                               |
@@ -839,7 +300,7 @@
 }
 /* ------------------------- End of L_msu() ------------------------- */
 
-
+#if INCLUDE_UNSAFE
 /*___________________________________________________________________________
  |                                                                           |
  |   Function Name : L_macNs                                                 |
@@ -897,9 +358,10 @@
 #endif
     return (L_var_out);
 }
+#endif
 /* ------------------------- End of L_macNs() ------------------------- */
 
-
+#if INCLUDE_UNSAFE
 /*___________________________________________________________________________
  |                                                                           |
  |   Function Name : L_msuNs                                                 |
@@ -957,115 +419,12 @@
 #endif
     return (L_var_out);
 }
+#endif
+
 /* ------------------------- End of L_msuNs() ------------------------- */
 
 
-/*___________________________________________________________________________
- |                                                                           |
- |   Function Name : L_add                                                   |
- |                                                                           |
- |   Purpose :                                                               |
- |                                                                           |
- |   32 bits addition of the two 32 bits variables (L_var1+L_var2) with      |
- |   overflow control and saturation; the result is set at +2147483647 when  |
- |   overflow occurs or at -2147483648 when underflow occurs.                |
- |                                                                           |
- |   Complexity weight : 2                                                   |
- |                                                                           |
- |   Inputs :                                                                |
- |                                                                           |
- |    L_var1   32 bit long signed integer (Word32) whose value falls in the  |
- |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
- |                                                                           |
- |    L_var2   32 bit long signed integer (Word32) whose value falls in the  |
- |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
- |                                                                           |
- |   Outputs :                                                               |
- |                                                                           |
- |    none                                                                   |
- |                                                                           |
- |   Return Value :                                                          |
- |                                                                           |
- |    L_var_out                                                              |
- |             32 bit long signed integer (Word32) whose value falls in the  |
- |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
- |___________________________________________________________________________|
-*/
-Word32 L_add (Word32 L_var1, Word32 L_var2)
-{
-    Word32 L_var_out;
-
-    L_var_out = L_var1 + L_var2;
-
-    if (((L_var1 ^ L_var2) & MIN_32) == 0)
-    {
-        if ((L_var_out ^ L_var1) & MIN_32)
-        {
-            L_var_out = (L_var1 < 0) ? MIN_32 : MAX_32;
-            Overflow = 1;
-        }
-    }
-#if (WMOPS)
-    multiCounter[currCounter].L_add++;
-#endif
-    return (L_var_out);
-}
-/* ------------------------- End of L_add() ------------------------- */
-
-
-/*___________________________________________________________________________
- |                                                                           |
- |   Function Name : L_sub                                                   |
- |                                                                           |
- |   Purpose :                                                               |
- |                                                                           |
- |   32 bits subtraction of the two 32 bits variables (L_var1-L_var2) with   |
- |   overflow control and saturation; the result is set at +2147483647 when  |
- |   overflow occurs or at -2147483648 when underflow occurs.                |
- |                                                                           |
- |   Complexity weight : 2                                                   |
- |                                                                           |
- |   Inputs :                                                                |
- |                                                                           |
- |    L_var1   32 bit long signed integer (Word32) whose value falls in the  |
- |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
- |                                                                           |
- |    L_var2   32 bit long signed integer (Word32) whose value falls in the  |
- |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
- |                                                                           |
- |   Outputs :                                                               |
- |                                                                           |
- |    none                                                                   |
- |                                                                           |
- |   Return Value :                                                          |
- |                                                                           |
- |    L_var_out                                                              |
- |             32 bit long signed integer (Word32) whose value falls in the  |
- |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
- |___________________________________________________________________________|
-*/
-Word32 L_sub (Word32 L_var1, Word32 L_var2)
-{
-    Word32 L_var_out;
-
-    L_var_out = L_var1 - L_var2;
-
-    if (((L_var1 ^ L_var2) & MIN_32) != 0)
-    {
-        if ((L_var_out ^ L_var1) & MIN_32)
-        {
-            L_var_out = (L_var1 < 0L) ? MIN_32 : MAX_32;
-            Overflow = 1;
-        }
-    }
-#if (WMOPS)
-    multiCounter[currCounter].L_sub++;
-#endif
-    return (L_var_out);
-}
-/* ------------------------- End of L_sub() ------------------------- */
-
-
+#if INCLUDE_UNSAFE
 /*___________________________________________________________________________
  |                                                                           |
  |   Function Name : L_add_c                                                 |
@@ -1109,13 +468,13 @@
     Word32 L_test;
     Flag carry_int = 0;
 
-    L_var_out = L_var1 + L_var2 + Carry;
+    L_var_out = L_var1 + L_var2 + GET_CARRY();
 
     L_test = L_var1 + L_var2;
 
     if ((L_var1 > 0) && (L_var2 > 0) && (L_test < 0))
     {
-        Overflow = 1;
+        SET_OVERFLOW(1);
         carry_int = 0;
     }
     else
@@ -1124,12 +483,12 @@
         {
             if (L_test >= 0)
 	    {
-                Overflow = 1;
+                SET_OVERFLOW(1);
                 carry_int = 1;
 	    }
             else
 	    {
-                Overflow = 0;
+                SET_OVERFLOW(0);
                 carry_int = 1;
 	    }
         }
@@ -1137,39 +496,39 @@
         {
             if (((L_var1 ^ L_var2) < 0) && (L_test >= 0))
             {
-                Overflow = 0;
+                SET_OVERFLOW(0);
                 carry_int = 1;
             }
             else
             {
-                Overflow = 0;
+                SET_OVERFLOW(0);
                 carry_int = 0;
             }
         }
     }
 
-    if (Carry)
+    if (GET_CARRY())
     {
         if (L_test == MAX_32)
         {
-            Overflow = 1;
-            Carry = carry_int;
+            SET_OVERFLOW(1);
+            SET_CARRY(carry_int);
         }
         else
         {
             if (L_test == (Word32) 0xFFFFFFFFL)
             {
-                Carry = 1;
+                SET_CARRY(1);
             }
             else
             {
-                Carry = carry_int;
+                SET_CARRY(carry_int);
             }
         }
     }
     else
     {
-        Carry = carry_int;
+        SET_CARRY(carry_int);
     }
 
 #if (WMOPS)
@@ -1177,9 +536,11 @@
 #endif
     return (L_var_out);
 }
+#endif
+
 /* ------------------------- End of L_add_c() ------------------------- */
 
-
+#if INCLUDE_UNSAFE
 /*___________________________________________________________________________
  |                                                                           |
  |   Function Name : L_sub_c                                                 |
@@ -1223,9 +584,9 @@
     Word32 L_test;
     Flag carry_int = 0;
 
-    if (Carry)
+    if (GET_CARRY())
     {
-        Carry = 0;
+        SET_CARRY(0);
         if (L_var2 != MIN_32)
         {
             L_var_out = L_add_c (L_var1, -L_var2);
@@ -1238,8 +599,8 @@
             L_var_out = L_var1 - L_var2;
             if (L_var1 > 0L)
             {
-                Overflow = 1;
-                Carry = 0;
+                SET_OVERFLOW(1);
+                SET_CARRY(0);
             }
         }
     }
@@ -1250,27 +611,27 @@
 
         if ((L_test < 0) && (L_var1 > 0) && (L_var2 < 0))
         {
-            Overflow = 1;
+            SET_OVERFLOW(1);
             carry_int = 0;
         }
         else if ((L_test > 0) && (L_var1 < 0) && (L_var2 > 0))
         {
-            Overflow = 1;
+            SET_OVERFLOW(1);
             carry_int = 1;
         }
         else if ((L_test > 0) && ((L_var1 ^ L_var2) > 0))
         {
-            Overflow = 0;
+            SET_OVERFLOW(0);
             carry_int = 1;
         }
         if (L_test == MIN_32)
         {
-            Overflow = 1;
-            Carry = carry_int;
+            SET_OVERFLOW(1);
+            SET_CARRY(carry_int);
         }
         else
         {
-            Carry = carry_int;
+            SET_CARRY(carry_int);
         }
     }
 
@@ -1279,6 +640,7 @@
 #endif
     return (L_var_out);
 }
+#endif
 /* ------------------------- End of L_sub_c() ------------------------- */
 
 
@@ -1378,154 +740,6 @@
 /* ------------------------- End of mult_r() ------------------------- */
 
 
-/*___________________________________________________________________________
- |                                                                           |
- |   Function Name : L_shl                                                   |
- |                                                                           |
- |   Purpose :                                                               |
- |                                                                           |
- |   Arithmetically shift the 32 bit input L_var1 left var2 positions. Zero  |
- |   fill the var2 LSB of the result. If var2 is negative, arithmetically    |
- |   shift L_var1 right by -var2 with sign extension. Saturate the result in |
- |   case of underflows or overflows.                                        |
- |                                                                           |
- |   Complexity weight : 2                                                   |
- |                                                                           |
- |   Inputs :                                                                |
- |                                                                           |
- |    L_var1   32 bit long signed integer (Word32) whose value falls in the  |
- |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
- |                                                                           |
- |    var2                                                                   |
- |             16 bit short signed integer (Word16) whose value falls in the |
- |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
- |                                                                           |
- |   Outputs :                                                               |
- |                                                                           |
- |    none                                                                   |
- |                                                                           |
- |   Return Value :                                                          |
- |                                                                           |
- |    L_var_out                                                              |
- |             32 bit long signed integer (Word32) whose value falls in the  |
- |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
- |___________________________________________________________________________|
-*/
-Word32 L_shl (Word32 L_var1, Word16 var2)
-{
-    Word32 L_var_out;
-
-    if (var2 <= 0)
-    {
-        if (var2 < -32)
-            var2 = -32;
-        L_var_out = L_shr (L_var1, (Word16) -var2);
-#if (WMOPS)
-        multiCounter[currCounter].L_shr--;
-#endif
-    }
-    else
-    {
-        for (; var2 > 0; var2--)
-        {
-            if (L_var1 > (Word32) 0X3fffffffL)
-            {
-                Overflow = 1;
-                L_var_out = MAX_32;
-                break;
-            }
-            else
-            {
-                if (L_var1 < (Word32) 0xc0000000L)
-                {
-                    Overflow = 1;
-                    L_var_out = MIN_32;
-                    break;
-                }
-            }
-            L_var1 *= 2;
-            L_var_out = L_var1;
-        }
-    }
-#if (WMOPS)
-    multiCounter[currCounter].L_shl++;
-#endif
-    return (L_var_out);
-}
-/* ------------------------- End of L_shl() ------------------------- */
-
-
-/*___________________________________________________________________________
- |                                                                           |
- |   Function Name : L_shr                                                   |
- |                                                                           |
- |   Purpose :                                                               |
- |                                                                           |
- |   Arithmetically shift the 32 bit input L_var1 right var2 positions with  |
- |   sign extension. If var2 is negative, arithmetically shift L_var1 left   |
- |   by -var2 and zero fill the -var2 LSB of the result. Saturate the result |
- |   in case of underflows or overflows.                                     |
- |                                                                           |
- |   Complexity weight : 2                                                   |
- |                                                                           |
- |   Inputs :                                                                |
- |                                                                           |
- |    L_var1   32 bit long signed integer (Word32) whose value falls in the  |
- |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
- |                                                                           |
- |    var2                                                                   |
- |             16 bit short signed integer (Word16) whose value falls in the |
- |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
- |                                                                           |
- |   Outputs :                                                               |
- |                                                                           |
- |    none                                                                   |
- |                                                                           |
- |   Return Value :                                                          |
- |                                                                           |
- |    L_var_out                                                              |
- |             32 bit long signed integer (Word32) whose value falls in the  |
- |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
- |___________________________________________________________________________|
-*/
-Word32 L_shr (Word32 L_var1, Word16 var2)
-{
-    Word32 L_var_out;
-
-    if (var2 < 0)
-    {
-        if (var2 < -32)
-            var2 = -32;
-        L_var_out = L_shl (L_var1, (Word16) -var2);
-#if (WMOPS)
-        multiCounter[currCounter].L_shl--;
-#endif
-    }
-    else
-    {
-        if (var2 >= 31)
-        {
-            L_var_out = (L_var1 < 0L) ? -1 : 0;
-        }
-        else
-        {
-            if (L_var1 < 0)
-            {
-                L_var_out = ~((~L_var1) >> var2);
-            }
-            else
-            {
-                L_var_out = L_var1 >> var2;
-            }
-        }
-    }
-#if (WMOPS)
-    multiCounter[currCounter].L_shr++;
-#endif
-    return (L_var_out);
-}
-/* ------------------------- End of L_shr() ------------------------- */
-
 
 /*___________________________________________________________________________
  |                                                                           |
@@ -1930,65 +1144,6 @@
 
 /*___________________________________________________________________________
  |                                                                           |
- |   Function Name : L_sat                                                   |
- |                                                                           |
- |   Purpose :                                                               |
- |                                                                           |
- |    32 bit L_var1 is set to 2147483647 if an overflow occured or to        |
- |    -2147483648 if an underflow occured on the most recent L_add_c,        |
- |    L_sub_c, L_macNs or L_msuNs operations. The carry and overflow values  |
- |    are binary values which can be tested and assigned values.             |
- |                                                                           |
- |   Complexity weight : 4                                                   |
- |                                                                           |
- |   Inputs :                                                                |
- |                                                                           |
- |    L_var1                                                                 |
- |             32 bit long signed integer (Word32) whose value falls in the  |
- |             range : 0x8000 0000 <= var1 <= 0x7fff ffff.                   |
- |                                                                           |
- |   Outputs :                                                               |
- |                                                                           |
- |    none                                                                   |
- |                                                                           |
- |   Return Value :                                                          |
- |                                                                           |
- |    L_var_out                                                              |
- |             32 bit long signed integer (Word32) whose value falls in the  |
- |             range : 0x8000 0000 <= var_out <= 0x7fff ffff.                |
- |___________________________________________________________________________|
-*/
-Word32 L_sat (Word32 L_var1)
-{
-    Word32 L_var_out;
-
-    L_var_out = L_var1;
-
-    if (Overflow)
-    {
-
-        if (Carry)
-        {
-            L_var_out = MIN_32;
-        }
-        else
-        {
-            L_var_out = MAX_32;
-        }
-
-        Carry = 0;
-        Overflow = 0;
-    }
-#if (WMOPS)
-    multiCounter[currCounter].L_sat++;
-#endif
-    return (L_var_out);
-}
-/* ------------------------- End of L_sat() ------------------------- */
-
-
-/*___________________________________________________________________________
- |                                                                           |
  |   Function Name : norm_s                                                  |
  |                                                                           |
  |   Purpose :                                                               |
@@ -2275,7 +1430,7 @@
 
    Temp = Lv & (Word32) 0x0000ffff ;
    Temp = Temp * (Word32) v ;
-   Temp = L_shr( Temp, (Word16) 15 ) ;
+   Temp = L_shr_nocheck( Temp, (Word16) 15 ) ;
    Temp = L_mac( Temp, v, extract_h(Lv) ) ;
 
 #if (WMOPS)
@@ -2357,14 +1512,14 @@
         return MAX_16 ;
     }
     else {
-        L_num = L_shr(L_num, (Word16)1) ;
-        L_den = L_shr(L_den, (Word16)1);
+        L_num = L_shr_nocheck(L_num, (Word16)1) ;
+        L_den = L_shr_nocheck(L_den, (Word16)1);
 #if (WMOPS)
         multiCounter[currCounter].L_shr-=2;
 #endif
         for(iteration=(Word16)0; iteration< (Word16)15;iteration++) {
-            var_out = shl( var_out, (Word16)1);
-            L_num   = L_shl( L_num, (Word16)1);
+            var_out = shl_nocheck( var_out, (Word16)1);
+            L_num   = L_shl_nocheck( L_num, (Word16)1);
 #if (WMOPS)
             multiCounter[currCounter].shl--;
             multiCounter[currCounter].L_shl--;
@@ -2628,7 +1783,7 @@
         {
             if (L_var1 > (UWord32) 0X7fffffffL)
             {
-                Overflow = 1;
+                SET_OVERFLOW(1);
                 L_var_out = UMAX_32;
                 break;
             }
@@ -2636,7 +1791,7 @@
             {
                 if (L_var1 < (UWord32) 0x00000001L)
                 {
-                    Overflow = 1;
+                    SET_OVERFLOW(1);
                     L_var_out = MIN_32;
                     break;
                 }
diff --git a/third_party/g7221/common/stl-files/basop32.h b/third_party/g7221/common/stl-files/basop32.h
index 308f8d3..14da776 100644
--- a/third_party/g7221/common/stl-files/basop32.h
+++ b/third_party/g7221/common/stl-files/basop32.h
@@ -33,7 +33,7 @@
 #define MIN_32 (Word32)0x80000000L
 
 #define MAX_16 (Word16)0x7fff
-#define MIN_16 (Word16)0x8000
+#define MIN_16 ((Word16)0x8000)
 
 #define UMAX_32 (Word32)0xffffffffL
 #define UMIN_32 (Word32)0x00000000L
@@ -44,31 +44,33 @@
  |___________________________________________________________________________|
 */
 
-Word16 add (Word16 var1, Word16 var2);    /* Short add,           1   */
-Word16 sub (Word16 var1, Word16 var2);    /* Short sub,           1   */
-Word16 abs_s (Word16 var1);               /* Short abs,           1   */
+PJ_INLINE(Word16) add (Word16 var1, Word16 var2);    /* Short add,           1   */
+PJ_INLINE(Word16) sub (Word16 var1, Word16 var2);    /* Short sub,           1   */
+PJ_INLINE(Word16) abs_s (Word16 var1);               /* Short abs,           1   */
 Word16 shl (Word16 var1, Word16 var2);    /* Short shift left,    1   */
+PJ_INLINE(Word16) shl_nocheck(Word16 var1, Word16 var2);
 Word16 shr (Word16 var1, Word16 var2);    /* Short shift right,   1   */
+PJ_INLINE(Word16) shr_nocheck(Word16 var1, Word16 var2);
 Word16 mult (Word16 var1, Word16 var2);   /* Short mult,          1   */
-Word32 L_mult (Word16 var1, Word16 var2); /* Long mult,           1   */
-Word16 negate (Word16 var1);              /* Short negate,        1   */
-Word16 extract_h (Word32 L_var1);         /* Extract high,        1   */
-Word16 extract_l (Word32 L_var1);         /* Extract low,         1   */
-Word16 itu_round (Word32 L_var1);         /* Round,               1   */
-Word32 L_mac (Word32 L_var3, Word16 var1, Word16 var2);   /* Mac,  1  */
+PJ_INLINE(Word32) L_mult (Word16 var1, Word16 var2); /* Long mult,           1   */
+PJ_INLINE(Word16) negate (Word16 var1);              /* Short negate,        1   */
+PJ_INLINE(Word16) extract_h (Word32 L_var1);         /* Extract high,        1   */
+PJ_INLINE(Word16) extract_l (Word32 L_var1);         /* Extract low,         1   */
+PJ_INLINE(Word16) itu_round (Word32 L_var1);         /* Round,               1   */
+PJ_INLINE(Word32) L_mac (Word32 L_var3, Word16 var1, Word16 var2);   /* Mac,  1  */
 Word32 L_msu (Word32 L_var3, Word16 var1, Word16 var2);   /* Msu,  1  */
 Word32 L_macNs (Word32 L_var3, Word16 var1, Word16 var2); /* Mac without
                                                              sat, 1   */
 Word32 L_msuNs (Word32 L_var3, Word16 var1, Word16 var2); /* Msu without
                                                              sat, 1   */
-Word32 L_add (Word32 L_var1, Word32 L_var2);    /* Long add,        2 */
-Word32 L_sub (Word32 L_var1, Word32 L_var2);    /* Long sub,        2 */
+//PJ_INLINE(Word32) L_add (Word32 L_var1, Word32 L_var2);    /* Long add,        2 */
+PJ_INLINE(Word32) L_sub (Word32 L_var1, Word32 L_var2);    /* Long sub,        2 */
 Word32 L_add_c (Word32 L_var1, Word32 L_var2);  /* Long add with c, 2 */
 Word32 L_sub_c (Word32 L_var1, Word32 L_var2);  /* Long sub with c, 2 */
 Word32 L_negate (Word32 L_var1);                /* Long negate,     2 */
 Word16 mult_r (Word16 var1, Word16 var2);       /* Mult with round, 2 */
-Word32 L_shl (Word32 L_var1, Word16 var2);      /* Long shift left, 2 */
-Word32 L_shr (Word32 L_var1, Word16 var2);      /* Long shift right, 2*/
+PJ_INLINE(Word32) L_shl (Word32 L_var1, Word16 var2);      /* Long shift left, 2 */
+PJ_INLINE(Word32) L_shr (Word32 L_var1, Word16 var2);      /* Long shift right, 2*/
 Word16 shr_r (Word16 var1, Word16 var2);        /* Shift right with
                                                    round, 2           */
 Word16 mac_r (Word32 L_var3, Word16 var1, Word16 var2); /* Mac with
@@ -105,6 +107,29 @@
 */
 UWord32 LU_shl (UWord32 L_var1, Word16 var2);
 UWord32 LU_shr (UWord32 L_var1, Word16 var2);
+
+#define INCLUDE_UNSAFE	    0
+
+/* Local */
+PJ_INLINE(Word16) saturate (Word32 L_var1);
+
+#if INCLUDE_UNSAFE
+    extern Flag g7221_Overflow;
+    extern Flag g7221_Carry;
+#   define SET_OVERFLOW(n)  g7221_Overflow = n
+#   define SET_CARRY(n)	    g7221_Carry = n
+
+#else
+#   define SET_OVERFLOW(n)
+#   define SET_CARRY(n)
+#   define GET_OVERFLOW()   0
+#   define GET_CARRY()	    0
+#endif
+
+#include "basop32_i.h"
+
+
+
 #endif /* BASOP_H_DEFINED */
 
 
diff --git a/third_party/g7221/common/stl-files/basop32_i.h b/third_party/g7221/common/stl-files/basop32_i.h
new file mode 100644
index 0000000..ca61ed0
--- /dev/null
+++ b/third_party/g7221/common/stl-files/basop32_i.h
@@ -0,0 +1,730 @@
+/*___________________________________________________________________________
+ |                                                                           |
+ |   Function Name : extract_h                                               |
+ |                                                                           |
+ |   Purpose :                                                               |
+ |                                                                           |
+ |   Return the 16 MSB of L_var1.                                            |
+ |                                                                           |
+ |   Complexity weight : 1                                                   |
+ |                                                                           |
+ |   Inputs :                                                                |
+ |                                                                           |
+ |    L_var1                                                                 |
+ |             32 bit long signed integer (Word32 ) whose value falls in the |
+ |             range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.                 |
+ |                                                                           |
+ |   Outputs :                                                               |
+ |                                                                           |
+ |    none                                                                   |
+ |                                                                           |
+ |   Return Value :                                                          |
+ |                                                                           |
+ |    var_out                                                                |
+ |             16 bit short signed integer (Word16) whose value falls in the |
+ |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
+ |___________________________________________________________________________|
+*/
+PJ_INLINE(Word16) extract_h (Word32 L_var1)
+{
+    return (Word16) (L_var1 >> 16);
+}
+/* ------------------------- End of extract_h() ------------------------- */
+
+
+/*___________________________________________________________________________
+ |                                                                           |
+ |   Function Name : extract_l                                               |
+ |                                                                           |
+ |   Purpose :                                                               |
+ |                                                                           |
+ |   Return the 16 LSB of L_var1.                                            |
+ |                                                                           |
+ |   Complexity weight : 1                                                   |
+ |                                                                           |
+ |   Inputs :                                                                |
+ |                                                                           |
+ |    L_var1                                                                 |
+ |             32 bit long signed integer (Word32 ) whose value falls in the |
+ |             range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.                 |
+ |                                                                           |
+ |   Outputs :                                                               |
+ |                                                                           |
+ |    none                                                                   |
+ |                                                                           |
+ |   Return Value :                                                          |
+ |                                                                           |
+ |    var_out                                                                |
+ |             16 bit short signed integer (Word16) whose value falls in the |
+ |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
+ |___________________________________________________________________________|
+*/
+PJ_INLINE(Word16) extract_l (Word32 L_var1)
+{
+    return (Word16) L_var1;
+}
+
+/* ------------------------- End of extract_l() ------------------------- */
+
+
+/*___________________________________________________________________________
+ |                                                                           |
+ |   Function Name : saturate                                                |
+ |                                                                           |
+ |   Purpose :                                                               |
+ |                                                                           |
+ |    Limit the 32 bit input to the range of a 16 bit word.                  |
+ |                                                                           |
+ |   Inputs :                                                                |
+ |                                                                           |
+ |    L_var1                                                                 |
+ |             32 bit long signed integer (Word32) whose value falls in the  |
+ |             range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.                 |
+ |                                                                           |
+ |   Outputs :                                                               |
+ |                                                                           |
+ |    none                                                                   |
+ |                                                                           |
+ |   Return Value :                                                          |
+ |                                                                           |
+ |    var_out                                                                |
+ |             16 bit short signed integer (Word16) whose value falls in the |
+ |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
+ |___________________________________________________________________________|
+*/
+PJ_INLINE(Word16) saturate (Word32 L_var1)
+{
+    Word16 val16 = (Word16) L_var1;
+
+    if (val16 == L_var1)
+	return val16;
+
+    if (val16 > MAX_16)
+        return MAX_16;
+    return MIN_16;
+}
+/* ------------------------- End of saturate() ------------------------- */
+
+
+#if PJ_HAS_INT64
+PJ_INLINE(Word32) L_saturate (pj_int64_t LL_var1)
+{
+    pj_int32_t L_var1 = (pj_int32_t)LL_var1;
+    if (LL_var1 == L_var1)
+	return L_var1;
+    else if (LL_var1 > MAX_32)
+	return MAX_32;
+    else
+	return MIN_32;
+}
+#endif
+
+
+/*___________________________________________________________________________
+ |                                                                           |
+ |   Function Name : add                                                     |
+ |                                                                           |
+ |   Purpose :                                                               |
+ |                                                                           |
+ |    Performs the addition (var1+var2) with overflow control and saturation;|
+ |    the 16 bit result is set at +32767 when overflow occurs or at -32768   |
+ |    when underflow occurs.                                                 |
+ |                                                                           |
+ |   Complexity weight : 1                                                   |
+ |                                                                           |
+ |   Inputs :                                                                |
+ |                                                                           |
+ |    var1                                                                   |
+ |             16 bit short signed integer (Word16) whose value falls in the |
+ |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
+ |                                                                           |
+ |    var2                                                                   |
+ |             16 bit short signed integer (Word16) whose value falls in the |
+ |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
+ |                                                                           |
+ |   Outputs :                                                               |
+ |                                                                           |
+ |    none                                                                   |
+ |                                                                           |
+ |   Return Value :                                                          |
+ |                                                                           |
+ |    var_out                                                                |
+ |             16 bit short signed integer (Word16) whose value falls in the |
+ |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
+ |___________________________________________________________________________|
+*/
+PJ_INLINE(Word16) add (Word16 var1, Word16 var2)
+{
+    return saturate (var1 + var2);
+}
+/* ------------------------- End of add() ------------------------- */
+
+
+/*___________________________________________________________________________
+ |                                                                           |
+ |   Function Name : sub                                                     |
+ |                                                                           |
+ |   Purpose :                                                               |
+ |                                                                           |
+ |    Performs the subtraction (var1+var2) with overflow control and satu-   |
+ |    ration; the 16 bit result is set at +32767 when overflow occurs or at  |
+ |    -32768 when underflow occurs.                                          |
+ |                                                                           |
+ |   Complexity weight : 1                                                   |
+ |                                                                           |
+ |   Inputs :                                                                |
+ |                                                                           |
+ |    var1                                                                   |
+ |             16 bit short signed integer (Word16) whose value falls in the |
+ |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
+ |                                                                           |
+ |    var2                                                                   |
+ |             16 bit short signed integer (Word16) whose value falls in the |
+ |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
+ |                                                                           |
+ |   Outputs :                                                               |
+ |                                                                           |
+ |    none                                                                   |
+ |                                                                           |
+ |   Return Value :                                                          |
+ |                                                                           |
+ |    var_out                                                                |
+ |             16 bit short signed integer (Word16) whose value falls in the |
+ |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
+ |___________________________________________________________________________|
+*/
+PJ_INLINE(Word16) sub (Word16 var1, Word16 var2)
+{
+    return saturate ((Word32) var1 - var2);
+}
+/* ------------------------- End of sub() ------------------------- */
+
+
+/*___________________________________________________________________________
+ |                                                                           |
+ |   Function Name : negate                                                  |
+ |                                                                           |
+ |   Purpose :                                                               |
+ |                                                                           |
+ |   Negate var1 with saturation, saturate in the case where input is -32768:|
+ |                negate(var1) = sub(0,var1).                                |
+ |                                                                           |
+ |   Complexity weight : 1                                                   |
+ |                                                                           |
+ |   Inputs :                                                                |
+ |                                                                           |
+ |    var1                                                                   |
+ |             16 bit short signed integer (Word16) whose value falls in the |
+ |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
+ |                                                                           |
+ |   Outputs :                                                               |
+ |                                                                           |
+ |    none                                                                   |
+ |                                                                           |
+ |   Return Value :                                                          |
+ |                                                                           |
+ |    var_out                                                                |
+ |             16 bit short signed integer (Word16) whose value falls in the |
+ |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
+ |___________________________________________________________________________|
+*/
+PJ_INLINE(Word16) negate (Word16 var1)
+{
+    return (Word16)((var1 == MIN_16) ? MAX_16 : -var1);
+}
+/* ------------------------- End of negate() ------------------------- */
+
+
+
+
+/*___________________________________________________________________________
+ |                                                                           |
+ |   Function Name : L_add                                                   |
+ |                                                                           |
+ |   Purpose :                                                               |
+ |                                                                           |
+ |   32 bits addition of the two 32 bits variables (L_var1+L_var2) with      |
+ |   overflow control and saturation; the result is set at +2147483647 when  |
+ |   overflow occurs or at -2147483648 when underflow occurs.                |
+ |                                                                           |
+ |   Complexity weight : 2                                                   |
+ |                                                                           |
+ |   Inputs :                                                                |
+ |                                                                           |
+ |    L_var1   32 bit long signed integer (Word32) whose value falls in the  |
+ |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
+ |                                                                           |
+ |    L_var2   32 bit long signed integer (Word32) whose value falls in the  |
+ |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
+ |                                                                           |
+ |   Outputs :                                                               |
+ |                                                                           |
+ |    none                                                                   |
+ |                                                                           |
+ |   Return Value :                                                          |
+ |                                                                           |
+ |    L_var_out                                                              |
+ |             32 bit long signed integer (Word32) whose value falls in the  |
+ |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
+ |___________________________________________________________________________|
+*/
+PJ_INLINE(Word32) L_add (Word32 L_var1, Word32 L_var2)
+{
+#if PJ_HAS_INT64
+    return L_saturate(((pj_int64_t)L_var1) + L_var2);
+#else
+    Word32 L_var_out;
+
+    L_var_out = L_var1 + L_var2;
+
+    if (((L_var1 ^ L_var2) & MIN_32) == 0)
+    {
+        if ((L_var_out ^ L_var1) & MIN_32)
+        {
+            SET_OVERFLOW(1);
+            L_var_out = (L_var1 < 0) ? MIN_32 : MAX_32;
+        }
+    }
+    return (L_var_out);
+#endif
+}
+
+/* ------------------------- End of L_add() ------------------------- */
+
+
+
+
+/*___________________________________________________________________________
+ |                                                                           |
+ |   Function Name : L_sub                                                   |
+ |                                                                           |
+ |   Purpose :                                                               |
+ |                                                                           |
+ |   32 bits subtraction of the two 32 bits variables (L_var1-L_var2) with   |
+ |   overflow control and saturation; the result is set at +2147483647 when  |
+ |   overflow occurs or at -2147483648 when underflow occurs.                |
+ |                                                                           |
+ |   Complexity weight : 2                                                   |
+ |                                                                           |
+ |   Inputs :                                                                |
+ |                                                                           |
+ |    L_var1   32 bit long signed integer (Word32) whose value falls in the  |
+ |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
+ |                                                                           |
+ |    L_var2   32 bit long signed integer (Word32) whose value falls in the  |
+ |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
+ |                                                                           |
+ |   Outputs :                                                               |
+ |                                                                           |
+ |    none                                                                   |
+ |                                                                           |
+ |   Return Value :                                                          |
+ |                                                                           |
+ |    L_var_out                                                              |
+ |             32 bit long signed integer (Word32) whose value falls in the  |
+ |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
+ |___________________________________________________________________________|
+*/
+PJ_INLINE(Word32) L_sub (Word32 L_var1, Word32 L_var2)
+{
+#if PJ_HAS_INT64
+    return L_saturate((pj_int64_t)L_var1 - L_var2);
+#else
+    Word32 L_var_out;
+
+    L_var_out = L_var1 - L_var2;
+
+    if (((L_var1 ^ L_var2) & MIN_32) != 0)
+    {
+        if ((L_var_out ^ L_var1) & MIN_32)
+        {
+            L_var_out = (L_var1 < 0L) ? MIN_32 : MAX_32;
+            SET_OVERFLOW(1);
+        }
+    }
+    return (L_var_out);
+#endif
+}
+/* ------------------------- End of L_sub() ------------------------- */
+
+/*___________________________________________________________________________
+ |                                                                           |
+ |   Function Name : L_mult                                                  |
+ |                                                                           |
+ |   Purpose :                                                               |
+ |                                                                           |
+ |   L_mult is the 32 bit result of the multiplication of var1 times var2    |
+ |   with one shift left i.e.:                                               |
+ |        L_mult(var1,var2) = L_shl((var1 times var2),1) and                 |
+ |        L_mult(-32768,-32768) = 2147483647.                                |
+ |                                                                           |
+ |   Complexity weight : 1                                                   |
+ |                                                                           |
+ |   Inputs :                                                                |
+ |                                                                           |
+ |    var1                                                                   |
+ |             16 bit short signed integer (Word16) whose value falls in the |
+ |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
+ |                                                                           |
+ |    var2                                                                   |
+ |             16 bit short signed integer (Word16) whose value falls in the |
+ |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
+ |                                                                           |
+ |   Outputs :                                                               |
+ |                                                                           |
+ |    none                                                                   |
+ |                                                                           |
+ |   Return Value :                                                          |
+ |                                                                           |
+ |    L_var_out                                                              |
+ |             32 bit long signed integer (Word32) whose value falls in the  |
+ |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
+ |___________________________________________________________________________|
+*/
+PJ_INLINE(Word32) L_mult (Word16 var1, Word16 var2)
+{
+    Word32 L_var_out;
+
+    L_var_out = (Word32) var1 *(Word32) var2;
+
+    if (L_var_out != (Word32) 0x40000000L)
+    {
+        return L_var_out << 1;
+    }
+    else
+    {
+        SET_OVERFLOW(1);
+        return MAX_32;
+    }
+}
+/* ------------------------- End of L_mult() ------------------------- */
+
+
+/*___________________________________________________________________________
+ |                                                                           |
+ |   Function Name : L_mac                                                   |
+ |                                                                           |
+ |   Purpose :                                                               |
+ |                                                                           |
+ |   Multiply var1 by var2 and shift the result left by 1. Add the 32 bit    |
+ |   result to L_var3 with saturation, return a 32 bit result:               |
+ |        L_mac(L_var3,var1,var2) = L_add(L_var3,L_mult(var1,var2)).         |
+ |                                                                           |
+ |   Complexity weight : 1                                                   |
+ |                                                                           |
+ |   Inputs :                                                                |
+ |                                                                           |
+ |    L_var3   32 bit long signed integer (Word32) whose value falls in the  |
+ |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
+ |                                                                           |
+ |    var1                                                                   |
+ |             16 bit short signed integer (Word16) whose value falls in the |
+ |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
+ |                                                                           |
+ |    var2                                                                   |
+ |             16 bit short signed integer (Word16) whose value falls in the |
+ |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
+ |                                                                           |
+ |   Outputs :                                                               |
+ |                                                                           |
+ |    none                                                                   |
+ |                                                                           |
+ |   Return Value :                                                          |
+ |                                                                           |
+ |    L_var_out                                                              |
+ |             32 bit long signed integer (Word32) whose value falls in the  |
+ |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
+ |___________________________________________________________________________|
+*/
+PJ_INLINE(Word32) L_mac (Word32 L_var3, Word16 var1, Word16 var2)
+{
+    return L_add (L_var3, L_mult (var1, var2));
+}
+/* ------------------------- End of L_mac() ------------------------- */
+
+
+/*___________________________________________________________________________
+ |                                                                           |
+ |   Function Name : round                                                   |
+ |                                                                           |
+ |   Purpose :                                                               |
+ |                                                                           |
+ |   Round the lower 16 bits of the 32 bit input number into the MS 16 bits  |
+ |   with saturation. Shift the resulting bits right by 16 and return the 16 |
+ |   bit number:                                                             |
+ |               round(L_var1) = extract_h(L_add(L_var1,32768))              |
+ |                                                                           |
+ |   Complexity weight : 1                                                   |
+ |                                                                           |
+ |   Inputs :                                                                |
+ |                                                                           |
+ |    L_var1                                                                 |
+ |             32 bit long signed integer (Word32 ) whose value falls in the |
+ |             range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.                 |
+ |                                                                           |
+ |   Outputs :                                                               |
+ |                                                                           |
+ |    none                                                                   |
+ |                                                                           |
+ |   Return Value :                                                          |
+ |                                                                           |
+ |    var_out                                                                |
+ |             16 bit short signed integer (Word16) whose value falls in the |
+ |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
+ |___________________________________________________________________________|
+*/
+PJ_INLINE(Word16) itu_round (Word32 L_var1)
+{
+    return extract_h (L_add (L_var1, (Word32) 0x00008000L));
+}
+/* ------------------------- End of round() ------------------------- */
+
+
+/*___________________________________________________________________________
+ |                                                                           |
+ |   Function Name : L_shr                                                   |
+ |                                                                           |
+ |   Purpose :                                                               |
+ |                                                                           |
+ |   Arithmetically shift the 32 bit input L_var1 right var2 positions with  |
+ |   sign extension. If var2 is negative, arithmetically shift L_var1 left   |
+ |   by -var2 and zero fill the -var2 LSB of the result. Saturate the result |
+ |   in case of underflows or overflows.                                     |
+ |                                                                           |
+ |   Complexity weight : 2                                                   |
+ |                                                                           |
+ |   Inputs :                                                                |
+ |                                                                           |
+ |    L_var1   32 bit long signed integer (Word32) whose value falls in the  |
+ |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
+ |                                                                           |
+ |    var2                                                                   |
+ |             16 bit short signed integer (Word16) whose value falls in the |
+ |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
+ |                                                                           |
+ |   Outputs :                                                               |
+ |                                                                           |
+ |    none                                                                   |
+ |                                                                           |
+ |   Return Value :                                                          |
+ |                                                                           |
+ |    L_var_out                                                              |
+ |             32 bit long signed integer (Word32) whose value falls in the  |
+ |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
+ |___________________________________________________________________________|
+*/
+PJ_INLINE(Word32) L_shr_nocheck(Word32 L_var1, Word16 var2)
+{
+#if 1
+    return L_var1 >> var2;
+#else
+    if (var2 >= 31)
+    {
+        return (L_var1 < 0L) ? -1 : 0;
+    }
+    else
+    {
+        if (L_var1 < 0)
+        {
+            return ~((~L_var1) >> var2);
+        }
+        else
+        {
+            return L_var1 >> var2;
+        }
+    }
+#endif
+}
+
+PJ_INLINE(Word32) L_shl_nocheck (Word32 L_var1, Word16 var2)
+{
+#if PJ_HAS_INT64
+    return L_saturate( ((pj_int64_t)L_var1) << var2 );
+#else
+    for (; var2 > 0; var2--)
+    {
+        if (L_var1 > (Word32) 0X3fffffffL)
+        {
+            SET_OVERFLOW(1);
+            return MAX_32;
+        }
+        else
+        {
+            if (L_var1 < (Word32) 0xc0000000L)
+            {
+                SET_OVERFLOW(1);
+                return MIN_32;
+            }
+        }
+        L_var1 <<= 1;
+    }
+    return (L_var1);
+#endif
+}
+
+PJ_INLINE(Word32) L_shr (Word32 L_var1, Word16 var2)
+{
+    if (var2 < 0)
+    {
+        if (var2 < -32)
+            var2 = -32;
+        return L_shl_nocheck (L_var1, (Word16) -var2);
+    }
+    else
+    {
+	return L_shr_nocheck(L_var1, var2);
+    }
+}
+/* ------------------------- End of L_shr() ------------------------- */
+
+/*___________________________________________________________________________
+ |                                                                           |
+ |   Function Name : L_shl                                                   |
+ |                                                                           |
+ |   Purpose :                                                               |
+ |                                                                           |
+ |   Arithmetically shift the 32 bit input L_var1 left var2 positions. Zero  |
+ |   fill the var2 LSB of the result. If var2 is negative, arithmetically    |
+ |   shift L_var1 right by -var2 with sign extension. Saturate the result in |
+ |   case of underflows or overflows.                                        |
+ |                                                                           |
+ |   Complexity weight : 2                                                   |
+ |                                                                           |
+ |   Inputs :                                                                |
+ |                                                                           |
+ |    L_var1   32 bit long signed integer (Word32) whose value falls in the  |
+ |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
+ |                                                                           |
+ |    var2                                                                   |
+ |             16 bit short signed integer (Word16) whose value falls in the |
+ |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
+ |                                                                           |
+ |   Outputs :                                                               |
+ |                                                                           |
+ |    none                                                                   |
+ |                                                                           |
+ |   Return Value :                                                          |
+ |                                                                           |
+ |    L_var_out                                                              |
+ |             32 bit long signed integer (Word32) whose value falls in the  |
+ |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
+ |___________________________________________________________________________|
+*/
+PJ_INLINE(Word32) L_shl (Word32 L_var1, Word16 var2)
+{
+    if (var2 <= 0)
+    {
+        if (var2 < -32)
+            var2 = -32;
+        return L_shr_nocheck(L_var1, (Word16) -var2);
+    }
+    else
+    {
+	return L_shl_nocheck(L_var1, var2);
+    }
+}
+/* ------------------------- End of L_shl() ------------------------- */
+
+
+/*___________________________________________________________________________
+ |                                                                           |
+ |   Function Name : abs_s                                                   |
+ |                                                                           |
+ |   Purpose :                                                               |
+ |                                                                           |
+ |    Absolute value of var1; abs_s(-32768) = 32767.                         |
+ |                                                                           |
+ |   Complexity weight : 1                                                   |
+ |                                                                           |
+ |   Inputs :                                                                |
+ |                                                                           |
+ |    var1                                                                   |
+ |             16 bit short signed integer (Word16) whose value falls in the |
+ |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
+ |                                                                           |
+ |   Outputs :                                                               |
+ |                                                                           |
+ |    none                                                                   |
+ |                                                                           |
+ |   Return Value :                                                          |
+ |                                                                           |
+ |    var_out                                                                |
+ |             16 bit short signed integer (Word16) whose value falls in the |
+ |             range : 0x0000 0000 <= var_out <= 0x0000 7fff.                |
+ |___________________________________________________________________________|
+*/
+PJ_INLINE(Word16) abs_s (Word16 var1)
+{
+#if 1
+    if (var1 >= 0)
+    	return var1;
+    else if (var1 == (Word16)0x8000)
+ 	return MAX_16;
+    else
+    	return (Word16)-var1;
+#else
+    if (var1 == (Word16) 0x8000)
+    {
+        return MAX_16;
+    }
+    else
+    {
+        if (var1 < 0)
+        {
+            return (Word16)-var1;
+        }
+        else
+        {
+            return var1;
+        }
+    }
+#endif
+}
+/* ------------------------- End of abs_s() ------------------------- */
+
+
+PJ_INLINE(Word16) shl_nocheck(Word16 var1, Word16 var2)
+{
+#if 1
+    /* blp: this should be more optimized */
+    return saturate (((Word32)var1) << var2);
+#else
+    /* Original algorithm */
+    Word32 result = (Word32) var1 *((Word32) 1 << var2);
+
+    if ((var2 > 15 && var1 != 0) || (result != (Word32) ((Word16) result)))
+    {
+        SET_OVERFLOW(1);
+        return (Word16) ((var1 > 0) ? MAX_16 : MIN_16);
+    }
+    else
+    {
+        return extract_l (result);
+    }
+#endif
+}
+
+PJ_INLINE(Word16) shr_nocheck(Word16 var1, Word16 var2)
+{
+#if 1
+    /* blp: this should yield the same value */
+    return (Word16) (var1 >> var2);
+#else
+    /* Original algorithm */
+    if (var2 >= 15)
+    {
+        return (Word16)((var1 < 0) ? -1 : 0);
+    }
+    else
+    {
+        if (var1 < 0)
+        {
+            return (Word16) (~((~var1) >> var2));
+        }
+        else
+        {
+            return (Word16)(var1 >> var2);
+        }
+    }
+#endif
+}
diff --git a/third_party/g7221/common/stl-files/count.c b/third_party/g7221/common/stl-files/count.c
deleted file mode 100644
index 17ce4b3..0000000
--- a/third_party/g7221/common/stl-files/count.c
+++ /dev/null
@@ -1,303 +0,0 @@
-/*
- ***************************************************************************
- *
- *   This file contains functions for the automatic complexity calculation
- * $Id $
- ***************************************************************************
-*/
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include "typedef.h"
-#include "count.h"
-
-/* Global counter variable for calculation of complexity weight */
-
-BASIC_OP multiCounter[MAXCOUNTERS];
-int currCounter=0; /* Zero equals global counter */
-
-/*BASIC_OP counter;*/
-const BASIC_OP op_weight =
-{
-  /* G.729 & G.723.1 common operators */
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-  3, 3, 3, 4, 15, 18, 30, 1, 2, 1, 2, 2, 
-  /* G.723.1 exclusives */ 
-  6, 1, 1, 
-  /* shiftless 32-bit operators */ 
-  1, 1, 1,
-  /* G.722.1 exclusives */ 
-  1, 1
-};
-
-/* function prototypes */
-Word32 TotalWeightedOperation (void);
-Word32 DeltaWeightedOperation (void);
-
-/* local variable */
-#if WMOPS
-
-/* Counters for separating counting for different objects */
-static int maxCounter=0;
-static char* objectName[MAXCOUNTERS+1];
-static Word16 fwc_corr[MAXCOUNTERS+1];
-
-#define NbFuncMax  1024
-
-static Word16 funcid[MAXCOUNTERS], nbframe[MAXCOUNTERS];
-static Word32 glob_wc[MAXCOUNTERS], wc[MAXCOUNTERS][NbFuncMax];
-static float total_wmops[MAXCOUNTERS];
-
-static Word32 LastWOper[MAXCOUNTERS];
-
-static char* my_strdup(const char *s)
-/*
- * duplicates UNIX function strdup() which is not ANSI standard:
- * -- malloc() memory area big enough to hold the string s
- * -- copy string into new area
- * -- return pointer to new area
- *
- * returns NULL if either s==NULL or malloc() fails
- */
-{
-    char *dup;
-    
-    if (s == NULL)
-        return NULL;
-
-    /* allocate memory for copy of ID string (including string terminator) */
-    /* NOTE: the ID strings will never be deallocated because there is no
-             way to "destroy" a counter that is not longer needed          */
-    if ((dup = (char *) malloc(strlen(s)+1)) == NULL)
-        return NULL;
-
-    return strcpy(dup, s);
-}
-
-#endif
-
-int getCounterId(char *objectNameArg)
-{
-#if WMOPS
-  if(maxCounter>=MAXCOUNTERS-1) return 0;
-  objectName[++maxCounter]=my_strdup(objectNameArg);
-  return maxCounter;
-#else
-  return 0; /* Dummy */
-#endif
-}
-
-void setCounter(int counterId)
-{
-#if WMOPS
-  if(counterId>maxCounter || counterId<0)
-    {
-      currCounter=0;
-      return;
-    }
-  currCounter=counterId;
-#endif
-}
-
-#if WMOPS
-static Word32 WMOPS_frameStat()
-/* calculate the WMOPS seen so far and update the global
-   per-frame maximum (glob_wc)
- */
-{
-    Word32 tot;
-
-    tot = TotalWeightedOperation ();
-    if (tot > glob_wc[currCounter])
-        glob_wc[currCounter] = tot;
-
-    /* check if fwc() was forgotten at end of last frame */
-    if (tot > LastWOper[currCounter]) {
-        if (!fwc_corr[currCounter]) {
-            fprintf(stderr,
-                    "count: operations counted after last fwc() for '%s'; "
-                    "-> fwc() called\n",
-                    objectName[currCounter]?objectName[currCounter]:"");
-        }
-        fwc();
-    }
-    
-    return tot;
-}
-
-static void WMOPS_clearMultiCounter()
-{
-    Word16 i;
-    
-    Word32 *ptr = (Word32 *) &multiCounter[currCounter];
-    for (i = 0; i < (sizeof (multiCounter[currCounter])/ sizeof (Word32)); i++)
-    {
-        *ptr++ = 0;
-    }
-}
-#endif
-
-Word32 TotalWeightedOperation ()
-{
-#if WMOPS
-    Word16 i;
-    Word32 tot, *ptr, *ptr2;
-
-    tot = 0;
-    ptr = (Word32 *) &multiCounter[currCounter];
-    ptr2 = (Word32 *) &op_weight;
-    for (i = 0; i < (sizeof (multiCounter[currCounter])/ sizeof (Word32)); i++)
-    {
-        tot += ((*ptr++) * (*ptr2++));
-    }
-
-    return ((Word32) tot);
-#else
-    return 0; /* Dummy */
-#endif
-}
-
-Word32 DeltaWeightedOperation ()
-{
-#if WMOPS
-    Word32 NewWOper, delta;
-
-    NewWOper = TotalWeightedOperation ();
-    delta = NewWOper - LastWOper[currCounter];
-    LastWOper[currCounter] = NewWOper;
-    return (delta);
-#else
-    return 0; /* Dummy */
-#endif
-}
-
-void move16 (void)
-{
-#if WMOPS
-    multiCounter[currCounter].DataMove16++;
-#endif
-}
-
-void move32 (void)
-{
-#if WMOPS
-    multiCounter[currCounter].DataMove32++;
-#endif
-}
-
-void test (void)
-{
-#if WMOPS
-    multiCounter[currCounter].Test++;
-#endif
-}
-
-void logic16 (void)
-{
-#if WMOPS
-    multiCounter[currCounter].Logic16++;
-#endif
-}
-
-void logic32 (void)
-{
-#if WMOPS
-    multiCounter[currCounter].Logic32++;
-#endif
-}
-
-void Init_WMOPS_counter (void)
-{
-#if WMOPS
-    Word16 i;
-
-    /* reset function weight operation counter variable */
-
-    for (i = 0; i < NbFuncMax; i++)
-        wc[currCounter][i] = (Word32) 0;
-    glob_wc[currCounter] = 0;
-    nbframe[currCounter] = 0;
-    total_wmops[currCounter] = 0.0;
-
-    /* initially clear all counters */
-    WMOPS_clearMultiCounter();
-    LastWOper[currCounter] = 0;
-    funcid[currCounter] = 0;
-#endif
-}
-
-
-void Reset_WMOPS_counter (void)
-{
-#if WMOPS
-    Word32 tot = WMOPS_frameStat();
-        
-    /* increase the frame counter --> a frame is counted WHEN IT BEGINS */
-    nbframe[currCounter]++;
-    /* add wmops used in last frame to count, then reset counter */
-    /* (in first frame, this is a no-op                          */
-    total_wmops[currCounter] += ((float) tot) * 0.00005;
-    
-    /* clear counter before new frame starts */
-    WMOPS_clearMultiCounter();
-    LastWOper[currCounter] = 0;
-    funcid[currCounter] = 0;           /* new frame, set function id to zero */
-#endif
-}
-
-Word32 fwc (void)                      /* function worst case */
-{
-#if WMOPS
-    Word32 tot;
-
-    tot = DeltaWeightedOperation ();
-    if (tot > wc[currCounter][funcid[currCounter]])
-        wc[currCounter][funcid[currCounter]] = tot;
-
-    funcid[currCounter]++;
-
-    return (tot);
-#else
-    return 0; /* Dummy */
-#endif
-}
-
-void WMOPS_output (Word16 dtx_mode)
-{
-#if WMOPS
-    Word16 i;
-    Word32 tot, tot_wm, tot_wc;
-
-    /* get operations since last reset (or init),
-       but do not update the counters (except the glob_wc[] maximum)
-       so output CAN be called in each frame without problems.
-       The frame counter is NOT updated!
-     */
-    tot = WMOPS_frameStat();
-    tot_wm = total_wmops[currCounter] + ((float) tot) * 0.00005;
-
-    fprintf (stdout, "%10s:WMOPS=%.3f",
-	     objectName[currCounter]?objectName[currCounter]:"",
-	     ((float) tot) * 0.00005);
-
-    if (nbframe[currCounter] != 0)
-        fprintf (stdout, "  Average=%.3f",
-                 tot_wm / (float) nbframe[currCounter]);
-    
-    fprintf (stdout, "  WorstCase=%.3f",
-             ((float) glob_wc[currCounter]) * 0.00005);
-
-    /* Worst worst case printed only when not in DTX mode */
-    if (dtx_mode == 0)
-    {
-        tot_wc = 0L;
-        for (i = 0; i < funcid[currCounter]; i++)
-            tot_wc += wc[currCounter][i];
-        fprintf (stdout, "  WorstWC=%.3f", ((float) tot_wc) * 0.00005);
-    }
-    fprintf (stdout, " (%d frames)\n", nbframe[currCounter]);
-    
-#endif
-}
diff --git a/third_party/g7221/common/stl-files/count.h b/third_party/g7221/common/stl-files/count.h
index 5f2227e..34c0461 100644
--- a/third_party/g7221/common/stl-files/count.h
+++ b/third_party/g7221/common/stl-files/count.h
@@ -35,6 +35,7 @@
                     operators L_mult0(), L_mac0(), L_msu0()
  ===========================================================================
 */
+#if 0
 #ifndef COUNT_H
 #define COUNT_H "$Id $"
 
@@ -71,7 +72,23 @@
  *
  */
 
-Word32 fwc (void);
+PJ_INLINE(Word32) fwc (void)
+{
+#if WMOPS
+    Word32 tot;
+
+    tot = DeltaWeightedOperation ();
+    if (tot > wc[currCounter][funcid[currCounter]])
+        wc[currCounter][funcid[currCounter]] = tot;
+
+    funcid[currCounter]++;
+
+    return (tot);
+#else
+    return 0; /* Dummy */
+#endif
+}
+
 /*
  * worst worst case counter.
  *
@@ -82,12 +99,42 @@
  *
  * The WMOPS_output function add together all parts and presents the sum.
  */
+PJ_INLINE(void) move16 (void)
+{
+#if WMOPS
+    multiCounter[currCounter].DataMove16++;
+#endif
+}
 
-void move16 (void);
-void move32 (void);
-void logic16 (void);
-void logic32 (void);
-void test (void);
+PJ_INLINE(void) move32 (void)
+{
+#if WMOPS
+    multiCounter[currCounter].DataMove32++;
+#endif
+}
+
+PJ_INLINE(void )logic16 (void)
+{
+#if WMOPS
+    multiCounter[currCounter].Logic16++;
+#endif
+}
+
+PJ_INLINE(void) logic32 (void)
+{
+#if WMOPS
+    multiCounter[currCounter].Logic32++;
+#endif
+}
+
+PJ_INLINE(void) test (void)
+{
+#if WMOPS
+    multiCounter[currCounter].Test++;
+#endif
+}
+
+
 /*
  * The functions above increases the corresponding operation counter for
  * the current counter group.
@@ -205,3 +252,12 @@
 #endif /* Example */
 
 #endif /* COUNT_H */
+#else
+
+#define move16()
+#define move32()
+#define logic16()
+#define logic32()
+#define test()
+
+#endif