int
 decadd(Numeric *arg1, Numeric *arg2, Numeric *sum)
 {
-   int i = PGTYPESnumeric_add(arg1, arg2, sum);
+   Numeric *temp_sum = malloc(sizeof(Numeric)) ;
+   int i;
+   
+   if (temp_sum == NULL)
+       return -1211;
+   
+   i = PGTYPESnumeric_add(arg1, arg2, temp_sum);
 
    if (i == 0) /* No error */
+   {
+
+       if (PGTYPESnumeric_copy(temp_sum, sum) !=0)
+           return -1211;
+
+       free(temp_sum);
        return 0;
-   if (errno == PGTYPES_NUM_OVERFLOW)
-       return -1200;
+   }
+   else
+   {
+       free(temp_sum);
+       
+       if (errno == PGTYPES_NUM_OVERFLOW)
+           return -1200;
+   }
 
    return -1201;   
 }
 {
    int i = PGTYPESnumeric_cmp(arg1, arg2);
    
-   /* TODO: Need to return DECUNKNOWN instead of PGTYPES_NUM_BAD_NUMERIC */
    return (i);
 }
 
 
    if (new)
    {
-       memcpy(str, new, use_len);
+       memcpy(new, str, use_len);
        new[use_len] = '\0';
    }
    else
 {
    char *str = strndup(cp, len); /* Numeric_in always converts the complete string */
    int ret = 0;
+   Numeric *result;
    
    if (!str)
        ret = -1201;
    else
    {
-       np = PGTYPESnumeric_from_asc(str, NULL);
-       if (!np)
+       result = PGTYPESnumeric_from_asc(str, NULL);
+       if (!result)
        {
            switch (errno)
            {
                              break;
            }
        }
+       else
+       {
+           if (PGTYPESnumeric_copy(result, np) !=0)
+               ret = -1211;
+
+           free(result);
+       }
    }
    
    return ret;
 int
 decdiv(Numeric *n1, Numeric *n2, Numeric *n3)
 {
-   int i = PGTYPESnumeric_div(n1, n2, n3), ret = 0;
+   Numeric *temp = malloc(sizeof(Numeric));
+   int i, ret = 0;
+
+   if (temp == NULL)
+       return -1211;
+   
+   i = PGTYPESnumeric_div(n1, n2, temp);
 
    if (i != 0)
        switch (errno)
            default:          ret = -1201;
                          break;
        }
-
+   else
+       if (PGTYPESnumeric_copy(temp, n3) !=0)
+           ret = -1211;
+       
+   free(temp);
    return ret;
 }
 
 int 
 decmul(Numeric *n1, Numeric *n2, Numeric *n3)
 {
-   int i = PGTYPESnumeric_mul(n1, n2, n3), ret = 0;
+   Numeric *temp = malloc(sizeof(Numeric));
+   int i, ret = 0;
+   
+   if (temp == NULL)
+       return -1211;
+   
+   i = PGTYPESnumeric_mul(n1, n2, temp);
 
    if (i != 0)
        switch (errno)
            default:          ret = -1201;
                          break;
        }
+   else
+       if (PGTYPESnumeric_copy(temp, n3) !=0)
+           ret = -1211;
+       
+   free(temp);
 
    return ret;
 }
 int
 decsub(Numeric *n1, Numeric *n2, Numeric *n3)
 {
-   int i = PGTYPESnumeric_sub(n1, n2, n3), ret = 0;
+   Numeric *temp = malloc(sizeof(Numeric));
+   int i, ret = 0;
+   
+   if (temp == NULL)
+       return -1211;
+   
+   i = PGTYPESnumeric_sub(n1, n2, temp);
 
    if (i != 0)
        switch (errno)
            default:          ret = -1201;
                          break;
        }
+   else
+       if (PGTYPESnumeric_copy(temp, n3) !=0)
+           ret = -1211;
+       
+   free(temp);
 
    return ret;
 }