diff --git a/math-func.c b/math-func.c
new file mode 100644
index 0000000..2bdd194
--- /dev/null
+++ b/math-func.c
@@ -0,0 +1,1947 @@
+/*
+This library will provide common mathematical and string functions in
+SQL queries using the operating system libraries or provided
+definitions.  It includes the following functions:
+
+Math: acos, asin, atan, atn2, atan2, acosh, asinh, atanh, difference,
+degrees, radians, cos, sin, tan, cot, cosh, sinh, tanh, coth, exp,
+log, log10, power, sign, sqrt, square, ceil, floor, pi.
+
+String: replicate, charindex, leftstr, rightstr, ltrim, rtrim, trim,
+replace, reverse, proper, padl, padr, padc, strfilter.
+
+Aggregate: stdev, variance, mode, median, lower_quartile,
+upper_quartile.
+
+The string functions ltrim, rtrim, trim, replace are included in
+recent versions of SQLite and so by default do not build.
+
+Compilation instructions:
+ Compile this C source file into a dynamic library as follows:
+ * Linux:
+   gcc -fPIC -lm -shared extension-functions.c -o libsqlitefunctions.so
+ * Mac OS X:
+   gcc -fno-common -dynamiclib extension-functions.c -o libsqlitefunctions.dylib
+ (You may need to add flags
+  -I /opt/local/include/ -L/opt/local/lib -lsqlite3
+  if your sqlite3 is installed from Mac ports, or
+  -I /sw/include/ -L/sw/lib -lsqlite3
+  if installed with Fink.)
+ * Windows:
+  1. Install MinGW (http://www.mingw.org/) and you will get the gcc
+  (gnu compiler collection)
+  2. add the path to your path variable (isn't done during the
+   installation!)
+  3. compile:
+   gcc -shared -I "path" -o libsqlitefunctions.so extension-functions.c
+   (path = path of sqlite3ext.h; i.e. C:\programs\sqlite)
+
+Usage instructions for applications calling the sqlite3 API functions:
+  In your application, call sqlite3_enable_load_extension(db,1) to
+  allow loading external libraries.  Then load the library libsqlitefunctions
+  using sqlite3_load_extension; the third argument should be 0.
+  See http://www.sqlite.org/cvstrac/wiki?p=LoadableExtensions.
+  Select statements may now use these functions, as in
+  SELECT cos(radians(inclination)) FROM satsum WHERE satnum = 25544;
+
+Usage instructions for the sqlite3 program:
+  If the program is built so that loading extensions is permitted,
+  the following will work:
+   sqlite> SELECT load_extension('./libsqlitefunctions.so');
+   sqlite> select cos(radians(45));
+   0.707106781186548
+  Note: Loading extensions is by default prohibited as a
+  security measure; see "Security Considerations" in
+  http://www.sqlite.org/cvstrac/wiki?p=LoadableExtensions.
+  If the sqlite3 program and library are built this
+  way, you cannot use these functions from the program, you 
+  must write your own program using the sqlite3 API, and call
+  sqlite3_enable_load_extension as described above, or else
+  rebuilt the sqlite3 program to allow loadable extensions.
+
+Alterations:
+The instructions are for Linux, Mac OS X, and Windows; users of other
+OSes may need to modify this procedure.  In particular, if your math
+library lacks one or more of the needed trig or log functions, comment
+out the appropriate HAVE_ #define at the top of file.  If you do not
+wish to make a loadable module, comment out the define for
+COMPILE_SQLITE_EXTENSIONS_AS_LOADABLE_MODULE.  If you are using a
+version of SQLite without the trim functions and replace, comment out
+the HAVE_TRIM #define.
+
+Liam Healy
+
+History:
+2010-01-06 Correct check for argc in squareFunc, and add Windows
+compilation instructions.
+2009-06-24 Correct check for argc in properFunc.
+2008-09-14 Add check that memory was actually allocated after
+sqlite3_malloc or sqlite3StrDup, call sqlite3_result_error_nomem if
+not.  Thanks to Robert Simpson.
+2008-06-13 Change to instructions to indicate use of the math library
+and that program might work.
+2007-10-01 Minor clarification to instructions.
+2007-09-29 Compilation as loadable module is optional with
+COMPILE_SQLITE_EXTENSIONS_AS_LOADABLE_MODULE.
+2007-09-28 Use sqlite3_extension_init and macros
+SQLITE_EXTENSION_INIT1, SQLITE_EXTENSION_INIT2, so that it works with
+sqlite3_load_extension.  Thanks to Eric Higashino and Joe Wilson.
+New instructions for Mac compilation.
+2007-09-17 With help from Joe Wilson and Nuno Luca, made use of
+external interfaces so that compilation is no longer dependent on
+SQLite source code.  Merged source, header, and README into a single
+file.  Added casts so that Mac will compile without warnings (unsigned
+and signed char).
+2007-09-05 Included some definitions from sqlite 3.3.13 so that this
+will continue to work in newer versions of sqlite.  Completed
+description of functions available.
+2007-03-27 Revised description.
+2007-03-23 Small cleanup and a bug fix on the code.  This was mainly
+letting errno flag errors encountered in the math library and checking
+the result, rather than pre-checking.  This fixes a bug in power that
+would cause an error if any non-positive number was raised to any
+power.
+2007-02-07 posted by Mikey C to sqlite mailing list.
+Original code 2006 June 05 by relicoder.
+
+*/
+
+//#include "config.h"
+
+#define COMPILE_SQLITE_EXTENSIONS_AS_LOADABLE_MODULE 1
+#define HAVE_ACOSH 1
+#define HAVE_ASINH 1
+#define HAVE_ATANH 1
+#define HAVE_SINH 1
+#define HAVE_COSH 1
+#define HAVE_TANH 1
+#define HAVE_LOG10 1
+#define HAVE_ISBLANK 1
+#define SQLITE_SOUNDEX 1
+#define HAVE_TRIM 1		/* LMH 2007-03-25 if sqlite has trim functions */
+
+#ifdef COMPILE_SQLITE_EXTENSIONS_AS_LOADABLE_MODULE
+#include "sqlite3ext.h"
+SQLITE_EXTENSION_INIT1
+#else
+#include "sqlite3.h"
+#endif
+
+#include <ctype.h>
+/* relicoder */
+#include <math.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>		/* LMH 2007-03-25 */
+
+#include <stdlib.h>
+#include <assert.h>
+
+#ifndef _MAP_H_
+#define _MAP_H_
+
+#include <stdint.h>
+
+/*
+** Simple binary tree implementation to use in median, mode and quartile calculations
+** Tree is not necessarily balanced. That would require something like red&black trees of AVL
+*/
+
+typedef int(*cmp_func)(const void *, const void *);
+typedef void(*map_iterator)(void*, int64_t, void*);
+
+typedef struct node{
+  struct node *l;
+  struct node *r;
+  void* data;
+  int64_t count;
+} node;
+
+typedef struct map{
+  node *base;
+  cmp_func cmp;
+  short free;
+} map;
+
+/*
+** creates a map given a comparison function
+*/
+map map_make(cmp_func cmp);
+
+/*
+** inserts the element e into map m
+*/
+void map_insert(map *m, void *e);
+
+/*
+** executes function iter over all elements in the map, in key increasing order
+*/
+void map_iterate(map *m, map_iterator iter, void* p);
+
+/*
+** frees all memory used by a map
+*/
+void map_destroy(map *m);
+
+/*
+** compares 2 integers
+** to use with map_make
+*/
+int int_cmp(const void *a, const void *b);
+
+/*
+** compares 2 doubles
+** to use with map_make
+*/
+int double_cmp(const void *a, const void *b);
+
+#endif /* _MAP_H_ */
+
+typedef uint8_t         u8;
+typedef uint16_t        u16;
+typedef int64_t         i64;
+
+static char *sqlite3StrDup( const char *z ) {
+    char *res = sqlite3_malloc( strlen(z)+1 );
+    return strcpy( res, z );
+}
+
+/*
+** These are copied verbatim from fun.c so as to not have the names exported
+*/
+
+/* LMH from sqlite3 3.3.13 */
+/*
+** This table maps from the first byte of a UTF-8 character to the number
+** of trailing bytes expected. A value '4' indicates that the table key
+** is not a legal first byte for a UTF-8 character.
+*/
+static const u8 xtra_utf8_bytes[256]  = {
+/* 0xxxxxxx */
+0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
+0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
+0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
+0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
+0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
+0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
+0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
+0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
+
+/* 10wwwwww */
+4, 4, 4, 4, 4, 4, 4, 4,     4, 4, 4, 4, 4, 4, 4, 4,
+4, 4, 4, 4, 4, 4, 4, 4,     4, 4, 4, 4, 4, 4, 4, 4,
+4, 4, 4, 4, 4, 4, 4, 4,     4, 4, 4, 4, 4, 4, 4, 4,
+4, 4, 4, 4, 4, 4, 4, 4,     4, 4, 4, 4, 4, 4, 4, 4,
+
+/* 110yyyyy */
+1, 1, 1, 1, 1, 1, 1, 1,     1, 1, 1, 1, 1, 1, 1, 1,
+1, 1, 1, 1, 1, 1, 1, 1,     1, 1, 1, 1, 1, 1, 1, 1,
+
+/* 1110zzzz */
+2, 2, 2, 2, 2, 2, 2, 2,     2, 2, 2, 2, 2, 2, 2, 2,
+
+/* 11110yyy */
+3, 3, 3, 3, 3, 3, 3, 3,     4, 4, 4, 4, 4, 4, 4, 4,
+};
+
+
+/*
+** This table maps from the number of trailing bytes in a UTF-8 character
+** to an integer constant that is effectively calculated for each character
+** read by a naive implementation of a UTF-8 character reader. The code
+** in the READ_UTF8 macro explains things best.
+*/
+static const int xtra_utf8_bits[] =  {
+  0,
+  12416,          /* (0xC0 << 6) + (0x80) */
+  925824,         /* (0xE0 << 12) + (0x80 << 6) + (0x80) */
+  63447168        /* (0xF0 << 18) + (0x80 << 12) + (0x80 << 6) + 0x80 */
+};
+
+/*
+** If a UTF-8 character contains N bytes extra bytes (N bytes follow
+** the initial byte so that the total character length is N+1) then
+** masking the character with utf8_mask[N] must produce a non-zero
+** result.  Otherwise, we have an (illegal) overlong encoding.
+*/
+static const int utf_mask[] = {
+  0x00000000,
+  0xffffff80,
+  0xfffff800,
+  0xffff0000,
+};
+
+/* LMH salvaged from sqlite3 3.3.13 source code src/utf.c */
+#define READ_UTF8(zIn, c) { \
+  int xtra;                                            \
+  c = *(zIn)++;                                        \
+  xtra = xtra_utf8_bytes[c];                           \
+  switch( xtra ){                                      \
+    case 4: c = (int)0xFFFD; break;                    \
+    case 3: c = (c<<6) + *(zIn)++;                     \
+    case 2: c = (c<<6) + *(zIn)++;                     \
+    case 1: c = (c<<6) + *(zIn)++;                     \
+    c -= xtra_utf8_bits[xtra];                         \
+    if( (utf_mask[xtra]&c)==0                          \
+        || (c&0xFFFFF800)==0xD800                      \
+        || (c&0xFFFFFFFE)==0xFFFE ){  c = 0xFFFD; }    \
+  }                                                    \
+}
+
+static int sqlite3ReadUtf8(const unsigned char *z){
+  int c;
+  READ_UTF8(z, c);
+  return c;
+}
+
+#define SKIP_UTF8(zIn) {                               \
+  zIn += (xtra_utf8_bytes[*(u8 *)zIn] + 1);            \
+}
+
+/*
+** pZ is a UTF-8 encoded unicode string. If nByte is less than zero,
+** return the number of unicode characters in pZ up to (but not including)
+** the first 0x00 byte. If nByte is not less than zero, return the
+** number of unicode characters in the first nByte of pZ (or up to 
+** the first 0x00, whichever comes first).
+*/
+static int sqlite3Utf8CharLen(const char *z, int nByte){
+  int r = 0;
+  const char *zTerm;
+  if( nByte>=0 ){
+    zTerm = &z[nByte];
+  }else{
+    zTerm = (const char *)(-1);
+  }
+  assert( z<=zTerm );
+  while( *z!=0 && z<zTerm ){
+    SKIP_UTF8(z);
+    r++;
+  }
+  return r;
+}
+
+/*
+** X is a pointer to the first byte of a UTF-8 character.  Increment
+** X so that it points to the next character.  This only works right
+** if X points to a well-formed UTF-8 string.
+*/
+#define sqliteNextChar(X)  while( (0xc0&*++(X))==0x80 ){}
+#define sqliteCharVal(X)   sqlite3ReadUtf8(X)
+
+/*
+** This is a macro that facilitates writting wrappers for math.h functions
+** it creates code for a function to use in SQlite that gets one numeric input
+** and returns a floating point value.
+**
+** Could have been implemented using pointers to functions but this way it's inline
+** and thus more efficient. Lower * ranking though...
+** 
+** Parameters:
+** name:      function name to de defined (eg: sinFunc)
+** function:  function defined in math.h to wrap (eg: sin)
+** domain:    boolean condition that CAN'T happen in terms of the input parameter rVal
+**            (eg: rval<0 for sqrt)
+*/
+/* LMH 2007-03-25 Changed to use errno and remove domain; no pre-checking for errors. */
+#define GEN_MATH_WRAP_DOUBLE_1(name, function) \
+static void name(sqlite3_context *context, int argc, sqlite3_value **argv){\
+  double rVal = 0.0, val;\
+  assert( argc==1 );\
+  switch( sqlite3_value_type(argv[0]) ){\
+    case SQLITE_NULL: {\
+      sqlite3_result_null(context);\
+      break;\
+    }\
+    default: {\
+      rVal = sqlite3_value_double(argv[0]);\
+      errno = 0;\
+      val = function(rVal);\
+      if (errno == 0) {\
+        sqlite3_result_double(context, val);\
+      } else {\
+        sqlite3_result_error(context, strerror(errno), errno);\
+      }\
+      break;\
+    }\
+  }\
+}\
+
+
+/*
+** Example of GEN_MATH_WRAP_DOUBLE_1 usage
+** this creates function sqrtFunc to wrap the math.h standard function sqrt(x)=x^0.5
+*/
+GEN_MATH_WRAP_DOUBLE_1(sqrtFunc, sqrt)
+
+/* trignometric functions */
+GEN_MATH_WRAP_DOUBLE_1(acosFunc, acos)
+GEN_MATH_WRAP_DOUBLE_1(asinFunc, asin)
+GEN_MATH_WRAP_DOUBLE_1(atanFunc, atan)
+
+/*
+** Many of systems don't have inverse hyperbolic trig functions so this will emulate
+** them on those systems in terms of log and sqrt (formulas are too trivial to demand 
+** written proof here)
+*/
+
+#ifndef HAVE_ACOSH
+static double acosh(double x){
+  return log(x + sqrt(x*x - 1.0));
+}
+#endif
+
+GEN_MATH_WRAP_DOUBLE_1(acoshFunc, acosh)
+
+#ifndef HAVE_ASINH
+static double asinh(double x){
+  return log(x + sqrt(x*x + 1.0));
+}
+#endif
+
+GEN_MATH_WRAP_DOUBLE_1(asinhFunc, asinh)
+
+#ifndef HAVE_ATANH
+static double atanh(double x){
+  return (1.0/2.0)*log((1+x)/(1-x)) ;
+}
+#endif
+
+GEN_MATH_WRAP_DOUBLE_1(atanhFunc, atanh)
+
+/*
+** math.h doesn't require cot (cotangent) so it's defined here
+*/
+static double cot(double x){
+  return 1.0/tan(x);
+}
+
+GEN_MATH_WRAP_DOUBLE_1(sinFunc, sin)
+GEN_MATH_WRAP_DOUBLE_1(cosFunc, cos)
+GEN_MATH_WRAP_DOUBLE_1(tanFunc, tan)
+GEN_MATH_WRAP_DOUBLE_1(cotFunc, cot)
+
+static double coth(double x){
+  return 1.0/tanh(x);
+}
+
+/*
+** Many systems don't have hyperbolic trigonometric functions so this will emulate
+** them on those systems directly from the definition in terms of exp
+*/
+#ifndef HAVE_SINH
+static double sinh(double x){
+  return (exp(x)-exp(-x))/2.0;
+}
+#endif
+
+GEN_MATH_WRAP_DOUBLE_1(sinhFunc, sinh)
+
+#ifndef HAVE_COSH
+static double cosh(double x){
+  return (exp(x)+exp(-x))/2.0;
+}
+#endif
+
+GEN_MATH_WRAP_DOUBLE_1(coshFunc, cosh)
+
+#ifndef HAVE_TANH
+static double tanh(double x){
+  return sinh(x)/cosh(x);
+}
+#endif
+
+GEN_MATH_WRAP_DOUBLE_1(tanhFunc, tanh)
+
+GEN_MATH_WRAP_DOUBLE_1(cothFunc, coth)
+
+/*
+** Some systems lack log in base 10. This will emulate it
+*/
+
+#ifndef HAVE_LOG10
+static double log10(double x){
+  static double l10 = -1.0;
+  if( l10<0.0 ){
+    l10 = log(10.0);
+  }
+  return log(x)/l10;
+}
+#endif
+
+GEN_MATH_WRAP_DOUBLE_1(logFunc, log)
+GEN_MATH_WRAP_DOUBLE_1(log10Func, log10)
+GEN_MATH_WRAP_DOUBLE_1(expFunc, exp)
+
+/*
+** Fallback for systems where math.h doesn't define M_PI
+*/
+#undef M_PI
+#ifndef M_PI
+/*
+** static double PI = acos(-1.0);
+** #define M_PI (PI)
+*/
+#define M_PI 3.14159265358979323846
+#endif
+
+/* Convert Degrees into Radians */
+static double deg2rad(double x){
+  return x*M_PI/180.0;
+}
+
+/* Convert Radians into Degrees */
+static double rad2deg(double x){
+  return 180.0*x/M_PI;
+}
+
+GEN_MATH_WRAP_DOUBLE_1(rad2degFunc, rad2deg)
+GEN_MATH_WRAP_DOUBLE_1(deg2radFunc, deg2rad)
+
+/* constant function that returns the value of PI=3.1415... */
+static void piFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  sqlite3_result_double(context, M_PI);
+}
+
+/*
+** Implements the sqrt function, it has the peculiarity of returning an integer when the
+** the argument is an integer.
+** Since SQLite isn't strongly typed (almost untyped actually) this is a bit pedantic
+*/
+static void squareFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  i64 iVal = 0;
+  double rVal = 0.0;
+  assert( argc==1 );
+  switch( sqlite3_value_type(argv[0]) ){
+    case SQLITE_INTEGER: {
+      iVal = sqlite3_value_int64(argv[0]);
+      sqlite3_result_int64(context, iVal*iVal);
+      break;
+    }
+    case SQLITE_NULL: {
+      sqlite3_result_null(context);
+      break;
+    }
+    default: {
+      rVal = sqlite3_value_double(argv[0]);
+      sqlite3_result_double(context, rVal*rVal);
+      break;
+    }
+  }
+}
+
+/*
+** Wraps the pow math.h function
+** When both the base and the exponent are integers the result should be integer
+** (see sqrt just before this). Here the result is always double
+*/
+/* LMH 2007-03-25 Changed to use errno; no pre-checking for errors.  Also removes
+  but that was present in the pre-checking that called sqlite3_result_error on 
+  a non-positive first argument, which is not always an error. */
+static void powerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  double r1 = 0.0;
+  double r2 = 0.0;
+  double val;
+
+  assert( argc==2 );
+  
+  if( sqlite3_value_type(argv[0]) == SQLITE_NULL || sqlite3_value_type(argv[1]) == SQLITE_NULL ){
+    sqlite3_result_null(context); 
+  }else{
+    r1 = sqlite3_value_double(argv[0]);
+    r2 = sqlite3_value_double(argv[1]);
+    errno = 0;
+    val = pow(r1,r2);
+    if (errno == 0) {
+      sqlite3_result_double(context, val);
+    } else {  
+      sqlite3_result_error(context, strerror(errno), errno);
+    }  
+  }
+}
+
+/*
+** atan2 wrapper
+*/
+static void atn2Func(sqlite3_context *context, int argc, sqlite3_value **argv){
+  double r1 = 0.0;
+  double r2 = 0.0;
+
+  assert( argc==2 );
+  
+  if( sqlite3_value_type(argv[0]) == SQLITE_NULL || sqlite3_value_type(argv[1]) == SQLITE_NULL ){
+    sqlite3_result_null(context); 
+  }else{
+    r1 = sqlite3_value_double(argv[0]);
+    r2 = sqlite3_value_double(argv[1]);
+    sqlite3_result_double(context, atan2(r1,r2));
+  }
+}
+
+/*
+** Implementation of the sign() function
+** return one of 3 possibilities +1,0 or -1 when the argument is respectively
+** positive, 0 or negative.
+** When the argument is NULL the result is also NULL (completly conventional)
+*/
+static void signFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  double rVal=0.0;
+  i64 iVal=0;
+  assert( argc==1 );
+  switch( sqlite3_value_type(argv[0]) ){
+    case SQLITE_INTEGER: {
+      iVal = sqlite3_value_int64(argv[0]);
+      iVal = ( iVal > 0) ? 1: ( iVal < 0 ) ? -1: 0;
+      sqlite3_result_int64(context, iVal);
+      break;
+    }
+    case SQLITE_NULL: {
+      sqlite3_result_null(context);
+      break;
+    }
+    default: {
+ /* 2nd change below. Line for abs was: if( rVal<0 ) rVal = rVal * -1.0;  */
+
+      rVal = sqlite3_value_double(argv[0]);
+      rVal = ( rVal > 0) ? 1: ( rVal < 0 ) ? -1: 0;
+      sqlite3_result_double(context, rVal);
+      break;
+    }
+  }
+}
+
+
+/*
+** smallest integer value not less than argument
+*/
+static void ceilFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  double rVal=0.0;
+  i64 iVal=0;
+  assert( argc==1 );
+  switch( sqlite3_value_type(argv[0]) ){
+    case SQLITE_INTEGER: {
+      i64 iVal = sqlite3_value_int64(argv[0]);
+      sqlite3_result_int64(context, iVal);
+      break;
+    }
+    case SQLITE_NULL: {
+      sqlite3_result_null(context);
+      break;
+    }
+    default: {
+      rVal = sqlite3_value_double(argv[0]);
+      sqlite3_result_int64(context, (i64) ceil(rVal));
+      break;
+    }
+  }
+}
+
+/*
+** largest integer value not greater than argument
+*/
+static void floorFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  double rVal=0.0;
+  i64 iVal=0;
+  assert( argc==1 );
+  switch( sqlite3_value_type(argv[0]) ){
+    case SQLITE_INTEGER: {
+      i64 iVal = sqlite3_value_int64(argv[0]);
+      sqlite3_result_int64(context, iVal);
+      break;
+    }
+    case SQLITE_NULL: {
+      sqlite3_result_null(context);
+      break;
+    }
+    default: {
+      rVal = sqlite3_value_double(argv[0]);
+      sqlite3_result_int64(context, (i64) floor(rVal));
+      break;
+    }
+  }
+}
+
+/*
+** Given a string (s) in the first argument and an integer (n) in the second returns the 
+** string that constains s contatenated n times
+*/
+static void replicateFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  unsigned char *z;        /* input string */
+  unsigned char *zo;       /* result string */
+  i64 iCount;              /* times to repeat */
+  i64 nLen;                /* length of the input string (no multibyte considerations) */ 
+  i64 nTLen;               /* length of the result string (no multibyte considerations) */
+  i64 i=0;
+
+  if( argc!=2 || SQLITE_NULL==sqlite3_value_type(argv[0]) )
+    return;
+
+  iCount = sqlite3_value_int64(argv[1]);
+
+  if( iCount<0 ){
+    sqlite3_result_error(context, "domain error", -1);
+  }else{
+
+    nLen  = sqlite3_value_bytes(argv[0]);
+    nTLen = nLen*iCount;
+    z=sqlite3_malloc(nTLen+1);
+    zo=sqlite3_malloc(nLen+1);
+    if (!z || !zo){
+      sqlite3_result_error_nomem(context);
+      if (z) sqlite3_free(z);
+      if (zo) sqlite3_free(zo);
+      return;
+    }
+    strcpy((char*)zo, (char*)sqlite3_value_text(argv[0]));
+
+    for(i=0; i<iCount; ++i){
+      strcpy((char*)(z+i*nLen), (char*)zo);
+    }
+
+    sqlite3_result_text(context, (char*)z, -1, SQLITE_TRANSIENT);
+    sqlite3_free(z);
+    sqlite3_free(zo);
+  }
+}
+
+/* 
+** Some systems (win32 among others) don't have an isblank function, this will emulate it.
+** This function is not UFT-8 safe since it only analyses a byte character.
+*/
+#ifndef HAVE_ISBLANK
+int isblank(char c){
+  return( ' '==c || '\t'==c );
+}
+#endif
+
+static void properFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  const unsigned char *z;     /* input string */
+  unsigned char *zo;          /* output string */
+  unsigned char *zt;          /* iterator */
+  char r;
+  int c=1;
+
+  assert( argc==1);
+  if( SQLITE_NULL==sqlite3_value_type(argv[0]) ){
+    sqlite3_result_null(context);
+    return;
+  }
+
+  z = sqlite3_value_text(argv[0]);
+  zo = (unsigned char *)sqlite3StrDup((char *) z);
+  if (!zo) {
+    sqlite3_result_error_nomem(context);
+    return;
+  }
+  zt = zo;
+
+  while( (r = *(z++))!=0 ){
+    if( isblank(r) ){
+      c=1;
+    }else{
+      if( c==1 ){
+        r = toupper(r);
+      }else{
+        r = tolower(r);
+      }
+      c=0;
+    }
+    *(zt++) = r;
+  }
+  *zt = '\0';
+
+  sqlite3_result_text(context, (char*)zo, -1, SQLITE_TRANSIENT);
+  sqlite3_free(zo);
+}
+
+/*
+** given an input string (s) and an integer (n) adds spaces at the begining of  s
+** until it has a length of n characters.
+** When s has a length >=n it's a NOP
+** padl(NULL) = NULL
+*/
+static void padlFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  i64 ilen;          /* length to pad to */
+  i64 zl;            /* length of the input string (UTF-8 chars) */
+  int i = 0;
+  const char *zi;    /* input string */
+  char *zo;          /* output string */
+  char *zt;
+
+  assert( argc==2 );
+  
+  if( sqlite3_value_type(argv[0]) == SQLITE_NULL ){
+    sqlite3_result_null(context); 
+  }else{
+    zi = (char *)sqlite3_value_text(argv[0]);
+    ilen = sqlite3_value_int64(argv[1]);
+    /* check domain */
+    if(ilen<0){
+      sqlite3_result_error(context, "domain error", -1);
+      return;
+    }
+    zl = sqlite3Utf8CharLen(zi, -1);
+    if( zl>=ilen ){
+      /* string is longer than the requested pad length, return the same string (dup it) */
+      zo = sqlite3StrDup(zi);
+      if (!zo){
+        sqlite3_result_error_nomem(context);
+        return;
+      }
+      sqlite3_result_text(context, zo, -1, SQLITE_TRANSIENT);
+    }else{
+      zo = sqlite3_malloc(strlen(zi)+ilen-zl+1);
+      if (!zo){
+        sqlite3_result_error_nomem(context);
+        return;
+      }
+      zt = zo;
+      for(i=1; i+zl<=ilen; ++i){
+        *(zt++)=' ';
+      }
+      /* no need to take UTF-8 into consideration here */
+      strcpy(zt,zi);
+    }
+    sqlite3_result_text(context, zo, -1, SQLITE_TRANSIENT);
+    sqlite3_free(zo);
+  }
+}
+
+/*
+** given an input string (s) and an integer (n) appends spaces at the end of  s
+** until it has a length of n characters.
+** When s has a length >=n it's a NOP
+** padl(NULL) = NULL
+*/
+static void padrFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  i64 ilen;          /* length to pad to */
+  i64 zl;            /* length of the input string (UTF-8 chars) */
+  i64 zll;           /* length of the input string (bytes) */
+  int i = 0;
+  const char *zi;    /* input string */
+  char *zo;          /* output string */
+  char *zt;
+
+  assert( argc==2 );
+  
+  if( sqlite3_value_type(argv[0]) == SQLITE_NULL ){
+    sqlite3_result_null(context); 
+  }else{
+    zi = (char *)sqlite3_value_text(argv[0]);
+    ilen = sqlite3_value_int64(argv[1]);
+    /* check domain */
+    if(ilen<0){
+      sqlite3_result_error(context, "domain error", -1);
+      return;
+    }
+    zl = sqlite3Utf8CharLen(zi, -1);
+    if( zl>=ilen ){
+      /* string is longer than the requested pad length, return the same string (dup it) */
+      zo = sqlite3StrDup(zi);
+      if (!zo){
+        sqlite3_result_error_nomem(context);
+        return;
+      }
+      sqlite3_result_text(context, zo, -1, SQLITE_TRANSIENT);
+    }else{
+      zll = strlen(zi);
+      zo = sqlite3_malloc(zll+ilen-zl+1);
+      if (!zo){
+        sqlite3_result_error_nomem(context);
+        return;
+      }
+      zt = strcpy(zo,zi)+zll;
+      for(i=1; i+zl<=ilen; ++i){
+        *(zt++) = ' ';
+      }
+      *zt = '\0';
+    }
+    sqlite3_result_text(context, zo, -1, SQLITE_TRANSIENT);
+    sqlite3_free(zo);
+  }
+}
+
+/*
+** given an input string (s) and an integer (n) appends spaces at the end of  s
+** and adds spaces at the begining of s until it has a length of n characters.
+** Tries to add has many characters at the left as at the right.
+** When s has a length >=n it's a NOP
+** padl(NULL) = NULL
+*/
+static void padcFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  i64 ilen;           /* length to pad to */
+  i64 zl;             /* length of the input string (UTF-8 chars) */
+  i64 zll;            /* length of the input string (bytes) */
+  int i = 0;
+  const char *zi;     /* input string */
+  char *zo;           /* output string */
+  char *zt;
+
+  assert( argc==2 );
+  
+  if( sqlite3_value_type(argv[0]) == SQLITE_NULL ){
+    sqlite3_result_null(context); 
+  }else{
+    zi = (char *)sqlite3_value_text(argv[0]);
+    ilen = sqlite3_value_int64(argv[1]);
+    /* check domain */
+    if(ilen<0){
+      sqlite3_result_error(context, "domain error", -1);
+      return;
+    }
+    zl = sqlite3Utf8CharLen(zi, -1);
+    if( zl>=ilen ){
+      /* string is longer than the requested pad length, return the same string (dup it) */
+      zo = sqlite3StrDup(zi);
+      if (!zo){
+        sqlite3_result_error_nomem(context);
+        return;
+      }
+      sqlite3_result_text(context, zo, -1, SQLITE_TRANSIENT);
+    }else{
+      zll = strlen(zi);
+      zo = sqlite3_malloc(zll+ilen-zl+1);
+      if (!zo){
+        sqlite3_result_error_nomem(context);
+        return;
+      }
+      zt = zo;
+      for(i=1; 2*i+zl<=ilen; ++i){
+        *(zt++) = ' ';
+      }
+      strcpy(zt, zi);
+      zt+=zll;
+      for(; i+zl<=ilen; ++i){
+        *(zt++) = ' ';
+      }
+      *zt = '\0';
+    }
+    sqlite3_result_text(context, zo, -1, SQLITE_TRANSIENT);
+    sqlite3_free(zo);
+  }
+}
+
+/*
+** given 2 string (s1,s2) returns the string s1 with the characters NOT in s2 removed
+** assumes strings are UTF-8 encoded
+*/
+static void strfilterFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  const char *zi1;        /* first parameter string (searched string) */
+  const char *zi2;        /* second parameter string (vcontains valid characters) */
+  const char *z1;
+  const char *z21;
+  const char *z22;
+  char *zo;               /* output string */
+  char *zot;
+  int c1 = 0;
+  int c2 = 0;
+
+  assert( argc==2 );
+  
+  if( sqlite3_value_type(argv[0]) == SQLITE_NULL || sqlite3_value_type(argv[1]) == SQLITE_NULL ){
+    sqlite3_result_null(context); 
+  }else{
+    zi1 = (char *)sqlite3_value_text(argv[0]);
+    zi2 = (char *)sqlite3_value_text(argv[1]);
+    /* 
+    ** maybe I could allocate less, but that would imply 2 passes, rather waste 
+    ** (possibly) some memory
+    */
+    zo = sqlite3_malloc(strlen(zi1)+1); 
+    if (!zo){
+      sqlite3_result_error_nomem(context);
+      return;
+    }
+    zot = zo;
+    z1 = zi1;
+    while( (c1=sqliteCharVal((unsigned char *)z1))!=0 ){
+      z21=zi2;
+      while( (c2=sqliteCharVal((unsigned char *)z21))!=0 && c2!=c1 ){
+        sqliteNextChar(z21);
+      }
+      if( c2!=0){
+        z22=z21;
+        sqliteNextChar(z22);
+        strncpy(zot, z21, z22-z21);
+        zot+=z22-z21;
+      }
+      sqliteNextChar(z1);
+    }
+    *zot = '\0';
+
+    sqlite3_result_text(context, zo, -1, SQLITE_TRANSIENT);
+    sqlite3_free(zo);
+  }
+}
+
+/*
+** Given a string z1, retutns the (0 based) index of it's first occurence
+** in z2 after the first s characters.
+** Returns -1 when there isn't a match.
+** updates p to point to the character where the match occured.
+** This is an auxiliary function.
+*/
+static int _substr(const char* z1, const char* z2, int s, const char** p){
+  int c = 0;
+  int rVal=-1;
+  const char* zt1;
+  const char* zt2;
+  int c1,c2;
+
+  if( '\0'==*z1 ){
+    return -1;
+  }
+  
+  while( (sqliteCharVal((unsigned char *)z2) != 0) && (c++)<s){
+    sqliteNextChar(z2);
+  }
+  
+  c = 0;
+  while( (sqliteCharVal((unsigned char *)z2)) != 0 ){
+    zt1 = z1;
+    zt2 = z2;
+
+    do{
+      c1 = sqliteCharVal((unsigned char *)zt1);
+      c2 = sqliteCharVal((unsigned char *)zt2);
+      sqliteNextChar(zt1);
+      sqliteNextChar(zt2);
+    }while( c1 == c2 && c1 != 0 && c2 != 0 );
+
+    if( c1 == 0 ){
+      rVal = c;
+      break; 
+    }
+    
+    sqliteNextChar(z2);
+    ++c;
+  }
+  if(p){
+    *p=z2;
+  }
+  return rVal >=0 ? rVal+s : rVal;
+}
+
+/*
+** given 2 input strings (s1,s2) and an integer (n) searches from the nth character
+** for the string s1. Returns the position where the match occured.
+** Characters are counted from 1.
+** 0 is returned when no match occurs.
+*/
+
+static void charindexFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  const u8 *z1;          /* s1 string */
+  u8 *z2;                /* s2 string */
+  int s=0;
+  int rVal=0;
+
+  assert( argc==3 ||argc==2);
+
+  if( SQLITE_NULL==sqlite3_value_type(argv[0]) || SQLITE_NULL==sqlite3_value_type(argv[1])){
+    sqlite3_result_null(context);
+    return;
+  }
+
+  z1 = sqlite3_value_text(argv[0]);
+  if( z1==0 ) return;
+  z2 = (u8*) sqlite3_value_text(argv[1]);
+  if(argc==3){
+    s = sqlite3_value_int(argv[2])-1;
+    if(s<0){
+      s=0;
+    }
+  }else{
+    s = 0;
+  }
+
+  rVal = _substr((char *)z1,(char *)z2,s,NULL);
+  sqlite3_result_int(context, rVal+1);
+}
+
+/*
+** given a string (s) and an integer (n) returns the n leftmost (UTF-8) characters
+** if the string has a length<=n or is NULL this function is NOP
+*/
+static void leftFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  int c=0;
+  int cc=0;
+  int l=0;
+  const unsigned char *z;       /* input string */
+  const unsigned char *zt;
+  unsigned char *rz;            /* output string */
+
+  assert( argc==2);
+
+  if( SQLITE_NULL==sqlite3_value_type(argv[0]) || SQLITE_NULL==sqlite3_value_type(argv[1])){
+    sqlite3_result_null(context);
+    return;
+  }
+
+  z  = sqlite3_value_text(argv[0]);
+  l  = sqlite3_value_int(argv[1]);
+  zt = z;
+
+  while( sqliteCharVal(zt) && c++<l)
+    sqliteNextChar(zt);
+
+  cc=zt-z;
+
+  rz = sqlite3_malloc(zt-z+1);
+  if (!rz){
+    sqlite3_result_error_nomem(context);
+    return;
+  }
+  strncpy((char*) rz, (char*) z, zt-z);
+  *(rz+cc) = '\0';
+  sqlite3_result_text(context, (char*)rz, -1, SQLITE_TRANSIENT); 
+  sqlite3_free(rz);
+}
+
+/*
+** given a string (s) and an integer (n) returns the n rightmost (UTF-8) characters
+** if the string has a length<=n or is NULL this function is NOP
+*/
+static void rightFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  int l=0;
+  int c=0;
+  int cc=0;
+  const char *z;
+  const char *zt;
+  const char *ze;
+  char *rz;
+
+  assert( argc==2);
+
+  if( SQLITE_NULL == sqlite3_value_type(argv[0]) || SQLITE_NULL == sqlite3_value_type(argv[1])){
+    sqlite3_result_null(context);
+    return;
+  }
+
+  z  = (char *)sqlite3_value_text(argv[0]);
+  l  = sqlite3_value_int(argv[1]);
+  zt = z;
+
+  while( sqliteCharVal((unsigned char *)zt)!=0){
+    sqliteNextChar(zt);
+    ++c;
+  }
+
+  ze = zt;
+  zt = z;
+
+  cc=c-l;
+  if(cc<0)
+    cc=0;
+  
+  while( cc-- > 0 ){
+    sqliteNextChar(zt);
+  }
+
+  rz = sqlite3_malloc(ze-zt+1);
+  if (!rz){
+    sqlite3_result_error_nomem(context);
+    return;
+  }
+  strcpy((char*) rz, (char*) (zt));
+  sqlite3_result_text(context, (char*)rz, -1, SQLITE_TRANSIENT); 
+  sqlite3_free(rz);
+}
+
+#ifndef HAVE_TRIM
+/*
+** removes the whitespaces at the begining of a string.
+*/
+const char* ltrim(const char* s){
+  while( *s==' ' )
+    ++s;
+  return s;
+}
+
+/*
+** removes the whitespaces at the end of a string.
+** !mutates the input string!
+*/
+void rtrim(char* s){
+  char* ss = s+strlen(s)-1;
+  while( ss>=s && *ss==' ' )
+    --ss;
+  *(ss+1)='\0';
+}
+
+/*
+**  Removes the whitespace at the begining of a string
+*/
+static void ltrimFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  const char *z;
+
+  assert( argc==1);
+
+  if( SQLITE_NULL==sqlite3_value_type(argv[0]) ){
+    sqlite3_result_null(context);
+    return;
+  }
+  z = sqlite3_value_text(argv[0]);
+  sqlite3_result_text(context, ltrim(z), -1, SQLITE_TRANSIENT); 
+}
+
+/*
+**  Removes the whitespace at the end of a string
+*/
+static void rtrimFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  const char *z;
+  char *rz;
+  /* try not to change data in argv */
+
+  assert( argc==1);
+
+  if( SQLITE_NULL==sqlite3_value_type(argv[0]) ){
+    sqlite3_result_null(context);
+    return;
+  }
+  z = sqlite3_value_text(argv[0]);
+  rz = sqlite3StrDup(z);
+  rtrim(rz);
+  sqlite3_result_text(context, rz, -1, SQLITE_TRANSIENT);
+  sqlite3_free(rz);
+}
+
+/*
+**  Removes the whitespace at the begining and end of a string
+*/
+static void trimFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  const char *z;
+  char *rz;
+  /* try not to change data in argv */
+
+  assert( argc==1);
+
+  if( SQLITE_NULL==sqlite3_value_type(argv[0]) ){
+    sqlite3_result_null(context);
+    return;
+  }
+  z = sqlite3_value_text(argv[0]);
+  rz = sqlite3StrDup(z);
+  rtrim(rz);
+  sqlite3_result_text(context, ltrim(rz), -1, SQLITE_TRANSIENT);
+  sqlite3_free(rz);
+}
+#endif
+
+/*
+** given a pointer to a string s1, the length of that string (l1), a new string (s2)
+** and it's length (l2) appends s2 to s1.
+** All lengths in bytes.
+** This is just an auxiliary function
+*/
+// static void _append(char **s1, int l1, const char *s2, int l2){
+//   *s1 = realloc(*s1, (l1+l2+1)*sizeof(char));
+//   strncpy((*s1)+l1, s2, l2);
+//   *(*(s1)+l1+l2) = '\0';
+// }
+
+#ifndef HAVE_TRIM
+
+/*
+** given strings s, s1 and s2 replaces occurrences of s1 in s by s2
+*/
+static void replaceFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  const char *z1;     /* string s (first parameter) */
+  const char *z2;     /* string s1 (second parameter) string to look for */
+  const char *z3;     /* string s2 (third parameter) string to replace occurrences of s1 with */
+  int lz1;
+  int lz2;
+  int lz3;
+  int lzo=0;
+  char *zo=0;
+  int ret=0;
+  const char *zt1;
+  const char *zt2;
+
+  assert( 3==argc );
+
+  if( SQLITE_NULL==sqlite3_value_type(argv[0]) ){
+    sqlite3_result_null(context);
+    return;
+  }
+
+  z1 = sqlite3_value_text(argv[0]);
+  z2 = sqlite3_value_text(argv[1]);
+  z3 = sqlite3_value_text(argv[2]);
+  /* handle possible null values */
+  if( 0==z2 ){
+    z2="";
+  }
+  if( 0==z3 ){
+    z3="";
+  }
+
+  lz1 = strlen(z1);
+  lz2 = strlen(z2);
+  lz3 = strlen(z3);
+
+#if 0
+  /* special case when z2 is empty (or null) nothing will be changed */
+  if( 0==lz2 ){
+    sqlite3_result_text(context, z1, -1, SQLITE_TRANSIENT);
+    return;
+  }
+#endif
+
+  zt1=z1;
+  zt2=z1;
+
+  while(1){
+    ret=_substr(z2,zt1 , 0, &zt2);
+
+    if( ret<0 )
+      break;
+
+    _append(&zo, lzo, zt1, zt2-zt1);
+    lzo+=zt2-zt1;
+    _append(&zo, lzo, z3, lz3);
+    lzo+=lz3;
+
+    zt1=zt2+lz2;
+  }
+  _append(&zo, lzo, zt1, lz1-(zt1-z1));
+  sqlite3_result_text(context, zo, -1, SQLITE_TRANSIENT);
+  sqlite3_free(zo);
+}
+#endif
+
+/*
+** given a string returns the same string but with the characters in reverse order
+*/
+static void reverseFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  const char *z;
+  const char *zt;
+  char *rz;
+  char *rzt;
+  int l = 0;
+  int i = 0;
+
+  assert( 1==argc );
+
+  if( SQLITE_NULL==sqlite3_value_type(argv[0]) ){
+    sqlite3_result_null(context);
+    return;
+  }
+  z = (char *)sqlite3_value_text(argv[0]);
+  l = strlen(z);
+  rz = sqlite3_malloc(l+1);
+  if (!rz){
+    sqlite3_result_error_nomem(context);
+    return;
+  }
+  rzt = rz+l;
+  *(rzt--) = '\0';
+
+  zt=z;
+  while( sqliteCharVal((unsigned char *)zt)!=0 ){
+    z=zt;
+    sqliteNextChar(zt);
+    for(i=1; zt-i>=z; ++i){
+      *(rzt--)=*(zt-i);
+    }
+  }
+
+  sqlite3_result_text(context, rz, -1, SQLITE_TRANSIENT);
+  sqlite3_free(rz);
+}
+
+/*
+** An instance of the following structure holds the context of a
+** stdev() or variance() aggregate computation.
+** implementaion of http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Algorithm_II
+** less prone to rounding errors
+*/
+typedef struct StdevCtx StdevCtx;
+struct StdevCtx {
+  double rM;
+  double rS;
+  i64 cnt;          /* number of elements */
+};
+
+/*
+** An instance of the following structure holds the context of a
+** mode() or median() aggregate computation.
+** Depends on structures defined in map.c (see map & map)
+** These aggregate functions only work for integers and floats although
+** they could be made to work for strings. This is usually considered meaningless.
+** Only usuall order (for median), no use of collation functions (would this even make sense?)
+*/
+typedef struct ModeCtx ModeCtx;
+struct ModeCtx {
+  i64 riM;            /* integer value found so far */
+  double rdM;         /* double value found so far */
+  i64 cnt;            /* number of elements so far */
+  double pcnt;        /* number of elements smaller than a percentile */
+  i64 mcnt;           /* maximum number of occurrences (for mode) */
+  i64 mn;             /* number of occurrences (for mode and percentiles) */
+  i64 is_double;      /* whether the computation is being done for doubles (>0) or integers (=0) */
+  map* m;             /* map structure used for the computation */
+  int done;           /* whether the answer has been found */
+};
+
+/*
+** called for each value received during a calculation of stdev or variance
+*/
+static void varianceStep(sqlite3_context *context, int argc, sqlite3_value **argv){
+  StdevCtx *p;
+
+  double delta;
+  double x;
+
+  assert( argc==1 );
+  p = sqlite3_aggregate_context(context, sizeof(*p));
+  /* only consider non-null values */
+  if( SQLITE_NULL != sqlite3_value_numeric_type(argv[0]) ){
+    p->cnt++;
+    x = sqlite3_value_double(argv[0]);
+    delta = (x-p->rM);
+    p->rM += delta/p->cnt;
+    p->rS += delta*(x-p->rM);
+  }
+}
+
+/*
+** called for each value received during a calculation of mode of median
+*/
+static void modeStep(sqlite3_context *context, int argc, sqlite3_value **argv){
+  ModeCtx *p;
+  i64 xi=0;
+  double xd=0.0;
+  i64 *iptr;
+  double *dptr;
+  int type;
+
+  assert( argc==1 );
+  type = sqlite3_value_numeric_type(argv[0]);
+
+  if( type == SQLITE_NULL)
+    return;
+  
+  p = sqlite3_aggregate_context(context, sizeof(*p));
+
+  if( 0==(p->m) ){
+    p->m = calloc(1, sizeof(map));
+    if( type==SQLITE_INTEGER ){
+      /* map will be used for integers */
+      *(p->m) = map_make(int_cmp);
+      p->is_double = 0;
+    }else{
+      p->is_double = 1;
+      /* map will be used for doubles */
+      *(p->m) = map_make(double_cmp);
+    }
+  }
+
+  ++(p->cnt);
+
+  if( 0==p->is_double ){
+    xi = sqlite3_value_int64(argv[0]);
+    iptr = (i64*)calloc(1,sizeof(i64));
+    *iptr = xi;
+    map_insert(p->m, iptr);
+  }else{
+    xd = sqlite3_value_double(argv[0]);
+    dptr = (double*)calloc(1,sizeof(double));
+    *dptr = xd;
+    map_insert(p->m, dptr);
+  }
+}
+
+/*
+**  Auxiliary function that iterates all elements in a map and finds the mode
+**  (most frequent value)
+*/
+static void modeIterate(void* e, i64 c, void* pp){
+  i64 ei;
+  double ed;
+  ModeCtx *p = (ModeCtx*)pp;
+  
+  if( 0==p->is_double ){
+    ei = *(int*)(e);
+
+	if( p->mcnt==c ){
+      ++p->mn;
+    }else if( p->mcnt<c ){
+      p->riM = ei;
+      p->mcnt = c;
+	  p->mn=1;
+    }
+  }else{
+    ed = *(double*)(e);
+
+	if( p->mcnt==c ){
+      ++p->mn;
+    }else if(p->mcnt<c){
+      p->rdM = ed;
+      p->mcnt = c;
+	  p->mn=1;
+    }
+  }
+}
+
+/*
+**  Auxiliary function that iterates all elements in a map and finds the median
+**  (the value such that the number of elements smaller is equal the the number of 
+**  elements larger)
+*/
+static void medianIterate(void* e, i64 c, void* pp){
+  i64 ei;
+  double ed;
+  double iL;
+  double iR;
+  int il;
+  int ir;
+  ModeCtx *p = (ModeCtx*)pp;
+
+  if(p->done>0)
+    return;
+
+  iL = p->pcnt;
+  iR = p->cnt - p->pcnt;
+  il = p->mcnt + c;
+  ir = p->cnt - p->mcnt;
+
+  if( il >= iL ){
+    if( ir >= iR ){
+    ++p->mn;
+      if( 0==p->is_double ){
+        ei = *(int*)(e);
+        p->riM += ei;
+      }else{
+        ed = *(double*)(e);
+        p->rdM += ed;
+      }
+    }else{
+      p->done=1;
+    }
+  }
+  p->mcnt+=c;
+}
+
+/*
+** Returns the mode value
+*/
+static void modeFinalize(sqlite3_context *context){
+  ModeCtx *p;
+  p = sqlite3_aggregate_context(context, 0);
+  if( p && p->m ){
+    map_iterate(p->m, modeIterate, p);
+    map_destroy(p->m);
+    free(p->m);
+
+    if( 1==p->mn ){
+      if( 0==p->is_double )
+        sqlite3_result_int64(context, p->riM);
+      else
+        sqlite3_result_double(context, p->rdM);
+    }
+  }
+}
+
+/*
+** auxiliary function for percentiles
+*/
+static void _medianFinalize(sqlite3_context *context){
+  ModeCtx *p;
+  p = (ModeCtx*) sqlite3_aggregate_context(context, 0);
+  if( p && p->m ){
+    p->done=0;
+    map_iterate(p->m, medianIterate, p);
+    map_destroy(p->m);
+    free(p->m);
+
+    if( 0==p->is_double )
+      if( 1==p->mn )
+      	sqlite3_result_int64(context, p->riM);
+      else
+      	sqlite3_result_double(context, p->riM*1.0/p->mn);
+    else
+      sqlite3_result_double(context, p->rdM/p->mn);
+  }
+}
+
+/*
+** Returns the median value
+*/
+static void medianFinalize(sqlite3_context *context){
+  ModeCtx *p;
+  p = (ModeCtx*) sqlite3_aggregate_context(context, 0);
+  if( p!=0 ){
+    p->pcnt = (p->cnt)/2.0;
+    _medianFinalize(context);
+  }
+}
+
+/*
+** Returns the lower_quartile value
+*/
+static void lower_quartileFinalize(sqlite3_context *context){
+  ModeCtx *p;
+  p = (ModeCtx*) sqlite3_aggregate_context(context, 0);
+  if( p!=0 ){
+    p->pcnt = (p->cnt)/4.0;
+    _medianFinalize(context);
+  }
+}
+
+/*
+** Returns the upper_quartile value
+*/
+static void upper_quartileFinalize(sqlite3_context *context){
+  ModeCtx *p;
+  p = (ModeCtx*) sqlite3_aggregate_context(context, 0);
+  if( p!=0 ){
+    p->pcnt = (p->cnt)*3/4.0;
+    _medianFinalize(context);
+  }
+}
+
+/*
+** Returns the stdev value
+*/
+static void stdevFinalize(sqlite3_context *context){
+  StdevCtx *p;
+  p = sqlite3_aggregate_context(context, 0);
+  if( p && p->cnt>1 ){
+    sqlite3_result_double(context, sqrt(p->rS/(p->cnt-1)));
+  }else{
+    sqlite3_result_double(context, 0.0);
+  }
+}
+
+/*
+** Returns the variance value
+*/
+static void varianceFinalize(sqlite3_context *context){
+  StdevCtx *p;
+  p = sqlite3_aggregate_context(context, 0);
+  if( p && p->cnt>1 ){
+    sqlite3_result_double(context, p->rS/(p->cnt-1));
+  }else{
+    sqlite3_result_double(context, 0.0);
+  }
+}
+
+#ifdef SQLITE_SOUNDEX
+
+/* relicoder factored code */
+/*
+** Calculates the soundex value of a string
+*/
+
+static void soundex(const u8 *zIn, char *zResult){
+  int i, j;
+  static const unsigned char iCode[] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
+    1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
+    0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
+    1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
+  };
+
+  for(i=0; zIn[i] && !isalpha(zIn[i]); i++){}
+  if( zIn[i] ){
+    zResult[0] = toupper(zIn[i]);
+    for(j=1; j<4 && zIn[i]; i++){
+      int code = iCode[zIn[i]&0x7f];
+      if( code>0 ){
+        zResult[j++] = code + '0';
+      }
+    }
+    while( j<4 ){
+      zResult[j++] = '0';
+    }
+    zResult[j] = 0;
+  }else{
+    strcpy(zResult, "?000");
+  }
+}
+
+/*
+** computes the number of different characters between the soundex value fo 2 strings
+*/
+static void differenceFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
+  char zResult1[8];
+  char zResult2[8];
+  char *zR1 = zResult1;
+  char *zR2 = zResult2;
+  int rVal = 0;
+  int i = 0;
+  const u8 *zIn1;
+  const u8 *zIn2;
+
+  assert( argc==2 );
+  
+  if( sqlite3_value_type(argv[0])==SQLITE_NULL || sqlite3_value_type(argv[1])==SQLITE_NULL ){
+    sqlite3_result_null(context);
+    return;
+  }
+  
+  zIn1 = (u8*)sqlite3_value_text(argv[0]);
+  zIn2 = (u8*)sqlite3_value_text(argv[1]);
+
+  soundex(zIn1, zR1);
+  soundex(zIn2, zR2);
+
+  for(i=0; i<4; ++i){
+    if( sqliteCharVal((unsigned char *)zR1)==sqliteCharVal((unsigned char *)zR2) )
+      ++rVal;
+    sqliteNextChar(zR1);
+    sqliteNextChar(zR2);
+  }
+  sqlite3_result_int(context, rVal);
+}
+#endif
+
+/*
+** This function registered all of the above C functions as SQL
+** functions.  This should be the only routine in this file with
+** external linkage.
+*/
+int RegisterExtensionFunctions(sqlite3 *db){
+  static const struct FuncDef {
+     char *zName;
+     signed char nArg;
+     u8 argType;           /* 0: none.  1: db  2: (-1) */
+     u8 eTextRep;          /* 1: UTF-16.  0: UTF-8 */
+     u8 needCollSeq;
+     void (*xFunc)(sqlite3_context*,int,sqlite3_value **);
+  } aFuncs[] = {
+    /* math.h */
+    { "acos",               1, 0, SQLITE_UTF8,    0, acosFunc  },
+    { "asin",               1, 0, SQLITE_UTF8,    0, asinFunc  },
+    { "atan",               1, 0, SQLITE_UTF8,    0, atanFunc  },
+    { "atn2",               2, 0, SQLITE_UTF8,    0, atn2Func  },
+    /* XXX alias */
+    { "atan2",              2, 0, SQLITE_UTF8,    0, atn2Func  },
+    { "acosh",              1, 0, SQLITE_UTF8,    0, acoshFunc  },
+    { "asinh",              1, 0, SQLITE_UTF8,    0, asinhFunc  },
+    { "atanh",              1, 0, SQLITE_UTF8,    0, atanhFunc  },
+
+    { "difference",         2, 0, SQLITE_UTF8,    0, differenceFunc},
+    { "degrees",            1, 0, SQLITE_UTF8,    0, rad2degFunc  },
+    { "radians",            1, 0, SQLITE_UTF8,    0, deg2radFunc  },
+
+    { "cos",                1, 0, SQLITE_UTF8,    0, cosFunc  },
+    { "sin",                1, 0, SQLITE_UTF8,    0, sinFunc },
+    { "tan",                1, 0, SQLITE_UTF8,    0, tanFunc },
+    { "cot",                1, 0, SQLITE_UTF8,    0, cotFunc },
+    { "cosh",               1, 0, SQLITE_UTF8,    0, coshFunc  },
+    { "sinh",               1, 0, SQLITE_UTF8,    0, sinhFunc },
+    { "tanh",               1, 0, SQLITE_UTF8,    0, tanhFunc },
+    { "coth",               1, 0, SQLITE_UTF8,    0, cothFunc },
+
+    { "exp",                1, 0, SQLITE_UTF8,    0, expFunc  },
+    { "log",                1, 0, SQLITE_UTF8,    0, logFunc  },
+    { "log10",              1, 0, SQLITE_UTF8,    0, log10Func  },
+    { "power",              2, 0, SQLITE_UTF8,    0, powerFunc  },
+    { "sign",               1, 0, SQLITE_UTF8,    0, signFunc },
+    { "sqrt",               1, 0, SQLITE_UTF8,    0, sqrtFunc },
+    { "square",             1, 0, SQLITE_UTF8,    0, squareFunc },
+
+    { "ceil",               1, 0, SQLITE_UTF8,    0, ceilFunc },
+    { "floor",              1, 0, SQLITE_UTF8,    0, floorFunc },
+
+    { "pi",                 0, 0, SQLITE_UTF8,    1, piFunc },
+
+
+    /* string */
+    { "replicate",          2, 0, SQLITE_UTF8,    0, replicateFunc },
+    { "charindex",          2, 0, SQLITE_UTF8,    0, charindexFunc },
+    { "charindex",          3, 0, SQLITE_UTF8,    0, charindexFunc },
+    { "leftstr",            2, 0, SQLITE_UTF8,    0, leftFunc },
+    { "rightstr",           2, 0, SQLITE_UTF8,    0, rightFunc },
+#ifndef HAVE_TRIM
+    { "ltrim",              1, 0, SQLITE_UTF8,    0, ltrimFunc },
+    { "rtrim",              1, 0, SQLITE_UTF8,    0, rtrimFunc },
+    { "trim",               1, 0, SQLITE_UTF8,    0, trimFunc },
+    { "replace",            3, 0, SQLITE_UTF8,    0, replaceFunc },
+#endif
+    { "reverse",            1, 0, SQLITE_UTF8,    0, reverseFunc },
+    { "proper",             1, 0, SQLITE_UTF8,    0, properFunc },
+    { "padl",               2, 0, SQLITE_UTF8,    0, padlFunc },
+    { "padr",               2, 0, SQLITE_UTF8,    0, padrFunc },
+    { "padc",               2, 0, SQLITE_UTF8,    0, padcFunc },
+    { "strfilter",          2, 0, SQLITE_UTF8,    0, strfilterFunc },
+
+  };
+  /* Aggregate functions */
+  static const struct FuncDefAgg {
+    char *zName;
+    signed char nArg;
+    u8 argType;
+    u8 needCollSeq;
+    void (*xStep)(sqlite3_context*,int,sqlite3_value**);
+    void (*xFinalize)(sqlite3_context*);
+  } aAggs[] = {
+    { "stdev",            1, 0, 0, varianceStep, stdevFinalize  },
+    { "variance",         1, 0, 0, varianceStep, varianceFinalize  },
+    { "mode",             1, 0, 0, modeStep,     modeFinalize  },
+    { "median",           1, 0, 0, modeStep,     medianFinalize  },
+    { "lower_quartile",   1, 0, 0, modeStep,     lower_quartileFinalize  },
+    { "upper_quartile",   1, 0, 0, modeStep,     upper_quartileFinalize  },
+  };
+  int i;
+
+  for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
+    void *pArg = 0;
+    switch( aFuncs[i].argType ){
+      case 1: pArg = db; break;
+      case 2: pArg = (void *)(-1); break;
+    }
+    //sqlite3CreateFunc
+    /* LMH no error checking */
+    sqlite3_create_function(db, aFuncs[i].zName, aFuncs[i].nArg,
+        aFuncs[i].eTextRep, pArg, aFuncs[i].xFunc, 0, 0);
+#if 0
+    if( aFuncs[i].needCollSeq ){
+      struct FuncDef *pFunc = sqlite3FindFunction(db, aFuncs[i].zName, 
+          strlen(aFuncs[i].zName), aFuncs[i].nArg, aFuncs[i].eTextRep, 0);
+      if( pFunc && aFuncs[i].needCollSeq ){
+        pFunc->needCollSeq = 1;
+      }
+    }
+#endif
+  }
+
+  for(i=0; i<sizeof(aAggs)/sizeof(aAggs[0]); i++){
+    void *pArg = 0;
+    switch( aAggs[i].argType ){
+      case 1: pArg = db; break;
+      case 2: pArg = (void *)(-1); break;
+    }
+    //sqlite3CreateFunc
+    /* LMH no error checking */
+    sqlite3_create_function(db, aAggs[i].zName, aAggs[i].nArg, SQLITE_UTF8, 
+        pArg, 0, aAggs[i].xStep, aAggs[i].xFinalize);
+#if 0
+    if( aAggs[i].needCollSeq ){
+      struct FuncDefAgg *pFunc = sqlite3FindFunction( db, aAggs[i].zName,
+          strlen(aAggs[i].zName), aAggs[i].nArg, SQLITE_UTF8, 0);
+      if( pFunc && aAggs[i].needCollSeq ){
+        pFunc->needCollSeq = 1;
+      }
+    }
+#endif
+  }
+  return 0;
+}
+
+#ifdef COMPILE_SQLITE_EXTENSIONS_AS_LOADABLE_MODULE
+int sqlite3_extension_init(
+    sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi){
+  SQLITE_EXTENSION_INIT2(pApi);
+  RegisterExtensionFunctions(db);
+  return 0;
+}
+#endif /* COMPILE_SQLITE_EXTENSIONS_AS_LOADABLE_MODULE */
+
+map map_make(cmp_func cmp){
+  map r;
+  r.cmp=cmp;
+  r.base = 0;
+
+  return r;
+}
+
+void* xcalloc(size_t nmemb, size_t size, char* s){
+  void* ret = calloc(nmemb, size);
+  return ret;
+}
+
+void xfree(void* p){
+  free(p);
+}
+
+void node_insert(node** n, cmp_func cmp, void *e){
+  int c;
+  node* nn;
+  if(*n==0){
+    nn = (node*)xcalloc(1,sizeof(node), "for node");
+    nn->data = e;
+    nn->count = 1;
+    *n=nn;
+  }else{
+    c=cmp((*n)->data,e);
+    if(0==c){
+      ++((*n)->count);
+      xfree(e);
+    }else if(c>0){
+      /* put it right here */
+      node_insert(&((*n)->l), cmp, e);
+    }else{
+      node_insert(&((*n)->r), cmp, e);
+    }
+  }
+}
+
+void map_insert(map *m, void *e){
+  node_insert(&(m->base), m->cmp, e);
+}
+
+void node_iterate(node *n, map_iterator iter, void* p){
+  if(n){
+    if(n->l)
+      node_iterate(n->l, iter, p);
+    iter(n->data, n->count, p);
+    if(n->r)
+      node_iterate(n->r, iter, p);
+  }
+}
+
+void map_iterate(map *m, map_iterator iter, void* p){
+  node_iterate(m->base, iter, p);
+}
+
+void node_destroy(node *n){
+  if(0!=n){
+    xfree(n->data);
+    if(n->l)
+      node_destroy(n->l);
+    if(n->r)
+      node_destroy(n->r);
+
+    xfree(n);
+  }
+}
+
+void map_destroy(map *m){
+  node_destroy(m->base);
+}
+
+int int_cmp(const void *a, const void *b){
+  int64_t aa = *(int64_t *)(a);
+  int64_t bb = *(int64_t *)(b);
+  /* printf("cmp %d <=> %d\n",aa,bb); */
+  if(aa==bb)
+    return 0;
+  else if(aa<bb)
+    return -1;
+  else
+    return 1;
+}
+
+int double_cmp(const void *a, const void *b){
+  double aa = *(double *)(a);
+  double bb = *(double *)(b);
+  /* printf("cmp %d <=> %d\n",aa,bb); */
+  if(aa==bb)
+    return 0;
+  else if(aa<bb)
+    return -1;
+  else
+    return 1;
+}
+
+void print_elem(void *e, int64_t c, void* p){
+  int ee = *(int*)(e);
+  printf("%d => %lld\n", ee,c);
+}
+
diff --git a/math-func.dll b/math-func.dll
new file mode 100644
index 0000000..973c878
Binary files /dev/null and b/math-func.dll differ