added ogg/vorbis source code for ease of building on msvc
authorJohn Tsiombikas <nuclear@member.fsf.org>
Wed, 12 Sep 2018 23:21:34 +0000 (02:21 +0300)
committerJohn Tsiombikas <nuclear@member.fsf.org>
Wed, 12 Sep 2018 23:21:34 +0000 (02:21 +0300)
76 files changed:
libs/ogg/AUTHORS [new file with mode: 0644]
libs/ogg/COPYING [new file with mode: 0644]
libs/ogg/bitwise.c [new file with mode: 0644]
libs/ogg/config_types.h [new file with mode: 0644]
libs/ogg/framing.c [new file with mode: 0644]
libs/ogg/ogg.h [new file with mode: 0644]
libs/ogg/os_types.h [new file with mode: 0644]
libs/vorbis/AUTHORS [new file with mode: 0644]
libs/vorbis/COPYING [new file with mode: 0644]
libs/vorbis/analysis.c [new file with mode: 0644]
libs/vorbis/backends.h [new file with mode: 0644]
libs/vorbis/bitrate.c [new file with mode: 0644]
libs/vorbis/bitrate.h [new file with mode: 0644]
libs/vorbis/block.c [new file with mode: 0644]
libs/vorbis/books/coupled/res_books_51.h [new file with mode: 0644]
libs/vorbis/books/coupled/res_books_stereo.h [new file with mode: 0644]
libs/vorbis/books/floor/floor_books.h [new file with mode: 0644]
libs/vorbis/books/uncoupled/res_books_uncoupled.h [new file with mode: 0644]
libs/vorbis/codebook.c [new file with mode: 0644]
libs/vorbis/codebook.h [new file with mode: 0644]
libs/vorbis/codec.h [new file with mode: 0644]
libs/vorbis/codec_internal.h [new file with mode: 0644]
libs/vorbis/envelope.c [new file with mode: 0644]
libs/vorbis/envelope.h [new file with mode: 0644]
libs/vorbis/floor0.c [new file with mode: 0644]
libs/vorbis/floor1.c [new file with mode: 0644]
libs/vorbis/highlevel.h [new file with mode: 0644]
libs/vorbis/info.c [new file with mode: 0644]
libs/vorbis/lookup.c [new file with mode: 0644]
libs/vorbis/lookup.h [new file with mode: 0644]
libs/vorbis/lookup_data.h [new file with mode: 0644]
libs/vorbis/lpc.c [new file with mode: 0644]
libs/vorbis/lpc.h [new file with mode: 0644]
libs/vorbis/lsp.c [new file with mode: 0644]
libs/vorbis/lsp.h [new file with mode: 0644]
libs/vorbis/mapping0.c [new file with mode: 0644]
libs/vorbis/masking.h [new file with mode: 0644]
libs/vorbis/mdct.c [new file with mode: 0644]
libs/vorbis/mdct.h [new file with mode: 0644]
libs/vorbis/misc.h [new file with mode: 0644]
libs/vorbis/modes/floor_all.h [new file with mode: 0644]
libs/vorbis/modes/psych_11.h [new file with mode: 0644]
libs/vorbis/modes/psych_16.h [new file with mode: 0644]
libs/vorbis/modes/psych_44.h [new file with mode: 0644]
libs/vorbis/modes/psych_8.h [new file with mode: 0644]
libs/vorbis/modes/residue_16.h [new file with mode: 0644]
libs/vorbis/modes/residue_44.h [new file with mode: 0644]
libs/vorbis/modes/residue_44p51.h [new file with mode: 0644]
libs/vorbis/modes/residue_44u.h [new file with mode: 0644]
libs/vorbis/modes/residue_8.h [new file with mode: 0644]
libs/vorbis/modes/setup_11.h [new file with mode: 0644]
libs/vorbis/modes/setup_16.h [new file with mode: 0644]
libs/vorbis/modes/setup_22.h [new file with mode: 0644]
libs/vorbis/modes/setup_32.h [new file with mode: 0644]
libs/vorbis/modes/setup_44.h [new file with mode: 0644]
libs/vorbis/modes/setup_44p51.h [new file with mode: 0644]
libs/vorbis/modes/setup_44u.h [new file with mode: 0644]
libs/vorbis/modes/setup_8.h [new file with mode: 0644]
libs/vorbis/modes/setup_X.h [new file with mode: 0644]
libs/vorbis/os.h [new file with mode: 0644]
libs/vorbis/psy.c [new file with mode: 0644]
libs/vorbis/psy.h [new file with mode: 0644]
libs/vorbis/registry.c [new file with mode: 0644]
libs/vorbis/registry.h [new file with mode: 0644]
libs/vorbis/res0.c [new file with mode: 0644]
libs/vorbis/scales.h [new file with mode: 0644]
libs/vorbis/sharedbook.c [new file with mode: 0644]
libs/vorbis/smallft.c [new file with mode: 0644]
libs/vorbis/smallft.h [new file with mode: 0644]
libs/vorbis/synthesis.c [new file with mode: 0644]
libs/vorbis/vorbisenc.c [new file with mode: 0644]
libs/vorbis/vorbisenc.h [new file with mode: 0644]
libs/vorbis/vorbisfile.c [new file with mode: 0644]
libs/vorbis/vorbisfile.h [new file with mode: 0644]
libs/vorbis/window.c [new file with mode: 0644]
libs/vorbis/window.h [new file with mode: 0644]

diff --git a/libs/ogg/AUTHORS b/libs/ogg/AUTHORS
new file mode 100644 (file)
index 0000000..a0023f2
--- /dev/null
@@ -0,0 +1,7 @@
+Monty <monty@xiph.org>
+Greg Maxwell <greg@xiph.org>
+Ralph Giles <giles@xiph.org>
+Cristian Adam <cristian.adam@gmail.com>
+Tim Terriberry <tterribe@xiph.org>
+
+and the rest of the Xiph.Org Foundation.
diff --git a/libs/ogg/COPYING b/libs/ogg/COPYING
new file mode 100644 (file)
index 0000000..6111c6c
--- /dev/null
@@ -0,0 +1,28 @@
+Copyright (c) 2002, Xiph.org Foundation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+- Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+- Neither the name of the Xiph.org Foundation nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/libs/ogg/bitwise.c b/libs/ogg/bitwise.c
new file mode 100644 (file)
index 0000000..68aca67
--- /dev/null
@@ -0,0 +1,857 @@
+/********************************************************************
+ *                                                                  *
+ * THIS FILE IS PART OF THE Ogg CONTAINER SOURCE CODE.              *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
+ *                                                                  *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2010             *
+ * by the Xiph.Org Foundation http://www.xiph.org/                  *
+ *                                                                  *
+ ********************************************************************
+
+  function: packing variable sized words into an octet stream
+  last mod: $Id: bitwise.c 18051 2011-08-04 17:56:39Z giles $
+
+ ********************************************************************/
+
+/* We're 'LSb' endian; if we write a word but read individual bits,
+   then we'll read the lsb first */
+
+#include <string.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <ogg/ogg.h>
+
+#define BUFFER_INCREMENT 256
+
+static const unsigned long mask[]=
+{0x00000000,0x00000001,0x00000003,0x00000007,0x0000000f,
+ 0x0000001f,0x0000003f,0x0000007f,0x000000ff,0x000001ff,
+ 0x000003ff,0x000007ff,0x00000fff,0x00001fff,0x00003fff,
+ 0x00007fff,0x0000ffff,0x0001ffff,0x0003ffff,0x0007ffff,
+ 0x000fffff,0x001fffff,0x003fffff,0x007fffff,0x00ffffff,
+ 0x01ffffff,0x03ffffff,0x07ffffff,0x0fffffff,0x1fffffff,
+ 0x3fffffff,0x7fffffff,0xffffffff };
+
+static const unsigned int mask8B[]=
+{0x00,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff};
+
+void oggpack_writeinit(oggpack_buffer *b){
+  memset(b,0,sizeof(*b));
+  b->ptr=b->buffer=_ogg_malloc(BUFFER_INCREMENT);
+  b->buffer[0]='\0';
+  b->storage=BUFFER_INCREMENT;
+}
+
+void oggpackB_writeinit(oggpack_buffer *b){
+  oggpack_writeinit(b);
+}
+
+int oggpack_writecheck(oggpack_buffer *b){
+  if(!b->ptr || !b->storage)return -1;
+  return 0;
+}
+
+int oggpackB_writecheck(oggpack_buffer *b){
+  return oggpack_writecheck(b);
+}
+
+void oggpack_writetrunc(oggpack_buffer *b,long bits){
+  long bytes=bits>>3;
+  if(b->ptr){
+    bits-=bytes*8;
+    b->ptr=b->buffer+bytes;
+    b->endbit=bits;
+    b->endbyte=bytes;
+    *b->ptr&=mask[bits];
+  }
+}
+
+void oggpackB_writetrunc(oggpack_buffer *b,long bits){
+  long bytes=bits>>3;
+  if(b->ptr){
+    bits-=bytes*8;
+    b->ptr=b->buffer+bytes;
+    b->endbit=bits;
+    b->endbyte=bytes;
+    *b->ptr&=mask8B[bits];
+  }
+}
+
+/* Takes only up to 32 bits. */
+void oggpack_write(oggpack_buffer *b,unsigned long value,int bits){
+  if(bits<0 || bits>32) goto err;
+  if(b->endbyte>=b->storage-4){
+    void *ret;
+    if(!b->ptr)return;
+    if(b->storage>LONG_MAX-BUFFER_INCREMENT) goto err;
+    ret=_ogg_realloc(b->buffer,b->storage+BUFFER_INCREMENT);
+    if(!ret) goto err;
+    b->buffer=ret;
+    b->storage+=BUFFER_INCREMENT;
+    b->ptr=b->buffer+b->endbyte;
+  }
+
+  value&=mask[bits];
+  bits+=b->endbit;
+
+  b->ptr[0]|=value<<b->endbit;
+
+  if(bits>=8){
+    b->ptr[1]=(unsigned char)(value>>(8-b->endbit));
+    if(bits>=16){
+      b->ptr[2]=(unsigned char)(value>>(16-b->endbit));
+      if(bits>=24){
+        b->ptr[3]=(unsigned char)(value>>(24-b->endbit));
+        if(bits>=32){
+          if(b->endbit)
+            b->ptr[4]=(unsigned char)(value>>(32-b->endbit));
+          else
+            b->ptr[4]=0;
+        }
+      }
+    }
+  }
+
+  b->endbyte+=bits/8;
+  b->ptr+=bits/8;
+  b->endbit=bits&7;
+  return;
+ err:
+  oggpack_writeclear(b);
+}
+
+/* Takes only up to 32 bits. */
+void oggpackB_write(oggpack_buffer *b,unsigned long value,int bits){
+  if(bits<0 || bits>32) goto err;
+  if(b->endbyte>=b->storage-4){
+    void *ret;
+    if(!b->ptr)return;
+    if(b->storage>LONG_MAX-BUFFER_INCREMENT) goto err;
+    ret=_ogg_realloc(b->buffer,b->storage+BUFFER_INCREMENT);
+    if(!ret) goto err;
+    b->buffer=ret;
+    b->storage+=BUFFER_INCREMENT;
+    b->ptr=b->buffer+b->endbyte;
+  }
+
+  value=(value&mask[bits])<<(32-bits);
+  bits+=b->endbit;
+
+  b->ptr[0]|=value>>(24+b->endbit);
+
+  if(bits>=8){
+    b->ptr[1]=(unsigned char)(value>>(16+b->endbit));
+    if(bits>=16){
+      b->ptr[2]=(unsigned char)(value>>(8+b->endbit));
+      if(bits>=24){
+        b->ptr[3]=(unsigned char)(value>>(b->endbit));
+        if(bits>=32){
+          if(b->endbit)
+            b->ptr[4]=(unsigned char)(value<<(8-b->endbit));
+          else
+            b->ptr[4]=0;
+        }
+      }
+    }
+  }
+
+  b->endbyte+=bits/8;
+  b->ptr+=bits/8;
+  b->endbit=bits&7;
+  return;
+ err:
+  oggpack_writeclear(b);
+}
+
+void oggpack_writealign(oggpack_buffer *b){
+  int bits=8-b->endbit;
+  if(bits<8)
+    oggpack_write(b,0,bits);
+}
+
+void oggpackB_writealign(oggpack_buffer *b){
+  int bits=8-b->endbit;
+  if(bits<8)
+    oggpackB_write(b,0,bits);
+}
+
+static void oggpack_writecopy_helper(oggpack_buffer *b,
+                                     void *source,
+                                     long bits,
+                                     void (*w)(oggpack_buffer *,
+                                               unsigned long,
+                                               int),
+                                     int msb){
+  unsigned char *ptr=(unsigned char *)source;
+
+  long bytes=bits/8;
+  bits-=bytes*8;
+
+  if(b->endbit){
+    int i;
+    /* unaligned copy.  Do it the hard way. */
+    for(i=0;i<bytes;i++)
+      w(b,(unsigned long)(ptr[i]),8);
+  }else{
+    /* aligned block copy */
+    if(b->endbyte+bytes+1>=b->storage){
+      void *ret;
+      if(!b->ptr) goto err;
+      if(b->endbyte+bytes+BUFFER_INCREMENT>b->storage) goto err;
+      b->storage=b->endbyte+bytes+BUFFER_INCREMENT;
+      ret=_ogg_realloc(b->buffer,b->storage);
+      if(!ret) goto err;
+      b->buffer=ret;
+      b->ptr=b->buffer+b->endbyte;
+    }
+
+    memmove(b->ptr,source,bytes);
+    b->ptr+=bytes;
+    b->endbyte+=bytes;
+    *b->ptr=0;
+
+  }
+  if(bits){
+    if(msb)
+      w(b,(unsigned long)(ptr[bytes]>>(8-bits)),bits);
+    else
+      w(b,(unsigned long)(ptr[bytes]),bits);
+  }
+  return;
+ err:
+  oggpack_writeclear(b);
+}
+
+void oggpack_writecopy(oggpack_buffer *b,void *source,long bits){
+  oggpack_writecopy_helper(b,source,bits,oggpack_write,0);
+}
+
+void oggpackB_writecopy(oggpack_buffer *b,void *source,long bits){
+  oggpack_writecopy_helper(b,source,bits,oggpackB_write,1);
+}
+
+void oggpack_reset(oggpack_buffer *b){
+  if(!b->ptr)return;
+  b->ptr=b->buffer;
+  b->buffer[0]=0;
+  b->endbit=b->endbyte=0;
+}
+
+void oggpackB_reset(oggpack_buffer *b){
+  oggpack_reset(b);
+}
+
+void oggpack_writeclear(oggpack_buffer *b){
+  if(b->buffer)_ogg_free(b->buffer);
+  memset(b,0,sizeof(*b));
+}
+
+void oggpackB_writeclear(oggpack_buffer *b){
+  oggpack_writeclear(b);
+}
+
+void oggpack_readinit(oggpack_buffer *b,unsigned char *buf,int bytes){
+  memset(b,0,sizeof(*b));
+  b->buffer=b->ptr=buf;
+  b->storage=bytes;
+}
+
+void oggpackB_readinit(oggpack_buffer *b,unsigned char *buf,int bytes){
+  oggpack_readinit(b,buf,bytes);
+}
+
+/* Read in bits without advancing the bitptr; bits <= 32 */
+long oggpack_look(oggpack_buffer *b,int bits){
+  unsigned long ret;
+  unsigned long m;
+
+  if(bits<0 || bits>32) return -1;
+  m=mask[bits];
+  bits+=b->endbit;
+
+  if(b->endbyte >= b->storage-4){
+    /* not the main path */
+    if(b->endbyte > b->storage-((bits+7)>>3)) return -1;
+    /* special case to avoid reading b->ptr[0], which might be past the end of
+        the buffer; also skips some useless accounting */
+    else if(!bits)return(0L);
+  }
+
+  ret=b->ptr[0]>>b->endbit;
+  if(bits>8){
+    ret|=b->ptr[1]<<(8-b->endbit);
+    if(bits>16){
+      ret|=b->ptr[2]<<(16-b->endbit);
+      if(bits>24){
+        ret|=b->ptr[3]<<(24-b->endbit);
+        if(bits>32 && b->endbit)
+          ret|=b->ptr[4]<<(32-b->endbit);
+      }
+    }
+  }
+  return(m&ret);
+}
+
+/* Read in bits without advancing the bitptr; bits <= 32 */
+long oggpackB_look(oggpack_buffer *b,int bits){
+  unsigned long ret;
+  int m=32-bits;
+
+  if(m<0 || m>32) return -1;
+  bits+=b->endbit;
+
+  if(b->endbyte >= b->storage-4){
+    /* not the main path */
+    if(b->endbyte > b->storage-((bits+7)>>3)) return -1;
+    /* special case to avoid reading b->ptr[0], which might be past the end of
+        the buffer; also skips some useless accounting */
+    else if(!bits)return(0L);
+  }
+
+  ret=b->ptr[0]<<(24+b->endbit);
+  if(bits>8){
+    ret|=b->ptr[1]<<(16+b->endbit);
+    if(bits>16){
+      ret|=b->ptr[2]<<(8+b->endbit);
+      if(bits>24){
+        ret|=b->ptr[3]<<(b->endbit);
+        if(bits>32 && b->endbit)
+          ret|=b->ptr[4]>>(8-b->endbit);
+      }
+    }
+  }
+  return ((ret&0xffffffff)>>(m>>1))>>((m+1)>>1);
+}
+
+long oggpack_look1(oggpack_buffer *b){
+  if(b->endbyte>=b->storage)return(-1);
+  return((b->ptr[0]>>b->endbit)&1);
+}
+
+long oggpackB_look1(oggpack_buffer *b){
+  if(b->endbyte>=b->storage)return(-1);
+  return((b->ptr[0]>>(7-b->endbit))&1);
+}
+
+void oggpack_adv(oggpack_buffer *b,int bits){
+  bits+=b->endbit;
+
+  if(b->endbyte > b->storage-((bits+7)>>3)) goto overflow;
+
+  b->ptr+=bits/8;
+  b->endbyte+=bits/8;
+  b->endbit=bits&7;
+  return;
+
+ overflow:
+  b->ptr=NULL;
+  b->endbyte=b->storage;
+  b->endbit=1;
+}
+
+void oggpackB_adv(oggpack_buffer *b,int bits){
+  oggpack_adv(b,bits);
+}
+
+void oggpack_adv1(oggpack_buffer *b){
+  if(++(b->endbit)>7){
+    b->endbit=0;
+    b->ptr++;
+    b->endbyte++;
+  }
+}
+
+void oggpackB_adv1(oggpack_buffer *b){
+  oggpack_adv1(b);
+}
+
+/* bits <= 32 */
+long oggpack_read(oggpack_buffer *b,int bits){
+  long ret;
+  unsigned long m;
+
+  if(bits<0 || bits>32) goto err;
+  m=mask[bits];
+  bits+=b->endbit;
+
+  if(b->endbyte >= b->storage-4){
+    /* not the main path */
+    if(b->endbyte > b->storage-((bits+7)>>3)) goto overflow;
+    /* special case to avoid reading b->ptr[0], which might be past the end of
+        the buffer; also skips some useless accounting */
+    else if(!bits)return(0L);
+  }
+
+  ret=b->ptr[0]>>b->endbit;
+  if(bits>8){
+    ret|=b->ptr[1]<<(8-b->endbit);
+    if(bits>16){
+      ret|=b->ptr[2]<<(16-b->endbit);
+      if(bits>24){
+        ret|=b->ptr[3]<<(24-b->endbit);
+        if(bits>32 && b->endbit){
+          ret|=b->ptr[4]<<(32-b->endbit);
+        }
+      }
+    }
+  }
+  ret&=m;
+  b->ptr+=bits/8;
+  b->endbyte+=bits/8;
+  b->endbit=bits&7;
+  return ret;
+
+ overflow:
+ err:
+  b->ptr=NULL;
+  b->endbyte=b->storage;
+  b->endbit=1;
+  return -1L;
+}
+
+/* bits <= 32 */
+long oggpackB_read(oggpack_buffer *b,int bits){
+  long ret;
+  long m=32-bits;
+
+  if(m<0 || m>32) goto err;
+  bits+=b->endbit;
+
+  if(b->endbyte+4>=b->storage){
+    /* not the main path */
+    if(b->endbyte > b->storage-((bits+7)>>3)) goto overflow;
+    /* special case to avoid reading b->ptr[0], which might be past the end of
+        the buffer; also skips some useless accounting */
+    else if(!bits)return(0L);
+  }
+
+  ret=b->ptr[0]<<(24+b->endbit);
+  if(bits>8){
+    ret|=b->ptr[1]<<(16+b->endbit);
+    if(bits>16){
+      ret|=b->ptr[2]<<(8+b->endbit);
+      if(bits>24){
+        ret|=b->ptr[3]<<(b->endbit);
+        if(bits>32 && b->endbit)
+          ret|=b->ptr[4]>>(8-b->endbit);
+      }
+    }
+  }
+  ret=((ret&0xffffffffUL)>>(m>>1))>>((m+1)>>1);
+
+  b->ptr+=bits/8;
+  b->endbyte+=bits/8;
+  b->endbit=bits&7;
+  return ret;
+
+ overflow:
+ err:
+  b->ptr=NULL;
+  b->endbyte=b->storage;
+  b->endbit=1;
+  return -1L;
+}
+
+long oggpack_read1(oggpack_buffer *b){
+  long ret;
+
+  if(b->endbyte >= b->storage) goto overflow;
+  ret=(b->ptr[0]>>b->endbit)&1;
+
+  b->endbit++;
+  if(b->endbit>7){
+    b->endbit=0;
+    b->ptr++;
+    b->endbyte++;
+  }
+  return ret;
+
+ overflow:
+  b->ptr=NULL;
+  b->endbyte=b->storage;
+  b->endbit=1;
+  return -1L;
+}
+
+long oggpackB_read1(oggpack_buffer *b){
+  long ret;
+
+  if(b->endbyte >= b->storage) goto overflow;
+  ret=(b->ptr[0]>>(7-b->endbit))&1;
+
+  b->endbit++;
+  if(b->endbit>7){
+    b->endbit=0;
+    b->ptr++;
+    b->endbyte++;
+  }
+  return ret;
+
+ overflow:
+  b->ptr=NULL;
+  b->endbyte=b->storage;
+  b->endbit=1;
+  return -1L;
+}
+
+long oggpack_bytes(oggpack_buffer *b){
+  return(b->endbyte+(b->endbit+7)/8);
+}
+
+long oggpack_bits(oggpack_buffer *b){
+  return(b->endbyte*8+b->endbit);
+}
+
+long oggpackB_bytes(oggpack_buffer *b){
+  return oggpack_bytes(b);
+}
+
+long oggpackB_bits(oggpack_buffer *b){
+  return oggpack_bits(b);
+}
+
+unsigned char *oggpack_get_buffer(oggpack_buffer *b){
+  return(b->buffer);
+}
+
+unsigned char *oggpackB_get_buffer(oggpack_buffer *b){
+  return oggpack_get_buffer(b);
+}
+
+/* Self test of the bitwise routines; everything else is based on
+   them, so they damned well better be solid. */
+
+#ifdef _V_SELFTEST
+#include <stdio.h>
+
+static int ilog(unsigned int v){
+  int ret=0;
+  while(v){
+    ret++;
+    v>>=1;
+  }
+  return(ret);
+}
+
+oggpack_buffer o;
+oggpack_buffer r;
+
+void report(char *in){
+  fprintf(stderr,"%s",in);
+  exit(1);
+}
+
+void cliptest(unsigned long *b,int vals,int bits,int *comp,int compsize){
+  long bytes,i;
+  unsigned char *buffer;
+
+  oggpack_reset(&o);
+  for(i=0;i<vals;i++)
+    oggpack_write(&o,b[i],bits?bits:ilog(b[i]));
+  buffer=oggpack_get_buffer(&o);
+  bytes=oggpack_bytes(&o);
+  if(bytes!=compsize)report("wrong number of bytes!\n");
+  for(i=0;i<bytes;i++)if(buffer[i]!=comp[i]){
+    for(i=0;i<bytes;i++)fprintf(stderr,"%x %x\n",(int)buffer[i],(int)comp[i]);
+    report("wrote incorrect value!\n");
+  }
+  oggpack_readinit(&r,buffer,bytes);
+  for(i=0;i<vals;i++){
+    int tbit=bits?bits:ilog(b[i]);
+    if(oggpack_look(&r,tbit)==-1)
+      report("out of data!\n");
+    if(oggpack_look(&r,tbit)!=(b[i]&mask[tbit]))
+      report("looked at incorrect value!\n");
+    if(tbit==1)
+      if(oggpack_look1(&r)!=(b[i]&mask[tbit]))
+        report("looked at single bit incorrect value!\n");
+    if(tbit==1){
+      if(oggpack_read1(&r)!=(b[i]&mask[tbit]))
+        report("read incorrect single bit value!\n");
+    }else{
+    if(oggpack_read(&r,tbit)!=(b[i]&mask[tbit]))
+      report("read incorrect value!\n");
+    }
+  }
+  if(oggpack_bytes(&r)!=bytes)report("leftover bytes after read!\n");
+}
+
+void cliptestB(unsigned long *b,int vals,int bits,int *comp,int compsize){
+  long bytes,i;
+  unsigned char *buffer;
+
+  oggpackB_reset(&o);
+  for(i=0;i<vals;i++)
+    oggpackB_write(&o,b[i],bits?bits:ilog(b[i]));
+  buffer=oggpackB_get_buffer(&o);
+  bytes=oggpackB_bytes(&o);
+  if(bytes!=compsize)report("wrong number of bytes!\n");
+  for(i=0;i<bytes;i++)if(buffer[i]!=comp[i]){
+    for(i=0;i<bytes;i++)fprintf(stderr,"%x %x\n",(int)buffer[i],(int)comp[i]);
+    report("wrote incorrect value!\n");
+  }
+  oggpackB_readinit(&r,buffer,bytes);
+  for(i=0;i<vals;i++){
+    int tbit=bits?bits:ilog(b[i]);
+    if(oggpackB_look(&r,tbit)==-1)
+      report("out of data!\n");
+    if(oggpackB_look(&r,tbit)!=(b[i]&mask[tbit]))
+      report("looked at incorrect value!\n");
+    if(tbit==1)
+      if(oggpackB_look1(&r)!=(b[i]&mask[tbit]))
+        report("looked at single bit incorrect value!\n");
+    if(tbit==1){
+      if(oggpackB_read1(&r)!=(b[i]&mask[tbit]))
+        report("read incorrect single bit value!\n");
+    }else{
+    if(oggpackB_read(&r,tbit)!=(b[i]&mask[tbit]))
+      report("read incorrect value!\n");
+    }
+  }
+  if(oggpackB_bytes(&r)!=bytes)report("leftover bytes after read!\n");
+}
+
+int main(void){
+  unsigned char *buffer;
+  long bytes,i;
+  static unsigned long testbuffer1[]=
+    {18,12,103948,4325,543,76,432,52,3,65,4,56,32,42,34,21,1,23,32,546,456,7,
+       567,56,8,8,55,3,52,342,341,4,265,7,67,86,2199,21,7,1,5,1,4};
+  int test1size=43;
+
+  static unsigned long testbuffer2[]=
+    {216531625L,1237861823,56732452,131,3212421,12325343,34547562,12313212,
+       1233432,534,5,346435231,14436467,7869299,76326614,167548585,
+       85525151,0,12321,1,349528352};
+  int test2size=21;
+
+  static unsigned long testbuffer3[]=
+    {1,0,14,0,1,0,12,0,1,0,0,0,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,1,1,1,1,1,0,0,1,
+       0,1,30,1,1,1,0,0,1,0,0,0,12,0,11,0,1,0,0,1};
+  int test3size=56;
+
+  static unsigned long large[]=
+    {2136531625L,2137861823,56732452,131,3212421,12325343,34547562,12313212,
+       1233432,534,5,2146435231,14436467,7869299,76326614,167548585,
+       85525151,0,12321,1,2146528352};
+
+  int onesize=33;
+  static int one[33]={146,25,44,151,195,15,153,176,233,131,196,65,85,172,47,40,
+                    34,242,223,136,35,222,211,86,171,50,225,135,214,75,172,
+                    223,4};
+  static int oneB[33]={150,101,131,33,203,15,204,216,105,193,156,65,84,85,222,
+                       8,139,145,227,126,34,55,244,171,85,100,39,195,173,18,
+                       245,251,128};
+
+  int twosize=6;
+  static int two[6]={61,255,255,251,231,29};
+  static int twoB[6]={247,63,255,253,249,120};
+
+  int threesize=54;
+  static int three[54]={169,2,232,252,91,132,156,36,89,13,123,176,144,32,254,
+                      142,224,85,59,121,144,79,124,23,67,90,90,216,79,23,83,
+                      58,135,196,61,55,129,183,54,101,100,170,37,127,126,10,
+                      100,52,4,14,18,86,77,1};
+  static int threeB[54]={206,128,42,153,57,8,183,251,13,89,36,30,32,144,183,
+                         130,59,240,121,59,85,223,19,228,180,134,33,107,74,98,
+                         233,253,196,135,63,2,110,114,50,155,90,127,37,170,104,
+                         200,20,254,4,58,106,176,144,0};
+
+  int foursize=38;
+  static int four[38]={18,6,163,252,97,194,104,131,32,1,7,82,137,42,129,11,72,
+                     132,60,220,112,8,196,109,64,179,86,9,137,195,208,122,169,
+                     28,2,133,0,1};
+  static int fourB[38]={36,48,102,83,243,24,52,7,4,35,132,10,145,21,2,93,2,41,
+                        1,219,184,16,33,184,54,149,170,132,18,30,29,98,229,67,
+                        129,10,4,32};
+
+  int fivesize=45;
+  static int five[45]={169,2,126,139,144,172,30,4,80,72,240,59,130,218,73,62,
+                     241,24,210,44,4,20,0,248,116,49,135,100,110,130,181,169,
+                     84,75,159,2,1,0,132,192,8,0,0,18,22};
+  static int fiveB[45]={1,84,145,111,245,100,128,8,56,36,40,71,126,78,213,226,
+                        124,105,12,0,133,128,0,162,233,242,67,152,77,205,77,
+                        172,150,169,129,79,128,0,6,4,32,0,27,9,0};
+
+  int sixsize=7;
+  static int six[7]={17,177,170,242,169,19,148};
+  static int sixB[7]={136,141,85,79,149,200,41};
+
+  /* Test read/write together */
+  /* Later we test against pregenerated bitstreams */
+  oggpack_writeinit(&o);
+
+  fprintf(stderr,"\nSmall preclipped packing (LSb): ");
+  cliptest(testbuffer1,test1size,0,one,onesize);
+  fprintf(stderr,"ok.");
+
+  fprintf(stderr,"\nNull bit call (LSb): ");
+  cliptest(testbuffer3,test3size,0,two,twosize);
+  fprintf(stderr,"ok.");
+
+  fprintf(stderr,"\nLarge preclipped packing (LSb): ");
+  cliptest(testbuffer2,test2size,0,three,threesize);
+  fprintf(stderr,"ok.");
+
+  fprintf(stderr,"\n32 bit preclipped packing (LSb): ");
+  oggpack_reset(&o);
+  for(i=0;i<test2size;i++)
+    oggpack_write(&o,large[i],32);
+  buffer=oggpack_get_buffer(&o);
+  bytes=oggpack_bytes(&o);
+  oggpack_readinit(&r,buffer,bytes);
+  for(i=0;i<test2size;i++){
+    if(oggpack_look(&r,32)==-1)report("out of data. failed!");
+    if(oggpack_look(&r,32)!=large[i]){
+      fprintf(stderr,"%ld != %ld (%lx!=%lx):",oggpack_look(&r,32),large[i],
+              oggpack_look(&r,32),large[i]);
+      report("read incorrect value!\n");
+    }
+    oggpack_adv(&r,32);
+  }
+  if(oggpack_bytes(&r)!=bytes)report("leftover bytes after read!\n");
+  fprintf(stderr,"ok.");
+
+  fprintf(stderr,"\nSmall unclipped packing (LSb): ");
+  cliptest(testbuffer1,test1size,7,four,foursize);
+  fprintf(stderr,"ok.");
+
+  fprintf(stderr,"\nLarge unclipped packing (LSb): ");
+  cliptest(testbuffer2,test2size,17,five,fivesize);
+  fprintf(stderr,"ok.");
+
+  fprintf(stderr,"\nSingle bit unclipped packing (LSb): ");
+  cliptest(testbuffer3,test3size,1,six,sixsize);
+  fprintf(stderr,"ok.");
+
+  fprintf(stderr,"\nTesting read past end (LSb): ");
+  oggpack_readinit(&r,(unsigned char *)"\0\0\0\0\0\0\0\0",8);
+  for(i=0;i<64;i++){
+    if(oggpack_read(&r,1)!=0){
+      fprintf(stderr,"failed; got -1 prematurely.\n");
+      exit(1);
+    }
+  }
+  if(oggpack_look(&r,1)!=-1 ||
+     oggpack_read(&r,1)!=-1){
+      fprintf(stderr,"failed; read past end without -1.\n");
+      exit(1);
+  }
+  oggpack_readinit(&r,(unsigned char *)"\0\0\0\0\0\0\0\0",8);
+  if(oggpack_read(&r,30)!=0 || oggpack_read(&r,16)!=0){
+      fprintf(stderr,"failed 2; got -1 prematurely.\n");
+      exit(1);
+  }
+
+  if(oggpack_look(&r,18)!=0 ||
+     oggpack_look(&r,18)!=0){
+    fprintf(stderr,"failed 3; got -1 prematurely.\n");
+      exit(1);
+  }
+  if(oggpack_look(&r,19)!=-1 ||
+     oggpack_look(&r,19)!=-1){
+    fprintf(stderr,"failed; read past end without -1.\n");
+      exit(1);
+  }
+  if(oggpack_look(&r,32)!=-1 ||
+     oggpack_look(&r,32)!=-1){
+    fprintf(stderr,"failed; read past end without -1.\n");
+      exit(1);
+  }
+  oggpack_writeclear(&o);
+  fprintf(stderr,"ok.\n");
+
+  /********** lazy, cut-n-paste retest with MSb packing ***********/
+
+  /* Test read/write together */
+  /* Later we test against pregenerated bitstreams */
+  oggpackB_writeinit(&o);
+
+  fprintf(stderr,"\nSmall preclipped packing (MSb): ");
+  cliptestB(testbuffer1,test1size,0,oneB,onesize);
+  fprintf(stderr,"ok.");
+
+  fprintf(stderr,"\nNull bit call (MSb): ");
+  cliptestB(testbuffer3,test3size,0,twoB,twosize);
+  fprintf(stderr,"ok.");
+
+  fprintf(stderr,"\nLarge preclipped packing (MSb): ");
+  cliptestB(testbuffer2,test2size,0,threeB,threesize);
+  fprintf(stderr,"ok.");
+
+  fprintf(stderr,"\n32 bit preclipped packing (MSb): ");
+  oggpackB_reset(&o);
+  for(i=0;i<test2size;i++)
+    oggpackB_write(&o,large[i],32);
+  buffer=oggpackB_get_buffer(&o);
+  bytes=oggpackB_bytes(&o);
+  oggpackB_readinit(&r,buffer,bytes);
+  for(i=0;i<test2size;i++){
+    if(oggpackB_look(&r,32)==-1)report("out of data. failed!");
+    if(oggpackB_look(&r,32)!=large[i]){
+      fprintf(stderr,"%ld != %ld (%lx!=%lx):",oggpackB_look(&r,32),large[i],
+              oggpackB_look(&r,32),large[i]);
+      report("read incorrect value!\n");
+    }
+    oggpackB_adv(&r,32);
+  }
+  if(oggpackB_bytes(&r)!=bytes)report("leftover bytes after read!\n");
+  fprintf(stderr,"ok.");
+
+  fprintf(stderr,"\nSmall unclipped packing (MSb): ");
+  cliptestB(testbuffer1,test1size,7,fourB,foursize);
+  fprintf(stderr,"ok.");
+
+  fprintf(stderr,"\nLarge unclipped packing (MSb): ");
+  cliptestB(testbuffer2,test2size,17,fiveB,fivesize);
+  fprintf(stderr,"ok.");
+
+  fprintf(stderr,"\nSingle bit unclipped packing (MSb): ");
+  cliptestB(testbuffer3,test3size,1,sixB,sixsize);
+  fprintf(stderr,"ok.");
+
+  fprintf(stderr,"\nTesting read past end (MSb): ");
+  oggpackB_readinit(&r,(unsigned char *)"\0\0\0\0\0\0\0\0",8);
+  for(i=0;i<64;i++){
+    if(oggpackB_read(&r,1)!=0){
+      fprintf(stderr,"failed; got -1 prematurely.\n");
+      exit(1);
+    }
+  }
+  if(oggpackB_look(&r,1)!=-1 ||
+     oggpackB_read(&r,1)!=-1){
+      fprintf(stderr,"failed; read past end without -1.\n");
+      exit(1);
+  }
+  oggpackB_readinit(&r,(unsigned char *)"\0\0\0\0\0\0\0\0",8);
+  if(oggpackB_read(&r,30)!=0 || oggpackB_read(&r,16)!=0){
+      fprintf(stderr,"failed 2; got -1 prematurely.\n");
+      exit(1);
+  }
+
+  if(oggpackB_look(&r,18)!=0 ||
+     oggpackB_look(&r,18)!=0){
+    fprintf(stderr,"failed 3; got -1 prematurely.\n");
+      exit(1);
+  }
+  if(oggpackB_look(&r,19)!=-1 ||
+     oggpackB_look(&r,19)!=-1){
+    fprintf(stderr,"failed; read past end without -1.\n");
+      exit(1);
+  }
+  if(oggpackB_look(&r,32)!=-1 ||
+     oggpackB_look(&r,32)!=-1){
+    fprintf(stderr,"failed; read past end without -1.\n");
+      exit(1);
+  }
+  oggpackB_writeclear(&o);
+  fprintf(stderr,"ok.\n\n");
+
+
+  return(0);
+}
+#endif  /* _V_SELFTEST */
+
+#undef BUFFER_INCREMENT
diff --git a/libs/ogg/config_types.h b/libs/ogg/config_types.h
new file mode 100644 (file)
index 0000000..4b00047
--- /dev/null
@@ -0,0 +1,25 @@
+#ifndef __CONFIG_TYPES_H__
+#define __CONFIG_TYPES_H__
+
+/* these are filled in by configure */
+#define INCLUDE_INTTYPES_H 1
+#define INCLUDE_STDINT_H 1
+#define INCLUDE_SYS_TYPES_H 1
+
+#if INCLUDE_INTTYPES_H
+#  include <inttypes.h>
+#endif
+#if INCLUDE_STDINT_H
+#  include <stdint.h>
+#endif
+#if INCLUDE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+
+typedef int16_t ogg_int16_t;
+typedef uint16_t ogg_uint16_t;
+typedef int32_t ogg_int32_t;
+typedef uint32_t ogg_uint32_t;
+typedef int64_t ogg_int64_t;
+
+#endif
diff --git a/libs/ogg/framing.c b/libs/ogg/framing.c
new file mode 100644 (file)
index 0000000..3a2f0a6
--- /dev/null
@@ -0,0 +1,2111 @@
+/********************************************************************
+ *                                                                  *
+ * THIS FILE IS PART OF THE Ogg CONTAINER SOURCE CODE.              *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
+ *                                                                  *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2010             *
+ * by the Xiph.Org Foundation http://www.xiph.org/                  *
+ *                                                                  *
+ ********************************************************************
+
+ function: code raw packets into framed OggSquish stream and
+           decode Ogg streams back into raw packets
+ last mod: $Id: framing.c 18758 2013-01-08 16:29:56Z tterribe $
+
+ note: The CRC code is directly derived from public domain code by
+ Ross Williams (ross@guest.adelaide.edu.au).  See docs/framing.html
+ for details.
+
+ ********************************************************************/
+
+#include <stdlib.h>
+#include <limits.h>
+#include <string.h>
+#include <ogg/ogg.h>
+
+/* A complete description of Ogg framing exists in docs/framing.html */
+
+int ogg_page_version(const ogg_page *og){
+  return((int)(og->header[4]));
+}
+
+int ogg_page_continued(const ogg_page *og){
+  return((int)(og->header[5]&0x01));
+}
+
+int ogg_page_bos(const ogg_page *og){
+  return((int)(og->header[5]&0x02));
+}
+
+int ogg_page_eos(const ogg_page *og){
+  return((int)(og->header[5]&0x04));
+}
+
+ogg_int64_t ogg_page_granulepos(const ogg_page *og){
+  unsigned char *page=og->header;
+  ogg_int64_t granulepos=page[13]&(0xff);
+  granulepos= (granulepos<<8)|(page[12]&0xff);
+  granulepos= (granulepos<<8)|(page[11]&0xff);
+  granulepos= (granulepos<<8)|(page[10]&0xff);
+  granulepos= (granulepos<<8)|(page[9]&0xff);
+  granulepos= (granulepos<<8)|(page[8]&0xff);
+  granulepos= (granulepos<<8)|(page[7]&0xff);
+  granulepos= (granulepos<<8)|(page[6]&0xff);
+  return(granulepos);
+}
+
+int ogg_page_serialno(const ogg_page *og){
+  return(og->header[14] |
+         (og->header[15]<<8) |
+         (og->header[16]<<16) |
+         (og->header[17]<<24));
+}
+
+long ogg_page_pageno(const ogg_page *og){
+  return(og->header[18] |
+         (og->header[19]<<8) |
+         (og->header[20]<<16) |
+         (og->header[21]<<24));
+}
+
+
+
+/* returns the number of packets that are completed on this page (if
+   the leading packet is begun on a previous page, but ends on this
+   page, it's counted */
+
+/* NOTE:
+   If a page consists of a packet begun on a previous page, and a new
+   packet begun (but not completed) on this page, the return will be:
+     ogg_page_packets(page)   ==1,
+     ogg_page_continued(page) !=0
+
+   If a page happens to be a single packet that was begun on a
+   previous page, and spans to the next page (in the case of a three or
+   more page packet), the return will be:
+     ogg_page_packets(page)   ==0,
+     ogg_page_continued(page) !=0
+*/
+
+int ogg_page_packets(const ogg_page *og){
+  int i,n=og->header[26],count=0;
+  for(i=0;i<n;i++)
+    if(og->header[27+i]<255)count++;
+  return(count);
+}
+
+
+#if 0
+/* helper to initialize lookup for direct-table CRC (illustrative; we
+   use the static init below) */
+
+static ogg_uint32_t _ogg_crc_entry(unsigned long index){
+  int           i;
+  unsigned long r;
+
+  r = index << 24;
+  for (i=0; i<8; i++)
+    if (r & 0x80000000UL)
+      r = (r << 1) ^ 0x04c11db7; /* The same as the ethernet generator
+                                    polynomial, although we use an
+                                    unreflected alg and an init/final
+                                    of 0, not 0xffffffff */
+    else
+       r<<=1;
+ return (r & 0xffffffffUL);
+}
+#endif
+
+static const ogg_uint32_t crc_lookup[256]={
+  0x00000000,0x04c11db7,0x09823b6e,0x0d4326d9,
+  0x130476dc,0x17c56b6b,0x1a864db2,0x1e475005,
+  0x2608edb8,0x22c9f00f,0x2f8ad6d6,0x2b4bcb61,
+  0x350c9b64,0x31cd86d3,0x3c8ea00a,0x384fbdbd,
+  0x4c11db70,0x48d0c6c7,0x4593e01e,0x4152fda9,
+  0x5f15adac,0x5bd4b01b,0x569796c2,0x52568b75,
+  0x6a1936c8,0x6ed82b7f,0x639b0da6,0x675a1011,
+  0x791d4014,0x7ddc5da3,0x709f7b7a,0x745e66cd,
+  0x9823b6e0,0x9ce2ab57,0x91a18d8e,0x95609039,
+  0x8b27c03c,0x8fe6dd8b,0x82a5fb52,0x8664e6e5,
+  0xbe2b5b58,0xbaea46ef,0xb7a96036,0xb3687d81,
+  0xad2f2d84,0xa9ee3033,0xa4ad16ea,0xa06c0b5d,
+  0xd4326d90,0xd0f37027,0xddb056fe,0xd9714b49,
+  0xc7361b4c,0xc3f706fb,0xceb42022,0xca753d95,
+  0xf23a8028,0xf6fb9d9f,0xfbb8bb46,0xff79a6f1,
+  0xe13ef6f4,0xe5ffeb43,0xe8bccd9a,0xec7dd02d,
+  0x34867077,0x30476dc0,0x3d044b19,0x39c556ae,
+  0x278206ab,0x23431b1c,0x2e003dc5,0x2ac12072,
+  0x128e9dcf,0x164f8078,0x1b0ca6a1,0x1fcdbb16,
+  0x018aeb13,0x054bf6a4,0x0808d07d,0x0cc9cdca,
+  0x7897ab07,0x7c56b6b0,0x71159069,0x75d48dde,
+  0x6b93dddb,0x6f52c06c,0x6211e6b5,0x66d0fb02,
+  0x5e9f46bf,0x5a5e5b08,0x571d7dd1,0x53dc6066,
+  0x4d9b3063,0x495a2dd4,0x44190b0d,0x40d816ba,
+  0xaca5c697,0xa864db20,0xa527fdf9,0xa1e6e04e,
+  0xbfa1b04b,0xbb60adfc,0xb6238b25,0xb2e29692,
+  0x8aad2b2f,0x8e6c3698,0x832f1041,0x87ee0df6,
+  0x99a95df3,0x9d684044,0x902b669d,0x94ea7b2a,
+  0xe0b41de7,0xe4750050,0xe9362689,0xedf73b3e,
+  0xf3b06b3b,0xf771768c,0xfa325055,0xfef34de2,
+  0xc6bcf05f,0xc27dede8,0xcf3ecb31,0xcbffd686,
+  0xd5b88683,0xd1799b34,0xdc3abded,0xd8fba05a,
+  0x690ce0ee,0x6dcdfd59,0x608edb80,0x644fc637,
+  0x7a089632,0x7ec98b85,0x738aad5c,0x774bb0eb,
+  0x4f040d56,0x4bc510e1,0x46863638,0x42472b8f,
+  0x5c007b8a,0x58c1663d,0x558240e4,0x51435d53,
+  0x251d3b9e,0x21dc2629,0x2c9f00f0,0x285e1d47,
+  0x36194d42,0x32d850f5,0x3f9b762c,0x3b5a6b9b,
+  0x0315d626,0x07d4cb91,0x0a97ed48,0x0e56f0ff,
+  0x1011a0fa,0x14d0bd4d,0x19939b94,0x1d528623,
+  0xf12f560e,0xf5ee4bb9,0xf8ad6d60,0xfc6c70d7,
+  0xe22b20d2,0xe6ea3d65,0xeba91bbc,0xef68060b,
+  0xd727bbb6,0xd3e6a601,0xdea580d8,0xda649d6f,
+  0xc423cd6a,0xc0e2d0dd,0xcda1f604,0xc960ebb3,
+  0xbd3e8d7e,0xb9ff90c9,0xb4bcb610,0xb07daba7,
+  0xae3afba2,0xaafbe615,0xa7b8c0cc,0xa379dd7b,
+  0x9b3660c6,0x9ff77d71,0x92b45ba8,0x9675461f,
+  0x8832161a,0x8cf30bad,0x81b02d74,0x857130c3,
+  0x5d8a9099,0x594b8d2e,0x5408abf7,0x50c9b640,
+  0x4e8ee645,0x4a4ffbf2,0x470cdd2b,0x43cdc09c,
+  0x7b827d21,0x7f436096,0x7200464f,0x76c15bf8,
+  0x68860bfd,0x6c47164a,0x61043093,0x65c52d24,
+  0x119b4be9,0x155a565e,0x18197087,0x1cd86d30,
+  0x029f3d35,0x065e2082,0x0b1d065b,0x0fdc1bec,
+  0x3793a651,0x3352bbe6,0x3e119d3f,0x3ad08088,
+  0x2497d08d,0x2056cd3a,0x2d15ebe3,0x29d4f654,
+  0xc5a92679,0xc1683bce,0xcc2b1d17,0xc8ea00a0,
+  0xd6ad50a5,0xd26c4d12,0xdf2f6bcb,0xdbee767c,
+  0xe3a1cbc1,0xe760d676,0xea23f0af,0xeee2ed18,
+  0xf0a5bd1d,0xf464a0aa,0xf9278673,0xfde69bc4,
+  0x89b8fd09,0x8d79e0be,0x803ac667,0x84fbdbd0,
+  0x9abc8bd5,0x9e7d9662,0x933eb0bb,0x97ffad0c,
+  0xafb010b1,0xab710d06,0xa6322bdf,0xa2f33668,
+  0xbcb4666d,0xb8757bda,0xb5365d03,0xb1f740b4};
+
+/* init the encode/decode logical stream state */
+
+int ogg_stream_init(ogg_stream_state *os,int serialno){
+  if(os){
+    memset(os,0,sizeof(*os));
+    os->body_storage=16*1024;
+    os->lacing_storage=1024;
+
+    os->body_data=_ogg_malloc(os->body_storage*sizeof(*os->body_data));
+    os->lacing_vals=_ogg_malloc(os->lacing_storage*sizeof(*os->lacing_vals));
+    os->granule_vals=_ogg_malloc(os->lacing_storage*sizeof(*os->granule_vals));
+
+    if(!os->body_data || !os->lacing_vals || !os->granule_vals){
+      ogg_stream_clear(os);
+      return -1;
+    }
+
+    os->serialno=serialno;
+
+    return(0);
+  }
+  return(-1);
+}
+
+/* async/delayed error detection for the ogg_stream_state */
+int ogg_stream_check(ogg_stream_state *os){
+  if(!os || !os->body_data) return -1;
+  return 0;
+}
+
+/* _clear does not free os, only the non-flat storage within */
+int ogg_stream_clear(ogg_stream_state *os){
+  if(os){
+    if(os->body_data)_ogg_free(os->body_data);
+    if(os->lacing_vals)_ogg_free(os->lacing_vals);
+    if(os->granule_vals)_ogg_free(os->granule_vals);
+
+    memset(os,0,sizeof(*os));
+  }
+  return(0);
+}
+
+int ogg_stream_destroy(ogg_stream_state *os){
+  if(os){
+    ogg_stream_clear(os);
+    _ogg_free(os);
+  }
+  return(0);
+}
+
+/* Helpers for ogg_stream_encode; this keeps the structure and
+   what's happening fairly clear */
+
+static int _os_body_expand(ogg_stream_state *os,long needed){
+  if(os->body_storage-needed<=os->body_fill){
+    long body_storage;
+    void *ret;
+    if(os->body_storage>LONG_MAX-needed){
+      ogg_stream_clear(os);
+      return -1;
+    }
+    body_storage=os->body_storage+needed;
+    if(body_storage<LONG_MAX-1024)body_storage+=1024;
+    ret=_ogg_realloc(os->body_data,body_storage*sizeof(*os->body_data));
+    if(!ret){
+      ogg_stream_clear(os);
+      return -1;
+    }
+    os->body_storage=body_storage;
+    os->body_data=ret;
+  }
+  return 0;
+}
+
+static int _os_lacing_expand(ogg_stream_state *os,long needed){
+  if(os->lacing_storage-needed<=os->lacing_fill){
+    long lacing_storage;
+    void *ret;
+    if(os->lacing_storage>LONG_MAX-needed){
+      ogg_stream_clear(os);
+      return -1;
+    }
+    lacing_storage=os->lacing_storage+needed;
+    if(lacing_storage<LONG_MAX-32)lacing_storage+=32;
+    ret=_ogg_realloc(os->lacing_vals,lacing_storage*sizeof(*os->lacing_vals));
+    if(!ret){
+      ogg_stream_clear(os);
+      return -1;
+    }
+    os->lacing_vals=ret;
+    ret=_ogg_realloc(os->granule_vals,lacing_storage*
+                     sizeof(*os->granule_vals));
+    if(!ret){
+      ogg_stream_clear(os);
+      return -1;
+    }
+    os->granule_vals=ret;
+    os->lacing_storage=lacing_storage;
+  }
+  return 0;
+}
+
+/* checksum the page */
+/* Direct table CRC; note that this will be faster in the future if we
+   perform the checksum simultaneously with other copies */
+
+void ogg_page_checksum_set(ogg_page *og){
+  if(og){
+    ogg_uint32_t crc_reg=0;
+    int i;
+
+    /* safety; needed for API behavior, but not framing code */
+    og->header[22]=0;
+    og->header[23]=0;
+    og->header[24]=0;
+    og->header[25]=0;
+
+    for(i=0;i<og->header_len;i++)
+      crc_reg=(crc_reg<<8)^crc_lookup[((crc_reg >> 24)&0xff)^og->header[i]];
+    for(i=0;i<og->body_len;i++)
+      crc_reg=(crc_reg<<8)^crc_lookup[((crc_reg >> 24)&0xff)^og->body[i]];
+
+    og->header[22]=(unsigned char)(crc_reg&0xff);
+    og->header[23]=(unsigned char)((crc_reg>>8)&0xff);
+    og->header[24]=(unsigned char)((crc_reg>>16)&0xff);
+    og->header[25]=(unsigned char)((crc_reg>>24)&0xff);
+  }
+}
+
+/* submit data to the internal buffer of the framing engine */
+int ogg_stream_iovecin(ogg_stream_state *os, ogg_iovec_t *iov, int count,
+                       long e_o_s, ogg_int64_t granulepos){
+
+  long bytes = 0, lacing_vals;
+  int i;
+
+  if(ogg_stream_check(os)) return -1;
+  if(!iov) return 0;
+
+  for (i = 0; i < count; ++i){
+    if(iov[i].iov_len>LONG_MAX) return -1;
+    if(bytes>LONG_MAX-(long)iov[i].iov_len) return -1;
+    bytes += (long)iov[i].iov_len;
+  }
+  lacing_vals=bytes/255+1;
+
+  if(os->body_returned){
+    /* advance packet data according to the body_returned pointer. We
+       had to keep it around to return a pointer into the buffer last
+       call */
+
+    os->body_fill-=os->body_returned;
+    if(os->body_fill)
+      memmove(os->body_data,os->body_data+os->body_returned,
+              os->body_fill);
+    os->body_returned=0;
+  }
+
+  /* make sure we have the buffer storage */
+  if(_os_body_expand(os,bytes) || _os_lacing_expand(os,lacing_vals))
+    return -1;
+
+  /* Copy in the submitted packet.  Yes, the copy is a waste; this is
+     the liability of overly clean abstraction for the time being.  It
+     will actually be fairly easy to eliminate the extra copy in the
+     future */
+
+  for (i = 0; i < count; ++i) {
+    memcpy(os->body_data+os->body_fill, iov[i].iov_base, iov[i].iov_len);
+    os->body_fill += (int)iov[i].iov_len;
+  }
+
+  /* Store lacing vals for this packet */
+  for(i=0;i<lacing_vals-1;i++){
+    os->lacing_vals[os->lacing_fill+i]=255;
+    os->granule_vals[os->lacing_fill+i]=os->granulepos;
+  }
+  os->lacing_vals[os->lacing_fill+i]=bytes%255;
+  os->granulepos=os->granule_vals[os->lacing_fill+i]=granulepos;
+
+  /* flag the first segment as the beginning of the packet */
+  os->lacing_vals[os->lacing_fill]|= 0x100;
+
+  os->lacing_fill+=lacing_vals;
+
+  /* for the sake of completeness */
+  os->packetno++;
+
+  if(e_o_s)os->e_o_s=1;
+
+  return(0);
+}
+
+int ogg_stream_packetin(ogg_stream_state *os,ogg_packet *op){
+  ogg_iovec_t iov;
+  iov.iov_base = op->packet;
+  iov.iov_len = op->bytes;
+  return ogg_stream_iovecin(os, &iov, 1, op->e_o_s, op->granulepos);
+}
+
+/* Conditionally flush a page; force==0 will only flush nominal-size
+   pages, force==1 forces us to flush a page regardless of page size
+   so long as there's any data available at all. */
+static int ogg_stream_flush_i(ogg_stream_state *os,ogg_page *og, int force, int nfill){
+  int i;
+  int vals=0;
+  int maxvals=(os->lacing_fill>255?255:os->lacing_fill);
+  int bytes=0;
+  long acc=0;
+  ogg_int64_t granule_pos=-1;
+
+  if(ogg_stream_check(os)) return(0);
+  if(maxvals==0) return(0);
+
+  /* construct a page */
+  /* decide how many segments to include */
+
+  /* If this is the initial header case, the first page must only include
+     the initial header packet */
+  if(os->b_o_s==0){  /* 'initial header page' case */
+    granule_pos=0;
+    for(vals=0;vals<maxvals;vals++){
+      if((os->lacing_vals[vals]&0x0ff)<255){
+        vals++;
+        break;
+      }
+    }
+  }else{
+
+    /* The extra packets_done, packet_just_done logic here attempts to do two things:
+       1) Don't unneccessarily span pages.
+       2) Unless necessary, don't flush pages if there are less than four packets on
+          them; this expands page size to reduce unneccessary overhead if incoming packets
+          are large.
+       These are not necessary behaviors, just 'always better than naive flushing'
+       without requiring an application to explicitly request a specific optimized
+       behavior. We'll want an explicit behavior setup pathway eventually as well. */
+
+    int packets_done=0;
+    int packet_just_done=0;
+    for(vals=0;vals<maxvals;vals++){
+      if(acc>nfill && packet_just_done>=4){
+        force=1;
+        break;
+      }
+      acc+=os->lacing_vals[vals]&0x0ff;
+      if((os->lacing_vals[vals]&0xff)<255){
+        granule_pos=os->granule_vals[vals];
+        packet_just_done=++packets_done;
+      }else
+        packet_just_done=0;
+    }
+    if(vals==255)force=1;
+  }
+
+  if(!force) return(0);
+
+  /* construct the header in temp storage */
+  memcpy(os->header,"OggS",4);
+
+  /* stream structure version */
+  os->header[4]=0x00;
+
+  /* continued packet flag? */
+  os->header[5]=0x00;
+  if((os->lacing_vals[0]&0x100)==0)os->header[5]|=0x01;
+  /* first page flag? */
+  if(os->b_o_s==0)os->header[5]|=0x02;
+  /* last page flag? */
+  if(os->e_o_s && os->lacing_fill==vals)os->header[5]|=0x04;
+  os->b_o_s=1;
+
+  /* 64 bits of PCM position */
+  for(i=6;i<14;i++){
+    os->header[i]=(unsigned char)(granule_pos&0xff);
+    granule_pos>>=8;
+  }
+
+  /* 32 bits of stream serial number */
+  {
+    long serialno=os->serialno;
+    for(i=14;i<18;i++){
+      os->header[i]=(unsigned char)(serialno&0xff);
+      serialno>>=8;
+    }
+  }
+
+  /* 32 bits of page counter (we have both counter and page header
+     because this val can roll over) */
+  if(os->pageno==-1)os->pageno=0; /* because someone called
+                                     stream_reset; this would be a
+                                     strange thing to do in an
+                                     encode stream, but it has
+                                     plausible uses */
+  {
+    long pageno=os->pageno++;
+    for(i=18;i<22;i++){
+      os->header[i]=(unsigned char)(pageno&0xff);
+      pageno>>=8;
+    }
+  }
+
+  /* zero for computation; filled in later */
+  os->header[22]=0;
+  os->header[23]=0;
+  os->header[24]=0;
+  os->header[25]=0;
+
+  /* segment table */
+  os->header[26]=(unsigned char)(vals&0xff);
+  for(i=0;i<vals;i++)
+    bytes+=os->header[i+27]=(unsigned char)(os->lacing_vals[i]&0xff);
+
+  /* set pointers in the ogg_page struct */
+  og->header=os->header;
+  og->header_len=os->header_fill=vals+27;
+  og->body=os->body_data+os->body_returned;
+  og->body_len=bytes;
+
+  /* advance the lacing data and set the body_returned pointer */
+
+  os->lacing_fill-=vals;
+  memmove(os->lacing_vals,os->lacing_vals+vals,os->lacing_fill*sizeof(*os->lacing_vals));
+  memmove(os->granule_vals,os->granule_vals+vals,os->lacing_fill*sizeof(*os->granule_vals));
+  os->body_returned+=bytes;
+
+  /* calculate the checksum */
+
+  ogg_page_checksum_set(og);
+
+  /* done */
+  return(1);
+}
+
+/* This will flush remaining packets into a page (returning nonzero),
+   even if there is not enough data to trigger a flush normally
+   (undersized page). If there are no packets or partial packets to
+   flush, ogg_stream_flush returns 0.  Note that ogg_stream_flush will
+   try to flush a normal sized page like ogg_stream_pageout; a call to
+   ogg_stream_flush does not guarantee that all packets have flushed.
+   Only a return value of 0 from ogg_stream_flush indicates all packet
+   data is flushed into pages.
+
+   since ogg_stream_flush will flush the last page in a stream even if
+   it's undersized, you almost certainly want to use ogg_stream_pageout
+   (and *not* ogg_stream_flush) unless you specifically need to flush
+   a page regardless of size in the middle of a stream. */
+
+int ogg_stream_flush(ogg_stream_state *os,ogg_page *og){
+  return ogg_stream_flush_i(os,og,1,4096);
+}
+
+/* Like the above, but an argument is provided to adjust the nominal
+   page size for applications which are smart enough to provide their
+   own delay based flushing */
+
+int ogg_stream_flush_fill(ogg_stream_state *os,ogg_page *og, int nfill){
+  return ogg_stream_flush_i(os,og,1,nfill);
+}
+
+/* This constructs pages from buffered packet segments.  The pointers
+returned are to static buffers; do not free. The returned buffers are
+good only until the next call (using the same ogg_stream_state) */
+
+int ogg_stream_pageout(ogg_stream_state *os, ogg_page *og){
+  int force=0;
+  if(ogg_stream_check(os)) return 0;
+
+  if((os->e_o_s&&os->lacing_fill) ||          /* 'were done, now flush' case */
+     (os->lacing_fill&&!os->b_o_s))           /* 'initial header page' case */
+    force=1;
+
+  return(ogg_stream_flush_i(os,og,force,4096));
+}
+
+/* Like the above, but an argument is provided to adjust the nominal
+page size for applications which are smart enough to provide their
+own delay based flushing */
+
+int ogg_stream_pageout_fill(ogg_stream_state *os, ogg_page *og, int nfill){
+  int force=0;
+  if(ogg_stream_check(os)) return 0;
+
+  if((os->e_o_s&&os->lacing_fill) ||          /* 'were done, now flush' case */
+     (os->lacing_fill&&!os->b_o_s))           /* 'initial header page' case */
+    force=1;
+
+  return(ogg_stream_flush_i(os,og,force,nfill));
+}
+
+int ogg_stream_eos(ogg_stream_state *os){
+  if(ogg_stream_check(os)) return 1;
+  return os->e_o_s;
+}
+
+/* DECODING PRIMITIVES: packet streaming layer **********************/
+
+/* This has two layers to place more of the multi-serialno and paging
+   control in the application's hands.  First, we expose a data buffer
+   using ogg_sync_buffer().  The app either copies into the
+   buffer, or passes it directly to read(), etc.  We then call
+   ogg_sync_wrote() to tell how many bytes we just added.
+
+   Pages are returned (pointers into the buffer in ogg_sync_state)
+   by ogg_sync_pageout().  The page is then submitted to
+   ogg_stream_pagein() along with the appropriate
+   ogg_stream_state* (ie, matching serialno).  We then get raw
+   packets out calling ogg_stream_packetout() with a
+   ogg_stream_state. */
+
+/* initialize the struct to a known state */
+int ogg_sync_init(ogg_sync_state *oy){
+  if(oy){
+    oy->storage = -1; /* used as a readiness flag */
+    memset(oy,0,sizeof(*oy));
+  }
+  return(0);
+}
+
+/* clear non-flat storage within */
+int ogg_sync_clear(ogg_sync_state *oy){
+  if(oy){
+    if(oy->data)_ogg_free(oy->data);
+    memset(oy,0,sizeof(*oy));
+  }
+  return(0);
+}
+
+int ogg_sync_destroy(ogg_sync_state *oy){
+  if(oy){
+    ogg_sync_clear(oy);
+    _ogg_free(oy);
+  }
+  return(0);
+}
+
+int ogg_sync_check(ogg_sync_state *oy){
+  if(oy->storage<0) return -1;
+  return 0;
+}
+
+char *ogg_sync_buffer(ogg_sync_state *oy, long size){
+  if(ogg_sync_check(oy)) return NULL;
+
+  /* first, clear out any space that has been previously returned */
+  if(oy->returned){
+    oy->fill-=oy->returned;
+    if(oy->fill>0)
+      memmove(oy->data,oy->data+oy->returned,oy->fill);
+    oy->returned=0;
+  }
+
+  if(size>oy->storage-oy->fill){
+    /* We need to extend the internal buffer */
+    long newsize=size+oy->fill+4096; /* an extra page to be nice */
+    void *ret;
+
+    if(oy->data)
+      ret=_ogg_realloc(oy->data,newsize);
+    else
+      ret=_ogg_malloc(newsize);
+    if(!ret){
+      ogg_sync_clear(oy);
+      return NULL;
+    }
+    oy->data=ret;
+    oy->storage=newsize;
+  }
+
+  /* expose a segment at least as large as requested at the fill mark */
+  return((char *)oy->data+oy->fill);
+}
+
+int ogg_sync_wrote(ogg_sync_state *oy, long bytes){
+  if(ogg_sync_check(oy))return -1;
+  if(oy->fill+bytes>oy->storage)return -1;
+  oy->fill+=bytes;
+  return(0);
+}
+
+/* sync the stream.  This is meant to be useful for finding page
+   boundaries.
+
+   return values for this:
+  -n) skipped n bytes
+   0) page not ready; more data (no bytes skipped)
+   n) page synced at current location; page length n bytes
+
+*/
+
+long ogg_sync_pageseek(ogg_sync_state *oy,ogg_page *og){
+  unsigned char *page=oy->data+oy->returned;
+  unsigned char *next;
+  long bytes=oy->fill-oy->returned;
+
+  if(ogg_sync_check(oy))return 0;
+
+  if(oy->headerbytes==0){
+    int headerbytes,i;
+    if(bytes<27)return(0); /* not enough for a header */
+
+    /* verify capture pattern */
+    if(memcmp(page,"OggS",4))goto sync_fail;
+
+    headerbytes=page[26]+27;
+    if(bytes<headerbytes)return(0); /* not enough for header + seg table */
+
+    /* count up body length in the segment table */
+
+    for(i=0;i<page[26];i++)
+      oy->bodybytes+=page[27+i];
+    oy->headerbytes=headerbytes;
+  }
+
+  if(oy->bodybytes+oy->headerbytes>bytes)return(0);
+
+  /* The whole test page is buffered.  Verify the checksum */
+  {
+    /* Grab the checksum bytes, set the header field to zero */
+    char chksum[4];
+    ogg_page log;
+
+    memcpy(chksum,page+22,4);
+    memset(page+22,0,4);
+
+    /* set up a temp page struct and recompute the checksum */
+    log.header=page;
+    log.header_len=oy->headerbytes;
+    log.body=page+oy->headerbytes;
+    log.body_len=oy->bodybytes;
+    ogg_page_checksum_set(&log);
+
+    /* Compare */
+    if(memcmp(chksum,page+22,4)){
+      /* D'oh.  Mismatch! Corrupt page (or miscapture and not a page
+         at all) */
+      /* replace the computed checksum with the one actually read in */
+      memcpy(page+22,chksum,4);
+
+      /* Bad checksum. Lose sync */
+      goto sync_fail;
+    }
+  }
+
+  /* yes, have a whole page all ready to go */
+  {
+    unsigned char *page=oy->data+oy->returned;
+    long bytes;
+
+    if(og){
+      og->header=page;
+      og->header_len=oy->headerbytes;
+      og->body=page+oy->headerbytes;
+      og->body_len=oy->bodybytes;
+    }
+
+    oy->unsynced=0;
+    oy->returned+=(bytes=oy->headerbytes+oy->bodybytes);
+    oy->headerbytes=0;
+    oy->bodybytes=0;
+    return(bytes);
+  }
+
+ sync_fail:
+
+  oy->headerbytes=0;
+  oy->bodybytes=0;
+
+  /* search for possible capture */
+  next=memchr(page+1,'O',bytes-1);
+  if(!next)
+    next=oy->data+oy->fill;
+
+  oy->returned=(int)(next-oy->data);
+  return((long)-(next-page));
+}
+
+/* sync the stream and get a page.  Keep trying until we find a page.
+   Suppress 'sync errors' after reporting the first.
+
+   return values:
+   -1) recapture (hole in data)
+    0) need more data
+    1) page returned
+
+   Returns pointers into buffered data; invalidated by next call to
+   _stream, _clear, _init, or _buffer */
+
+int ogg_sync_pageout(ogg_sync_state *oy, ogg_page *og){
+
+  if(ogg_sync_check(oy))return 0;
+
+  /* all we need to do is verify a page at the head of the stream
+     buffer.  If it doesn't verify, we look for the next potential
+     frame */
+
+  for(;;){
+    long ret=ogg_sync_pageseek(oy,og);
+    if(ret>0){
+      /* have a page */
+      return(1);
+    }
+    if(ret==0){
+      /* need more data */
+      return(0);
+    }
+
+    /* head did not start a synced page... skipped some bytes */
+    if(!oy->unsynced){
+      oy->unsynced=1;
+      return(-1);
+    }
+
+    /* loop. keep looking */
+
+  }
+}
+
+/* add the incoming page to the stream state; we decompose the page
+   into packet segments here as well. */
+
+int ogg_stream_pagein(ogg_stream_state *os, ogg_page *og){
+  unsigned char *header=og->header;
+  unsigned char *body=og->body;
+  long           bodysize=og->body_len;
+  int            segptr=0;
+
+  int version=ogg_page_version(og);
+  int continued=ogg_page_continued(og);
+  int bos=ogg_page_bos(og);
+  int eos=ogg_page_eos(og);
+  ogg_int64_t granulepos=ogg_page_granulepos(og);
+  int serialno=ogg_page_serialno(og);
+  long pageno=ogg_page_pageno(og);
+  int segments=header[26];
+
+  if(ogg_stream_check(os)) return -1;
+
+  /* clean up 'returned data' */
+  {
+    long lr=os->lacing_returned;
+    long br=os->body_returned;
+
+    /* body data */
+    if(br){
+      os->body_fill-=br;
+      if(os->body_fill)
+        memmove(os->body_data,os->body_data+br,os->body_fill);
+      os->body_returned=0;
+    }
+
+    if(lr){
+      /* segment table */
+      if(os->lacing_fill-lr){
+        memmove(os->lacing_vals,os->lacing_vals+lr,
+                (os->lacing_fill-lr)*sizeof(*os->lacing_vals));
+        memmove(os->granule_vals,os->granule_vals+lr,
+                (os->lacing_fill-lr)*sizeof(*os->granule_vals));
+      }
+      os->lacing_fill-=lr;
+      os->lacing_packet-=lr;
+      os->lacing_returned=0;
+    }
+  }
+
+  /* check the serial number */
+  if(serialno!=os->serialno)return(-1);
+  if(version>0)return(-1);
+
+  if(_os_lacing_expand(os,segments+1)) return -1;
+
+  /* are we in sequence? */
+  if(pageno!=os->pageno){
+    int i;
+
+    /* unroll previous partial packet (if any) */
+    for(i=os->lacing_packet;i<os->lacing_fill;i++)
+      os->body_fill-=os->lacing_vals[i]&0xff;
+    os->lacing_fill=os->lacing_packet;
+
+    /* make a note of dropped data in segment table */
+    if(os->pageno!=-1){
+      os->lacing_vals[os->lacing_fill++]=0x400;
+      os->lacing_packet++;
+    }
+  }
+
+  /* are we a 'continued packet' page?  If so, we may need to skip
+     some segments */
+  if(continued){
+    if(os->lacing_fill<1 ||
+       os->lacing_vals[os->lacing_fill-1]==0x400){
+      bos=0;
+      for(;segptr<segments;segptr++){
+        int val=header[27+segptr];
+        body+=val;
+        bodysize-=val;
+        if(val<255){
+          segptr++;
+          break;
+        }
+      }
+    }
+  }
+
+  if(bodysize){
+    if(_os_body_expand(os,bodysize)) return -1;
+    memcpy(os->body_data+os->body_fill,body,bodysize);
+    os->body_fill+=bodysize;
+  }
+
+  {
+    int saved=-1;
+    while(segptr<segments){
+      int val=header[27+segptr];
+      os->lacing_vals[os->lacing_fill]=val;
+      os->granule_vals[os->lacing_fill]=-1;
+
+      if(bos){
+        os->lacing_vals[os->lacing_fill]|=0x100;
+        bos=0;
+      }
+
+      if(val<255)saved=os->lacing_fill;
+
+      os->lacing_fill++;
+      segptr++;
+
+      if(val<255)os->lacing_packet=os->lacing_fill;
+    }
+
+    /* set the granulepos on the last granuleval of the last full packet */
+    if(saved!=-1){
+      os->granule_vals[saved]=granulepos;
+    }
+
+  }
+
+  if(eos){
+    os->e_o_s=1;
+    if(os->lacing_fill>0)
+      os->lacing_vals[os->lacing_fill-1]|=0x200;
+  }
+
+  os->pageno=pageno+1;
+
+  return(0);
+}
+
+/* clear things to an initial state.  Good to call, eg, before seeking */
+int ogg_sync_reset(ogg_sync_state *oy){
+  if(ogg_sync_check(oy))return -1;
+
+  oy->fill=0;
+  oy->returned=0;
+  oy->unsynced=0;
+  oy->headerbytes=0;
+  oy->bodybytes=0;
+  return(0);
+}
+
+int ogg_stream_reset(ogg_stream_state *os){
+  if(ogg_stream_check(os)) return -1;
+
+  os->body_fill=0;
+  os->body_returned=0;
+
+  os->lacing_fill=0;
+  os->lacing_packet=0;
+  os->lacing_returned=0;
+
+  os->header_fill=0;
+
+  os->e_o_s=0;
+  os->b_o_s=0;
+  os->pageno=-1;
+  os->packetno=0;
+  os->granulepos=0;
+
+  return(0);
+}
+
+int ogg_stream_reset_serialno(ogg_stream_state *os,int serialno){
+  if(ogg_stream_check(os)) return -1;
+  ogg_stream_reset(os);
+  os->serialno=serialno;
+  return(0);
+}
+
+static int _packetout(ogg_stream_state *os,ogg_packet *op,int adv){
+
+  /* The last part of decode. We have the stream broken into packet
+     segments.  Now we need to group them into packets (or return the
+     out of sync markers) */
+
+  int ptr=os->lacing_returned;
+
+  if(os->lacing_packet<=ptr)return(0);
+
+  if(os->lacing_vals[ptr]&0x400){
+    /* we need to tell the codec there's a gap; it might need to
+       handle previous packet dependencies. */
+    os->lacing_returned++;
+    os->packetno++;
+    return(-1);
+  }
+
+  if(!op && !adv)return(1); /* just using peek as an inexpensive way
+                               to ask if there's a whole packet
+                               waiting */
+
+  /* Gather the whole packet. We'll have no holes or a partial packet */
+  {
+    int size=os->lacing_vals[ptr]&0xff;
+    long bytes=size;
+    int eos=os->lacing_vals[ptr]&0x200; /* last packet of the stream? */
+    int bos=os->lacing_vals[ptr]&0x100; /* first packet of the stream? */
+
+    while(size==255){
+      int val=os->lacing_vals[++ptr];
+      size=val&0xff;
+      if(val&0x200)eos=0x200;
+      bytes+=size;
+    }
+
+    if(op){
+      op->e_o_s=eos;
+      op->b_o_s=bos;
+      op->packet=os->body_data+os->body_returned;
+      op->packetno=os->packetno;
+      op->granulepos=os->granule_vals[ptr];
+      op->bytes=bytes;
+    }
+
+    if(adv){
+      os->body_returned+=bytes;
+      os->lacing_returned=ptr+1;
+      os->packetno++;
+    }
+  }
+  return(1);
+}
+
+int ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op){
+  if(ogg_stream_check(os)) return 0;
+  return _packetout(os,op,1);
+}
+
+int ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op){
+  if(ogg_stream_check(os)) return 0;
+  return _packetout(os,op,0);
+}
+
+void ogg_packet_clear(ogg_packet *op) {
+  _ogg_free(op->packet);
+  memset(op, 0, sizeof(*op));
+}
+
+#ifdef _V_SELFTEST
+#include <stdio.h>
+
+ogg_stream_state os_en, os_de;
+ogg_sync_state oy;
+
+void checkpacket(ogg_packet *op,long len, int no, long pos){
+  long j;
+  static int sequence=0;
+  static int lastno=0;
+
+  if(op->bytes!=len){
+    fprintf(stderr,"incorrect packet length (%ld != %ld)!\n",op->bytes,len);
+    exit(1);
+  }
+  if(op->granulepos!=pos){
+    fprintf(stderr,"incorrect packet granpos (%ld != %ld)!\n",(long)op->granulepos,pos);
+    exit(1);
+  }
+
+  /* packet number just follows sequence/gap; adjust the input number
+     for that */
+  if(no==0){
+    sequence=0;
+  }else{
+    sequence++;
+    if(no>lastno+1)
+      sequence++;
+  }
+  lastno=no;
+  if(op->packetno!=sequence){
+    fprintf(stderr,"incorrect packet sequence %ld != %d\n",
+            (long)(op->packetno),sequence);
+    exit(1);
+  }
+
+  /* Test data */
+  for(j=0;j<op->bytes;j++)
+    if(op->packet[j]!=((j+no)&0xff)){
+      fprintf(stderr,"body data mismatch (1) at pos %ld: %x!=%lx!\n\n",
+              j,op->packet[j],(j+no)&0xff);
+      exit(1);
+    }
+}
+
+void check_page(unsigned char *data,const int *header,ogg_page *og){
+  long j;
+  /* Test data */
+  for(j=0;j<og->body_len;j++)
+    if(og->body[j]!=data[j]){
+      fprintf(stderr,"body data mismatch (2) at pos %ld: %x!=%x!\n\n",
+              j,data[j],og->body[j]);
+      exit(1);
+    }
+
+  /* Test header */
+  for(j=0;j<og->header_len;j++){
+    if(og->header[j]!=header[j]){
+      fprintf(stderr,"header content mismatch at pos %ld:\n",j);
+      for(j=0;j<header[26]+27;j++)
+        fprintf(stderr," (%ld)%02x:%02x",j,header[j],og->header[j]);
+      fprintf(stderr,"\n");
+      exit(1);
+    }
+  }
+  if(og->header_len!=header[26]+27){
+    fprintf(stderr,"header length incorrect! (%ld!=%d)\n",
+            og->header_len,header[26]+27);
+    exit(1);
+  }
+}
+
+void print_header(ogg_page *og){
+  int j;
+  fprintf(stderr,"\nHEADER:\n");
+  fprintf(stderr,"  capture: %c %c %c %c  version: %d  flags: %x\n",
+          og->header[0],og->header[1],og->header[2],og->header[3],
+          (int)og->header[4],(int)og->header[5]);
+
+  fprintf(stderr,"  granulepos: %d  serialno: %d  pageno: %ld\n",
+          (og->header[9]<<24)|(og->header[8]<<16)|
+          (og->header[7]<<8)|og->header[6],
+          (og->header[17]<<24)|(og->header[16]<<16)|
+          (og->header[15]<<8)|og->header[14],
+          ((long)(og->header[21])<<24)|(og->header[20]<<16)|
+          (og->header[19]<<8)|og->header[18]);
+
+  fprintf(stderr,"  checksum: %02x:%02x:%02x:%02x\n  segments: %d (",
+          (int)og->header[22],(int)og->header[23],
+          (int)og->header[24],(int)og->header[25],
+          (int)og->header[26]);
+
+  for(j=27;j<og->header_len;j++)
+    fprintf(stderr,"%d ",(int)og->header[j]);
+  fprintf(stderr,")\n\n");
+}
+
+void copy_page(ogg_page *og){
+  unsigned char *temp=_ogg_malloc(og->header_len);
+  memcpy(temp,og->header,og->header_len);
+  og->header=temp;
+
+  temp=_ogg_malloc(og->body_len);
+  memcpy(temp,og->body,og->body_len);
+  og->body=temp;
+}
+
+void free_page(ogg_page *og){
+  _ogg_free (og->header);
+  _ogg_free (og->body);
+}
+
+void error(void){
+  fprintf(stderr,"error!\n");
+  exit(1);
+}
+
+/* 17 only */
+const int head1_0[] = {0x4f,0x67,0x67,0x53,0,0x06,
+                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,0,0,0,0,
+                       0x15,0xed,0xec,0x91,
+                       1,
+                       17};
+
+/* 17, 254, 255, 256, 500, 510, 600 byte, pad */
+const int head1_1[] = {0x4f,0x67,0x67,0x53,0,0x02,
+                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,0,0,0,0,
+                       0x59,0x10,0x6c,0x2c,
+                       1,
+                       17};
+const int head2_1[] = {0x4f,0x67,0x67,0x53,0,0x04,
+                       0x07,0x18,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,1,0,0,0,
+                       0x89,0x33,0x85,0xce,
+                       13,
+                       254,255,0,255,1,255,245,255,255,0,
+                       255,255,90};
+
+/* nil packets; beginning,middle,end */
+const int head1_2[] = {0x4f,0x67,0x67,0x53,0,0x02,
+                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,0,0,0,0,
+                       0xff,0x7b,0x23,0x17,
+                       1,
+                       0};
+const int head2_2[] = {0x4f,0x67,0x67,0x53,0,0x04,
+                       0x07,0x28,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,1,0,0,0,
+                       0x5c,0x3f,0x66,0xcb,
+                       17,
+                       17,254,255,0,0,255,1,0,255,245,255,255,0,
+                       255,255,90,0};
+
+/* large initial packet */
+const int head1_3[] = {0x4f,0x67,0x67,0x53,0,0x02,
+                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,0,0,0,0,
+                       0x01,0x27,0x31,0xaa,
+                       18,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,255,10};
+
+const int head2_3[] = {0x4f,0x67,0x67,0x53,0,0x04,
+                       0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,1,0,0,0,
+                       0x7f,0x4e,0x8a,0xd2,
+                       4,
+                       255,4,255,0};
+
+
+/* continuing packet test */
+const int head1_4[] = {0x4f,0x67,0x67,0x53,0,0x02,
+                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,0,0,0,0,
+                       0xff,0x7b,0x23,0x17,
+                       1,
+                       0};
+
+const int head2_4[] = {0x4f,0x67,0x67,0x53,0,0x00,
+                       0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+                       0x01,0x02,0x03,0x04,1,0,0,0,
+                       0xf8,0x3c,0x19,0x79,
+                       255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255};
+
+const int head3_4[] = {0x4f,0x67,0x67,0x53,0,0x05,
+                       0x07,0x0c,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,2,0,0,0,
+                       0x38,0xe6,0xb6,0x28,
+                       6,
+                       255,220,255,4,255,0};
+
+
+/* spill expansion test */
+const int head1_4b[] = {0x4f,0x67,0x67,0x53,0,0x02,
+                        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                        0x01,0x02,0x03,0x04,0,0,0,0,
+                        0xff,0x7b,0x23,0x17,
+                        1,
+                        0};
+
+const int head2_4b[] = {0x4f,0x67,0x67,0x53,0,0x00,
+                        0x07,0x10,0x00,0x00,0x00,0x00,0x00,0x00,
+                        0x01,0x02,0x03,0x04,1,0,0,0,
+                        0xce,0x8f,0x17,0x1a,
+                        23,
+                        255,255,255,255,255,255,255,255,
+                        255,255,255,255,255,255,255,255,255,10,255,4,255,0,0};
+
+
+const int head3_4b[] = {0x4f,0x67,0x67,0x53,0,0x04,
+                        0x07,0x14,0x00,0x00,0x00,0x00,0x00,0x00,
+                        0x01,0x02,0x03,0x04,2,0,0,0,
+                        0x9b,0xb2,0x50,0xa1,
+                        1,
+                        0};
+
+/* page with the 255 segment limit */
+const int head1_5[] = {0x4f,0x67,0x67,0x53,0,0x02,
+                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,0,0,0,0,
+                       0xff,0x7b,0x23,0x17,
+                       1,
+                       0};
+
+const int head2_5[] = {0x4f,0x67,0x67,0x53,0,0x00,
+                       0x07,0xfc,0x03,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,1,0,0,0,
+                       0xed,0x2a,0x2e,0xa7,
+                       255,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10};
+
+const int head3_5[] = {0x4f,0x67,0x67,0x53,0,0x04,
+                       0x07,0x00,0x04,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,2,0,0,0,
+                       0x6c,0x3b,0x82,0x3d,
+                       1,
+                       50};
+
+
+/* packet that overspans over an entire page */
+const int head1_6[] = {0x4f,0x67,0x67,0x53,0,0x02,
+                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,0,0,0,0,
+                       0xff,0x7b,0x23,0x17,
+                       1,
+                       0};
+
+const int head2_6[] = {0x4f,0x67,0x67,0x53,0,0x00,
+                       0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,1,0,0,0,
+                       0x68,0x22,0x7c,0x3d,
+                       255,
+                       100,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255};
+
+const int head3_6[] = {0x4f,0x67,0x67,0x53,0,0x01,
+                       0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+                       0x01,0x02,0x03,0x04,2,0,0,0,
+                       0xf4,0x87,0xba,0xf3,
+                       255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255};
+
+const int head4_6[] = {0x4f,0x67,0x67,0x53,0,0x05,
+                       0x07,0x10,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,3,0,0,0,
+                       0xf7,0x2f,0x6c,0x60,
+                       5,
+                       254,255,4,255,0};
+
+/* packet that overspans over an entire page */
+const int head1_7[] = {0x4f,0x67,0x67,0x53,0,0x02,
+                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,0,0,0,0,
+                       0xff,0x7b,0x23,0x17,
+                       1,
+                       0};
+
+const int head2_7[] = {0x4f,0x67,0x67,0x53,0,0x00,
+                       0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,1,0,0,0,
+                       0x68,0x22,0x7c,0x3d,
+                       255,
+                       100,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255};
+
+const int head3_7[] = {0x4f,0x67,0x67,0x53,0,0x05,
+                       0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,2,0,0,0,
+                       0xd4,0xe0,0x60,0xe5,
+                       1,
+                       0};
+
+void test_pack(const int *pl, const int **headers, int byteskip,
+               int pageskip, int packetskip){
+  unsigned char *data=_ogg_malloc(1024*1024); /* for scripted test cases only */
+  long inptr=0;
+  long outptr=0;
+  long deptr=0;
+  long depacket=0;
+  long granule_pos=7,pageno=0;
+  int i,j,packets,pageout=pageskip;
+  int eosflag=0;
+  int bosflag=0;
+
+  int byteskipcount=0;
+
+  ogg_stream_reset(&os_en);
+  ogg_stream_reset(&os_de);
+  ogg_sync_reset(&oy);
+
+  for(packets=0;packets<packetskip;packets++)
+    depacket+=pl[packets];
+
+  for(packets=0;;packets++)if(pl[packets]==-1)break;
+
+  for(i=0;i<packets;i++){
+    /* construct a test packet */
+    ogg_packet op;
+    int len=pl[i];
+
+    op.packet=data+inptr;
+    op.bytes=len;
+    op.e_o_s=(pl[i+1]<0?1:0);
+    op.granulepos=granule_pos;
+
+    granule_pos+=1024;
+
+    for(j=0;j<len;j++)data[inptr++]=i+j;
+
+    /* submit the test packet */
+    ogg_stream_packetin(&os_en,&op);
+
+    /* retrieve any finished pages */
+    {
+      ogg_page og;
+
+      while(ogg_stream_pageout(&os_en,&og)){
+        /* We have a page.  Check it carefully */
+
+        fprintf(stderr,"%ld, ",pageno);
+
+        if(headers[pageno]==NULL){
+          fprintf(stderr,"coded too many pages!\n");
+          exit(1);
+        }
+
+        check_page(data+outptr,headers[pageno],&og);
+
+        outptr+=og.body_len;
+        pageno++;
+        if(pageskip){
+          bosflag=1;
+          pageskip--;
+          deptr+=og.body_len;
+        }
+
+        /* have a complete page; submit it to sync/decode */
+
+        {
+          ogg_page og_de;
+          ogg_packet op_de,op_de2;
+          char *buf=ogg_sync_buffer(&oy,og.header_len+og.body_len);
+          char *next=buf;
+          byteskipcount+=og.header_len;
+          if(byteskipcount>byteskip){
+            memcpy(next,og.header,byteskipcount-byteskip);
+            next+=byteskipcount-byteskip;
+            byteskipcount=byteskip;
+          }
+
+          byteskipcount+=og.body_len;
+          if(byteskipcount>byteskip){
+            memcpy(next,og.body,byteskipcount-byteskip);
+            next+=byteskipcount-byteskip;
+            byteskipcount=byteskip;
+          }
+
+          ogg_sync_wrote(&oy,next-buf);
+
+          while(1){
+            int ret=ogg_sync_pageout(&oy,&og_de);
+            if(ret==0)break;
+            if(ret<0)continue;
+            /* got a page.  Happy happy.  Verify that it's good. */
+
+            fprintf(stderr,"(%d), ",pageout);
+
+            check_page(data+deptr,headers[pageout],&og_de);
+            deptr+=og_de.body_len;
+            pageout++;
+
+            /* submit it to deconstitution */
+            ogg_stream_pagein(&os_de,&og_de);
+
+            /* packets out? */
+            while(ogg_stream_packetpeek(&os_de,&op_de2)>0){
+              ogg_stream_packetpeek(&os_de,NULL);
+              ogg_stream_packetout(&os_de,&op_de); /* just catching them all */
+
+              /* verify peek and out match */
+              if(memcmp(&op_de,&op_de2,sizeof(op_de))){
+                fprintf(stderr,"packetout != packetpeek! pos=%ld\n",
+                        depacket);
+                exit(1);
+              }
+
+              /* verify the packet! */
+              /* check data */
+              if(memcmp(data+depacket,op_de.packet,op_de.bytes)){
+                fprintf(stderr,"packet data mismatch in decode! pos=%ld\n",
+                        depacket);
+                exit(1);
+              }
+              /* check bos flag */
+              if(bosflag==0 && op_de.b_o_s==0){
+                fprintf(stderr,"b_o_s flag not set on packet!\n");
+                exit(1);
+              }
+              if(bosflag && op_de.b_o_s){
+                fprintf(stderr,"b_o_s flag incorrectly set on packet!\n");
+                exit(1);
+              }
+              bosflag=1;
+              depacket+=op_de.bytes;
+
+              /* check eos flag */
+              if(eosflag){
+                fprintf(stderr,"Multiple decoded packets with eos flag!\n");
+                exit(1);
+              }
+
+              if(op_de.e_o_s)eosflag=1;
+
+              /* check granulepos flag */
+              if(op_de.granulepos!=-1){
+                fprintf(stderr," granule:%ld ",(long)op_de.granulepos);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  _ogg_free(data);
+  if(headers[pageno]!=NULL){
+    fprintf(stderr,"did not write last page!\n");
+    exit(1);
+  }
+  if(headers[pageout]!=NULL){
+    fprintf(stderr,"did not decode last page!\n");
+    exit(1);
+  }
+  if(inptr!=outptr){
+    fprintf(stderr,"encoded page data incomplete!\n");
+    exit(1);
+  }
+  if(inptr!=deptr){
+    fprintf(stderr,"decoded page data incomplete!\n");
+    exit(1);
+  }
+  if(inptr!=depacket){
+    fprintf(stderr,"decoded packet data incomplete!\n");
+    exit(1);
+  }
+  if(!eosflag){
+    fprintf(stderr,"Never got a packet with EOS set!\n");
+    exit(1);
+  }
+  fprintf(stderr,"ok.\n");
+}
+
+int main(void){
+
+  ogg_stream_init(&os_en,0x04030201);
+  ogg_stream_init(&os_de,0x04030201);
+  ogg_sync_init(&oy);
+
+  /* Exercise each code path in the framing code.  Also verify that
+     the checksums are working.  */
+
+  {
+    /* 17 only */
+    const int packets[]={17, -1};
+    const int *headret[]={head1_0,NULL};
+
+    fprintf(stderr,"testing single page encoding... ");
+    test_pack(packets,headret,0,0,0);
+  }
+
+  {
+    /* 17, 254, 255, 256, 500, 510, 600 byte, pad */
+    const int packets[]={17, 254, 255, 256, 500, 510, 600, -1};
+    const int *headret[]={head1_1,head2_1,NULL};
+
+    fprintf(stderr,"testing basic page encoding... ");
+    test_pack(packets,headret,0,0,0);
+  }
+
+  {
+    /* nil packets; beginning,middle,end */
+    const int packets[]={0,17, 254, 255, 0, 256, 0, 500, 510, 600, 0, -1};
+    const int *headret[]={head1_2,head2_2,NULL};
+
+    fprintf(stderr,"testing basic nil packets... ");
+    test_pack(packets,headret,0,0,0);
+  }
+
+  {
+    /* large initial packet */
+    const int packets[]={4345,259,255,-1};
+    const int *headret[]={head1_3,head2_3,NULL};
+
+    fprintf(stderr,"testing initial-packet lacing > 4k... ");
+    test_pack(packets,headret,0,0,0);
+  }
+
+  {
+    /* continuing packet test; with page spill expansion, we have to
+       overflow the lacing table. */
+    const int packets[]={0,65500,259,255,-1};
+    const int *headret[]={head1_4,head2_4,head3_4,NULL};
+
+    fprintf(stderr,"testing single packet page span... ");
+    test_pack(packets,headret,0,0,0);
+  }
+
+  {
+    /* spill expand packet test */
+    const int packets[]={0,4345,259,255,0,0,-1};
+    const int *headret[]={head1_4b,head2_4b,head3_4b,NULL};
+
+    fprintf(stderr,"testing page spill expansion... ");
+    test_pack(packets,headret,0,0,0);
+  }
+
+  /* page with the 255 segment limit */
+  {
+
+    const int packets[]={0,10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,50,-1};
+    const int *headret[]={head1_5,head2_5,head3_5,NULL};
+
+    fprintf(stderr,"testing max packet segments... ");
+    test_pack(packets,headret,0,0,0);
+  }
+
+  {
+    /* packet that overspans over an entire page */
+    const int packets[]={0,100,130049,259,255,-1};
+    const int *headret[]={head1_6,head2_6,head3_6,head4_6,NULL};
+
+    fprintf(stderr,"testing very large packets... ");
+    test_pack(packets,headret,0,0,0);
+  }
+
+  {
+    /* test for the libogg 1.1.1 resync in large continuation bug
+       found by Josh Coalson)  */
+    const int packets[]={0,100,130049,259,255,-1};
+    const int *headret[]={head1_6,head2_6,head3_6,head4_6,NULL};
+
+    fprintf(stderr,"testing continuation resync in very large packets... ");
+    test_pack(packets,headret,100,2,3);
+  }
+
+  {
+    /* term only page.  why not? */
+    const int packets[]={0,100,64770,-1};
+    const int *headret[]={head1_7,head2_7,head3_7,NULL};
+
+    fprintf(stderr,"testing zero data page (1 nil packet)... ");
+    test_pack(packets,headret,0,0,0);
+  }
+
+
+
+  {
+    /* build a bunch of pages for testing */
+    unsigned char *data=_ogg_malloc(1024*1024);
+    int pl[]={0, 1,1,98,4079, 1,1,2954,2057, 76,34,912,0,234,1000,1000, 1000,300,-1};
+    int inptr=0,i,j;
+    ogg_page og[5];
+
+    ogg_stream_reset(&os_en);
+
+    for(i=0;pl[i]!=-1;i++){
+      ogg_packet op;
+      int len=pl[i];
+
+      op.packet=data+inptr;
+      op.bytes=len;
+      op.e_o_s=(pl[i+1]<0?1:0);
+      op.granulepos=(i+1)*1000;
+
+      for(j=0;j<len;j++)data[inptr++]=i+j;
+      ogg_stream_packetin(&os_en,&op);
+    }
+
+    _ogg_free(data);
+
+    /* retrieve finished pages */
+    for(i=0;i<5;i++){
+      if(ogg_stream_pageout(&os_en,&og[i])==0){
+        fprintf(stderr,"Too few pages output building sync tests!\n");
+        exit(1);
+      }
+      copy_page(&og[i]);
+    }
+
+    /* Test lost pages on pagein/packetout: no rollback */
+    {
+      ogg_page temp;
+      ogg_packet test;
+
+      fprintf(stderr,"Testing loss of pages... ");
+
+      ogg_sync_reset(&oy);
+      ogg_stream_reset(&os_de);
+      for(i=0;i<5;i++){
+        memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header,
+               og[i].header_len);
+        ogg_sync_wrote(&oy,og[i].header_len);
+        memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len);
+        ogg_sync_wrote(&oy,og[i].body_len);
+      }
+
+      ogg_sync_pageout(&oy,&temp);
+      ogg_stream_pagein(&os_de,&temp);
+      ogg_sync_pageout(&oy,&temp);
+      ogg_stream_pagein(&os_de,&temp);
+      ogg_sync_pageout(&oy,&temp);
+      /* skip */
+      ogg_sync_pageout(&oy,&temp);
+      ogg_stream_pagein(&os_de,&temp);
+
+      /* do we get the expected results/packets? */
+
+      if(ogg_stream_packetout(&os_de,&test)!=1)error();
+      checkpacket(&test,0,0,0);
+      if(ogg_stream_packetout(&os_de,&test)!=1)error();
+      checkpacket(&test,1,1,-1);
+      if(ogg_stream_packetout(&os_de,&test)!=1)error();
+      checkpacket(&test,1,2,-1);
+      if(ogg_stream_packetout(&os_de,&test)!=1)error();
+      checkpacket(&test,98,3,-1);
+      if(ogg_stream_packetout(&os_de,&test)!=1)error();
+      checkpacket(&test,4079,4,5000);
+      if(ogg_stream_packetout(&os_de,&test)!=-1){
+        fprintf(stderr,"Error: loss of page did not return error\n");
+        exit(1);
+      }
+      if(ogg_stream_packetout(&os_de,&test)!=1)error();
+      checkpacket(&test,76,9,-1);
+      if(ogg_stream_packetout(&os_de,&test)!=1)error();
+      checkpacket(&test,34,10,-1);
+      fprintf(stderr,"ok.\n");
+    }
+
+    /* Test lost pages on pagein/packetout: rollback with continuation */
+    {
+      ogg_page temp;
+      ogg_packet test;
+
+      fprintf(stderr,"Testing loss of pages (rollback required)... ");
+
+      ogg_sync_reset(&oy);
+      ogg_stream_reset(&os_de);
+      for(i=0;i<5;i++){
+        memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header,
+               og[i].header_len);
+        ogg_sync_wrote(&oy,og[i].header_len);
+        memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len);
+        ogg_sync_wrote(&oy,og[i].body_len);
+      }
+
+      ogg_sync_pageout(&oy,&temp);
+      ogg_stream_pagein(&os_de,&temp);
+      ogg_sync_pageout(&oy,&temp);
+      ogg_stream_pagein(&os_de,&temp);
+      ogg_sync_pageout(&oy,&temp);
+      ogg_stream_pagein(&os_de,&temp);
+      ogg_sync_pageout(&oy,&temp);
+      /* skip */
+      ogg_sync_pageout(&oy,&temp);
+      ogg_stream_pagein(&os_de,&temp);
+
+      /* do we get the expected results/packets? */
+
+      if(ogg_stream_packetout(&os_de,&test)!=1)error();
+      checkpacket(&test,0,0,0);
+      if(ogg_stream_packetout(&os_de,&test)!=1)error();
+      checkpacket(&test,1,1,-1);
+      if(ogg_stream_packetout(&os_de,&test)!=1)error();
+      checkpacket(&test,1,2,-1);
+      if(ogg_stream_packetout(&os_de,&test)!=1)error();
+      checkpacket(&test,98,3,-1);
+      if(ogg_stream_packetout(&os_de,&test)!=1)error();
+      checkpacket(&test,4079,4,5000);
+      if(ogg_stream_packetout(&os_de,&test)!=1)error();
+      checkpacket(&test,1,5,-1);
+      if(ogg_stream_packetout(&os_de,&test)!=1)error();
+      checkpacket(&test,1,6,-1);
+      if(ogg_stream_packetout(&os_de,&test)!=1)error();
+      checkpacket(&test,2954,7,-1);
+      if(ogg_stream_packetout(&os_de,&test)!=1)error();
+      checkpacket(&test,2057,8,9000);
+      if(ogg_stream_packetout(&os_de,&test)!=-1){
+        fprintf(stderr,"Error: loss of page did not return error\n");
+        exit(1);
+      }
+      if(ogg_stream_packetout(&os_de,&test)!=1)error();
+      checkpacket(&test,300,17,18000);
+      fprintf(stderr,"ok.\n");
+    }
+
+    /* the rest only test sync */
+    {
+      ogg_page og_de;
+      /* Test fractional page inputs: incomplete capture */
+      fprintf(stderr,"Testing sync on partial inputs... ");
+      ogg_sync_reset(&oy);
+      memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
+             3);
+      ogg_sync_wrote(&oy,3);
+      if(ogg_sync_pageout(&oy,&og_de)>0)error();
+
+      /* Test fractional page inputs: incomplete fixed header */
+      memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+3,
+             20);
+      ogg_sync_wrote(&oy,20);
+      if(ogg_sync_pageout(&oy,&og_de)>0)error();
+
+      /* Test fractional page inputs: incomplete header */
+      memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+23,
+             5);
+      ogg_sync_wrote(&oy,5);
+      if(ogg_sync_pageout(&oy,&og_de)>0)error();
+
+      /* Test fractional page inputs: incomplete body */
+
+      memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+28,
+             og[1].header_len-28);
+      ogg_sync_wrote(&oy,og[1].header_len-28);
+      if(ogg_sync_pageout(&oy,&og_de)>0)error();
+
+      memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,1000);
+      ogg_sync_wrote(&oy,1000);
+      if(ogg_sync_pageout(&oy,&og_de)>0)error();
+
+      memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body+1000,
+             og[1].body_len-1000);
+      ogg_sync_wrote(&oy,og[1].body_len-1000);
+      if(ogg_sync_pageout(&oy,&og_de)<=0)error();
+
+      fprintf(stderr,"ok.\n");
+    }
+
+    /* Test fractional page inputs: page + incomplete capture */
+    {
+      ogg_page og_de;
+      fprintf(stderr,"Testing sync on 1+partial inputs... ");
+      ogg_sync_reset(&oy);
+
+      memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
+             og[1].header_len);
+      ogg_sync_wrote(&oy,og[1].header_len);
+
+      memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
+             og[1].body_len);
+      ogg_sync_wrote(&oy,og[1].body_len);
+
+      memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
+             20);
+      ogg_sync_wrote(&oy,20);
+      if(ogg_sync_pageout(&oy,&og_de)<=0)error();
+      if(ogg_sync_pageout(&oy,&og_de)>0)error();
+
+      memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+20,
+             og[1].header_len-20);
+      ogg_sync_wrote(&oy,og[1].header_len-20);
+      memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
+             og[1].body_len);
+      ogg_sync_wrote(&oy,og[1].body_len);
+      if(ogg_sync_pageout(&oy,&og_de)<=0)error();
+
+      fprintf(stderr,"ok.\n");
+    }
+
+    /* Test recapture: garbage + page */
+    {
+      ogg_page og_de;
+      fprintf(stderr,"Testing search for capture... ");
+      ogg_sync_reset(&oy);
+
+      /* 'garbage' */
+      memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
+             og[1].body_len);
+      ogg_sync_wrote(&oy,og[1].body_len);
+
+      memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
+             og[1].header_len);
+      ogg_sync_wrote(&oy,og[1].header_len);
+
+      memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
+             og[1].body_len);
+      ogg_sync_wrote(&oy,og[1].body_len);
+
+      memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,
+             20);
+      ogg_sync_wrote(&oy,20);
+      if(ogg_sync_pageout(&oy,&og_de)>0)error();
+      if(ogg_sync_pageout(&oy,&og_de)<=0)error();
+      if(ogg_sync_pageout(&oy,&og_de)>0)error();
+
+      memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header+20,
+             og[2].header_len-20);
+      ogg_sync_wrote(&oy,og[2].header_len-20);
+      memcpy(ogg_sync_buffer(&oy,og[2].body_len),og[2].body,
+             og[2].body_len);
+      ogg_sync_wrote(&oy,og[2].body_len);
+      if(ogg_sync_pageout(&oy,&og_de)<=0)error();
+
+      fprintf(stderr,"ok.\n");
+    }
+
+    /* Test recapture: page + garbage + page */
+    {
+      ogg_page og_de;
+      fprintf(stderr,"Testing recapture... ");
+      ogg_sync_reset(&oy);
+
+      memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
+             og[1].header_len);
+      ogg_sync_wrote(&oy,og[1].header_len);
+
+      memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
+             og[1].body_len);
+      ogg_sync_wrote(&oy,og[1].body_len);
+
+      memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,
+             og[2].header_len);
+      ogg_sync_wrote(&oy,og[2].header_len);
+
+      memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,
+             og[2].header_len);
+      ogg_sync_wrote(&oy,og[2].header_len);
+
+      if(ogg_sync_pageout(&oy,&og_de)<=0)error();
+
+      memcpy(ogg_sync_buffer(&oy,og[2].body_len),og[2].body,
+             og[2].body_len-5);
+      ogg_sync_wrote(&oy,og[2].body_len-5);
+
+      memcpy(ogg_sync_buffer(&oy,og[3].header_len),og[3].header,
+             og[3].header_len);
+      ogg_sync_wrote(&oy,og[3].header_len);
+
+      memcpy(ogg_sync_buffer(&oy,og[3].body_len),og[3].body,
+             og[3].body_len);
+      ogg_sync_wrote(&oy,og[3].body_len);
+
+      if(ogg_sync_pageout(&oy,&og_de)>0)error();
+      if(ogg_sync_pageout(&oy,&og_de)<=0)error();
+
+      fprintf(stderr,"ok.\n");
+    }
+
+    /* Free page data that was previously copied */
+    {
+      for(i=0;i<5;i++){
+        free_page(&og[i]);
+      }
+    }
+  }
+
+  return(0);
+}
+
+#endif
diff --git a/libs/ogg/ogg.h b/libs/ogg/ogg.h
new file mode 100644 (file)
index 0000000..cea4ebe
--- /dev/null
@@ -0,0 +1,210 @@
+/********************************************************************
+ *                                                                  *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.   *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
+ *                                                                  *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007             *
+ * by the Xiph.Org Foundation http://www.xiph.org/                  *
+ *                                                                  *
+ ********************************************************************
+
+ function: toplevel libogg include
+ last mod: $Id: ogg.h 18044 2011-08-01 17:55:20Z gmaxwell $
+
+ ********************************************************************/
+#ifndef _OGG_H
+#define _OGG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include <ogg/os_types.h>
+
+typedef struct {
+  void *iov_base;
+  size_t iov_len;
+} ogg_iovec_t;
+
+typedef struct {
+  long endbyte;
+  int  endbit;
+
+  unsigned char *buffer;
+  unsigned char *ptr;
+  long storage;
+} oggpack_buffer;
+
+/* ogg_page is used to encapsulate the data in one Ogg bitstream page *****/
+
+typedef struct {
+  unsigned char *header;
+  long header_len;
+  unsigned char *body;
+  long body_len;
+} ogg_page;
+
+/* ogg_stream_state contains the current encode/decode state of a logical
+   Ogg bitstream **********************************************************/
+
+typedef struct {
+  unsigned char   *body_data;    /* bytes from packet bodies */
+  long    body_storage;          /* storage elements allocated */
+  long    body_fill;             /* elements stored; fill mark */
+  long    body_returned;         /* elements of fill returned */
+
+
+  int     *lacing_vals;      /* The values that will go to the segment table */
+  ogg_int64_t *granule_vals; /* granulepos values for headers. Not compact
+                                this way, but it is simple coupled to the
+                                lacing fifo */
+  long    lacing_storage;
+  long    lacing_fill;
+  long    lacing_packet;
+  long    lacing_returned;
+
+  unsigned char    header[282];      /* working space for header encode */
+  int              header_fill;
+
+  int     e_o_s;          /* set when we have buffered the last packet in the
+                             logical bitstream */
+  int     b_o_s;          /* set after we've written the initial page
+                             of a logical bitstream */
+  long    serialno;
+  long    pageno;
+  ogg_int64_t  packetno;  /* sequence number for decode; the framing
+                             knows where there's a hole in the data,
+                             but we need coupling so that the codec
+                             (which is in a separate abstraction
+                             layer) also knows about the gap */
+  ogg_int64_t   granulepos;
+
+} ogg_stream_state;
+
+/* ogg_packet is used to encapsulate the data and metadata belonging
+   to a single raw Ogg/Vorbis packet *************************************/
+
+typedef struct {
+  unsigned char *packet;
+  long  bytes;
+  long  b_o_s;
+  long  e_o_s;
+
+  ogg_int64_t  granulepos;
+
+  ogg_int64_t  packetno;     /* sequence number for decode; the framing
+                                knows where there's a hole in the data,
+                                but we need coupling so that the codec
+                                (which is in a separate abstraction
+                                layer) also knows about the gap */
+} ogg_packet;
+
+typedef struct {
+  unsigned char *data;
+  int storage;
+  int fill;
+  int returned;
+
+  int unsynced;
+  int headerbytes;
+  int bodybytes;
+} ogg_sync_state;
+
+/* Ogg BITSTREAM PRIMITIVES: bitstream ************************/
+
+extern void  oggpack_writeinit(oggpack_buffer *b);
+extern int   oggpack_writecheck(oggpack_buffer *b);
+extern void  oggpack_writetrunc(oggpack_buffer *b,long bits);
+extern void  oggpack_writealign(oggpack_buffer *b);
+extern void  oggpack_writecopy(oggpack_buffer *b,void *source,long bits);
+extern void  oggpack_reset(oggpack_buffer *b);
+extern void  oggpack_writeclear(oggpack_buffer *b);
+extern void  oggpack_readinit(oggpack_buffer *b,unsigned char *buf,int bytes);
+extern void  oggpack_write(oggpack_buffer *b,unsigned long value,int bits);
+extern long  oggpack_look(oggpack_buffer *b,int bits);
+extern long  oggpack_look1(oggpack_buffer *b);
+extern void  oggpack_adv(oggpack_buffer *b,int bits);
+extern void  oggpack_adv1(oggpack_buffer *b);
+extern long  oggpack_read(oggpack_buffer *b,int bits);
+extern long  oggpack_read1(oggpack_buffer *b);
+extern long  oggpack_bytes(oggpack_buffer *b);
+extern long  oggpack_bits(oggpack_buffer *b);
+extern unsigned char *oggpack_get_buffer(oggpack_buffer *b);
+
+extern void  oggpackB_writeinit(oggpack_buffer *b);
+extern int   oggpackB_writecheck(oggpack_buffer *b);
+extern void  oggpackB_writetrunc(oggpack_buffer *b,long bits);
+extern void  oggpackB_writealign(oggpack_buffer *b);
+extern void  oggpackB_writecopy(oggpack_buffer *b,void *source,long bits);
+extern void  oggpackB_reset(oggpack_buffer *b);
+extern void  oggpackB_writeclear(oggpack_buffer *b);
+extern void  oggpackB_readinit(oggpack_buffer *b,unsigned char *buf,int bytes);
+extern void  oggpackB_write(oggpack_buffer *b,unsigned long value,int bits);
+extern long  oggpackB_look(oggpack_buffer *b,int bits);
+extern long  oggpackB_look1(oggpack_buffer *b);
+extern void  oggpackB_adv(oggpack_buffer *b,int bits);
+extern void  oggpackB_adv1(oggpack_buffer *b);
+extern long  oggpackB_read(oggpack_buffer *b,int bits);
+extern long  oggpackB_read1(oggpack_buffer *b);
+extern long  oggpackB_bytes(oggpack_buffer *b);
+extern long  oggpackB_bits(oggpack_buffer *b);
+extern unsigned char *oggpackB_get_buffer(oggpack_buffer *b);
+
+/* Ogg BITSTREAM PRIMITIVES: encoding **************************/
+
+extern int      ogg_stream_packetin(ogg_stream_state *os, ogg_packet *op);
+extern int      ogg_stream_iovecin(ogg_stream_state *os, ogg_iovec_t *iov,
+                                   int count, long e_o_s, ogg_int64_t granulepos);
+extern int      ogg_stream_pageout(ogg_stream_state *os, ogg_page *og);
+extern int      ogg_stream_pageout_fill(ogg_stream_state *os, ogg_page *og, int nfill);
+extern int      ogg_stream_flush(ogg_stream_state *os, ogg_page *og);
+extern int      ogg_stream_flush_fill(ogg_stream_state *os, ogg_page *og, int nfill);
+
+/* Ogg BITSTREAM PRIMITIVES: decoding **************************/
+
+extern int      ogg_sync_init(ogg_sync_state *oy);
+extern int      ogg_sync_clear(ogg_sync_state *oy);
+extern int      ogg_sync_reset(ogg_sync_state *oy);
+extern int      ogg_sync_destroy(ogg_sync_state *oy);
+extern int      ogg_sync_check(ogg_sync_state *oy);
+
+extern char    *ogg_sync_buffer(ogg_sync_state *oy, long size);
+extern int      ogg_sync_wrote(ogg_sync_state *oy, long bytes);
+extern long     ogg_sync_pageseek(ogg_sync_state *oy,ogg_page *og);
+extern int      ogg_sync_pageout(ogg_sync_state *oy, ogg_page *og);
+extern int      ogg_stream_pagein(ogg_stream_state *os, ogg_page *og);
+extern int      ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op);
+extern int      ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op);
+
+/* Ogg BITSTREAM PRIMITIVES: general ***************************/
+
+extern int      ogg_stream_init(ogg_stream_state *os,int serialno);
+extern int      ogg_stream_clear(ogg_stream_state *os);
+extern int      ogg_stream_reset(ogg_stream_state *os);
+extern int      ogg_stream_reset_serialno(ogg_stream_state *os,int serialno);
+extern int      ogg_stream_destroy(ogg_stream_state *os);
+extern int      ogg_stream_check(ogg_stream_state *os);
+extern int      ogg_stream_eos(ogg_stream_state *os);
+
+extern void     ogg_page_checksum_set(ogg_page *og);
+
+extern int      ogg_page_version(const ogg_page *og);
+extern int      ogg_page_continued(const ogg_page *og);
+extern int      ogg_page_bos(const ogg_page *og);
+extern int      ogg_page_eos(const ogg_page *og);
+extern ogg_int64_t  ogg_page_granulepos(const ogg_page *og);
+extern int      ogg_page_serialno(const ogg_page *og);
+extern long     ogg_page_pageno(const ogg_page *og);
+extern int      ogg_page_packets(const ogg_page *og);
+
+extern void     ogg_packet_clear(ogg_packet *op);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* _OGG_H */
diff --git a/libs/ogg/os_types.h b/libs/ogg/os_types.h
new file mode 100644 (file)
index 0000000..d6691b7
--- /dev/null
@@ -0,0 +1,147 @@
+/********************************************************************
+ *                                                                  *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.   *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
+ *                                                                  *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2002             *
+ * by the Xiph.Org Foundation http://www.xiph.org/                  *
+ *                                                                  *
+ ********************************************************************
+
+ function: #ifdef jail to whip a few platforms into the UNIX ideal.
+ last mod: $Id: os_types.h 17712 2010-12-03 17:10:02Z xiphmont $
+
+ ********************************************************************/
+#ifndef _OS_TYPES_H
+#define _OS_TYPES_H
+
+/* make it easy on the folks that want to compile the libs with a
+   different malloc than stdlib */
+#define _ogg_malloc  malloc
+#define _ogg_calloc  calloc
+#define _ogg_realloc realloc
+#define _ogg_free    free
+
+#if defined(_WIN32) 
+
+#  if defined(__CYGWIN__)
+#    include <stdint.h>
+     typedef int16_t ogg_int16_t;
+     typedef uint16_t ogg_uint16_t;
+     typedef int32_t ogg_int32_t;
+     typedef uint32_t ogg_uint32_t;
+     typedef int64_t ogg_int64_t;
+     typedef uint64_t ogg_uint64_t;
+#  elif defined(__MINGW32__)
+#    include <sys/types.h>
+     typedef short ogg_int16_t;
+     typedef unsigned short ogg_uint16_t;
+     typedef int ogg_int32_t;
+     typedef unsigned int ogg_uint32_t;
+     typedef long long ogg_int64_t;
+     typedef unsigned long long ogg_uint64_t;
+#  elif defined(__MWERKS__)
+     typedef long long ogg_int64_t;
+     typedef int ogg_int32_t;
+     typedef unsigned int ogg_uint32_t;
+     typedef short ogg_int16_t;
+     typedef unsigned short ogg_uint16_t;
+#  else
+     /* MSVC/Borland */
+     typedef __int64 ogg_int64_t;
+     typedef __int32 ogg_int32_t;
+     typedef unsigned __int32 ogg_uint32_t;
+     typedef __int16 ogg_int16_t;
+     typedef unsigned __int16 ogg_uint16_t;
+#  endif
+
+#elif defined(__MACOS__)
+
+#  include <sys/types.h>
+   typedef SInt16 ogg_int16_t;
+   typedef UInt16 ogg_uint16_t;
+   typedef SInt32 ogg_int32_t;
+   typedef UInt32 ogg_uint32_t;
+   typedef SInt64 ogg_int64_t;
+
+#elif (defined(__APPLE__) && defined(__MACH__)) /* MacOS X Framework build */
+
+#  include <inttypes.h>
+   typedef int16_t ogg_int16_t;
+   typedef uint16_t ogg_uint16_t;
+   typedef int32_t ogg_int32_t;
+   typedef uint32_t ogg_uint32_t;
+   typedef int64_t ogg_int64_t;
+
+#elif defined(__HAIKU__)
+
+  /* Haiku */
+#  include <sys/types.h>
+   typedef short ogg_int16_t;
+   typedef unsigned short ogg_uint16_t;
+   typedef int ogg_int32_t;
+   typedef unsigned int ogg_uint32_t;
+   typedef long long ogg_int64_t;
+
+#elif defined(__BEOS__)
+
+   /* Be */
+#  include <inttypes.h>
+   typedef int16_t ogg_int16_t;
+   typedef uint16_t ogg_uint16_t;
+   typedef int32_t ogg_int32_t;
+   typedef uint32_t ogg_uint32_t;
+   typedef int64_t ogg_int64_t;
+
+#elif defined (__EMX__)
+
+   /* OS/2 GCC */
+   typedef short ogg_int16_t;
+   typedef unsigned short ogg_uint16_t;
+   typedef int ogg_int32_t;
+   typedef unsigned int ogg_uint32_t;
+   typedef long long ogg_int64_t;
+
+#elif defined (DJGPP)
+
+   /* DJGPP */
+   typedef short ogg_int16_t;
+   typedef int ogg_int32_t;
+   typedef unsigned int ogg_uint32_t;
+   typedef long long ogg_int64_t;
+
+#elif defined(R5900)
+
+   /* PS2 EE */
+   typedef long ogg_int64_t;
+   typedef int ogg_int32_t;
+   typedef unsigned ogg_uint32_t;
+   typedef short ogg_int16_t;
+
+#elif defined(__SYMBIAN32__)
+
+   /* Symbian GCC */
+   typedef signed short ogg_int16_t;
+   typedef unsigned short ogg_uint16_t;
+   typedef signed int ogg_int32_t;
+   typedef unsigned int ogg_uint32_t;
+   typedef long long int ogg_int64_t;
+
+#elif defined(__TMS320C6X__)
+
+   /* TI C64x compiler */
+   typedef signed short ogg_int16_t;
+   typedef unsigned short ogg_uint16_t;
+   typedef signed int ogg_int32_t;
+   typedef unsigned int ogg_uint32_t;
+   typedef long long int ogg_int64_t;
+
+#else
+
+#  include <ogg/config_types.h>
+
+#endif
+
+#endif  /* _OS_TYPES_H */
diff --git a/libs/vorbis/AUTHORS b/libs/vorbis/AUTHORS
new file mode 100644 (file)
index 0000000..0da1036
--- /dev/null
@@ -0,0 +1,3 @@
+Monty <monty@xiph.org>
+
+and the rest of the Xiph.org Foundation.
diff --git a/libs/vorbis/COPYING b/libs/vorbis/COPYING
new file mode 100644 (file)
index 0000000..28de72a
--- /dev/null
@@ -0,0 +1,28 @@
+Copyright (c) 2002-2008 Xiph.org Foundation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+- Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+- Neither the name of the Xiph.org Foundation nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/libs/vorbis/analysis.c b/libs/vorbis/analysis.c
new file mode 100644 (file)
index 0000000..01aa6f3
--- /dev/null
@@ -0,0 +1,120 @@
+/********************************************************************
+ *                                                                  *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.   *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
+ *                                                                  *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007             *
+ * by the Xiph.Org Foundation http://www.xiph.org/                  *
+ *                                                                  *
+ ********************************************************************
+
+ function: single-block PCM analysis mode dispatch
+ last mod: $Id: analysis.c 16226 2009-07-08 06:43:49Z xiphmont $
+
+ ********************************************************************/
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <ogg/ogg.h>
+#include "vorbis/codec.h"
+#include "codec_internal.h"
+#include "registry.h"
+#include "scales.h"
+#include "os.h"
+#include "misc.h"
+
+/* decides between modes, dispatches to the appropriate mapping. */
+int vorbis_analysis(vorbis_block *vb, ogg_packet *op){
+  int ret,i;
+  vorbis_block_internal *vbi=vb->internal;
+
+  vb->glue_bits=0;
+  vb->time_bits=0;
+  vb->floor_bits=0;
+  vb->res_bits=0;
+
+  /* first things first.  Make sure encode is ready */
+  for(i=0;i<PACKETBLOBS;i++)
+    oggpack_reset(vbi->packetblob[i]);
+
+  /* we only have one mapping type (0), and we let the mapping code
+     itself figure out what soft mode to use.  This allows easier
+     bitrate management */
+
+  if((ret=_mapping_P[0]->forward(vb)))
+    return(ret);
+
+  if(op){
+    if(vorbis_bitrate_managed(vb))
+      /* The app is using a bitmanaged mode... but not using the
+         bitrate management interface. */
+      return(OV_EINVAL);
+
+    op->packet=oggpack_get_buffer(&vb->opb);
+    op->bytes=oggpack_bytes(&vb->opb);
+    op->b_o_s=0;
+    op->e_o_s=vb->eofflag;
+    op->granulepos=vb->granulepos;
+    op->packetno=vb->sequence; /* for sake of completeness */
+  }
+  return(0);
+}
+
+#ifdef ANALYSIS
+int analysis_noisy=1;
+
+/* there was no great place to put this.... */
+void _analysis_output_always(char *base,int i,float *v,int n,int bark,int dB,ogg_int64_t off){
+  int j;
+  FILE *of;
+  char buffer[80];
+
+  sprintf(buffer,"%s_%d.m",base,i);
+  of=fopen(buffer,"w");
+
+  if(!of)perror("failed to open data dump file");
+
+  for(j=0;j<n;j++){
+    if(bark){
+      float b=toBARK((4000.f*j/n)+.25);
+      fprintf(of,"%f ",b);
+    }else
+      if(off!=0)
+        fprintf(of,"%f ",(double)(j+off)/8000.);
+      else
+        fprintf(of,"%f ",(double)j);
+
+    if(dB){
+      float val;
+      if(v[j]==0.)
+        val=-140.;
+      else
+        val=todB(v+j);
+      fprintf(of,"%f\n",val);
+    }else{
+      fprintf(of,"%f\n",v[j]);
+    }
+  }
+  fclose(of);
+}
+
+void _analysis_output(char *base,int i,float *v,int n,int bark,int dB,
+                      ogg_int64_t off){
+  if(analysis_noisy)_analysis_output_always(base,i,v,n,bark,dB,off);
+}
+
+#endif
+
+
+
+
+
+
+
+
+
+
+
diff --git a/libs/vorbis/backends.h b/libs/vorbis/backends.h
new file mode 100644 (file)
index 0000000..ff5bcc9
--- /dev/null
@@ -0,0 +1,144 @@
+/********************************************************************
+ *                                                                  *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.   *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
+ *                                                                  *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009             *
+ * by the Xiph.Org Foundation http://www.xiph.org/                  *
+ *                                                                  *
+ ********************************************************************
+
+ function: libvorbis backend and mapping structures; needed for
+           static mode headers
+ last mod: $Id: backends.h 16962 2010-03-11 07:30:34Z xiphmont $
+
+ ********************************************************************/
+
+/* this is exposed up here because we need it for static modes.
+   Lookups for each backend aren't exposed because there's no reason
+   to do so */
+
+#ifndef _vorbis_backend_h_
+#define _vorbis_backend_h_
+
+#include "codec_internal.h"
+
+/* this would all be simpler/shorter with templates, but.... */
+/* Floor backend generic *****************************************/
+typedef struct{
+  void                   (*pack)  (vorbis_info_floor *,oggpack_buffer *);
+  vorbis_info_floor     *(*unpack)(vorbis_info *,oggpack_buffer *);
+  vorbis_look_floor     *(*look)  (vorbis_dsp_state *,vorbis_info_floor *);
+  void (*free_info) (vorbis_info_floor *);
+  void (*free_look) (vorbis_look_floor *);
+  void *(*inverse1)  (struct vorbis_block *,vorbis_look_floor *);
+  int   (*inverse2)  (struct vorbis_block *,vorbis_look_floor *,
+                     void *buffer,float *);
+} vorbis_func_floor;
+
+typedef struct{
+  int   order;
+  long  rate;
+  long  barkmap;
+
+  int   ampbits;
+  int   ampdB;
+
+  int   numbooks; /* <= 16 */
+  int   books[16];
+
+  float lessthan;     /* encode-only config setting hacks for libvorbis */
+  float greaterthan;  /* encode-only config setting hacks for libvorbis */
+
+} vorbis_info_floor0;
+
+
+#define VIF_POSIT 63
+#define VIF_CLASS 16
+#define VIF_PARTS 31
+typedef struct{
+  int   partitions;                /* 0 to 31 */
+  int   partitionclass[VIF_PARTS]; /* 0 to 15 */
+
+  int   class_dim[VIF_CLASS];        /* 1 to 8 */
+  int   class_subs[VIF_CLASS];       /* 0,1,2,3 (bits: 1<<n poss) */
+  int   class_book[VIF_CLASS];       /* subs ^ dim entries */
+  int   class_subbook[VIF_CLASS][8]; /* [VIF_CLASS][subs] */
+
+
+  int   mult;                      /* 1 2 3 or 4 */
+  int   postlist[VIF_POSIT+2];    /* first two implicit */
+
+
+  /* encode side analysis parameters */
+  float maxover;
+  float maxunder;
+  float maxerr;
+
+  float twofitweight;
+  float twofitatten;
+
+  int   n;
+
+} vorbis_info_floor1;
+
+/* Residue backend generic *****************************************/
+typedef struct{
+  void                 (*pack)  (vorbis_info_residue *,oggpack_buffer *);
+  vorbis_info_residue *(*unpack)(vorbis_info *,oggpack_buffer *);
+  vorbis_look_residue *(*look)  (vorbis_dsp_state *,
+                                 vorbis_info_residue *);
+  void (*free_info)    (vorbis_info_residue *);
+  void (*free_look)    (vorbis_look_residue *);
+  long **(*class)      (struct vorbis_block *,vorbis_look_residue *,
+                        int **,int *,int);
+  int  (*forward)      (oggpack_buffer *,struct vorbis_block *,
+                        vorbis_look_residue *,
+                        int **,int *,int,long **,int);
+  int  (*inverse)      (struct vorbis_block *,vorbis_look_residue *,
+                        float **,int *,int);
+} vorbis_func_residue;
+
+typedef struct vorbis_info_residue0{
+/* block-partitioned VQ coded straight residue */
+  long  begin;
+  long  end;
+
+  /* first stage (lossless partitioning) */
+  int    grouping;         /* group n vectors per partition */
+  int    partitions;       /* possible codebooks for a partition */
+  int    partvals;         /* partitions ^ groupbook dim */
+  int    groupbook;        /* huffbook for partitioning */
+  int    secondstages[64]; /* expanded out to pointers in lookup */
+  int    booklist[512];    /* list of second stage books */
+
+  const int classmetric1[64];
+  const int classmetric2[64];
+} vorbis_info_residue0;
+
+/* Mapping backend generic *****************************************/
+typedef struct{
+  void                 (*pack)  (vorbis_info *,vorbis_info_mapping *,
+                                 oggpack_buffer *);
+  vorbis_info_mapping *(*unpack)(vorbis_info *,oggpack_buffer *);
+  void (*free_info)    (vorbis_info_mapping *);
+  int  (*forward)      (struct vorbis_block *vb);
+  int  (*inverse)      (struct vorbis_block *vb,vorbis_info_mapping *);
+} vorbis_func_mapping;
+
+typedef struct vorbis_info_mapping0{
+  int   submaps;  /* <= 16 */
+  int   chmuxlist[256];   /* up to 256 channels in a Vorbis stream */
+
+  int   floorsubmap[16];   /* [mux] submap to floors */
+  int   residuesubmap[16]; /* [mux] submap to residue */
+
+  int   coupling_steps;
+  int   coupling_mag[256];
+  int   coupling_ang[256];
+
+} vorbis_info_mapping0;
+
+#endif
diff --git a/libs/vorbis/bitrate.c b/libs/vorbis/bitrate.c
new file mode 100644 (file)
index 0000000..3a71b1d
--- /dev/null
@@ -0,0 +1,253 @@
+/********************************************************************
+ *                                                                  *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.   *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
+ *                                                                  *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009             *
+ * by the Xiph.Org Foundation http://www.xiph.org/                  *
+ *                                                                  *
+ ********************************************************************
+
+ function: bitrate tracking and management
+ last mod: $Id: bitrate.c 16227 2009-07-08 06:58:46Z xiphmont $
+
+ ********************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <ogg/ogg.h>
+#include "vorbis/codec.h"
+#include "codec_internal.h"
+#include "os.h"
+#include "misc.h"
+#include "bitrate.h"
+
+/* compute bitrate tracking setup  */
+void vorbis_bitrate_init(vorbis_info *vi,bitrate_manager_state *bm){
+  codec_setup_info *ci=vi->codec_setup;
+  bitrate_manager_info *bi=&ci->bi;
+
+  memset(bm,0,sizeof(*bm));
+
+  if(bi && (bi->reservoir_bits>0)){
+    long ratesamples=vi->rate;
+    int  halfsamples=ci->blocksizes[0]>>1;
+
+    bm->short_per_long=ci->blocksizes[1]/ci->blocksizes[0];
+    bm->managed=1;
+
+    bm->avg_bitsper= rint(1.*bi->avg_rate*halfsamples/ratesamples);
+    bm->min_bitsper= rint(1.*bi->min_rate*halfsamples/ratesamples);
+    bm->max_bitsper= rint(1.*bi->max_rate*halfsamples/ratesamples);
+
+    bm->avgfloat=PACKETBLOBS/2;
+
+    /* not a necessary fix, but one that leads to a more balanced
+       typical initialization */
+    {
+      long desired_fill=bi->reservoir_bits*bi->reservoir_bias;
+      bm->minmax_reservoir=desired_fill;
+      bm->avg_reservoir=desired_fill;
+    }
+
+  }
+}
+
+void vorbis_bitrate_clear(bitrate_manager_state *bm){
+  memset(bm,0,sizeof(*bm));
+  return;
+}
+
+int vorbis_bitrate_managed(vorbis_block *vb){
+  vorbis_dsp_state      *vd=vb->vd;
+  private_state         *b=vd->backend_state;
+  bitrate_manager_state *bm=&b->bms;
+
+  if(bm && bm->managed)return(1);
+  return(0);
+}
+
+/* finish taking in the block we just processed */
+int vorbis_bitrate_addblock(vorbis_block *vb){
+  vorbis_block_internal *vbi=vb->internal;
+  vorbis_dsp_state      *vd=vb->vd;
+  private_state         *b=vd->backend_state;
+  bitrate_manager_state *bm=&b->bms;
+  vorbis_info           *vi=vd->vi;
+  codec_setup_info      *ci=vi->codec_setup;
+  bitrate_manager_info  *bi=&ci->bi;
+
+  int  choice=rint(bm->avgfloat);
+  long this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
+  long min_target_bits=(vb->W?bm->min_bitsper*bm->short_per_long:bm->min_bitsper);
+  long max_target_bits=(vb->W?bm->max_bitsper*bm->short_per_long:bm->max_bitsper);
+  int  samples=ci->blocksizes[vb->W]>>1;
+  long desired_fill=bi->reservoir_bits*bi->reservoir_bias;
+  if(!bm->managed){
+    /* not a bitrate managed stream, but for API simplicity, we'll
+       buffer the packet to keep the code path clean */
+
+    if(bm->vb)return(-1); /* one has been submitted without
+                             being claimed */
+    bm->vb=vb;
+    return(0);
+  }
+
+  bm->vb=vb;
+
+  /* look ahead for avg floater */
+  if(bm->avg_bitsper>0){
+    double slew=0.;
+    long avg_target_bits=(vb->W?bm->avg_bitsper*bm->short_per_long:bm->avg_bitsper);
+    double slewlimit= 15./bi->slew_damp;
+
+    /* choosing a new floater:
+       if we're over target, we slew down
+       if we're under target, we slew up
+
+       choose slew as follows: look through packetblobs of this frame
+       and set slew as the first in the appropriate direction that
+       gives us the slew we want.  This may mean no slew if delta is
+       already favorable.
+
+       Then limit slew to slew max */
+
+    if(bm->avg_reservoir+(this_bits-avg_target_bits)>desired_fill){
+      while(choice>0 && this_bits>avg_target_bits &&
+            bm->avg_reservoir+(this_bits-avg_target_bits)>desired_fill){
+        choice--;
+        this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
+      }
+    }else if(bm->avg_reservoir+(this_bits-avg_target_bits)<desired_fill){
+      while(choice+1<PACKETBLOBS && this_bits<avg_target_bits &&
+            bm->avg_reservoir+(this_bits-avg_target_bits)<desired_fill){
+        choice++;
+        this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
+      }
+    }
+
+    slew=rint(choice-bm->avgfloat)/samples*vi->rate;
+    if(slew<-slewlimit)slew=-slewlimit;
+    if(slew>slewlimit)slew=slewlimit;
+    choice=rint(bm->avgfloat+= slew/vi->rate*samples);
+    this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
+  }
+
+
+
+  /* enforce min(if used) on the current floater (if used) */
+  if(bm->min_bitsper>0){
+    /* do we need to force the bitrate up? */
+    if(this_bits<min_target_bits){
+      while(bm->minmax_reservoir-(min_target_bits-this_bits)<0){
+        choice++;
+        if(choice>=PACKETBLOBS)break;
+        this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
+      }
+    }
+  }
+
+  /* enforce max (if used) on the current floater (if used) */
+  if(bm->max_bitsper>0){
+    /* do we need to force the bitrate down? */
+    if(this_bits>max_target_bits){
+      while(bm->minmax_reservoir+(this_bits-max_target_bits)>bi->reservoir_bits){
+        choice--;
+        if(choice<0)break;
+        this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
+      }
+    }
+  }
+
+  /* Choice of packetblobs now made based on floater, and min/max
+     requirements. Now boundary check extreme choices */
+
+  if(choice<0){
+    /* choosing a smaller packetblob is insufficient to trim bitrate.
+       frame will need to be truncated */
+    long maxsize=(max_target_bits+(bi->reservoir_bits-bm->minmax_reservoir))/8;
+    bm->choice=choice=0;
+
+    if(oggpack_bytes(vbi->packetblob[choice])>maxsize){
+
+      oggpack_writetrunc(vbi->packetblob[choice],maxsize*8);
+      this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
+    }
+  }else{
+    long minsize=(min_target_bits-bm->minmax_reservoir+7)/8;
+    if(choice>=PACKETBLOBS)
+      choice=PACKETBLOBS-1;
+
+    bm->choice=choice;
+
+    /* prop up bitrate according to demand. pad this frame out with zeroes */
+    minsize-=oggpack_bytes(vbi->packetblob[choice]);
+    while(minsize-->0)oggpack_write(vbi->packetblob[choice],0,8);
+    this_bits=oggpack_bytes(vbi->packetblob[choice])*8;
+
+  }
+
+  /* now we have the final packet and the final packet size.  Update statistics */
+  /* min and max reservoir */
+  if(bm->min_bitsper>0 || bm->max_bitsper>0){
+
+    if(max_target_bits>0 && this_bits>max_target_bits){
+      bm->minmax_reservoir+=(this_bits-max_target_bits);
+    }else if(min_target_bits>0 && this_bits<min_target_bits){
+      bm->minmax_reservoir+=(this_bits-min_target_bits);
+    }else{
+      /* inbetween; we want to take reservoir toward but not past desired_fill */
+      if(bm->minmax_reservoir>desired_fill){
+        if(max_target_bits>0){ /* logical bulletproofing against initialization state */
+          bm->minmax_reservoir+=(this_bits-max_target_bits);
+          if(bm->minmax_reservoir<desired_fill)bm->minmax_reservoir=desired_fill;
+        }else{
+          bm->minmax_reservoir=desired_fill;
+        }
+      }else{
+        if(min_target_bits>0){ /* logical bulletproofing against initialization state */
+          bm->minmax_reservoir+=(this_bits-min_target_bits);
+          if(bm->minmax_reservoir>desired_fill)bm->minmax_reservoir=desired_fill;
+        }else{
+          bm->minmax_reservoir=desired_fill;
+        }
+      }
+    }
+  }
+
+  /* avg reservoir */
+  if(bm->avg_bitsper>0){
+    long avg_target_bits=(vb->W?bm->avg_bitsper*bm->short_per_long:bm->avg_bitsper);
+    bm->avg_reservoir+=this_bits-avg_target_bits;
+  }
+
+  return(0);
+}
+
+int vorbis_bitrate_flushpacket(vorbis_dsp_state *vd,ogg_packet *op){
+  private_state         *b=vd->backend_state;
+  bitrate_manager_state *bm=&b->bms;
+  vorbis_block          *vb=bm->vb;
+  int                    choice=PACKETBLOBS/2;
+  if(!vb)return 0;
+
+  if(op){
+    vorbis_block_internal *vbi=vb->internal;
+
+    if(vorbis_bitrate_managed(vb))
+      choice=bm->choice;
+
+    op->packet=oggpack_get_buffer(vbi->packetblob[choice]);
+    op->bytes=oggpack_bytes(vbi->packetblob[choice]);
+    op->b_o_s=0;
+    op->e_o_s=vb->eofflag;
+    op->granulepos=vb->granulepos;
+    op->packetno=vb->sequence; /* for sake of completeness */
+  }
+
+  bm->vb=0;
+  return(1);
+}
diff --git a/libs/vorbis/bitrate.h b/libs/vorbis/bitrate.h
new file mode 100644 (file)
index 0000000..db48fcb
--- /dev/null
@@ -0,0 +1,59 @@
+/********************************************************************
+ *                                                                  *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.   *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
+ *                                                                  *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007             *
+ * by the Xiph.Org Foundation http://www.xiph.org/                  *
+ *                                                                  *
+ ********************************************************************
+
+ function: bitrate tracking and management
+ last mod: $Id: bitrate.h 13293 2007-07-24 00:09:47Z xiphmont $
+
+ ********************************************************************/
+
+#ifndef _V_BITRATE_H_
+#define _V_BITRATE_H_
+
+#include "vorbis/codec.h"
+#include "codec_internal.h"
+#include "os.h"
+
+/* encode side bitrate tracking */
+typedef struct bitrate_manager_state {
+  int            managed;
+
+  long           avg_reservoir;
+  long           minmax_reservoir;
+  long           avg_bitsper;
+  long           min_bitsper;
+  long           max_bitsper;
+
+  long           short_per_long;
+  double         avgfloat;
+
+  vorbis_block  *vb;
+  int            choice;
+} bitrate_manager_state;
+
+typedef struct bitrate_manager_info{
+  long           avg_rate;
+  long           min_rate;
+  long           max_rate;
+  long           reservoir_bits;
+  double         reservoir_bias;
+
+  double         slew_damp;
+
+} bitrate_manager_info;
+
+extern void vorbis_bitrate_init(vorbis_info *vi,bitrate_manager_state *bs);
+extern void vorbis_bitrate_clear(bitrate_manager_state *bs);
+extern int vorbis_bitrate_managed(vorbis_block *vb);
+extern int vorbis_bitrate_addblock(vorbis_block *vb);
+extern int vorbis_bitrate_flushpacket(vorbis_dsp_state *vd, ogg_packet *op);
+
+#endif
diff --git a/libs/vorbis/block.c b/libs/vorbis/block.c
new file mode 100644 (file)
index 0000000..eee9abf
--- /dev/null
@@ -0,0 +1,1046 @@
+/********************************************************************
+ *                                                                  *
+ * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.   *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
+ *                                                                  *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009             *
+ * by the Xiph.Org Foundation http://www.xiph.org/                  *
+ *                                                                  *
+ ********************************************************************
+
+ function: PCM data vector blocking, windowing and dis/reassembly
+ last mod: $Id: block.c 17561 2010-10-23 10:34:24Z xiphmont $
+
+ Handle windowing, overlap-add, etc of the PCM vectors.  This is made
+ more amusing by Vorbis' current two allowed block sizes.
+
+ ********************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ogg/ogg.h>
+#include "vorbis/codec.h"
+#include "codec_internal.h"
+
+#include "window.h"
+#include "mdct.h"
+#include "lpc.h"
+#include "registry.h"
+#include "misc.h"
+
+static int ilog2(unsigned int v){
+  int ret=0;
+  if(v)--v;
+  while(v){
+    ret++;
+    v>>=1;
+  }
+  return(ret);
+}
+
+/* pcm accumulator examples (not exhaustive):
+
+ <-------------- lW ---------------->
+                   <--------------- W ---------------->
+:            .....|.....       _______________         |
+:        .'''     |     '''_---      |       |\        |
+:.....'''         |_____--- '''......|       | \_______|
+:.................|__________________|_______|__|______|
+                  |<------ Sl ------>|      > Sr <     |endW
+                  |beginSl           |endSl  |  |endSr
+                  |beginW            |endlW  |beginSr
+
+
+                      |< lW >|
+                   <--------------- W ---------------->
+                  |   |  ..  ______________            |
+                  |   | '  `/        |     ---_        |
+                  |___.'___/`.       |         ---_____|
+                  |_______|__|_______|_________________|
+                  |      >|Sl|<      |<------ Sr ----->|endW
+                  |       |  |endSl  |beginSr          |endSr
+                  |beginW |  |endlW
+                  mult[0] |beginSl                     mult[n]
+
+ <-------------- lW ----------------->
+                          |<--W-->|
+:            ..............  ___  |   |
+:        .'''             |`/   \ |   |
+:.....'''                 |/`....\|...|
+:.........................|___|___|___|
+                          |Sl |Sr |endW
+                          |   |   |endSr
+                          |   |beginSr
+                          |   |endSl
+                          |beginSl
+                          |beginW
+*/
+
+/* block abstraction setup *********************************************/
+
+#ifndef WORD_ALIGN
+#define WORD_ALIGN 8
+#endif
+
+int vorbis_block_init(vorbis_dsp_state *v, vorbis_block *vb){
+  int i;
+  memset(vb,0,sizeof(*vb));
+  vb->vd=v;
+  vb->localalloc=0;
+  vb->localstore=NULL;
+  if(v->analysisp){
+    vorbis_block_internal *vbi=
+      vb->internal=_ogg_calloc(1,sizeof(vorbis_block_internal));
+    vbi->ampmax=-9999;
+
+    for(i=0;i<PACKETBLOBS;i++){
+      if(i==PACKETBLOBS/2){
+        vbi->packetblob[i]=&vb->opb;
+      }else{
+        vbi->packetblob[i]=
+          _ogg_calloc(1,sizeof(oggpack_buffer));
+      }
+      oggpack_writeinit(vbi->packetblob[i]);
+    }
+  }
+
+  return(0);
+}
+
+void *_vorbis_block_alloc(vorbis_block *vb,long bytes){
+  bytes=(bytes+(WORD_ALIGN-1)) & ~(WORD_ALIGN-1);
+  if(bytes+vb->localtop>vb->localalloc){
+    /* can't just _ogg_realloc... there are outstanding pointers */
+    if(vb->localstore){
+      struct alloc_chain *link=_ogg_malloc(sizeof(*link));
+      vb->totaluse+=vb->localtop;
+      link->next=vb->reap;
+      link->ptr=vb->localstore;
+      vb->reap=link;
+    }
+    /* highly conservative */
+    vb->localalloc=bytes;
+    vb->localstore=_ogg_malloc(vb->localalloc);
+    vb->localtop=0;
+  }
+  {
+    void *ret=(void *)(((char *)vb->localstore)+vb->localtop);
+    vb->localtop+=bytes;
+    return ret;
+  }
+}
+
+/* reap the chain, pull the ripcord */
+void _vorbis_block_ripcord(vorbis_block *vb){
+  /* reap the chain */
+  struct alloc_chain *reap=vb->reap;
+  while(reap){
+    struct alloc_chain *next=reap->next;
+    _ogg_free(reap->ptr);
+    memset(reap,0,sizeof(*reap));
+    _ogg_free(reap);
+    reap=next;
+  }
+  /* consolidate storage */
+  if(vb->totaluse){
+    vb->localstore=_ogg_realloc(vb->localstore,vb->totaluse+vb->localalloc);
+    vb->localalloc+=vb->totaluse;
+    vb->totaluse=0;
+  }
+
+  /* pull the ripcord */
+  vb->localtop=0;
+  vb->reap=NULL;
+}
+
+int vorbis_block_clear(vorbis_block *vb){
+  int i;
+  vorbis_block_internal *vbi=vb->internal;
+
+  _vorbis_block_ripcord(vb);
+  if(vb->localstore)_ogg_free(vb->localstore);
+
+  if(vbi){
+    for(i=0;i<PACKETBLOBS;i++){
+      oggpack_writeclear(vbi->packetblob[i]);
+      if(i!=PACKETBLOBS/2)_ogg_free(vbi->packetblob[i]);
+    }
+    _ogg_free(vbi);
+  }
+  memset(vb,0,sizeof(*vb));
+  return(0);
+}
+
+/* Analysis side code, but directly related to blocking.  Thus it's
+   here and not in analysis.c (which is for analysis transforms only).
+   The init is here because some of it is shared */
+
+static int _vds_shared_init(vorbis_dsp_state *v,vorbis_info *vi,int encp){
+  int i;
+  codec_setup_info *ci=vi->codec_setup;
+  private_state *b=NULL;
+  int hs;
+
+  if(ci==NULL) return 1;
+  hs=ci->halfrate_flag;
+
+  memset(v,0,sizeof(*v));
+  b=v->backend_state=_ogg_calloc(1,sizeof(*b));
+
+  v->vi=vi;
+  b->modebits=ilog2(ci->modes);
+
+  b->transform[0]=_ogg_calloc(VI_TRANSFORMB,sizeof(*b->transform[0]));
+  b->transform[1]=_ogg_calloc(VI_TRANSFORMB,sizeof(*b->transform[1]));
+
+  /* MDCT is tranform 0 */
+
+  b->transform[0][0]=_ogg_calloc(1,sizeof(mdct_lookup));
+  b->transform[1][0]=_ogg_calloc(1,sizeof(mdct_lookup));
+  mdct_init(b->transform[0][0],ci->blocksizes[0]>>hs);
+  mdct_init(b->transform[1][0],ci->blocksizes[1]>>hs);
+
+  /* Vorbis I uses only window type 0 */
+  b->window[0]=ilog2(ci->blocksizes[0])-6;
+  b->window[1]=ilog2(ci->blocksizes[1])-6;
+
+  if(encp){ /* encode/decode differ here */
+
+    /* analysis always needs an fft */
+    drft_init(&b->fft_look[0],ci->blocksizes[0]);
+    drft_init(&b->fft_look[1],ci->blocksizes[1]);
+
+    /* finish the codebooks */
+    if(!ci->fullbooks){
+      ci->fullbooks=_ogg_calloc(ci->books,sizeof(*ci->fullbooks));
+      for(i=0;i<ci->books;i++)
+        vorbis_book_init_encode(ci->fullbooks+i,ci->book_param[i]);
+    }
+
+    b->psy=_ogg_calloc(ci->psys,sizeof(*b->psy));
+    for(i=0;i<ci->psys;i++){
+      _vp_psy_init(b->psy+i,
+                   ci->psy_param[i],
+                   &ci->psy_g_param,
+                   ci->blocksizes[ci->psy_param[i]->blockflag]/2,
+                   vi->rate);
+    }
+
+    v->analysisp=1;
+  }else{
+    /* finish the codebooks */
+    if(!ci->fullbooks){
+      ci->fullbooks=_ogg_calloc(ci->books,sizeof(*ci->fullbooks));
+      for(i=0;i<ci->books;i++){
+        if(ci->book_param[i]==NULL)
+          goto abort_books;
+        if(vorbis_book_init_decode(ci->fullbooks+i,ci->book_param[i]))
+          goto abort_books;
+        /* decode codebooks are now standalone after init */
+        vorbis_staticbook_destroy(ci->book_param[i]);
+        ci->book_param[i]=NULL;
+      }
+    }
+  }
+
+  /* initialize the storage vectors. blocksize[1] is small for encode,
+     but the correct size for decode */
+  v->pcm_storage=ci->blocksizes[1];
+  v->pcm=_ogg_malloc(vi->channels*sizeof(*v->pcm));
+  v->pcmret=_ogg_malloc(vi->channels*sizeof(*v->pcmret));
+  {
+    int i;
+    for(i=0;i<vi->channels;i++)
+      v->pcm[i]=_ogg_calloc(v->pcm_storage,sizeof(*v->pcm[i]));
+  }
+
+  /* all 1 (large block) or 0 (small block) */
+  /* explicitly set for the sake of clarity */
+  v->lW=0; /* previous window size */
+  v->W=0;  /* current window size */
+
+  /* all vector indexes */
+  v->centerW=ci->blocksizes[1]/2;
+
+  v->pcm_current=v->centerW;
+
+  /* initialize all the backend lookups */
+  b->flr=_ogg_calloc(ci->floors,sizeof(*b->flr));
+  b->residue=_ogg_calloc(ci->residues,sizeof(*b->residue));
+
+  for(i=0;i<ci->floors;i++)
+    b->flr[i]=_floor_P[ci->floor_type[i]]->
+      look(v,ci->floor_param[i]);
+
+  for(i=0;i<ci->residues;i++)
+    b->residue[i]=_residue_P[ci->residue_type[i]]->
+      look(v,ci->residue_param[i]);
+
+  return 0;
+ abort_books:
+  for(i=0;i<ci->books;i++){
+    if(ci->book_param[i]!=NULL){
+      vorbis_staticbook_destroy(ci->book_param[i]);
+      ci->book_param[i]=NULL;
+    }
+  }
+  vorbis_dsp_clear(v);
+  return -1;
+}
+
+/* arbitrary settings and spec-mandated numbers get filled in here */
+int vorbis_analysis_init(vorbis_dsp_state *v,vorbis_info *vi){
+  private_state *b=NULL;
+
+  if(_vds_shared_init(v,vi,1))return 1;
+  b=v->backend_state;
+  b->psy_g_look=_vp_global_look(vi);
+
+  /* Initialize the envelope state storage */
+  b->ve=_ogg_calloc(1,sizeof(*b->ve));
+  _ve_envelope_init(b->ve,vi);
+
+  vorbis_bitrate_init(vi,&b->bms);
+
+  /* compressed audio packets start after the headers
+     with sequence number 3 */
+  v->sequence=3;
+
+  return(0);
+}
+
+void vorbis_dsp_clear(vorbis_dsp_state *v){
+  int i;
+  if(v){
+    vorbis_info *vi=v->vi;
+    codec_setup_info *ci=(vi?vi->codec_setup:NULL);
+    private_state *b=v->backend_state;
+
+    if(b){
+
+      if(b->ve){
+        _ve_envelope_clear(b->ve);
+        _ogg_free(b->ve);
+      }
+
+      if(b->transform[0]){
+        mdct_clear(b->transform[0][0]);
+        _ogg_free(b->transform[0][0]);
+        _ogg_free(b->transform[0]);
+      }
+      if(b->transform[1]){
+        mdct_clear(b->transform[1][0]);
+        _ogg_free(b->transform[1][0]);
+        _ogg_free(b->transform[1]);
+      }
+
+      if(b->flr){
+        if(ci)
+          for(i=0;i<ci->floors;i++)
+            _floor_P[ci->floor_type[i]]->
+              free_look(b->flr[i]);
+        _ogg_free(b->flr);
+      }
+      if(b->residue){
+        if(ci)
+          for(i=0;i<ci->residues;i++)
+            _residue_P[ci->residue_type[i]]->
+              free_look(b->residue[i]);
+        _ogg_free(b->residue);
+      }
+      if(b->psy){
+        if(ci)
+          for(i=0;i<ci->psys;i++)
+            _vp_psy_clear(b->psy+i);
+        _ogg_free(b->psy);
+      }
+
+      if(b->psy_g_look)_vp_global_free(b->psy_g_look);
+      vorbis_bitrate_clear(&b->bms);
+
+      drft_clear(&b->fft_look[0]);
+      drft_clear(&b->fft_look[1]);
+
+    }
+
+    if(v->pcm){
+      if(vi)
+        for(i=0;i<vi->channels;i++)
+          if(v->pcm[i])_ogg_free(v->pcm[i]);
+      _ogg_free(v->pcm);
+      if(v->pcmret)_ogg_free(v->pcmret);
+    }
+
+    if(b){
+      /* free header, header1, header2 */
+      if(b->header)_ogg_free(b->header);
+      if(b->header1)_ogg_free(b->header1);
+      if(b->header2)_ogg_free(b->header2);
+      _ogg_free(b);
+    }
+
+    memset(v,0,sizeof(*v));
+  }
+}
+
+float **vorbis_analysis_buffer(vorbis_dsp_state *v, int vals){
+  int i;
+  vorbis_info *vi=v->vi;
+  private_state *b=v->backend_state;
+
+  /* free header, header1, header2 */
+  if(b->header)_ogg_free(b->header);b->header=NULL;
+  if(b->header1)_ogg_free(b->header1);b->header1=NULL;
+  if(b->header2)_ogg_free(b->header2);b->header2=NULL;
+
+  /* Do we have enough storage space for the requested buffer? If not,
+     expand the PCM (and envelope) storage */
+
+  if(v->pcm_current+vals>=v->pcm_storage){
+    v->pcm_storage=v->pcm_current+vals*2;
+
+    for(i=0;i<vi->channels;i++){
+      v->pcm[i]=_ogg_realloc(v->pcm[i],v->pcm_storage*sizeof(*v->pcm[i]));
+    }
+  }
+
+  for(i=0;i<vi->channels;i++)
+    v->pcmret[i]=v->pcm[i]+v->pcm_current;
+
+  return(v->pcmret);
+}
+
+static void _preextrapolate_helper(vorbis_dsp_state *v){
+  int i;
+  int order=16;
+  float *lpc=alloca(order*sizeof(*lpc));
+  float *work=alloca(v->pcm_current*sizeof(*work));
+  long j;
+  v->preextrapolate=1;
+
+  if(v->pcm_current-v->centerW>order*2){ /* safety */
+    for(i=0;i<v->vi->channels;i++){
+      /* need to run the extrapolation in reverse! */
+      for(j=0;j<v->pcm_current;j++)
+        work[j]=v->pcm[i][v->pcm_current-j-1];
+
+      /* prime as above */
+      vorbis_lpc_from_data(work,lpc,v->pcm_current-v->centerW,order);
+
+#if 0
+      if(v->vi->channels==2){
+        if(i==0)
+          _analysis_output("predataL",0,work,v->pcm_current-v->centerW,0,0,0);
+        else
+          _analysis_output("predataR",0,work,v->pcm_current-v->centerW,0,0,0);
+      }else{
+        _analysis_output("predata",0,work,v->pcm_current-v->centerW,0,0,0);
+      }
+#endif
+
+      /* run the predictor filter */
+      vorbis_lpc_predict(lpc,work+v->pcm_current-v->centerW-order,
+                         order,
+                         work+v->pcm_current-v->centerW,
+                         v->centerW);
+
+      for(j=0;j<v->pcm_current;j++)
+        v->pcm[i][v->pcm_current-j-1]=work[j];
+
+    }
+  }
+}
+
+
+/* call with val<=0 to set eof */
+
+int vorbis_analysis_wrote(vorbis_dsp_state *v, int vals){
+  vorbis_info *vi=v->vi;
+  codec_setup_info *ci=vi->codec_setup;
+
+  if(vals<=0){
+    int order=32;
+    int i;
+    float *lpc=alloca(order*sizeof(*lpc));
+
+    /* if it wasn't done earlier (very short sample) */
+    if(!v->preextrapolate)
+      _preextrapolate_helper(v);
+
+    /* We're encoding the end of the stream.  Just make sure we have
+       [at least] a few full blocks of zeroes at the end. */
+    /* actually, we don't want zeroes; that could drop a large
+       amplitude off a cliff, creating spread spectrum noise that will
+       suck to encode.  Extrapolate for the sake of cleanliness. */
+
+    vorbis_analysis_buffer(v,ci->blocksizes[1]*3);
+    v->eofflag=v->pcm_current;
+    v->pcm_current+=ci->blocksizes[1]*3;
+
+    for(i=0;i<vi->channels;i++){
+      if(v->eofflag>order*2){
+        /* extrapolate with LPC to fill in */
+        long n;
+
+        /* make a predictor filter */
+        n=v->eofflag;
+        if(n>ci->blocksizes[1])n=ci->blocksizes[1];
+        vorbis_lpc_from_data(v->pcm[i]+v->eofflag-n,lpc,n,order);
+
+        /* run the predictor filter */
+        vorbis_lpc_predict(lpc,v->pcm[i]+v->eofflag-order,order,
+                           v->pcm[i]+v->eofflag,v->pcm_current-v->eofflag);
+      }else{
+        /* not enough data to extrapolate (unlikely to happen due to
+           guarding the overlap, but bulletproof in case that
+           assumtion goes away). zeroes will do. */
+        memset(v->pcm[i]+v->eofflag,0,
+               (v->pcm_current-v->eofflag)*sizeof(*v->pcm[i]));
+
+      }
+    }
+  }else{
+
+    if(v->pcm_current+vals>v->pcm_storage)
+      return(OV_EINVAL);
+
+    v->pcm_current+=vals;
+
+    /* we may want to reverse extrapolate the beginning of a stream
+       too... in case we're beginning on a cliff! */
+    /* clumsy, but simple.  It only runs once, so simple is good. */
+    if(!v->preextrapolate && v->pcm_current-v->centerW>ci->blocksizes[1])
+      _preextrapolate_helper(v);
+
+  }
+  return(0);
+}
+
+/* do the deltas, envelope shaping, pre-echo and determine the size of
+   the next block on which to continue analysis */
+int vorbis_analysis_blockout(vorbis_dsp_state *v,vorbis_block *vb){
+  int i;
+  vorbis_info *vi=v->vi;
+  codec_setup_info *ci=vi->codec_setup;
+  private_state *b=v->backend_state;
+  vorbis_look_psy_global *g=b->psy_g_look;
+  long beginW=v->centerW-ci->blocksizes[v->W]/2,centerNext;
+  vorbis_block_internal *vbi=(vorbis_block_internal *)vb->internal;
+
+  /* check to see if we're started... */
+  if(!v->preextrapolate)return(0);
+
+  /* check to see if we're done... */
+  if(v->eofflag==-1)return(0);
+
+  /* By our invariant, we have lW, W and centerW set.  Search for
+     the next boundary so we can determine nW (the next window size)
+     which lets us compute the shape of the current block's window */
+
+  /* we do an envelope search even on a single blocksize; we may still
+     be throwing more bits at impulses, and envelope search handles
+     marking impulses too. */
+  {
+    long bp=_ve_envelope_search(v);
+    if(bp==-1){
+
+      if(v->eofflag==0)return(0); /* not enough data currently to search for a
+                                     full long block */
+      v->nW=0;
+    }else{
+
+      if(ci->blocksizes[0]==ci->blocksizes[1])
+        v->nW=0;
+      else
+        v->nW=bp;
+    }
+  }
+
+  centerNext=v->centerW+ci->blocksizes[v->W]/4+ci->blocksizes[v->nW]/4;
+
+  {
+    /* center of next block + next block maximum right side. */
+
+    long blockbound=centerNext+ci->blocksizes[v->nW]/2;
+    if(v->pcm_current<blockbound)return(0); /* not enough data yet;
+                                               although this check is
+                                               less strict that the
+                                               _ve_envelope_search,
+                                               the search is not run
+                                               if we only use one
+                                               block size */
+
+
+  }
+
+  /* fill in the block.  Note that for a short window, lW and nW are *short*
+     regardless of actual settings in the stream */
+
+  _vorbis_block_ripcord(vb);
+  vb->lW=v->lW;
+  vb->W=v->W;
+  vb->nW=v->nW;
+
+  if(v->W){
+    if(!v->lW || !v->nW){
+      vbi->blocktype=BLOCKTYPE_TRANSITION;
+      /*fprintf(stderr,"-");*/
+    }else{
+      vbi->blocktype=BLOCKTYPE_LONG;
+      /*fprintf(stderr,"_");*/
+    }
+  }else{
+    if(_ve_envelope_mark(v)){
+      vbi->blocktype=BLOCKTYPE_IMPULSE;
+      /*fprintf(stderr,"|");*/
+
+    }else{
+      vbi->blocktype=BLOCKTYPE_PADDING;
+      /*fprintf(stderr,".");*/
+
+    }
+  }
+
+  vb->vd=v;
+  vb->sequence=v->sequence++;
+  vb->granulepos=v->granulepos;
+  vb->pcmend=ci->blocksizes[v->W];
+
+  /* copy the vectors; this uses the local storage in vb */
+
+  /* this tracks 'strongest peak' for later psychoacoustics */
+  /* moved to the global psy state; clean this mess up */
+  if(vbi->ampmax>g->ampmax)g->ampmax=vbi->ampmax;
+  g->ampmax=_vp_ampmax_decay(g->ampmax,v);
+  vbi->ampmax=g->ampmax;
+
+  vb->pcm=_vorbis_block_alloc(vb,sizeof(*vb->pcm)*vi->channels);
+  vbi->pcmdelay=_vorbis_block_alloc(vb,sizeof(*vbi->pcmdelay)*vi->channels);
+  for(i=0;i<vi->channels;i++){
+    vbi->pcmdelay[i]=
+      _vorbis_block_alloc(vb,(vb->pcmend+beginW)*sizeof(*vbi->pcmdelay[i]));
+    memcpy(vbi->pcmdelay[i],v->pcm[i],(vb->pcmend+beginW)*sizeof(*vbi->pcmdelay[i]));
+    vb->pcm[i]=vbi->pcmdelay[i]+beginW;
+
+    /* before we added the delay
+       vb->pcm[i]=_vorbis_block_alloc(vb,vb->pcmend*sizeof(*vb->pcm[i]));
+       memcpy(vb->pcm[i],v->pcm[i]+beginW,ci->blocksizes[v->W]*sizeof(*vb->pcm[i]));
+    */
+
+  }
+
+  /* handle eof detection: eof==0 means that we've not yet received EOF
+                           eof>0  marks the last 'real' sample in pcm[]
+                           eof<0  'no more to do'; doesn't get here */
+
+  if(v->eofflag){
+    if(v->centerW>=v->eofflag){
+      v->eofflag=-1;
+      vb->eofflag=1;
+      return(1);
+    }
+  }
+
+  /* advance storage vectors and clean up */
+  {
+    int new_centerNext=ci->blocksizes[1]/2;
+    int movementW=centerNext-new_centerNext;
+
+    if(movementW>0){
+
+      _ve_envelope_shift(b->ve,movementW);
+      v->pcm_current-=movementW;
+
+      for(i=0;i<vi->channels;i++)
+        memmove(v->pcm[i],v->pcm[i]+movementW,
+                v->pcm_current*sizeof(*v->pcm[i]));
+
+
+      v->lW=v->W;
+      v->W=v->nW;
+      v->centerW=new_centerNext;
+
+      if(v->eofflag){
+        v->eofflag-=movementW;
+        if(v->eofflag<=0)v->eofflag=-1;
+        /* do not add padding to end of stream! */
+        if(v->centerW>=v->eofflag){
+          v->granulepos+=movementW-(v->centerW-v->eofflag);
+        }else{
+          v->granulepos+=movementW;
+        }
+      }else{
+        v->granulepos+=movementW;
+      }
+    }
+  }
+
+  /* done */
+  return(1);
+}
+
+int vorbis_synthesis_restart(vorbis_dsp_state *v){
+  vorbis_info *vi=v->vi;
+  codec_setup_info *ci;
+  int hs;
+
+  if(!v->backend_state)return -1;
+  if(!vi)return -1;
+  ci=vi->codec_setup;
+  if(!ci)return -1;
+  hs=ci->halfrate_flag;
+
+  v->centerW=ci->blocksizes[1]>>(hs+1);
+  v->pcm_current=v->centerW>>hs;
+
+  v->pcm_returned=-1;
+  v->granulepos=-1;
+  v->sequence=-1;
+  v->eofflag=0;
+  ((private_state *)(v->backend_state))->sample_count=-1;
+
+  return(0);
+}
+
+int vorbis_synthesis_init(vorbis_dsp_state *v,vorbis_info *vi){
+  if(_vds_shared_init(v,vi,0)){
+    vorbis_dsp_clear(v);
+    return 1;
+  }
+  vorbis_synthesis_restart(v);
+  return 0;
+}
+
+/* Unlike in analysis, the window is only partially applied for each
+   block.  The time domain envelope is not yet handled at the point of
+   calling (as it relies on the previous block). */
+
+int vorbis_synthesis_blockin(vorbis_dsp_state *v,vorbis_block *vb){
+  vorbis_info *vi=v->vi;
+  codec_setup_info *ci=vi->codec_setup;
+  private_state *b=v->backend_state;
+  int hs=ci->halfrate_flag;
+  int i,j;
+
+  if(!vb)return(OV_EINVAL);
+  if(v->pcm_current>v->pcm_returned  && v->pcm_returned!=-1)return(OV_EINVAL);
+
+  v->lW=v->W;
+  v->W=vb->W;
+  v->nW=-1;
+
+  if((v->sequence==-1)||
+     (v->sequence+1 != vb->sequence)){
+    v->granulepos=-1; /* out of sequence; lose count */
+    b->sample_count=-1;
+  }
+
+  v->sequence=vb->sequence;
+
+  if(vb->pcm){  /* no pcm to process if vorbis_synthesis_trackonly
+                   was called on block */
+    int n=ci->blocksizes[v->W]>>(hs+1);
+    int n0=ci->blocksizes[0]>>(hs+1);
+    int n1=ci->blocksizes[1]>>(hs+1);
+
+    int thisCenter;
+    int prevCenter;
+
+    v->glue_bits+=vb->glue_bits;
+    v->time_bits+=vb->time_bits;
+    v->floor_bits+=vb->floor_bits;
+    v->res_bits+=vb->res_bits;
+
+    if(v->centerW){
+      thisCenter=n1;
+      prevCenter=0;
+    }else{
+      thisCenter=0;
+      prevCenter=n1;
+    }
+
+    /* v->pcm is now used like a two-stage double buffer.  We don't want
+       to have to constantly shift *or* adjust memory usage.  Don't
+       accept a new block until the old is shifted out */
+
+    for(j=0;j<vi->channels;j++){
+      /* the overlap/add section */
+      if(v->lW){
+        if(v->W){
+          /* large/large */
+          float *w=_vorbis_window_get(b->window[1]-hs);
+          float *pcm=v->pcm[j]+prevCenter;
+          float *p=vb->pcm[j];
+          for(i=0;i<n1;i++)
+            pcm[i]=pcm[i]*w[n1-i-1] + p[i]*w[i];
+        }else{
+          /* large/small */
+          float *w=_vorbis_window_get(b->window[0]-hs);
+          float *pcm=v->pcm[j]+prevCenter+n1/2-n0/2;
+          float *p=vb->pcm[j];
+          for(i=0;i<n0;i++)
+            pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
+        }
+      }else{
+        if(v->W){
+          /* small/large */
+          float *w=_vorbis_window_get(b->window[0]-hs);
+          float *pcm=v->pcm[j]+prevCenter;
+          float *p=vb->pcm[j]+n1/2-n0/2;
+          for(i=0;i<n0;i++)
+            pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
+          for(;i<n1/2+n0/2;i++)
+            pcm[i]=p[i];
+        }else{
+          /* small/small */
+          float *w=_vorbis_window_get(b->window[0]-hs);
+          float *pcm=v->pcm[j]+prevCenter;
+          float *p=vb->pcm[j];
+          for(i=0;i<n0;i++)
+            pcm[i]=pcm[i]*w[n0-i-1] +p[i]*w[i];
+        }
+      }
+
+      /* the copy section */
+      {
+        float *pcm=v->pcm[j]+thisCenter;
+        float *p=vb->pcm[j]+n;
+        for(i=0;i<n;i++)
+          pcm[i]=p[i];
+      }
+    }
+
+    if(v->centerW)
+      v->centerW=0;
+    else
+      v->centerW=n1;
+
+    /* deal with initial packet state; we do this using the explicit
+       pcm_returned==-1 flag otherwise we're sensitive to first block
+       being short or long */
+
+    if(v->pcm_returned==-1){
+      v->pcm_returned=thisCenter;
+      v->pcm_current=thisCenter;
+    }else{
+      v->pcm_returned=prevCenter;
+      v->pcm_current=prevCenter+
+        ((ci->blocksizes[v->lW]/4+
+        ci->blocksizes[v->W]/4)>>hs);
+    }
+
+  }
+
+  /* track the frame number... This is for convenience, but also
+     making sure our last packet doesn't end with added padding.  If
+     the last packet is partial, the number of samples we'll have to
+     return will be past the vb->granulepos.
+
+     This is not foolproof!  It will be confused if we begin
+     decoding at the last page after a seek or hole.  In that case,
+     we don't have a starting point to judge where the last frame
+     is.  For this reason, vorbisfile will always try to make sure
+     it reads the last two marked pages in proper sequence */
+
+  if(b->sample_count==-1){
+    b->sample_count=0;
+  }else{
+    b->sample_count+=ci->blocksizes[v->lW]/4+ci->blocksizes[v->W]/4;
+  }
+
+  if(v->granulepos==-1){
+    if(vb->granulepos!=-1){ /* only set if we have a position to set to */
+
+      v->granulepos=vb->granulepos;
+
+      /* is this a short page? */
+      if(b->sample_count>v->granulepos){
+        /* corner case; if this is both the first and last audio page,
+           then spec says the end is cut, not beginning */
+       long extra=b->sample_count-vb->granulepos;
+
+        /* we use ogg_int64_t for granule positions because a
+           uint64 isn't universally available.  Unfortunately,
+           that means granposes can be 'negative' and result in
+           extra being negative */
+        if(extra<0)
+          extra=0;
+
+        if(vb->eofflag){
+          /* trim the end */
+          /* no preceding granulepos; assume we started at zero (we'd
+             have to in a short single-page stream) */
+          /* granulepos could be -1 due to a seek, but that would result
+             in a long count, not short count */
+
+          /* Guard against corrupt/malicious frames that set EOP and
+             a backdated granpos; don't rewind more samples than we
+             actually have */
+          if(extra > (v->pcm_current - v->pcm_returned)<<hs)
+            extra = (v->pcm_current - v->pcm_returned)<<hs;
+
+          v->pcm_current-=extra>>hs;
+        }else{
+          /* trim the beginning */
+          v->pcm_returned+=extra>>hs;
+          if(v->pcm_returned>v->pcm_current)
+            v->pcm_returned=v->pcm_current;
+        }
+
+      }
+
+    }
+  }else{
+    v->granulepos+=ci->blocksizes[v->lW]/4+ci->blocksizes[v->W]/4;
+    if(vb->granulepos!=-1 && v->granulepos!=vb->granulepos){
+
+      if(v->granulepos>vb->granulepos){
+        long extra=v->granulepos-vb->granulepos;
+
+        if(extra)
+          if(vb->eofflag){
+            /* partial last frame.  Strip the extra samples off */
+
+            /* Guard against corrupt/malicious frames that set EOP and
+               a backdated granpos; don't rewind more samples than we
+               actually have */
+            if(extra > (v->pcm_current - v->pcm_returned)<<hs)
+              extra = (v->pcm_current - v->pcm_returned)<<hs;
+
+            /* we use ogg_int64_t for granule positions because a
+               uint64 isn't universally available.  Unfortunately,
+               that means granposes can be 'negative' and result in
+               extra being negative */
+            if(extra<0)
+              extra=0;
+
+            v->pcm_current-=extra>>hs;
+          } /* else {Shouldn't happen *unless* the bitstream is out of
+               spec.  Either way, believe the bitstream } */
+      } /* else {Shouldn't happen *unless* the bitstream is out of
+           spec.  Either way, believe the bitstream } */
+      v->granulepos=vb->granulepos;
+    }
+  }
+
+  /* Update, cleanup */
+
+  if(vb->eofflag)v->eofflag=1;
+  return(0);
+
+}
+
+/* pcm==NULL indicates we just want the pending samples, no more */
+int vorbis_synthesis_pcmout(vorbis_dsp_state *v,float ***pcm){
+  vorbis_info *vi=v->vi;
+
+  if(v->pcm_returned>-1 && v->pcm_returned<v->pcm_current){
+    if(pcm){
+      int i;
+      for(i=0;i<vi->channels;i++)
+        v->pcmret[i]=v->pcm[i]+v->pcm_returned;
+      *pcm=v->pcmret;
+    }
+    return(v->pcm_current-v->pcm_returned);
+  }
+  return(0);
+}
+
+int vorbis_synthesis_read(vorbis_dsp_state *v,int n){
+  if(n && v->pcm_returned+n>v->pcm_current)return(OV_EINVAL);
+  v->pcm_returned+=n;
+  return(0);
+}
+
+/* intended for use with a specific vorbisfile feature; we want access
+   to the [usually synthetic/postextrapolated] buffer and lapping at
+   the end of a decode cycle, specifically, a half-short-block worth.
+   This funtion works like pcmout above, except it will also expose
+   this implicit buffer data not normally decoded. */
+int vorbis_synthesis_lapout(vorbis_dsp_state *v,float ***pcm){
+  vorbis_info *vi=v->vi;
+  codec_setup_info *ci=vi->codec_setup;
+  int hs=ci->halfrate_flag;
+
+  int n=ci->blocksizes[v->W]>>(hs+1);
+  int n0=ci->blocksizes[0]>>(hs+1);
+  int n1=ci->blocksizes[1]>>(hs+1);
+  int i,j;
+
+  if(v->pcm_returned<0)return 0;
+
+  /* our returned data ends at pcm_returned; because the synthesis pcm
+     buffer is a two-fragment ring, that means our data block may be
+     fragmented by buffering, wrapping or a short block not filling
+     out a buffer.  To simplify things, we unfragment if it's at all
+     possibly needed. Otherwise, we'd need to call lapout more than
+     once as well as hold additional dsp state.  Opt for
+     simplicity. */
+
+  /* centerW was advanced by blockin; it would be the center of the
+     *next* block */
+  if(v->centerW==n1){
+    /* the data buffer wraps; swap the halves */
+    /* slow, sure, small */
+    for(j=0;j<vi->channels;j++){
+      float *p=v->pcm[j];
+      for(i=0;i<n1;i++){
+        float temp=p[i];
+        p[i]=p[i+n1];
+        p[i+n1]=temp;
+      }
+    }
+
+    v->pcm_current-=n1;
+    v->pcm_returned-=n1;
+    v->centerW=0;
+  }
+
+  /* solidify buffer into contiguous space */
+  if((v->lW^v->W)==1){
+    /* long/short or short/long */
+    for(j=0;j<vi->channels;j++){
+      float *s=v->pcm[j];
+      float *d=v->pcm[j]+(n1-n0)/2;
+      for(i=(n1+n0)/2-1;i>=0;--i)
+        d[i]=s[i];
+    }
+    v->pcm_returned+=(n1-n0)/2;
+    v->pcm_current+=(n1-n0)/2;
+  }else{
+    if(v->lW==0){
+      /* short/short */
+      for(j=0;j<vi->channels;j++){
+        float *s=v->pcm[j];
+        float *d=v->pcm[j]+n1-n0;
+        for(i=n0-1;i>=0;--i)
+          d[i]=s[i];
+      }
+      v->pcm_returned+=n1-n0;
+      v->pcm_current+=n1-n0;
+    }
+  }
+
+  if(pcm){
+    int i;
+    for(i=0;i<vi->channels;i++)
+      v->pcmret[i]=v->pcm[i]+v->pcm_returned;
+    *pcm=v->pcmret;
+  }
+
+  return(n1+n-v->pcm_returned);
+
+}
+
+float *vorbis_window(vorbis_dsp_state *v,int W){
+  vorbis_info *vi=v->vi;
+  codec_setup_info *ci=vi->codec_setup;
+  int hs=ci->halfrate_flag;
+  private_state *b=v->backend_state;
+
+  if(b->window[W]-1<0)return NULL;
+  return _vorbis_window_get(b->window[W]-hs);
+}
diff --git a/libs/vorbis/books/coupled/res_books_51.h b/libs/vorbis/books/coupled/res_books_51.h
new file mode 100644 (file)
index 0000000..917a955
--- /dev/null
@@ -0,0 +1,12257 @@
+static const long _vq_quantlist__44p0_l0_0[] = {
+       6,
+       5,
+       7,
+       4,
+       8,
+       3,
+       9,
+       2,
+       10,
+       1,
+       11,
+       0,
+       12,
+};
+
+static const long _vq_lengthlist__44p0_l0_0[] = {
+        1, 3, 4, 7, 7, 8, 8, 9, 9, 9,10,10,10, 5, 6, 5,
+        8, 7, 9, 8, 9, 9,10, 9,11,10, 5, 5, 7, 7, 8, 8,
+        9, 9, 9, 9,10,10,11, 8, 9, 8,10, 9,10, 9,10, 9,
+       11,10,11,10, 8, 8, 9, 9,10, 9,10, 9,11,10,11,10,
+       11,10,11,11,11,11,11,11,11,11,11,11,11,11,10,11,
+       11,11,12,11,11,11,11,11,11,10,12,12,12,12,12,12,
+       12,11,12,12,12,11,11,11,12,12,12,12,12,12,12,11,
+       12,11,12,11,11,13,12,12,12,13,12,12,12,12,11,12,
+       11,11,13,13,13,12,12,12,12,12,12,11,11,11,10,13,
+       13,13,12,13,12,13,11,13,10,12,11,11,13,13,12,13,
+       12,12,12,12,11,12,11,11,11,
+};
+
+static const static_codebook _44p0_l0_0 = {
+       2, 169,
+       (long *)_vq_lengthlist__44p0_l0_0,
+       1, -526516224, 1616117760, 4, 0,
+       (long *)_vq_quantlist__44p0_l0_0,
+       0
+};
+
+static const long _vq_quantlist__44p0_l0_1[] = {
+       2,
+       1,
+       3,
+       0,
+       4,
+};
+
+static const long _vq_lengthlist__44p0_l0_1[] = {
+        1, 4, 4, 6, 6, 5, 5, 5, 7, 5, 5, 5, 5, 6, 7, 7,
+        6, 7, 7, 7, 6, 7, 7, 7, 7,
+};
+
+static const static_codebook _44p0_l0_1 = {
+       2, 25,
+       (long *)_vq_lengthlist__44p0_l0_1,
+       1, -533725184, 1611661312, 3, 0,
+       (long *)_vq_quantlist__44p0_l0_1,
+       0
+};
+
+static const long _vq_quantlist__44p0_l1_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p0_l1_0[] = {
+        1, 4, 4, 4, 4, 4, 4, 4, 4,
+};
+
+static const static_codebook _44p0_l1_0 = {
+       2, 9,
+       (long *)_vq_lengthlist__44p0_l1_0,
+       1, -516716544, 1630767104, 2, 0,
+       (long *)_vq_quantlist__44p0_l1_0,
+       0
+};
+
+static const long _huff_lengthlist__44p0_lfe[] = {
+        1, 3, 2, 3,
+};
+
+static const static_codebook _huff_book__44p0_lfe = {
+       2, 4,
+       (long *)_huff_lengthlist__44p0_lfe,
+       0, 0, 0, 0, 0,
+       NULL,
+       0
+};
+
+static const long _huff_lengthlist__44p0_long[] = {
+        2, 3, 6, 7,10,14,16, 3, 2, 5, 7,11,14,17, 6, 5,
+        5, 7,10,12,14, 7, 7, 6, 6, 7, 9,13,10,11, 9, 6,
+        6, 9,11,15,15,13,10, 9,10,12,18,18,16,14,12,13,
+       16,
+};
+
+static const static_codebook _huff_book__44p0_long = {
+       2, 49,
+       (long *)_huff_lengthlist__44p0_long,
+       0, 0, 0, 0, 0,
+       NULL,
+       0
+};
+
+static const long _vq_quantlist__44p0_p1_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p0_p1_0[] = {
+        1, 2, 2, 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, 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,
+};
+
+static const static_codebook _44p0_p1_0 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p0_p1_0,
+       1, -535822336, 1611661312, 2, 0,
+       (long *)_vq_quantlist__44p0_p1_0,
+       0
+};
+
+static const long _vq_quantlist__44p0_p2_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p0_p2_0[] = {
+        1, 5, 5, 0, 7, 7, 0, 8, 8, 0, 9, 9, 0,12,12, 0,
+        8, 8, 0, 9, 9, 0,12,12, 0, 8, 8, 0, 6, 6, 0,11,
+       11, 0,12,12, 0,12,12, 0,15,15, 0,11,11, 0,12,12,
+        0,15,15, 0,12,12, 0, 5, 5, 0, 5, 5, 0, 6, 6, 0,
+        7, 7, 0,11,11, 0, 6, 6, 0, 7, 7, 0,10,11, 0, 6,
+        6, 0, 7, 7, 0,11,11, 0,12,12, 0,11,11, 0,15,15,
+        0,10,10, 0,12,12, 0,15,15, 0,12,12, 0, 6, 6, 0,
+       12,12, 0,12,12, 0,12,12, 0,15,15, 0,11,11, 0,12,
+       12, 0,15,15, 0,12,12, 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, 8, 8, 0,12,12, 0,12,12, 0,12,12, 0,15,
+       15, 0,12,12, 0,11,12, 0,15,16, 0,11,11, 0, 6, 6,
+        0,11,12, 0,12,12, 0,12,12, 0,16,15, 0,12,12, 0,
+       13,12, 0,15,14, 0,12,12, 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,
+};
+
+static const static_codebook _44p0_p2_0 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p0_p2_0,
+       1, -533200896, 1614282752, 2, 0,
+       (long *)_vq_quantlist__44p0_p2_0,
+       0
+};
+
+static const long _vq_quantlist__44p0_p2_1[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p0_p2_1[] = {
+        1, 3, 3, 0, 9, 9, 0, 9, 9, 0,10,10, 0, 9, 9, 0,
+       10,10, 0,10,10, 0, 9, 9, 0,10,10, 0, 7, 7, 0, 7,
+        7, 0, 6, 6, 0, 8, 8, 0, 7, 7, 0, 8, 8, 0, 8, 9,
+        0, 8, 8, 0, 8, 8, 0, 7, 7, 0, 9, 9, 0, 8, 8, 0,
+       10,10, 0, 9, 9, 0,10,10, 0,10,10, 0, 9, 9, 0,10,
+       10, 0, 9, 9, 0,11,11, 0,11,11, 0,12,12, 0,11,11,
+        0,12,12, 0,13,13, 0,12,12, 0,13,12, 0, 8, 8, 0,
+       12,12, 0,12,12, 0,13,13, 0,12,12, 0,13,13, 0,13,
+       13, 0,13,13, 0,13,13, 0, 7, 7, 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, 9, 9, 0,11,11, 0,12,12, 0,13,13, 0,12,
+       12, 0,13,13, 0,13,13, 0,12,12, 0,12,12, 0, 8, 8,
+        0,12,12, 0,12,12, 0,13,13, 0,13,13, 0,13,14, 0,
+       14,13, 0,13,13, 0,13,13, 0, 7, 7, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0,
+};
+
+static const static_codebook _44p0_p2_1 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p0_p2_1,
+       1, -535822336, 1611661312, 2, 0,
+       (long *)_vq_quantlist__44p0_p2_1,
+       0
+};
+
+static const long _vq_quantlist__44p0_p3_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p0_p3_0[] = {
+        1, 6, 6, 7, 8, 8, 7, 8, 8, 7, 9, 9,10,12,11, 9,
+        8, 8, 7, 9, 9,11,12,12, 9, 9, 9, 6, 7, 7,10,11,
+       11,10,11,11,10,11,11,13,13,14,12,12,12,11,11,11,
+       14,14,14,12,12,12, 6, 5, 5, 9, 6, 5, 9, 6, 6, 9,
+        7, 7,12,10,10,11, 6, 6,10, 7, 7,13,10,10,12, 7,
+        7, 7, 8, 8,12,10,10,12,10,10,11,10,10,15,13,13,
+       13, 9, 9,12,11,11,16,13,13,15,11,11, 8, 7, 7,12,
+       12,12,12,11,11,12,11,11,14,14,14,14,12,12,12,12,
+       12,16,15,15,14,12,12, 0,10,10, 0,12,12, 0,12,12,
+        0,11,11, 0,14,14, 0,11,11, 0,12,12, 0,15,15, 0,
+       11,11, 8, 8, 8,13,11,11,13,10,10,13,11,11,15,13,
+       13,14,11,11,12,10,10,16,14,14,14,10,10, 9, 7, 7,
+       13,11,11,13,11,11,12,11,11,16,14,14,14,12,12,13,
+       12,12,15,14,14,15,13,12, 0,11,11, 0,12,12, 0,12,
+       12, 0,12,12, 0,15,15, 0,12,12, 0,13,12, 0,14,15,
+        0,12,12,
+};
+
+static const static_codebook _44p0_p3_0 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p0_p3_0,
+       1, -531365888, 1616117760, 2, 0,
+       (long *)_vq_quantlist__44p0_p3_0,
+       0
+};
+
+static const long _vq_quantlist__44p0_p3_1[] = {
+       2,
+       1,
+       3,
+       0,
+       4,
+};
+
+static const long _vq_lengthlist__44p0_p3_1[] = {
+        2, 4, 4, 8, 8,10,12,12,11,11, 9,11,11,12,13,11,
+       12,12,11,11,11,12,12,12,12,10,13,12,13,13,11,12,
+       12,13,13,11,12,12,13,13,11,12,13,13,13,11,13,13,
+       13,13,10,13,13,12,13,11,12,12,14,14,11,13,12,12,
+       12,11,12,12,13,13,11,13,13,12,12,11,13,13,13,13,
+       11,12,12,13,13,11,13,13,12,12,11,12,12,13,13,11,
+       13,13,12,12,11,13,13,13,13,11,12,12,14,14,11,13,
+       13,12,12,11,12,12,13,13,11,13,13,12,12,11,10,10,
+       10,10,12,10,10,11,11,11, 8, 8,11,11,13,10,10,10,
+       10,12,10,10,10,10,13,11,11,11,11,13,10,10,11,11,
+       13,11,11,12,12,13,11,11,11,11,13,11,11,12,12,13,
+       11,11,12,12,13,10,10,11,11,13,11,11,11,11,13,11,
+       10,11,11,13,11,11,11,11,13,11,11,11,11,13,10,10,
+       11,11,13,11,11,11,11,12,10,11,11,11,13,11,11,11,
+       11,13,11,11,11,11,13,10,10,11,11,13,11,11,11,11,
+       13,11,11,11,11,13,11,11,11,11,11,10,10,10,10,12,
+       10,10, 9, 9,12,12,12,11,11,13,12,12, 9, 9,13,12,
+       12,10,10,12,12,12,12,12,13,13,13,14,14,13,12,12,
+       11,11,13,13,13,12,12,13,12,12,11,11,13,12,13,11,
+       11,13,13,13,14,14,13,12,12,10,10,13,13,13,11,11,
+       13,12,12,10,10,13,13,13,11,11,13,13,13,14,14,13,
+       12,12,10,10,13,13,13,11,11,13,12,13,10,10,13,13,
+       13,11,11,13,13,13,14,14,13,12,12,10,10,13,13,13,
+       11,11,13,13,12,10,10,14,12,12, 8, 8,14,12,12, 9,
+        9,14,11,11, 9, 9,14,12,12, 8, 8,14,11,11, 7, 7,
+       14,13,13,10,10,15,12,12,10,10,15,13,13,10,10,15,
+       12,12, 9, 9,15,13,13,10,10,15,13,13,10,10,15,12,
+       12,10,10,15,13,13,10,10,14,12,12, 9, 9,14,13,13,
+        9, 9,14,13,13, 9, 9,15,12,12, 9, 9,15,13,13, 9,
+        9,14,12,12, 9, 9,14,13,13, 9, 9,14,13,13, 9, 9,
+       15,12,12, 9, 9,14,13,13, 9, 9,14,12,12, 9, 9,14,
+       13,13, 9, 9,13,12,12, 8, 8,13,13,13, 8, 8,14,13,
+       13, 9, 9,13,13,13, 7, 7,14,13,13, 8, 8,14,14,14,
+       10,10,14,14,14,11,11,14,14,14, 9, 9,14,14,14,10,
+       10,14,14,14, 9, 9,14,14,14,10, 9,15,14,14,11,11,
+       14,14,14, 9, 9,14,14,14,10,10,14,14,14, 9, 9,14,
+       14,14, 9, 9,15,14,14,11,11,14,14,14, 8, 8,14,14,
+       14, 9, 9,14,14,14, 8, 8,14,14,14, 9, 9,15,14,14,
+       11,11,14,14,14, 8, 8,14,14,14, 9, 9,14,14,14, 8,
+        8,12,12,12,13,13,16,15,15,11,11,16,15,16,12,12,
+       17,16,16,11,11,17,15,15,12,11,16,16,16,12,13,16,
+       15,15,13,13,16,16,16,12,12,16,16,15,13,13,16,16,
+       16,12,12,16,16,16,13,13,17,16,16,14,14,17,17,16,
+       12,12,17,16,16,13,13,17,17,16,12,13,16,16,17,13,
+       12,17,16,16,14,13,17,16,16,12,12,17,16,16,12,12,
+       17,16,17,12,12,17,17,17,13,13,16,16,16,13,14,17,
+       17,16,12,12,16,16,16,13,13,17,17,17,12,12,13,14,
+       14,10,10,16,14,14,12,12,16,15,15,14,14,16,14,14,
+       12,12,15,14,14,13,13,17,15,15,14,13,16,16,15,15,
+       15,16,15,15,14,14,16,15,15,14,14,17,15,15,14,14,
+       16,15,15,14,14,16,16,15,15,15,17,15,15,13,13,16,
+       15,15,14,14,17,15,15,13,13,17,15,15,14,14,16,15,
+       15,15,15,16,14,14,13,13,16,15,15,14,14,16,14,14,
+       13,13,17,15,15,14,14,16,16,15,15,15,17,14,14,13,
+       13,16,15,15,14,14,17,14,14,13,13,13,11,11,10,10,
+       16,14,14,13,13,15,14,14,13,13,16,14,14,12,12,16,
+       14,14,12,12,15,15,15,14,14,16,14,14,14,14,16,15,
+       14,14,14,16,14,14,14,14,16,15,15,14,13,16,15,15,
+       14,14,16,14,14,14,14,17,15,15,14,14,16,14,14,14,
+       14,16,15,15,13,14,16,15,15,14,14,16,14,14,14,14,
+       16,15,15,13,13,16,14,14,13,13,16,15,15,13,13,16,
+       15,15,14,14,16,14,14,14,14,17,15,15,13,13,16,15,
+       14,13,13,17,15,15,13,13,14,14,14, 9, 9,14,14,14,
+       17,17,14,15,15,18,18,14,14,14,18,19,14,14,14,18,
+       18,15,15,15,19,18,15,16,15,18,20,15,15,15,18,19,
+       15,15,15,19,19,15,15,15,18,20,15,15,15,18,19,15,
+       15,16,20,18,15,15,15,18,18,15,15,15,19,19,15,15,
+       15,18,19,15,15,15,18,19,15,15,15,19,19,14,15,14,
+       19,19,15,15,15,20,19,15,14,14,19,18,14,15,15,18,
+       19,15,15,16,20,20,14,14,14,18,19,15,15,15,19,18,
+       14,14,14,18,18,14,12,12, 9, 9,13,14,14,18,18,14,
+       13,13,18,19,14,14,14,18,18,14,14,14,18,18,15,15,
+       15,19,19,15,14,14,19,18,14,15,15,19,18,15,14,14,
+       18,18,15,15,15,19,18,14,15,15,19,19,15,14,14,19,
+       18,14,15,15,19,18,15,14,14,19,18,14,15,15,19,18,
+       15,15,15,21,18,15,14,14,19,18,14,15,15,18,19,14,
+       15,14,20,19,14,15,15,18,19,14,15,15,19,19,15,14,
+       14,19,20,14,15,15,18,18,14,14,14,19,19,14,15,15,
+       19,18,12,12,12,13,13,16,15,15,11,11,16,15,15,12,
+       12,16,16,16,11,11,16,15,15,11,11,16,16,16,13,13,
+       17,16,16,13,13,17,17,17,12,12,16,16,16,13,13,17,
+       16,17,13,12,15,16,16,12,12,16,15,15,13,13,17,16,
+       16,12,12,16,16,15,12,12,16,16,16,12,12,17,17,16,
+       13,12,16,16,16,13,13,17,16,16,12,12,17,16,16,12,
+       12,17,17,16,12,12,16,17,16,12,12,17,15,15,13,13,
+       17,16,16,12,12,16,16,16,12,12,16,16,16,12,12,13,
+       13,13, 9, 9,15,14,14,13,13,16,15,14,14,14,16,14,
+       14,13,13,15,14,14,13,13,17,15,15,14,14,16,15,15,
+       15,15,16,15,15,14,14,16,15,15,15,15,17,15,15,14,
+       14,16,15,15,14,14,16,15,15,15,15,17,14,15,14,14,
+       16,15,15,14,14,17,15,15,13,14,17,15,15,14,14,16,
+       15,15,15,15,17,14,14,13,13,16,15,15,14,14,17,14,
+       14,13,13,17,15,15,14,14,16,15,16,15,15,17,14,14,
+       13,13,16,15,15,14,14,18,14,14,13,13,13,11,11,11,
+       11,15,14,14,12,12,15,14,14,13,13,16,14,14,12,12,
+       16,13,14,12,12,16,15,15,13,13,16,14,14,14,14,16,
+       15,15,13,13,16,14,14,13,13,16,14,15,13,13,15,15,
+       15,13,13,16,14,14,14,13,16,14,14,13,13,16,14,14,
+       13,13,16,15,15,13,13,16,15,15,13,13,16,14,14,14,
+       14,16,15,15,12,12,16,14,14,13,13,16,15,15,12,12,
+       16,15,15,13,13,16,14,14,14,14,17,15,14,12,12,16,
+       14,14,13,13,16,15,15,12,12,14,14,14, 8, 8,14,14,
+       14,17,18,14,15,15,17,18,14,14,14,17,18,14,14,14,
+       18,18,14,15,15,18,18,14,16,15,19,19,15,15,15,18,
+       19,15,16,15,20,19,15,15,15,18,18,14,15,15,18,19,
+       15,16,16,20,19,15,15,15,19,17,14,15,15,20,18,14,
+       15,15,18,18,14,15,15,18,19,14,15,15,19,20,14,14,
+       14,18,18,14,15,15,18,19,14,14,14,18,19,14,15,15,
+       19,18,15,16,16,20,21,14,14,15,19,19,14,15,15,19,
+       19,14,14,14,19,18,13,12,12, 9, 9,13,14,14,18,19,
+       14,14,14,18,19,14,14,14,18,18,14,14,14,18,18,14,
+       15,15,19,19,15,14,14,19,18,15,15,15,19,19,15,14,
+       14,19,20,14,15,15,18,19,14,15,15,20,18,15,14,14,
+       18,18,14,15,15,18,18,14,14,14,19,19,14,15,15,18,
+       18,14,15,15,19,18,15,14,14,19,19,14,15,15,19,18,
+       15,14,14,19,18,14,14,15,18,19,14,15,15,19,18,15,
+       14,14,18,19,14,15,14,19,20,14,14,14,19,19,14,15,
+       15,19,19,12,12,12,13,13,16,16,16,11,11,16,16,16,
+       12,12,17,16,16,11,11,17,15,15,11,11,16,16,16,13,
+       13,17,15,16,13,13,16,16,16,12,12,17,16,16,13,13,
+       17,17,16,12,12,17,17,16,13,13,17,16,16,13,13,17,
+       17,17,12,12,17,16,16,13,13,17,17,17,12,12,16,16,
+       16,12,12,17,15,15,13,13,17,16,16,11,11,17,16,16,
+       12,12,16,16,16,11,11,16,17,16,12,12,17,16,16,13,
+       13,17,17,16,12,12,17,17,16,12,12,17,16,16,11,11,
+       13,14,14, 9, 9,16,14,14,13,13,16,14,15,14,14,16,
+       14,14,12,12,16,14,14,13,13,17,15,15,14,14,16,15,
+       15,15,15,17,15,15,14,14,16,15,15,14,14,17,15,15,
+       14,14,16,15,15,14,14,16,15,15,15,16,17,14,15,14,
+       14,16,15,15,14,14,17,15,15,14,14,16,15,15,14,14,
+       16,15,15,15,15,17,14,14,13,13,16,15,15,14,14,16,
+       14,14,13,13,17,15,15,14,14,16,16,15,15,15,17,14,
+       14,13,13,16,15,15,14,14,17,14,14,13,13,13,11,11,
+       10,10,16,14,14,12,12,15,13,13,13,12,16,14,14,11,
+       11,16,14,14,11,11,16,14,15,13,14,16,14,14,13,13,
+       16,15,15,13,13,16,14,14,13,13,16,15,15,13,13,16,
+       15,15,13,13,17,14,14,14,14,17,15,15,13,13,16,14,
+       15,13,13,16,15,15,13,13,16,15,15,13,13,16,14,14,
+       13,13,17,15,15,12,12,16,14,14,12,12,16,15,15,12,
+       12,16,15,15,13,13,16,14,14,13,13,17,15,15,12,12,
+       17,14,14,12,12,16,15,15,12,12,13,14,14, 8, 8,13,
+       14,14,18,18,13,15,15,17,18,14,14,14,18,19,14,14,
+       14,19,18,14,15,15,19,18,15,15,16,21,18,15,15,15,
+       19,19,14,16,16,19,19,14,15,15,18,19,14,15,15,19,
+       20,14,16,16,19,18,15,15,15,18,19,14,15,15,19,18,
+       15,15,15,18,18,15,15,15,20,18,15,16,16,20,19,14,
+       15,14,18,19,14,15,16,19,20,14,15,15,19,18,15,15,
+       15,19,18,15,16,16,20,19,15,14,14,18,18,14,15,15,
+       19,19,14,15,15,18,18,13,12,12, 8, 8,13,14,14,19,
+       18,14,13,13,20,18,14,14,14,19,18,14,13,13,18,19,
+       14,15,15,20,19,15,14,14,19,19,14,15,15,19,18,15,
+       14,14,20,20,15,15,15,19,18,14,15,15,19,18,15,14,
+       14,19,18,14,15,15,20,19,14,14,14,20,19,14,15,15,
+       19,18,15,15,15,18,18,15,14,14,18,18,14,15,15,19,
+       19,14,14,14,19,19,14,15,15,19,19,15,15,15,19,18,
+       15,14,14,20,19,15,15,15,19,19,14,14,14,20,19,14,
+       15,15,20,20,12,12,12,13,13,17,16,16,11,11,16,16,
+       15,12,12,17,16,16,11,11,17,15,15,11,11,17,17,17,
+       13,13,17,16,16,13,13,17,17,17,12,12,17,16,16,13,
+       13,17,17,16,12,13,16,17,16,13,13,17,16,15,13,13,
+       17,16,16,12,12,17,16,16,12,13,17,16,17,12,12,17,
+       17,17,12,12,17,16,15,13,13,17,16,16,12,12,17,16,
+       16,12,12,17,16,16,11,11,16,16,16,12,12,17,15,15,
+       13,13,17,16,15,11,11,16,16,16,12,12,17,16,16,11,
+       11,13,14,14, 9, 9,16,14,14,13,13,16,14,15,14,14,
+       16,14,14,12,12,16,14,14,13,13,17,15,15,14,15,16,
+       15,15,15,15,17,15,15,14,14,16,15,15,15,14,16,15,
+       15,14,14,16,15,15,14,14,16,15,16,15,15,17,15,14,
+       14,14,16,15,15,14,14,17,15,15,13,13,16,15,15,14,
+       14,16,16,16,15,15,17,14,14,13,13,16,15,15,14,14,
+       18,14,15,13,13,16,15,15,14,14,16,16,15,15,15,16,
+       14,14,13,13,16,15,15,14,14,17,14,15,13,13,13,11,
+       11,10,10,15,14,14,12,12,15,14,14,13,13,16,14,14,
+       12,12,16,13,14,12,12,16,14,15,14,13,16,14,14,14,
+       14,16,15,15,13,13,16,14,14,13,13,16,15,15,13,13,
+       15,15,15,13,13,16,14,14,14,14,17,15,15,13,13,16,
+       14,14,13,13,16,15,15,13,13,16,15,15,13,13,16,14,
+       14,13,13,17,15,15,12,12,16,14,14,12,12,16,14,15,
+       12,12,16,15,15,13,13,16,14,14,13,13,17,15,15,12,
+       12,16,14,14,12,12,16,15,15,12,12,14,14,14, 8, 8,
+       14,14,14,17,17,14,15,15,18,18,14,14,14,18,17,14,
+       14,14,18,18,14,15,15,18,20,15,16,15,19,18,15,15,
+       15,19,18,15,15,16,19,18,15,15,15,18,18,14,15,15,
+       18,18,15,16,16,18,19,15,15,15,18,18,15,15,15,19,
+       20,15,15,15,18,18,15,15,15,18,18,15,16,16,19,19,
+       15,14,15,19,19,15,15,15,19,20,14,14,15,18,18,15,
+       15,15,19,19,15,16,16,19,19,15,15,14,18,19,15,15,
+       15,20,20,15,15,14,18,18,13,12,12, 8, 8,13,14,14,
+       18,18,14,14,14,18,18,14,14,14,18,20,14,14,14,18,
+       18,14,15,15,19,18,15,14,14,18,19,15,15,15,18,19,
+       15,14,14,18,19,15,15,15,18,18,14,15,14,18,19,15,
+       14,14,21,19,15,15,15,19,18,14,14,14,19,18,14,15,
+       15,19,18,15,15,15,20,19,15,14,14,20,18,14,15,15,
+       18,19,14,14,14,19,18,14,15,15,18,19,15,15,15,18,
+       19,15,14,14,19,19,15,15,15,19,19,14,14,14,19,20,
+       14,15,15,18,19,
+};
+
+static const static_codebook _44p0_p3_1 = {
+       5, 3125,
+       (long *)_vq_lengthlist__44p0_p3_1,
+       1, -533725184, 1611661312, 3, 0,
+       (long *)_vq_quantlist__44p0_p3_1,
+       0
+};
+
+static const long _vq_quantlist__44p0_p4_0[] = {
+       2,
+       1,
+       3,
+       0,
+       4,
+};
+
+static const long _vq_lengthlist__44p0_p4_0[] = {
+        2, 6, 6,14,14, 6, 8, 8,14,14, 7, 7, 7,14,14, 0,
+       13,13,15,16, 0,13,13,15,15, 7, 8, 8,15,15, 9,10,
+       10,16,16, 9, 8, 8,14,15, 0,13,13,17,17, 0,13,13,
+       16,16, 8, 8, 8,15,15,12,11,11,16,16, 9, 8, 8,14,
+       14, 0,13,13,17,17, 0,13,13,15,15, 0,14,14,16,16,
+        0, 0, 0,18,19, 0,12,12,16,15, 0,16,16, 0,20, 0,
+       14,14,16,16, 0,14,14,17,17, 0, 0, 0,19,19, 0,12,
+       12,15,15, 0,18,17,21,21, 0,14,14,16,16, 5, 7, 7,
+       12,13, 9,10, 9,14,14,11,10,10,14,14, 0, 0, 0,18,
+       17, 0,20,21,18,18, 9,10,10,14,14,12,12,12,17,16,
+       12,10,10,14,14, 0,20,20,18,17, 0,21,21,17,17,11,
+       10,10,14,14,15,13,13,18,18,13,11,11,14,14, 0,20,
+        0,18,18, 0,20,21,18,17, 0,21, 0,18,19, 0, 0, 0,
+        0,21, 0,21,20,16,17, 0, 0, 0,21,21, 0, 0, 0,20,
+       18, 0,20, 0,17,18, 0, 0, 0, 0, 0, 0, 0,20,16,17,
+        0, 0, 0,20, 0, 0, 0, 0,18,18, 6, 6, 6,13,13, 8,
+        5, 5,11,11, 9, 6, 6,13,13, 0, 9, 9,12,12, 0,10,
+       10,14,14, 9, 7, 7,13,13,12, 9, 9,13,13,10, 6, 6,
+       13,13, 0,10,10,14,14, 0,10,10,13,13, 9, 7, 7,13,
+       13,13,10,10,13,13,11, 6, 6,13,13, 0,10,10,15,15,
+        0,10,10,13,13, 0,12,11,15,15, 0,20,19,17,16, 0,
+        9, 9,13,13, 0,13,13,20,19, 0,11,11,13,13, 0,11,
+       11,15,15, 0,20,19,17,17, 0,10,10,13,13, 0,14,15,
+        0,21, 0,12,12,13,13, 0,10,10,12,12, 0,11,11,15,
+       15, 0,11,11,15,15, 0,15,15,20,20, 0,16,16, 0, 0,
+        0,11,11,15,15, 0,14,14,17,17, 0,11,11,15,15, 0,
+       15,15,20,21, 0,16,16,21,21, 0,12,12,15,15, 0,15,
+       15,18,20, 0,11,11,16,15, 0,15,15,21,21, 0,16,16,
+        0,21, 0,16,16, 0, 0, 0, 0, 0, 0, 0, 0,14,14,21,
+       21, 0,17,18, 0, 0, 0,16,17,20, 0, 0,16,16, 0, 0,
+        0, 0, 0, 0, 0, 0,15,15,20,20, 0,19,18, 0,21, 0,
+       18,17, 0, 0, 0,10,10,11,11, 0,10,10,10,10, 0,11,
+       11,12,12, 0,11,11, 9, 9, 0,13,13,12,12, 0,11,11,
+       12,12, 0,13,13,12,12, 0,10,10,12,12, 0,12,12,13,
+       13, 0,12,12,12,12, 0,11,11,12,12, 0,13,13,12,12,
+        0,10,10,12,12, 0,13,13,13,13, 0,12,12,12,12, 0,
+       14,13,13,13, 0,19,21,15,15, 0,12,11,12,12, 0,16,
+       15,19,19, 0,13,13,11,11, 0,13,13,13,13, 0, 0,21,
+       15,16, 0,12,12,12,12, 0,16,16,19,21, 0,13,13,12,
+       12, 7, 7, 7,16,16,11, 9, 9,16,16,12, 9, 9,16,16,
+        0,13,13,16,16, 0,14,14,17,16,11, 9, 9,16,16,14,
+       12,11,17,17,13, 8, 9,15,15, 0,13,13,19,19, 0,13,
+       13,16,15,12,10,10,17,17,15,12,12,19,18,14, 9, 9,
+       17,16, 0,14,14,18, 0, 0,14,13,16,16, 0,14,15,18,
+       17, 0,21, 0,19,21, 0,12,12,16,16, 0,16,16, 0, 0,
+        0,14,14,16,16, 0,14,14,18,18, 0, 0,21,20, 0, 0,
+       13,13,16,17, 0,18,18, 0, 0, 0,15,14,17,16, 8, 7,
+        7,14,14,11,10,10,15,15,13,10,10,15,15, 0,21,20,
+       19,19, 0,21, 0,17,18,11,10,10,15,16,14,12,12,18,
+       18,14,11,11,15,14, 0,21,20,18,19, 0, 0,21,18,18,
+       12,11,11,16,16,16,14,14,18,20,14,11,11,16,15, 0,
+       20,20,19,19, 0, 0,20,18,18, 0,21, 0,18,19, 0, 0,
+        0, 0, 0, 0,20,20,17,18, 0, 0, 0,20,20, 0, 0, 0,
+       19,19, 0, 0, 0,20,18, 0, 0, 0, 0, 0, 0, 0,21,18,
+       18, 0,21,21, 0,21, 0, 0, 0,19,20,11, 9, 9,14,14,
+       13,10,10,14,14,13,11,11,15,15, 0,13,13,13,13, 0,
+       14,14,16,16,13,11,11,15,15,16,12,12,15,15,14,10,
+       10,14,14, 0,14,14,16,16, 0,14,14,15,15,13,10,10,
+       15,15,17,13,14,15,16,15,10,10,15,15, 0,14,14,17,
+       16, 0,14,14,15,15, 0,15,15,17,17, 0, 0,21,18,18,
+        0,13,13,15,15, 0,16,16,21,20, 0,14,14,15,14, 0,
+       15,14,16,17, 0, 0,20,20,19, 0,13,13,15,15, 0,19,
+       18, 0, 0, 0,15,15,15,15, 0,11,11,14,14, 0,12,12,
+       16,16, 0,12,12,16,16, 0,15,16,21,21, 0,16,17,21,
+        0, 0,12,12,17,16, 0,14,14,18,19, 0,11,11,16,16,
+        0,15,15,20,21, 0,16,16,21, 0, 0,12,12,17,16, 0,
+       15,15,19,19, 0,12,12,16,17, 0,16,15, 0, 0, 0,16,
+       16, 0, 0, 0,17,17, 0,21, 0, 0, 0, 0, 0, 0,14,15,
+       20, 0, 0,17,17, 0, 0, 0,17,17, 0, 0, 0,17,16, 0,
+        0, 0, 0, 0, 0, 0, 0,15,15, 0, 0, 0,18,18, 0, 0,
+        0,18,17, 0, 0, 0,11,11,14,14, 0,12,12,15,15, 0,
+       12,12,15,15, 0,13,13,14,14, 0,14,14,17,17, 0,12,
+       12,16,16, 0,14,14,16,16, 0,11,11,15,15, 0,13,13,
+       16,17, 0,13,13,16,16, 0,12,12,15,15, 0,14,14,17,
+       16, 0,11,11,15,15, 0,14,14,17,17, 0,13,13,16,16,
+        0,15,15,17,18, 0,21,20,20,21, 0,12,12,15,15, 0,
+       16,16,20,21, 0,14,14,15,15, 0,14,14,17,17, 0, 0,
+        0,18,19, 0,12,13,15,15, 0,18,17,21, 0, 0,14,15,
+       15,15, 8, 8, 8,16,16,12,10,10,16,16,13, 9, 9,16,
+       16, 0,14,14,18,17, 0,14,14,16,17,12,10,10,18,17,
+       14,12,11,18,18,14, 9, 9,16,16, 0,13,13,18,18, 0,
+       13,13,17,16,12, 9, 9,16,17,17,13,13,17,17,14, 9,
+        9,15,15, 0,14,14,20,19, 0,13,13,16,16, 0,15,15,
+       19,18, 0, 0, 0,20,19, 0,12,13,17,17, 0,16,16,20,
+        0, 0,14,14,16,17, 0,14,14,19,18, 0, 0, 0,20,20,
+        0,13,13,16,16, 0,18,17, 0, 0, 0,15,15,16,16, 9,
+        7, 7,14,14,12,10,10,15,15,13,10,10,15,15, 0,21,
+        0,18,19, 0,20,21,19,18,12,10,10,16,15,15,13,13,
+       18,18,14,11,11,15,15, 0, 0, 0,19,18, 0, 0,21,18,
+       18,13,11,11,15,15,16,14,14,17,19,15,11,11,15,15,
+        0,21,21,20,18, 0, 0,21,18,18, 0, 0,21,21,19, 0,
+        0, 0, 0, 0, 0,19,20,18,17, 0, 0, 0,21,21, 0,21,
+        0,20,18, 0, 0,21,19,19, 0, 0, 0, 0, 0, 0,20,21,
+       17,17, 0, 0, 0, 0, 0, 0,21, 0,18,20, 0,10,10,14,
+       14, 0,11,11,15,15, 0,11,11,15,15, 0,14,14,15,15,
+        0,15,15,16,16, 0,11,12,16,16, 0,13,13,16,16, 0,
+       11,11,15,15, 0,14,14,17,17, 0,14,14,15,15, 0,11,
+       11,16,15, 0,14,14,15,15, 0,11,11,15,15, 0,15,15,
+       17,17, 0,14,14,15,15, 0,16,16,18,18, 0, 0, 0,20,
+       19, 0,14,13,16,15, 0,17,17,21, 0, 0,15,15,15,15,
+        0,16,15,17,16, 0,20, 0,20,18, 0,13,14,15,15, 0,
+       19,18, 0,21, 0,15,15,15,15, 0,11,11,14,14, 0,12,
+       12,16,16, 0,12,12,16,16, 0,16,15,20,21, 0,17,16,
+        0, 0, 0,12,12,16,16, 0,14,14,18,18, 0,11,11,16,
+       16, 0,15,15,21,20, 0,16,16, 0, 0, 0,12,12,16,17,
+        0,15,14,19,19, 0,11,12,16,16, 0,15,15,21, 0, 0,
+       16,16, 0, 0, 0,16,17, 0, 0, 0, 0, 0, 0, 0, 0,15,
+       15,21, 0, 0,17,17, 0, 0, 0,17,17, 0, 0, 0,17,16,
+        0, 0, 0, 0, 0, 0, 0, 0,15,15, 0,20, 0,19,20, 0,
+        0, 0,17,17, 0, 0, 0,12,12,15,15, 0,12,12,15,15,
+        0,12,12,16,16, 0,13,13,15,15, 0,15,15,17,17, 0,
+       13,13,17,16, 0,14,14,17,17, 0,11,11,16,16, 0,14,
+       14,17,17, 0,13,13,16,16, 0,12,12,16,16, 0,15,15,
+       16,17, 0,11,11,15,16, 0,14,14,17,17, 0,13,14,16,
+       16, 0,15,15,18,18, 0,21,20,20,19, 0,13,13,16,17,
+        0,16,16, 0, 0, 0,14,14,16,16, 0,15,15,18,18, 0,
+        0, 0,20,19, 0,13,13,16,16, 0,17,17, 0, 0, 0,14,
+       14,16,16, 0,11,11,16,16, 0,13,13,18,17, 0,13,13,
+       17,17, 0,16,16,17,17, 0,16,16,17,18, 0,12,12,17,
+       17, 0,15,15,18,18, 0,12,12,16,16, 0,16,16,19,19,
+        0,15,15,16,17, 0,12,12,17,17, 0,17,17,18,18, 0,
+       12,12,17,17, 0,16,16,19,19, 0,15,16,17,17, 0,16,
+       16,18,17, 0, 0, 0,21,21, 0,13,13,16,16, 0,17,17,
+        0,20, 0,15,15,16,17, 0,16,16,19,18, 0, 0,21,20,
+       21, 0,14,14,17,16, 0,20, 0, 0, 0, 0,15,16,16,17,
+        0, 9, 9,14,14, 0,13,13,16,16, 0,14,14,15,15, 0,
+        0,20,19,19, 0, 0, 0,19,19, 0,12,12,15,15, 0,15,
+       16,19,18, 0,14,14,15,15, 0,21, 0,18,18, 0,20, 0,
+       17,18, 0,13,13,16,16, 0,17,17,17,19, 0,14,14,16,
+       15, 0,21,20,20,19, 0, 0, 0,19,19, 0, 0, 0,19,18,
+        0, 0, 0, 0, 0, 0,20,20,17,18, 0, 0, 0,21,21, 0,
+        0, 0,18,18, 0,21, 0,18,19, 0, 0, 0, 0, 0, 0,20,
+       21,18,18, 0, 0, 0,20,21, 0, 0, 0,19,19, 0,18,18,
+       15,15, 0,20,21,17,17, 0,19,21,17,17, 0, 0, 0,17,
+       18, 0, 0, 0,20,19, 0,19,19,17,17, 0, 0, 0,18,18,
+        0,19,20,16,17, 0, 0,21,20,20, 0,19,20,19,18, 0,
+       19,20,16,16, 0, 0, 0,18,19, 0,19,20,17,17, 0, 0,
+       21, 0,20, 0,21,21,17,19, 0,20, 0,19,20, 0, 0, 0,
+       20, 0, 0,19,18,17,16, 0, 0, 0, 0, 0, 0, 0,20,17,
+       17, 0,20,21,18,20, 0, 0, 0, 0,21, 0,19,20,17,17,
+        0, 0, 0, 0, 0, 0,20,21,17,17, 0,11,11,14,14, 0,
+       13,13,16,17, 0,13,13,16,16, 0,17,17, 0,21, 0,18,
+       17,21, 0, 0,13,13,16,16, 0,15,15,18,18, 0,12,12,
+       16,16, 0,17,16,21, 0, 0,17,17, 0, 0, 0,12,12,17,
+       17, 0,17,17,19,21, 0,13,12,16,16, 0,17,17, 0, 0,
+        0,17,17, 0, 0, 0,18,17, 0,21, 0, 0, 0, 0, 0, 0,
+       15,15,20, 0, 0,20,18, 0, 0, 0,17,18, 0, 0, 0,16,
+       17, 0, 0, 0, 0, 0, 0, 0, 0,15,15, 0, 0, 0,19,19,
+        0, 0, 0,18,18, 0, 0, 0,14,14,18,18, 0,16,16, 0,
+       21, 0,16,16,21,21, 0,17,17, 0,20, 0,17,17,20, 0,
+        0,16,15, 0, 0, 0,20,20, 0, 0, 0,15,15,20,20, 0,
+       17,17,21, 0, 0,17,18,20,20, 0,15,15,20,20, 0,18,
+       18, 0, 0, 0,15,15,19,20, 0,17,18, 0, 0, 0,17,17,
+       20,20, 0,18,17,21, 0, 0, 0, 0, 0,21, 0,15,15,20,
+       20, 0,19,19, 0, 0, 0,17,17,21, 0, 0,17,17, 0, 0,
+        0, 0, 0,21, 0, 0,15,15,19,19, 0,20,21, 0, 0, 0,
+       18,17,21,21, 0,12,12,16,16, 0,14,14,17,17, 0,13,
+       13,17,18, 0,16,16,18,17, 0,16,16,18,18, 0,13,13,
+       18,18, 0,15,16,19,18, 0,13,13,16,16, 0,16,16,20,
+       18, 0,16,16,17,17, 0,12,13,17,17, 0,17,16,18,18,
+        0,12,12,16,16, 0,17,16,20,19, 0,16,16,16,16, 0,
+       16,17,18,20, 0, 0, 0,21,20, 0,14,14,17,16, 0,19,
+       18, 0,20, 0,16,16,17,16, 0,16,16,17,18, 0, 0,21,
+       21,21, 0,14,14,16,16, 0,20,20,21, 0, 0,16,16,16,
+       16, 0,10,10,14,14, 0,14,14,15,16, 0,14,14,15,15,
+        0, 0,21,18,18, 0, 0,21,18,19, 0,13,13,16,16, 0,
+       16,16,18,18, 0,14,14,15,15, 0,21, 0,18,18, 0,21,
+        0,18,18, 0,13,13,16,16, 0,17,17,19,20, 0,14,14,
+       15,15, 0, 0, 0,18,20, 0, 0,21,18,18, 0, 0,21,19,
+       18, 0, 0, 0, 0, 0, 0,20,21,18,17, 0, 0, 0,21,21,
+        0, 0, 0,19,19, 0,21, 0,18,19, 0, 0, 0, 0, 0, 0,
+       21,20,17,17, 0, 0,21,20, 0, 0, 0, 0,19,19, 0,19,
+       20,15,16, 0, 0,20,18,17, 0,20,21,17,18, 0,21, 0,
+       18,18, 0, 0, 0,19,19, 0,20,20,17,18, 0, 0, 0,18,
+       19, 0,20,20,18,17, 0, 0, 0, 0,20, 0, 0,21,17,18,
+        0,20,21,17,17, 0, 0, 0,18,18, 0,19,19,17,17, 0,
+        0, 0,21,21, 0,20,20,17,17, 0, 0, 0,21,19, 0, 0,
+        0,20,19, 0,21,20,17,18, 0, 0, 0, 0, 0, 0, 0,20,
+       18,17, 0,21,20,18,18, 0, 0, 0,20,21, 0,20,20,17,
+       17, 0, 0, 0, 0, 0, 0,20, 0,17,17, 0,11,11,13,14,
+        0,13,13,16,16, 0,13,13,16,16, 0,17,17, 0, 0, 0,
+       17,18, 0, 0, 0,13,13,16,16, 0,15,16,18,18, 0,13,
+       13,16,17, 0,16,17,20, 0, 0,17,18,20, 0, 0,13,13,
+       17,17, 0,16,16,20,21, 0,13,13,16,16, 0,17,17,21,
+        0, 0,17,18, 0, 0, 0,17,18, 0,21, 0, 0, 0, 0, 0,
+        0,15,15,20, 0, 0,19,19, 0, 0, 0,17,17, 0, 0, 0,
+       18,17,21,20, 0, 0, 0, 0, 0, 0,16,16,20,21, 0,21,
+       20, 0,21, 0,19,21, 0, 0, 0,15,15, 0, 0, 0,16,17,
+        0,19, 0,16,16, 0, 0, 0,17,17, 0, 0, 0,19,18, 0,
+        0, 0,16,16,20,20, 0,20,18,21, 0, 0,15,15,21,21,
+        0,18,18, 0, 0, 0,18,19, 0, 0, 0,16,15, 0,21, 0,
+       20,19, 0, 0, 0,16,16, 0, 0, 0,20,18, 0,21, 0,17,
+       18,21, 0, 0,18,19, 0, 0, 0, 0, 0, 0, 0, 0,16,16,
+       20,20, 0,19,20, 0, 0, 0,17,17, 0, 0, 0,18,17,20,
+       21, 0, 0, 0, 0, 0, 0,16,16, 0,20, 0,20,22, 0, 0,
+        0,18,18, 0,22,
+};
+
+static const static_codebook _44p0_p4_0 = {
+       5, 3125,
+       (long *)_vq_lengthlist__44p0_p4_0,
+       1, -528744448, 1616642048, 3, 0,
+       (long *)_vq_quantlist__44p0_p4_0,
+       0
+};
+
+static const long _vq_quantlist__44p0_p4_1[] = {
+       3,
+       2,
+       4,
+       1,
+       5,
+       0,
+       6,
+};
+
+static const long _vq_lengthlist__44p0_p4_1[] = {
+        2, 3, 3, 3, 3, 3, 3,
+};
+
+static const static_codebook _44p0_p4_1 = {
+       1, 7,
+       (long *)_vq_lengthlist__44p0_p4_1,
+       1, -533200896, 1611661312, 3, 0,
+       (long *)_vq_quantlist__44p0_p4_1,
+       0
+};
+
+static const long _vq_quantlist__44p0_p5_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p0_p5_0[] = {
+        1, 6, 6, 6, 8, 8, 7, 8, 8, 7, 9, 8,10,11,11, 9,
+        8, 8, 7, 8, 8,11,11,11, 9, 8, 8, 6, 7, 7,10,10,
+       10,10,10,10,10,10,10,14,13,13,12,11,11,10,10,10,
+       14,14,13,13,11,11, 6, 6, 6, 8, 5, 5, 8, 7, 7, 8,
+        7, 7,11, 9, 9, 9, 7, 7, 8, 7, 7,12,10,10,10, 7,
+        7, 7, 8, 8,12,11,11,12,10,10,11,10,10,14,13,13,
+       13,10,10,11,10,11,16,14,14,13,10,10, 7, 8, 7,12,
+       12,12,12,11,11,12,11,11,16,14,15,13,12,12,11,11,
+       11,17,15,14,14,13,13,10, 9, 9,13,11,11,13,11,11,
+       12,11,11,16,14,13,14,11,11,12,11,11,16,15,14,14,
+       11,11, 7, 8, 8,12,11,11,12,10,10,12,10,10,16,14,
+       13,13,11,11,12,10,10,16,14,14,13,10,10, 8, 8, 8,
+       12,12,12,12,11,11,12,11,11,16,14,15,14,12,12,12,
+       11,11,16,15,15,14,12,12,10,10,10,13,11,11,13,11,
+       11,12,12,12,16,14,14,14,11,11,12,11,11,17,14,15,
+       14,11,11,
+};
+
+static const static_codebook _44p0_p5_0 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p0_p5_0,
+       1, -527106048, 1620377600, 2, 0,
+       (long *)_vq_quantlist__44p0_p5_0,
+       0
+};
+
+static const long _vq_quantlist__44p0_p5_1[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p0_p5_1[] = {
+        2, 7, 7, 7, 8, 8, 7, 7, 7, 7, 8, 8, 8, 8, 9, 8,
+        7, 7, 8, 8, 8, 9, 9, 9, 9, 7, 7, 6, 6, 6, 9, 7,
+        7, 9, 7, 7, 9, 8, 8,10, 8, 8,10, 8, 8,10, 8, 8,
+       10, 8, 8,10, 8, 8, 7, 6, 6, 9, 6, 6, 9, 6, 6, 9,
+        7, 7,10, 8, 8, 9, 6, 6, 9, 7, 7,10, 8, 8, 9, 7,
+        7, 7, 8, 8,11, 9, 9,11, 9, 9,11, 9, 9,12, 9, 9,
+       12, 8, 8,12, 9, 9,12,10, 9,12, 8, 8, 8, 7, 7,10,
+        9, 9,11, 9, 9,11, 9, 9,11,11,10,11, 9, 9,11,10,
+        9,11,10,11,11, 9, 9,10, 8, 8,11, 9, 9,11, 9, 9,
+       11, 9, 9,11,10,10,11, 9, 9,11, 9, 9,11,10,10,11,
+        9, 9, 9, 8, 8,12, 9, 9,12, 9, 9,11, 9, 9,12, 9,
+        9,12, 8, 8,12, 9, 9,12, 9, 9,12, 8, 8, 9, 7, 7,
+       11, 9,10,11,10, 9,11, 9, 9,11,11,11,11, 9, 9,11,
+       10,10,11,11,11,11, 9, 9,10, 9, 9,11, 9, 9,11,10,
+       10,11,10, 9,11,10,10,11, 9, 9,11,10,10,11,10,11,
+       11, 9, 9,
+};
+
+static const static_codebook _44p0_p5_1 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p0_p5_1,
+       1, -530841600, 1616642048, 2, 0,
+       (long *)_vq_quantlist__44p0_p5_1,
+       0
+};
+
+static const long _vq_quantlist__44p0_p6_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p0_p6_0[] = {
+        1, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9,
+};
+
+static const static_codebook _44p0_p6_0 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p0_p6_0,
+       1, -516716544, 1630767104, 2, 0,
+       (long *)_vq_quantlist__44p0_p6_0,
+       0
+};
+
+static const long _vq_quantlist__44p0_p6_1[] = {
+       12,
+       11,
+       13,
+       10,
+       14,
+       9,
+       15,
+       8,
+       16,
+       7,
+       17,
+       6,
+       18,
+       5,
+       19,
+       4,
+       20,
+       3,
+       21,
+       2,
+       22,
+       1,
+       23,
+       0,
+       24,
+};
+
+static const long _vq_lengthlist__44p0_p6_1[] = {
+        1, 3, 2, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,10,10,11,
+       11,12,12,12,14,14,14,15,15,
+};
+
+static const static_codebook _44p0_p6_1 = {
+       1, 25,
+       (long *)_vq_lengthlist__44p0_p6_1,
+       1, -518864896, 1620639744, 5, 0,
+       (long *)_vq_quantlist__44p0_p6_1,
+       0
+};
+
+static const long _vq_quantlist__44p0_p6_2[] = {
+       12,
+       11,
+       13,
+       10,
+       14,
+       9,
+       15,
+       8,
+       16,
+       7,
+       17,
+       6,
+       18,
+       5,
+       19,
+       4,
+       20,
+       3,
+       21,
+       2,
+       22,
+       1,
+       23,
+       0,
+       24,
+};
+
+static const long _vq_lengthlist__44p0_p6_2[] = {
+        3, 4, 4, 5, 4, 5, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+        5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44p0_p6_2 = {
+       1, 25,
+       (long *)_vq_lengthlist__44p0_p6_2,
+       1, -529006592, 1611661312, 5, 0,
+       (long *)_vq_quantlist__44p0_p6_2,
+       0
+};
+
+static const long _huff_lengthlist__44p0_short[] = {
+        3, 3, 7, 8,10,13,16, 3, 2, 5, 7, 9,13,16, 6, 4,
+        4, 6,10,14,15, 7, 5, 5, 7,10,13,14, 9, 8, 9, 9,
+        9,11,13,12,11,12, 9, 7, 8,11,14,12,10, 6, 5, 7,
+       10,
+};
+
+static const static_codebook _huff_book__44p0_short = {
+       2, 49,
+       (long *)_huff_lengthlist__44p0_short,
+       0, 0, 0, 0, 0,
+       NULL,
+       0
+};
+
+static const long _vq_quantlist__44p1_l0_0[] = {
+       6,
+       5,
+       7,
+       4,
+       8,
+       3,
+       9,
+       2,
+       10,
+       1,
+       11,
+       0,
+       12,
+};
+
+static const long _vq_lengthlist__44p1_l0_0[] = {
+        1, 4, 4, 7, 7, 8, 8, 9, 9,10,10,11,11, 4, 6, 5,
+        8, 6, 9, 8,10, 9,10,10,11,10, 5, 5, 6, 6, 8, 8,
+        9, 9,10,10,10,10,11, 7, 8, 8, 9, 8,10, 9,10, 9,
+       11,10,11,10, 7, 8, 8, 8,10, 9,10,10,10,10,11,10,
+       11, 9,10,10,11,11,11,11,12,11,12,11,12,11, 9,10,
+       10,11,11,11,11,11,11,11,12,11,12,11,11,11,12,12,
+       12,12,12,12,12,12,12,11,11,12,11,12,12,12,12,12,
+       12,12,12,11,12,12,12,12,12,13,12,13,12,12,12,12,
+       12,12,12,12,12,13,13,13,13,12,13,12,12,12,12,12,
+       13,13,12,13,12,13,12,13,12,12,12,12,13,13,13,13,
+       13,13,12,12,12,12,12,11,12,
+};
+
+static const static_codebook _44p1_l0_0 = {
+       2, 169,
+       (long *)_vq_lengthlist__44p1_l0_0,
+       1, -526516224, 1616117760, 4, 0,
+       (long *)_vq_quantlist__44p1_l0_0,
+       0
+};
+
+static const long _vq_quantlist__44p1_l0_1[] = {
+       2,
+       1,
+       3,
+       0,
+       4,
+};
+
+static const long _vq_lengthlist__44p1_l0_1[] = {
+        1, 4, 4, 6, 6, 5, 5, 5, 6, 6, 5, 6, 5, 6, 6, 6,
+        6, 7, 7, 7, 6, 7, 6, 7, 7,
+};
+
+static const static_codebook _44p1_l0_1 = {
+       2, 25,
+       (long *)_vq_lengthlist__44p1_l0_1,
+       1, -533725184, 1611661312, 3, 0,
+       (long *)_vq_quantlist__44p1_l0_1,
+       0
+};
+
+static const long _vq_quantlist__44p1_l1_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p1_l1_0[] = {
+        1, 4, 4, 4, 4, 4, 4, 4, 4,
+};
+
+static const static_codebook _44p1_l1_0 = {
+       2, 9,
+       (long *)_vq_lengthlist__44p1_l1_0,
+       1, -516716544, 1630767104, 2, 0,
+       (long *)_vq_quantlist__44p1_l1_0,
+       0
+};
+
+static const long _huff_lengthlist__44p1_lfe[] = {
+        1, 3, 2, 3,
+};
+
+static const static_codebook _huff_book__44p1_lfe = {
+       2, 4,
+       (long *)_huff_lengthlist__44p1_lfe,
+       0, 0, 0, 0, 0,
+       NULL,
+       0
+};
+
+static const long _huff_lengthlist__44p1_long[] = {
+        3, 3, 7, 7, 9,13,16, 3, 2, 4, 6,10,13,17, 7, 4,
+        4, 6, 9,12,14, 7, 6, 6, 5, 7, 9,12,10,10, 9, 6,
+        6, 9,12,14,14,13, 9, 8,10,11,18,18,15,13,11,10,
+       11,
+};
+
+static const static_codebook _huff_book__44p1_long = {
+       2, 49,
+       (long *)_huff_lengthlist__44p1_long,
+       0, 0, 0, 0, 0,
+       NULL,
+       0
+};
+
+static const long _vq_quantlist__44p1_p1_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p1_p1_0[] = {
+        1, 2, 2, 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, 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,
+};
+
+static const static_codebook _44p1_p1_0 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p1_p1_0,
+       1, -535822336, 1611661312, 2, 0,
+       (long *)_vq_quantlist__44p1_p1_0,
+       0
+};
+
+static const long _vq_quantlist__44p1_p2_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p1_p2_0[] = {
+        1, 4, 4, 0, 7, 7, 0, 8, 8, 0, 9, 9, 0,12,12, 0,
+        8, 8, 0, 9, 9, 0,12,12, 0, 8, 8, 0, 6, 6, 0,11,
+       11, 0,11,11, 0,12,12, 0,14,14, 0,11,11, 0,12,12,
+        0,14,14, 0,11,11, 0, 6, 6, 0, 6, 5, 0, 7, 6, 0,
+        7, 7, 0,10,10, 0, 6, 6, 0, 7, 7, 0,10,10, 0, 7,
+        7, 0, 7, 7, 0,10,10, 0,11,11, 0,11,11, 0,14,14,
+        0,10,10, 0,12,12, 0,14,14, 0,12,12, 0, 6, 6, 0,
+       11,11, 0,11,11, 0,12,12, 0,14,14, 0,11,11, 0,12,
+       12, 0,15,15, 0,11,11, 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, 8, 8, 0,11,11, 0,11,11, 0,12,12, 0,15,
+       15, 0,12,12, 0,11,11, 0,15,15, 0,11,11, 0, 6, 6,
+        0,11,11, 0,12,12, 0,12,12, 0,15,15, 0,11,11, 0,
+       12,12, 0,14,14, 0,12,12, 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,
+};
+
+static const static_codebook _44p1_p2_0 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p1_p2_0,
+       1, -533200896, 1614282752, 2, 0,
+       (long *)_vq_quantlist__44p1_p2_0,
+       0
+};
+
+static const long _vq_quantlist__44p1_p2_1[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p1_p2_1[] = {
+        1, 3, 3, 0, 8, 8, 0, 8, 8, 0,10,10, 0, 9, 9, 0,
+       10,10, 0,10,10, 0, 9, 9, 0,10,10, 0, 7, 7, 0, 7,
+        7, 0, 7, 7, 0, 8, 8, 0, 8, 8, 0, 8, 8, 0, 9, 9,
+        0, 8, 8, 0, 8, 8, 0, 7, 7, 0, 8, 8, 0, 8, 8, 0,
+       10,10, 0, 9, 9, 0, 9, 9, 0,10,10, 0, 9, 9, 0,10,
+       10, 0, 8, 8, 0,11,11, 0,11,11, 0,12,12, 0,11,11,
+        0,12,12, 0,12,12, 0,12,12, 0,12,12, 0, 8, 8, 0,
+       11,11, 0,11,11, 0,13,12, 0,12,12, 0,13,12, 0,13,
+       13, 0,12,12, 0,13,13, 0, 7, 7, 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, 8, 8, 0,11,11, 0,11,11, 0,13,12, 0,12,
+       12, 0,12,12, 0,12,12, 0,11,11, 0,12,12, 0, 8, 8,
+        0,12,12, 0,12,12, 0,13,13, 0,12,12, 0,13,13, 0,
+       13,13, 0,12,13, 0,13,13, 0, 7, 7, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0,
+};
+
+static const static_codebook _44p1_p2_1 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p1_p2_1,
+       1, -535822336, 1611661312, 2, 0,
+       (long *)_vq_quantlist__44p1_p2_1,
+       0
+};
+
+static const long _vq_quantlist__44p1_p3_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p1_p3_0[] = {
+        1, 6, 6, 6, 7, 7, 7, 8, 8, 7, 8, 8,10,11,11, 9,
+        8, 8, 7, 9, 9,11,12,12, 9, 8, 8, 6, 7, 7, 9,11,
+       11,10,11,11,10,11,11,13,13,13,11,12,12,10,11,11,
+       13,14,14,12,12,12, 6, 6, 6, 8, 6, 6, 8, 6, 6, 9,
+        7, 7,12,10,10,10, 6, 6, 9, 7, 7,12,10,10,11, 7,
+        6, 7, 8, 8,12,10,10,12,10,10,11,10,10,15,13,13,
+       13,10,10,12,11,11,15,13,13,14,11,11, 8, 7, 7,12,
+       11,11,12,11,11,11,11,11,14,14,14,13,12,12,12,11,
+       11,16,15,15,14,12,12, 0,10,10, 0,11,11, 0,12,12,
+        0,11,11, 0,14,14, 0,11,11, 0,11,11, 0,15,15, 0,
+       11,11, 7, 8, 8,13,10,10,12,10,10,12,11,11,15,13,
+       13,14,11,11,12,10,10,16,14,14,14,10,10, 8, 7, 7,
+       12,11,11,13,11,11,12,11,11,15,14,14,14,12,12,13,
+       12,12,15,14,14,15,12,12, 0,11,11, 0,12,12, 0,12,
+       12, 0,12,12, 0,15,15, 0,12,12, 0,12,12, 0,15,14,
+        0,12,12,
+};
+
+static const static_codebook _44p1_p3_0 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p1_p3_0,
+       1, -531365888, 1616117760, 2, 0,
+       (long *)_vq_quantlist__44p1_p3_0,
+       0
+};
+
+static const long _vq_quantlist__44p1_p3_1[] = {
+       2,
+       1,
+       3,
+       0,
+       4,
+};
+
+static const long _vq_lengthlist__44p1_p3_1[] = {
+        2, 3, 4, 7, 7,10,12,12,12,12,10,11,11,13,13,11,
+       12,12,11,11,12,12,12,12,12,11,13,13,13,13,12,12,
+       12,13,14,12,13,13,13,13,12,13,13,13,13,12,13,13,
+       13,13,11,13,13,13,13,12,12,12,14,14,12,13,13,12,
+       12,12,12,13,13,13,12,13,13,13,13,12,13,13,13,13,
+       12,12,12,14,14,12,13,13,12,12,12,13,13,13,13,12,
+       13,13,12,12,12,13,13,13,13,12,12,12,14,14,12,13,
+       13,12,12,12,13,13,13,13,12,13,13,12,12,10,10,11,
+       10,10,11,11,11,11,11,11, 9, 9,10,10,12,11,11,10,
+       10,12,10,10,10,10,13,12,12,12,12,13,11,11,11,11,
+       13,12,12,12,12,13,11,11,11,11,13,12,12,12,12,13,
+       12,12,12,12,13,11,11,11,11,13,12,12,12,12,13,11,
+       11,11,11,13,12,12,11,11,13,12,12,11,11,13,11,11,
+       11,11,13,12,12,11,11,13,11,11,11,11,13,12,12,11,
+       11,13,12,12,11,11,13,11,11,11,11,13,12,12,11,11,
+       13,11,11,11,11,13,12,12,11,11,11,11,11,10,10,11,
+       11,11, 9, 9,11,12,12,11,11,12,12,12, 9, 9,13,13,
+       13,10,10,13,13,13,11,11,13,13,13,14,14,13,13,13,
+       11,10,13,13,14,12,12,13,13,13,11,11,13,13,13,11,
+       11,13,13,13,14,14,13,13,13,10,10,13,13,13,11,11,
+       13,13,13,10,10,13,14,13,11,11,13,14,14,14,14,13,
+       13,13,10,10,13,14,14,11,11,13,13,13,10,10,13,14,
+       14,11,11,13,13,13,14,14,14,13,13,10,10,13,14,14,
+       11,11,13,13,13,10,10,14,12,12, 9, 9,14,12,12, 9,
+        9,14,11,11, 9, 9,14,12,12, 8, 8,14,11,11, 7, 7,
+       15,13,13,10,10,15,12,12,10,10,15,13,13,10,10,15,
+       12,12,10,10,15,13,13,10,10,15,13,13,10,10,15,12,
+       12,10,10,15,13,13,10,10,15,12,12,10,10,15,13,13,
+       10,10,15,13,13,10,10,15,12,12,10,10,15,13,13, 9,
+        9,15,12,12, 9, 9,14,13,13, 9, 9,15,13,13,10,10,
+       15,12,12,10,10,15,13,13, 9, 9,15,12,12, 9, 9,15,
+       13,13, 9, 9,13,12,12, 9, 9,13,13,13, 8, 8,13,13,
+       13, 9, 9,13,13,13, 7, 7,14,13,13, 8, 8,14,14,14,
+       10,10,15,14,14,11,11,14,14,14, 9, 9,15,14,14,10,
+       10,15,14,14, 9, 9,14,14,14,10,10,15,14,14,11,11,
+       15,14,14, 9, 9,14,14,14,10,10,14,14,14, 9, 9,15,
+       14,15,10,10,15,14,14,11,11,14,14,14, 9, 9,14,14,
+       14, 9, 9,14,14,14, 8, 8,15,14,14,10,10,15,14,14,
+       11,11,14,14,14, 9, 9,15,14,14, 9, 9,14,14,14, 8,
+        8,12,12,12,13,13,16,16,16,11,11,17,16,16,12,12,
+       17,16,16,11,11,17,16,16,11,11,17,17,16,13,13,17,
+       16,16,13,13,18,17,16,12,12,17,16,16,13,13,17,16,
+       17,12,12,18,17,17,13,13,17,16,16,14,14,18,17,17,
+       12,12,18,16,16,13,13,17,17,17,13,12,17,17,17,13,
+       13,17,16,16,13,13,18,17,17,12,12,17,16,16,13,12,
+       17,17,17,12,12,18,17,17,13,13,18,16,16,14,14,18,
+       17,17,12,12,17,17,17,13,13,18,17,18,12,12,13,14,
+       14,10,10,16,14,14,13,13,17,15,15,14,14,17,14,14,
+       12,13,16,14,14,13,13,17,15,15,14,14,16,16,16,15,
+       15,17,15,15,14,14,17,16,16,14,15,17,15,15,14,14,
+       17,15,16,14,14,17,16,16,15,15,17,15,15,13,13,17,
+       15,15,14,14,18,15,15,13,14,17,15,15,14,14,16,16,
+       16,15,15,17,15,15,13,13,17,15,15,14,14,17,15,15,
+       13,13,17,15,15,14,14,16,16,16,15,15,17,15,15,13,
+       13,17,15,15,14,14,18,15,15,13,13,13,11,11,10,10,
+       16,14,14,13,12,16,14,14,13,13,16,15,14,12,12,16,
+       14,14,12,12,16,15,15,14,14,16,14,14,14,14,17,15,
+       15,13,13,16,15,15,14,14,17,15,15,13,14,17,15,15,
+       14,14,17,15,14,14,14,17,15,15,13,13,17,15,15,14,
+       14,17,15,15,13,13,17,15,15,14,14,17,14,14,14,14,
+       17,15,15,13,13,17,15,15,13,13,17,15,15,13,13,17,
+       15,15,14,14,17,15,15,14,14,17,15,15,13,13,17,15,
+       15,13,13,17,15,15,13,13,14,14,15, 8, 8,14,14,14,
+       19,19,14,15,15,18,19,14,14,14,19,18,14,14,14,19,
+       19,15,15,15,19,18,15,16,16,19,19,15,15,15,19,19,
+       15,16,16,20,19,15,15,15,19,19,15,15,15,19,19,16,
+       16,16,20,19,15,15,15,19,18,15,16,16,20,19,15,15,
+       15,18,18,15,15,15,19,20,15,16,16,19,19,15,15,15,
+       20,19,15,15,15,20,19,15,15,15,19,18,15,15,15,19,
+       19,15,16,16,19,20,15,15,15,19,19,15,15,15,19,20,
+       15,15,15,19,19,14,12,12, 9, 9,14,14,14,19,19,14,
+       14,14,19,19,14,14,15,20,19,15,14,14,18,19,15,15,
+       15,19,19,15,15,14,20,19,15,15,15,20,19,15,15,14,
+       20,19,15,15,15,20,19,15,15,15,19,20,15,14,14,19,
+       20,15,15,15,20,20,15,14,14,20,19,15,15,15,19,19,
+       15,15,15,19,19,15,14,14,19,19,15,15,15,19,20,15,
+       15,15,20,20,15,15,15,19,19,15,15,15,20,19,16,14,
+       14,19,19,15,15,15,20,19,15,14,15,20,19,14,15,15,
+       20,19,12,12,12,13,13,16,16,16,11,11,16,16,16,12,
+       12,17,16,16,11,11,17,15,16,11,11,17,17,17,13,13,
+       18,16,17,13,13,18,17,17,13,12,17,16,17,13,13,17,
+       17,17,13,13,16,16,16,12,12,17,16,16,13,13,17,16,
+       16,12,12,17,16,16,12,13,17,17,17,12,12,17,17,17,
+       13,13,18,16,16,13,13,18,17,17,12,12,18,17,17,12,
+       12,17,17,17,12,12,17,17,17,12,12,17,16,16,13,13,
+       17,17,17,12,12,17,16,16,12,12,17,17,17,12,12,13,
+       14,14, 9, 9,16,14,14,13,13,16,15,15,14,14,17,14,
+       14,13,13,16,14,14,13,13,17,15,15,15,15,16,16,16,
+       15,15,17,15,15,14,14,17,15,15,15,15,17,15,15,14,
+       14,17,15,15,14,14,16,16,16,15,15,17,15,15,14,14,
+       17,15,15,14,14,17,15,15,14,14,17,15,15,14,14,16,
+       16,16,15,15,18,15,15,14,13,17,15,15,14,14,17,15,
+       15,13,13,17,15,15,14,14,16,16,16,15,15,17,15,15,
+       14,13,17,15,15,14,14,17,15,15,13,13,13,11,11,11,
+       11,16,14,14,12,12,16,14,14,13,13,16,15,14,12,12,
+       17,14,14,12,12,17,15,15,13,13,17,14,14,14,14,17,
+       15,15,13,13,17,14,15,14,13,17,15,15,13,13,16,15,
+       15,13,13,16,14,14,14,14,17,15,15,13,13,16,14,14,
+       13,13,16,15,15,13,13,17,15,15,13,13,17,14,14,14,
+       14,17,15,15,12,12,17,15,15,13,13,17,15,15,12,12,
+       16,15,15,13,13,17,14,14,13,14,17,15,15,12,12,17,
+       14,14,13,13,17,15,15,12,12,14,14,14, 8, 8,14,14,
+       14,18,18,14,15,15,19,19,14,14,14,19,19,14,15,14,
+       18,19,15,15,15,18,19,15,16,16,20,20,15,15,15,19,
+       20,15,16,16,19,20,15,15,15,19,20,15,15,16,19,19,
+       15,16,16,20,20,15,15,15,20,19,15,16,16,20,19,15,
+       15,15,19,20,15,15,15,19,19,15,16,16,20,19,15,15,
+       15,19,19,15,16,15,20,19,15,15,15,19,19,15,15,15,
+       19,20,15,16,16,20,20,15,15,15,19,19,15,15,15,20,
+       20,15,15,15,19,19,14,12,12, 9, 9,14,14,14,18,18,
+       14,14,14,19,20,14,14,14,18,18,14,14,14,18,19,15,
+       15,15,19,20,15,14,14,19,19,15,15,15,19,19,15,14,
+       15,19,19,15,15,15,18,20,15,15,15,19,19,15,14,14,
+       19,19,15,15,15,20,19,15,15,14,20,20,15,15,15,19,
+       19,15,15,15,19,19,15,14,14,19,19,15,15,15,19,19,
+       15,14,14,19,20,14,15,15,19,19,15,15,15,19,19,15,
+       14,14,20,19,15,15,15,19,19,15,14,14,20,19,15,15,
+       15,19,19,13,12,12,13,13,17,17,16,11,11,16,16,16,
+       12,12,17,17,16,11,11,17,16,16,11,11,17,17,17,13,
+       13,17,16,16,13,13,18,17,17,12,12,17,16,16,13,13,
+       18,17,17,12,12,18,17,17,13,13,18,16,17,13,13,17,
+       17,17,12,12,18,17,17,13,13,18,17,17,12,12,17,16,
+       17,12,12,17,16,16,13,13,17,16,16,11,11,17,16,16,
+       12,12,17,17,17,11,11,17,17,17,12,12,18,16,16,13,
+       13,18,17,17,12,11,17,16,16,12,12,18,17,17,11,11,
+       13,14,14, 9, 9,16,14,14,13,13,16,15,15,14,14,17,
+       14,14,12,12,16,14,14,13,13,17,15,15,14,14,17,16,
+       16,15,16,18,15,15,14,14,17,15,15,14,14,17,15,15,
+       14,14,18,15,15,14,14,16,16,16,15,16,18,15,15,14,
+       14,17,16,15,14,14,18,15,15,14,14,17,15,15,14,14,
+       17,16,16,15,15,18,14,15,13,13,17,15,15,14,14,18,
+       15,15,13,13,17,15,15,14,14,17,16,15,15,15,17,15,
+       15,13,13,17,15,15,14,14,18,15,15,13,13,13,11,11,
+       10,10,16,14,14,12,12,16,14,14,12,12,17,14,15,11,
+       11,17,14,14,11,11,17,15,15,13,13,17,14,14,14,13,
+       17,15,15,13,13,16,15,15,13,13,17,15,15,13,13,17,
+       15,15,13,13,17,14,14,14,14,17,15,15,13,13,17,14,
+       15,13,13,16,15,15,13,13,17,15,15,13,13,17,14,14,
+       13,13,17,15,15,12,12,16,14,14,12,12,17,15,15,12,
+       12,17,15,15,13,13,17,14,14,13,13,17,15,15,12,12,
+       17,14,14,12,12,17,15,15,12,12,13,15,14, 8, 8,14,
+       14,14,19,19,14,15,15,18,19,14,14,14,18,19,14,15,
+       14,19,19,15,16,15,19,19,15,16,16,19,20,15,15,15,
+       19,19,15,16,16,19,19,15,16,16,19,19,15,15,15,19,
+       19,15,16,16,20,20,15,15,15,19,19,15,15,15,19,19,
+       15,15,15,19,19,15,15,15,19,19,15,16,16,20,19,15,
+       15,15,19,19,15,15,15,19,19,15,15,15,19,19,15,16,
+       15,19,19,15,16,16,21,19,15,15,15,20,20,15,15,15,
+       20,21,15,15,15,19,20,14,12,12, 8, 8,14,14,14,19,
+       19,14,13,13,19,19,14,14,14,19,19,14,13,14,19,19,
+       15,15,15,20,20,15,14,14,20,19,15,15,15,19,20,15,
+       14,14,19,20,15,15,15,20,19,15,15,15,19,20,15,14,
+       14,20,20,15,15,15,20,19,15,14,14,19,19,15,15,15,
+       19,19,15,15,15,20,19,15,14,14,21,19,15,15,15,20,
+       21,15,14,14,21,19,15,15,15,19,19,15,15,15,20,20,
+       15,14,14,19,21,15,15,15,19,19,15,14,14,19,20,15,
+       15,15,19,19,13,12,12,13,13,17,16,16,11,11,17,16,
+       15,12,12,18,16,16,11,11,17,16,16,11,11,18,17,17,
+       13,13,18,16,16,13,13,17,17,17,12,13,18,17,16,13,
+       13,18,17,17,13,13,17,17,17,13,13,17,16,16,13,13,
+       18,16,17,12,12,17,16,16,13,12,17,17,17,12,12,18,
+       17,17,13,12,18,16,16,13,13,18,17,17,12,12,17,16,
+       16,12,12,17,17,17,11,11,17,16,16,12,12,17,16,16,
+       13,13,17,16,16,11,11,17,16,16,12,12,17,17,17,11,
+       11,13,14,14, 9, 9,16,14,14,13,13,16,15,15,14,14,
+       17,14,14,12,12,16,14,14,13,13,17,15,15,14,14,17,
+       15,16,15,15,17,15,15,14,14,17,15,16,14,15,18,15,
+       15,14,14,17,15,15,14,14,16,16,16,15,15,18,15,15,
+       13,14,17,15,15,14,14,18,15,15,14,14,17,15,15,14,
+       14,17,16,16,15,15,17,15,15,13,13,17,15,15,14,14,
+       18,15,15,13,13,17,15,15,14,14,17,16,16,15,15,17,
+       15,15,13,13,17,15,15,14,14,18,15,15,13,13,13,11,
+       11,10,10,16,14,14,12,12,16,14,14,13,13,17,14,14,
+       11,11,17,14,14,12,12,17,15,15,14,14,17,14,14,14,
+       14,17,15,15,13,13,17,15,14,13,13,16,15,15,13,13,
+       16,15,15,13,13,17,14,14,14,14,17,15,15,13,13,17,
+       14,14,13,13,16,15,15,13,13,16,15,15,13,13,17,14,
+       14,13,13,17,15,15,12,12,17,14,14,12,12,16,15,15,
+       12,12,17,15,15,13,13,17,14,14,13,13,17,15,15,12,
+       12,17,14,14,12,12,16,15,15,12,12,14,14,14, 8, 8,
+       14,14,14,18,18,14,15,15,19,18,14,14,14,18,18,14,
+       14,14,18,19,15,16,15,19,19,15,17,16,20,20,15,15,
+       15,19,19,15,16,16,19,19,15,15,15,19,19,15,16,15,
+       18,19,15,16,16,20,20,15,15,15,19,19,15,16,16,19,
+       20,15,15,15,19,19,15,15,16,19,19,15,16,16,20,20,
+       15,15,15,19,19,15,15,15,19,20,15,15,15,19,19,15,
+       15,15,19,19,15,16,16,20,20,15,15,15,19,20,15,16,
+       16,20,20,15,15,15,19,19,13,12,12, 8, 8,14,14,14,
+       19,20,14,14,14,19,19,14,14,14,18,19,14,14,14,19,
+       20,15,15,15,19,20,15,14,14,21,20,15,15,15,20,20,
+       15,15,14,19,19,15,15,15,19,19,15,15,15,19,19,15,
+       14,14,19,20,15,15,15,19,20,15,14,14,19,19,15,15,
+       15,19,19,15,15,15,19,19,16,14,14,19,19,15,15,15,
+       20,20,15,14,14,21,19,15,15,15,19,19,15,15,15,19,
+       20,16,14,14,19,20,15,15,15,19,19,15,14,14,19,19,
+       15,15,15,20,19,
+};
+
+static const static_codebook _44p1_p3_1 = {
+       5, 3125,
+       (long *)_vq_lengthlist__44p1_p3_1,
+       1, -533725184, 1611661312, 3, 0,
+       (long *)_vq_quantlist__44p1_p3_1,
+       0
+};
+
+static const long _vq_quantlist__44p1_p4_0[] = {
+       2,
+       1,
+       3,
+       0,
+       4,
+};
+
+static const long _vq_lengthlist__44p1_p4_0[] = {
+        2, 6, 6,14,14, 6, 7, 7,14,14, 7, 7, 7,14,14, 0,
+       13,13,16,16, 0,13,13,15,14, 7, 8, 8,15,15, 9,10,
+       10,16,16, 9, 8, 8,15,15, 0,13,13,17,16, 0,13,13,
+       15,16, 8, 8, 8,15,15,12,11,11,16,16, 9, 8, 8,14,
+       14, 0,13,13,17,18, 0,13,13,15,15, 0,14,14,16,16,
+        0, 0, 0,19,18, 0,12,12,16,15, 0,15,16, 0,20, 0,
+       14,14,16,16, 0,14,14,17,17, 0, 0, 0,19,18, 0,12,
+       12,15,15, 0,17,17, 0,20, 0,14,14,16,16, 5, 6, 7,
+       12,12, 9, 9, 9,14,14,10,10,10,14,14, 0,21,21,18,
+       17, 0,20,20,18,17, 9,10,10,14,14,12,12,12,16,16,
+       12,10,10,14,14, 0,20,19,18,17, 0, 0,20,17,18,11,
+       10,10,14,14,14,13,13,18,18,13,11,11,14,14, 0,20,
+       20,17,18, 0,21,21,17,17, 0,21, 0,18,18, 0, 0, 0,
+        0, 0, 0,20,19,16,17, 0, 0, 0,19,19, 0, 0, 0,18,
+       18, 0,21,21,18,18, 0, 0, 0, 0, 0, 0,20,20,16,17,
+        0, 0, 0,21,21, 0, 0, 0,18,19, 6, 6, 6,13,12, 8,
+        6, 6,11,11, 8, 6, 6,13,13, 0, 9, 9,11,11, 0,11,
+       10,14,14, 9, 7, 7,13,13,11, 9, 9,13,13,10, 6, 6,
+       13,13, 0,10,10,14,15, 0,10,10,13,13, 9, 7, 7,13,
+       13,13,10, 9,13,13,10, 6, 6,13,13, 0,10,10,15,14,
+        0,10,10,13,13, 0,11,11,15,15, 0,19,20,17,17, 0,
+        9, 9,13,13, 0,13,13,20,20, 0,11,11,13,13, 0,11,
+       11,15,15, 0,19,19,17,17, 0,10,10,13,13, 0,15,15,
+       20,20, 0,12,12,13,13, 0,10,10,12,12, 0,11,11,15,
+       15, 0,11,11,15,15, 0,15,15,20, 0, 0,16,16, 0,21,
+        0,11,11,15,15, 0,14,14,18,17, 0,11,11,15,15, 0,
+       15,16,19,20, 0,16,16,21,21, 0,12,12,15,15, 0,15,
+       14,18,18, 0,11,11,16,16, 0,15,15,21,21, 0,16,15,
+        0, 0, 0,16,16,21, 0, 0, 0, 0, 0, 0, 0,14,14,20,
+       20, 0,18,18, 0, 0, 0,16,17,21, 0, 0,16,16,21,21,
+        0, 0, 0, 0, 0, 0,15,15,21,21, 0,20,19, 0,21, 0,
+       17,17, 0, 0, 0,10,10,12,11, 0,10,10,10,11, 0,11,
+       11,12,12, 0,11,11, 9, 9, 0,13,13,11,12, 0,11,11,
+       12,12, 0,13,13,12,12, 0,10,10,12,12, 0,12,12,13,
+       13, 0,12,12,12,12, 0,11,11,12,12, 0,13,13,12,12,
+        0,10,10,12,12, 0,13,13,14,14, 0,12,12,12,12, 0,
+       14,14,14,13, 0,19,20,15,15, 0,12,11,12,12, 0,15,
+       15,21,20, 0,13,13,11,11, 0,13,13,13,13, 0,19, 0,
+       15,15, 0,12,12,12,12, 0,17,16,19, 0, 0,13,13,12,
+       12, 7, 7, 7,16,16,11, 9, 9,15,15,12, 9, 9,16,16,
+        0,13,13,15,14, 0,14,14,17,16,10, 9, 9,16,16,14,
+       11,11,17,16,12, 9, 8,15,15, 0,13,13,18,18, 0,13,
+       13,15,15,12,10,10,18,17,15,12,12,17,17,14, 9, 9,
+       16,16, 0,13,13,18,19, 0,14,13,17,16, 0,14,14,18,
+       18, 0, 0, 0,20,21, 0,12,12,16,16, 0,16,16,20,21,
+        0,14,14,17,16, 0,14,14,18,19, 0, 0, 0,19,21, 0,
+       13,13,17,17, 0,17,17, 0,21, 0,15,15,16,16, 8, 7,
+        7,14,14,11,10,10,15,15,12,10,10,15,15, 0,20,20,
+       18,18, 0, 0, 0,17,17,11,10,10,16,16,14,12,12,18,
+       17,14,11,11,15,15, 0,20,21,18,18, 0, 0,19,18,17,
+       12,10,10,16,16,17,14,14,19,19,14,11,11,15,15, 0,
+       21,21,19,19, 0,21,20,19,18, 0,21, 0,18,19, 0, 0,
+        0, 0, 0, 0,20,20,18,17, 0,21, 0, 0, 0, 0, 0, 0,
+       19,18, 0, 0, 0,18,19, 0, 0, 0, 0, 0, 0, 0,21,17,
+       18, 0, 0, 0, 0,21, 0, 0,21,18,19,11, 9, 9,14,14,
+       13,10,10,13,13,13,11,11,15,15, 0,13,13,12,12, 0,
+       15,15,16,16,13,10,10,15,15,16,12,12,15,15,15,10,
+       10,15,15, 0,14,13,16,15, 0,14,13,15,15,13,10,10,
+       15,15,18,14,14,15,15,15,10,10,14,15, 0,14,14,16,
+       16, 0,14,14,16,15, 0,15,15,17,16, 0,21, 0,18,18,
+        0,12,13,15,15, 0,16,16, 0, 0, 0,14,14,15,15, 0,
+       15,15,16,16, 0,21,20,18,18, 0,13,13,15,15, 0,19,
+       18, 0, 0, 0,15,15,15,15, 0,11,11,13,13, 0,12,12,
+       16,16, 0,12,12,16,16, 0,15,16,20, 0, 0,16,17, 0,
+        0, 0,12,12,16,16, 0,14,14,18,18, 0,11,11,16,17,
+        0,15,15,20, 0, 0,16,16, 0, 0, 0,12,12,16,16, 0,
+       15,15,19,19, 0,11,11,17,17, 0,16,16,21, 0, 0,16,
+       16, 0, 0, 0,17,17,20,20, 0, 0, 0, 0, 0, 0,15,15,
+       20, 0, 0,17,18, 0, 0, 0,17,17, 0, 0, 0,16,16, 0,
+       21, 0, 0, 0, 0, 0, 0,15,15,21, 0, 0,19,18, 0, 0,
+        0,18,17, 0, 0, 0,11,11,14,14, 0,11,11,15,15, 0,
+       12,12,16,16, 0,13,13,14,14, 0,14,14,17,17, 0,12,
+       12,16,16, 0,14,14,16,16, 0,11,11,16,15, 0,13,13,
+       16,17, 0,13,13,16,16, 0,12,12,15,16, 0,15,14,16,
+       16, 0,11,11,15,15, 0,14,14,17,17, 0,13,13,16,16,
+        0,15,14,18,18, 0,21, 0,19,19, 0,13,13,15,15, 0,
+       16,16,20,20, 0,14,14,16,15, 0,14,14,17,17, 0,21,
+        0,20,18, 0,13,13,15,15, 0,17,17, 0, 0, 0,14,14,
+       16,15, 8, 8, 8,16,16,12, 9, 9,16,16,13, 9, 9,16,
+       16, 0,14,14,18,17, 0,14,14,16,17,12,10,10,18,17,
+       14,11,11,18,18,14, 9, 9,16,16, 0,13,13,18,18, 0,
+       13,13,17,16,12, 9, 9,16,17,17,13,13,16,16,14, 9,
+        9,15,15, 0,14,14,20,20, 0,13,13,15,15, 0,15,14,
+       18,18, 0, 0, 0,20,21, 0,12,13,16,17, 0,16,16,20,
+       21, 0,14,14,16,17, 0,14,14,18,17, 0, 0, 0,20,21,
+        0,13,13,16,16, 0,19,17, 0,21, 0,14,15,16,16, 8,
+        7, 7,14,13,12,10,10,15,15,13,10,10,15,15, 0,21,
+       21,18,19, 0,20,21,18,18,12,10,10,16,15,15,12,12,
+       17,17,14,11,11,15,15, 0,21,21,19,18, 0, 0,21,17,
+       18,13,11,11,15,15,16,13,13,18,19,15,11,11,15,14,
+        0,21, 0,19,19, 0, 0,21,18,18, 0, 0,21,19,19, 0,
+        0, 0, 0, 0, 0,20,19,17,17, 0, 0, 0,21, 0, 0,21,
+        0,18,19, 0, 0,20,20,19, 0, 0, 0, 0, 0, 0,21,20,
+       18,17, 0, 0, 0, 0,20, 0, 0, 0,18,19, 0,10,10,15,
+       14, 0,11,11,14,14, 0,11,11,15,16, 0,14,14,15,15,
+        0,15,15,16,16, 0,11,11,16,16, 0,14,13,16,16, 0,
+       11,11,15,15, 0,14,14,16,16, 0,14,14,15,15, 0,11,
+       11,15,15, 0,13,13,15,15, 0,11,11,15,15, 0,15,15,
+       18,17, 0,14,14,15,15, 0,15,16,18,18, 0, 0, 0,20,
+       20, 0,14,13,16,15, 0,17,17,21, 0, 0,15,15,15,15,
+        0,16,15,17,17, 0, 0, 0,19,19, 0,13,13,15,15, 0,
+       20,19, 0, 0, 0,15,15,15,15, 0,11,11,13,13, 0,12,
+       12,16,16, 0,12,12,16,16, 0,15,15,21,21, 0,17,16,
+        0, 0, 0,12,12,16,16, 0,14,14,17,17, 0,11,11,16,
+       16, 0,15,15, 0, 0, 0,16,16,21, 0, 0,12,12,17,16,
+        0,14,15,20,20, 0,11,11,16,16, 0,15,15, 0,20, 0,
+       16,16, 0,21, 0,16,17,21, 0, 0, 0, 0, 0, 0, 0,15,
+       15, 0,21, 0,18,18, 0, 0, 0,17,16, 0, 0, 0,17,17,
+       21, 0, 0, 0, 0, 0, 0, 0,15,15, 0,20, 0,19,20,21,
+        0, 0,17,18, 0, 0, 0,12,12,15,15, 0,12,12,15,15,
+        0,12,12,16,16, 0,13,13,15,15, 0,15,15,17,17, 0,
+       13,12,17,16, 0,14,14,17,16, 0,11,11,16,16, 0,14,
+       14,17,17, 0,14,14,17,17, 0,12,12,16,16, 0,15,15,
+       17,17, 0,11,11,16,16, 0,14,14,17,17, 0,14,14,16,
+       16, 0,15,15,18,17, 0, 0, 0,19, 0, 0,13,13,16,16,
+        0,16,16, 0,21, 0,14,14,16,16, 0,15,15,18,17, 0,
+        0, 0,19,19, 0,13,13,16,16, 0,18,17, 0,21, 0,14,
+       15,16,16, 0,11,11,16,16, 0,13,13,17,17, 0,13,13,
+       17,17, 0,16,16,16,17, 0,16,16,18,18, 0,12,12,17,
+       17, 0,16,15,18,17, 0,12,12,16,16, 0,16,15,19,19,
+        0,16,15,17,17, 0,12,12,17,18, 0,16,16,18,18, 0,
+       12,12,16,16, 0,16,16,19,19, 0,15,16,17,17, 0,15,
+       16,18,18, 0, 0, 0,20,20, 0,13,13,16,16, 0,18,18,
+       21,20, 0,15,15,16,16, 0,16,16,19,18, 0, 0, 0,19,
+       20, 0,14,14,17,17, 0,19,19, 0,21, 0,15,16,16,16,
+        0, 9, 9,14,14, 0,13,13,15,15, 0,14,14,15,15, 0,
+        0,21,19,19, 0, 0,21,18,18, 0,12,12,15,15, 0,15,
+       15,18,18, 0,14,13,15,15, 0,21,21,18,19, 0,21,20,
+       18,18, 0,13,13,16,16, 0,17,17,18,19, 0,14,14,15,
+       15, 0, 0,21,19,19, 0,21,20,18,19, 0,20,20,19,19,
+        0, 0, 0, 0, 0, 0,19,20,17,17, 0, 0, 0,21,21, 0,
+       21, 0,18,20, 0,21, 0,18,21, 0, 0, 0, 0, 0, 0,21,
+       21,19,18, 0, 0, 0, 0, 0, 0, 0, 0,19,19, 0,18,18,
+       15,15, 0,18,20,17,16, 0,20, 0,17,17, 0,21, 0,17,
+       17, 0,21,20,19,20, 0,19,19,16,16, 0,21,21,17,18,
+        0,19,19,17,17, 0,20,21,21,21, 0,20,20,18,18, 0,
+       19,19,16,16, 0, 0,21,18,19, 0,18,19,16,17, 0,21,
+       21,19,20, 0,21,19,18,18, 0,21,20,19,21, 0, 0, 0,
+       20,21, 0,19,19,17,16, 0, 0, 0, 0, 0, 0,21,20,17,
+       17, 0,20,21,19,18, 0, 0, 0, 0,21, 0,19,18,16,17,
+        0, 0, 0, 0, 0, 0,20,20,17,17, 0,11,11,14,14, 0,
+       13,13,16,16, 0,13,13,16,16, 0,17,17,21, 0, 0,17,
+       18, 0, 0, 0,12,12,16,16, 0,15,15,17,18, 0,12,12,
+       16,16, 0,16,16, 0,20, 0,17,17, 0,21, 0,12,12,17,
+       17, 0,16,16,19,20, 0,12,12,17,17, 0,17,17, 0,20,
+        0,17,17, 0, 0, 0,17,17,21, 0, 0, 0, 0, 0, 0, 0,
+       15,15, 0,20, 0,19,19, 0, 0, 0,18,18, 0, 0, 0,17,
+       17, 0, 0, 0, 0, 0, 0, 0, 0,15,15, 0, 0, 0,20,19,
+        0, 0, 0,19,18, 0, 0, 0,14,14,21,19, 0,16,16,20,
+       21, 0,16,16,20,20, 0,17,17,20, 0, 0,17,17,20,20,
+        0,15,15,20,20, 0,19,18,20, 0, 0,15,15,20,20, 0,
+       17,18,21,20, 0,17,17,20,21, 0,15,15,19,19, 0,19,
+       18,21,21, 0,15,15,19,20, 0,17,18, 0, 0, 0,17,17,
+       20,20, 0,17,18,20,21, 0, 0, 0, 0, 0, 0,15,15,20,
+       20, 0,19,19, 0, 0, 0,17,17,19,21, 0,17,17, 0,21,
+        0, 0, 0, 0,21, 0,15,15,20,19, 0, 0,20, 0, 0, 0,
+       17,17,21,20, 0,12,12,16,16, 0,14,14,17,17, 0,13,
+       13,17,17, 0,16,16,17,18, 0,17,16,18,18, 0,13,13,
+       18,17, 0,15,16,19,18, 0,13,13,16,16, 0,16,16,19,
+       19, 0,16,16,17,17, 0,13,12,17,17, 0,16,16,18,17,
+        0,12,12,16,16, 0,17,17,19,18, 0,16,15,16,16, 0,
+       16,17,18,19, 0, 0, 0,20,20, 0,14,14,17,16, 0,18,
+       18,21, 0, 0,16,16,16,16, 0,16,16,18,17, 0, 0,21,
+       21,21, 0,14,14,16,16, 0,21,20,21, 0, 0,16,16,16,
+       16, 0,10,10,14,14, 0,14,14,15,16, 0,14,14,15,15,
+        0, 0,21,18,18, 0, 0,21,18,19, 0,13,13,16,16, 0,
+       16,16,18,17, 0,14,14,15,15, 0,20, 0,18,18, 0,21,
+        0,18,17, 0,13,13,16,15, 0,17,17,19,19, 0,14,14,
+       15,15, 0,20,20,18,19, 0, 0, 0,18,17, 0, 0,21,18,
+       18, 0, 0, 0, 0, 0, 0,20,21,18,17, 0, 0, 0, 0, 0,
+        0, 0, 0,19,19, 0, 0,21,18,18, 0, 0, 0, 0, 0, 0,
+       21, 0,18,17, 0, 0, 0, 0,21, 0, 0, 0,19,20, 0,19,
+       19,16,16, 0, 0,21,18,17, 0,21, 0,18,18, 0,20, 0,
+       19,18, 0,21,20,19,19, 0,21,19,17,18, 0, 0,21,19,
+       19, 0,21,19,18,18, 0,21, 0,20,18, 0, 0,21,18,18,
+        0,20,21,17,17, 0,21, 0,18,18, 0,21,19,17,17, 0,
+       21, 0, 0,20, 0, 0,20,17,18, 0, 0, 0,19,20, 0, 0,
+        0,20,19, 0,19,21,17,18, 0,21, 0, 0, 0, 0,21,21,
+       18,17, 0, 0,21,18,18, 0, 0, 0, 0,21, 0,20,19,16,
+       17, 0, 0, 0, 0, 0, 0,21,20,17,17, 0,11,11,13,13,
+        0,13,13,16,16, 0,13,13,16,16, 0,17,17, 0,21, 0,
+       18,19,21, 0, 0,12,12,16,16, 0,15,15,19,18, 0,13,
+       13,16,16, 0,16,17,21,19, 0,17,17,21,21, 0,13,13,
+       16,16, 0,16,16,20,18, 0,13,13,16,16, 0,17,17, 0,
+        0, 0,18,18, 0, 0, 0,18,17, 0,20, 0, 0, 0, 0, 0,
+        0,15,15,21,21, 0,19,18, 0, 0, 0,17,17,21,21, 0,
+       17,17, 0, 0, 0, 0, 0, 0, 0, 0,15,15,20,21, 0,20,
+       20, 0, 0, 0,19,19, 0, 0, 0,14,15,21,19, 0,16,16,
+        0,21, 0,17,16,21,21, 0,17,18,21,20, 0,18,18, 0,
+       21, 0,16,16, 0,20, 0,19,19, 0, 0, 0,16,15, 0,20,
+        0,18,18, 0, 0, 0,17,17, 0,21, 0,16,16,20,20, 0,
+       20,19, 0, 0, 0,15,16,21,22, 0,18,18, 0, 0, 0,18,
+       17, 0, 0, 0,18,18, 0, 0, 0, 0, 0, 0, 0, 0,16,16,
+       21,20, 0,19,20, 0, 0, 0,18,17,21, 0, 0,17,18, 0,
+        0, 0, 0, 0, 0, 0, 0,16,16, 0,20, 0, 0,20, 0, 0,
+        0,18,18,22, 0,
+};
+
+static const static_codebook _44p1_p4_0 = {
+       5, 3125,
+       (long *)_vq_lengthlist__44p1_p4_0,
+       1, -528744448, 1616642048, 3, 0,
+       (long *)_vq_quantlist__44p1_p4_0,
+       0
+};
+
+static const long _vq_quantlist__44p1_p4_1[] = {
+       3,
+       2,
+       4,
+       1,
+       5,
+       0,
+       6,
+};
+
+static const long _vq_lengthlist__44p1_p4_1[] = {
+        2, 3, 3, 3, 3, 3, 3,
+};
+
+static const static_codebook _44p1_p4_1 = {
+       1, 7,
+       (long *)_vq_lengthlist__44p1_p4_1,
+       1, -533200896, 1611661312, 3, 0,
+       (long *)_vq_quantlist__44p1_p4_1,
+       0
+};
+
+static const long _vq_quantlist__44p1_p5_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p1_p5_0[] = {
+        1, 6, 6, 7, 8, 8, 7, 8, 8, 7, 9, 8,10,11,11, 9,
+        8, 8, 7, 8, 8,11,11,11, 9, 8, 8, 6, 7, 7,10,10,
+       10,10,10,10,10,10,10,14,13,13,12,11,11,10,10,10,
+       14,14,13,12,11,11, 6, 6, 6, 8, 5, 5, 8, 7, 7, 9,
+        7, 7,11,10,10, 9, 7, 7, 9, 7, 7,12,10,10,10, 7,
+        7, 7, 8, 8,12,11,10,12,10,10,11,10,10,15,13,13,
+       13,10,10,11,10,10,17,14,13,13,10,10, 7, 7, 7,12,
+       11,12,12,11,11,12,11,11,16,14,14,13,12,12,12,11,
+       11,17,15,14,14,12,12,10, 9, 9,13,11,11,13,11,11,
+       13,11,11,17,14,13,14,11,11,12,11,11,16,15,14,14,
+       11,11, 7, 8, 8,12,11,11,12,10,10,12,10,10,15,13,
+       13,14,11,10,12,10,10,16,14,14,14,10,10, 8, 7, 7,
+       12,11,11,12,11,11,12,11,11,17,14,14,14,12,12,12,
+       11,11,16,15,15,14,12,12,10,10,10,13,11,11,13,11,
+       11,13,11,12,16,14,14,14,11,11,13,12,11,16,15,15,
+       14,11,11,
+};
+
+static const static_codebook _44p1_p5_0 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p1_p5_0,
+       1, -527106048, 1620377600, 2, 0,
+       (long *)_vq_quantlist__44p1_p5_0,
+       0
+};
+
+static const long _vq_quantlist__44p1_p5_1[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p1_p5_1[] = {
+        2, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 9, 8, 8, 8,
+        7, 7, 8, 8, 8, 9, 8, 8, 9, 7, 7, 6, 6, 6, 9, 8,
+        7, 9, 7, 7, 9, 8, 8,10, 8, 8,10, 8, 8,10, 8, 8,
+       10, 8, 8,10, 8, 8, 7, 6, 6, 9, 6, 6, 9, 7, 7, 9,
+        7, 7,10, 8, 8, 9, 6, 6, 9, 7, 7,10, 8, 8, 9, 7,
+        7, 7, 8, 8,11, 9, 9,11, 9, 9,11, 8, 9,12, 9, 9,
+       12, 8, 8,11, 9, 9,12, 9, 9,12, 8, 8, 8, 7, 7,10,
+        9, 9,10,10, 9,10, 9, 9,11,10,10,11, 9, 9,11, 9,
+        9,11,10,11,11, 9, 9,10, 8, 8,11, 9, 9,10, 9, 9,
+       11, 9, 9,11,10,10,11, 9, 9,11, 9, 9,11,10,10,11,
+        9, 9, 9, 8, 8,11, 9, 9,12, 9, 9,11, 9, 9,12, 9,
+        9,12, 8, 8,12, 9, 9,12, 9, 9,12, 8, 8, 9, 7, 7,
+       11, 9, 9,11,10,10,11, 9, 9,11,11,11,11, 9, 9,11,
+       10,10,11,11,11,11, 9, 9,10, 9, 9,11, 9, 9,11,10,
+       10,11, 9, 9,11,10,10,11, 9, 9,11, 9,10,11,10,10,
+       11, 9, 9,
+};
+
+static const static_codebook _44p1_p5_1 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p1_p5_1,
+       1, -530841600, 1616642048, 2, 0,
+       (long *)_vq_quantlist__44p1_p5_1,
+       0
+};
+
+static const long _vq_quantlist__44p1_p6_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p1_p6_0[] = {
+        1, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9,
+};
+
+static const static_codebook _44p1_p6_0 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p1_p6_0,
+       1, -516716544, 1630767104, 2, 0,
+       (long *)_vq_quantlist__44p1_p6_0,
+       0
+};
+
+static const long _vq_quantlist__44p1_p6_1[] = {
+       12,
+       11,
+       13,
+       10,
+       14,
+       9,
+       15,
+       8,
+       16,
+       7,
+       17,
+       6,
+       18,
+       5,
+       19,
+       4,
+       20,
+       3,
+       21,
+       2,
+       22,
+       1,
+       23,
+       0,
+       24,
+};
+
+static const long _vq_lengthlist__44p1_p6_1[] = {
+        1, 3, 2, 5, 4, 7, 7, 8, 8, 9, 9,10,10,11,11,12,
+       12,13,13,13,14,16,16,16,16,
+};
+
+static const static_codebook _44p1_p6_1 = {
+       1, 25,
+       (long *)_vq_lengthlist__44p1_p6_1,
+       1, -518864896, 1620639744, 5, 0,
+       (long *)_vq_quantlist__44p1_p6_1,
+       0
+};
+
+static const long _vq_quantlist__44p1_p6_2[] = {
+       12,
+       11,
+       13,
+       10,
+       14,
+       9,
+       15,
+       8,
+       16,
+       7,
+       17,
+       6,
+       18,
+       5,
+       19,
+       4,
+       20,
+       3,
+       21,
+       2,
+       22,
+       1,
+       23,
+       0,
+       24,
+};
+
+static const long _vq_lengthlist__44p1_p6_2[] = {
+        3, 4, 4, 5, 4, 5, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+        5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44p1_p6_2 = {
+       1, 25,
+       (long *)_vq_lengthlist__44p1_p6_2,
+       1, -529006592, 1611661312, 5, 0,
+       (long *)_vq_quantlist__44p1_p6_2,
+       0
+};
+
+static const long _huff_lengthlist__44p1_short[] = {
+        4, 5, 7, 8,10,13,14, 4, 2, 4, 6, 8,11,12, 7, 4,
+        3, 5, 8,12,14, 8, 5, 4, 4, 8,12,12, 9, 7, 7, 7,
+        9,10,11,13,11,11, 9, 7, 8,10,13,11,10, 6, 5, 7,
+        9,
+};
+
+static const static_codebook _huff_book__44p1_short = {
+       2, 49,
+       (long *)_huff_lengthlist__44p1_short,
+       0, 0, 0, 0, 0,
+       NULL,
+       0
+};
+
+static const long _vq_quantlist__44p2_l0_0[] = {
+       6,
+       5,
+       7,
+       4,
+       8,
+       3,
+       9,
+       2,
+       10,
+       1,
+       11,
+       0,
+       12,
+};
+
+static const long _vq_lengthlist__44p2_l0_0[] = {
+        1, 4, 4, 7, 7, 8, 8, 9, 9,10,10,11,11, 4, 6, 5,
+        8, 7, 9, 8,10, 9,11,10,11,11, 4, 5, 6, 7, 8, 8,
+        9, 9,10,10,10,10,11, 8, 9, 8,10, 8,10, 9,11,10,
+       11,11,11,11, 8, 8, 9, 8,10, 9,10,10,11,11,11,11,
+       11, 9,10,10,11,11,11,11,11,11,12,11,12,11, 9,10,
+       10,10,11,11,11,11,11,11,12,11,12,10,11,11,12,11,
+       12,12,12,12,12,12,12,12,10,11,11,11,11,12,12,12,
+       13,12,12,12,12,11,12,12,12,12,13,13,12,12,12,12,
+       12,12,11,12,12,12,12,13,13,12,13,12,12,12,12,12,
+       13,13,13,13,13,13,12,13,12,13,12,12,12,13,13,13,
+       13,13,13,13,12,13,12,12,12,
+};
+
+static const static_codebook _44p2_l0_0 = {
+       2, 169,
+       (long *)_vq_lengthlist__44p2_l0_0,
+       1, -526516224, 1616117760, 4, 0,
+       (long *)_vq_quantlist__44p2_l0_0,
+       0
+};
+
+static const long _vq_quantlist__44p2_l0_1[] = {
+       2,
+       1,
+       3,
+       0,
+       4,
+};
+
+static const long _vq_lengthlist__44p2_l0_1[] = {
+        2, 4, 4, 5, 5, 4, 5, 5, 6, 5, 4, 5, 5, 5, 6, 5,
+        5, 6, 6, 6, 5, 6, 5, 6, 6,
+};
+
+static const static_codebook _44p2_l0_1 = {
+       2, 25,
+       (long *)_vq_lengthlist__44p2_l0_1,
+       1, -533725184, 1611661312, 3, 0,
+       (long *)_vq_quantlist__44p2_l0_1,
+       0
+};
+
+static const long _vq_quantlist__44p2_l1_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p2_l1_0[] = {
+        1, 4, 4, 4, 4, 4, 4, 4, 4,
+};
+
+static const static_codebook _44p2_l1_0 = {
+       2, 9,
+       (long *)_vq_lengthlist__44p2_l1_0,
+       1, -516716544, 1630767104, 2, 0,
+       (long *)_vq_quantlist__44p2_l1_0,
+       0
+};
+
+static const long _huff_lengthlist__44p2_lfe[] = {
+        1, 3, 2, 3,
+};
+
+static const static_codebook _huff_book__44p2_lfe = {
+       2, 4,
+       (long *)_huff_lengthlist__44p2_lfe,
+       0, 0, 0, 0, 0,
+       NULL,
+       0
+};
+
+static const long _huff_lengthlist__44p2_long[] = {
+        3, 4, 9, 8, 8,10,13,16, 4, 2, 9, 5, 7,10,14,18,
+        9, 7, 6, 5, 7, 9,12,16, 7, 5, 5, 3, 5, 8,11,13,
+        8, 7, 7, 5, 5, 7, 9,11,10,10, 9, 8, 6, 6, 8,10,
+       13,14,13,11, 9, 8, 9,10,17,18,16,14,11,10,10,10,
+};
+
+static const static_codebook _huff_book__44p2_long = {
+       2, 64,
+       (long *)_huff_lengthlist__44p2_long,
+       0, 0, 0, 0, 0,
+       NULL,
+       0
+};
+
+static const long _vq_quantlist__44p2_p1_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p2_p1_0[] = {
+        1, 2, 2, 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, 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,
+};
+
+static const static_codebook _44p2_p1_0 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p2_p1_0,
+       1, -535822336, 1611661312, 2, 0,
+       (long *)_vq_quantlist__44p2_p1_0,
+       0
+};
+
+static const long _vq_quantlist__44p2_p2_0[] = {
+       2,
+       1,
+       3,
+       0,
+       4,
+};
+
+static const long _vq_lengthlist__44p2_p2_0[] = {
+        1, 4, 4, 0, 0, 0, 8, 8, 0, 0, 0, 9, 9, 0, 0, 0,
+       10,10, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0, 0, 0, 0,
+        0, 0, 0, 0, 9, 9, 0, 0, 0,11,11, 0, 0, 0, 0, 0,
+        0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0,
+        0, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0,11,11, 0, 0,
+        0, 0, 0, 0, 0, 0,10,10, 0, 0, 0,11,11, 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, 7, 7,
+        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, 7, 7, 0, 0, 0,
+        6, 6, 0, 0, 0, 7, 7, 0, 0, 0, 8, 8, 0, 0, 0, 0,
+        0, 0, 0, 0, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7,
+        0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 0,
+        0, 0, 0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 9, 9, 0, 0,
+        0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0,
+        8, 8, 0, 0, 0, 9, 9, 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, 8, 8, 0, 0, 0, 8, 8, 0,
+        0, 0,10,10, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0,
+        0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,
+       11,11, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0, 0, 0, 0,
+        0, 0, 0, 0, 9, 9, 0, 0, 0,11,10, 0, 0, 0, 0, 0,
+        0, 0, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0,
+        0, 0,11,11, 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, 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, 8, 8, 0, 0, 0,10,10, 0, 0, 0,11,11, 0, 0,
+        0,12,12, 0, 0, 0, 0, 0, 0, 0, 0,11,11, 0, 0, 0,
+        0, 0, 0, 0, 0,10,10, 0, 0, 0,13,13, 0, 0, 0, 0,
+        0, 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0,12,12,
+        0, 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0,13,13, 0,
+        0, 0, 0, 0, 0, 0, 0,12,12, 0, 0, 0,13,13, 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, 6,
+        6, 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, 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, 9, 9, 0, 0, 0,11,11,
+        0, 0, 0,12,12, 0, 0, 0,12,12, 0, 0, 0, 0, 0, 0,
+        0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0,12,11, 0, 0,
+        0,12,12, 0, 0, 0, 0, 0, 0, 0, 0,13,13, 0, 0, 0,
+        0, 0, 0, 0, 0,12,12, 0, 0, 0,13,13, 0, 0, 0, 0,
+        0, 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0,12,12,
+        0, 0, 0,13,13, 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, 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, 8, 8, 0, 0, 0,10,10, 0, 0, 0,11,11, 0,
+        0, 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0,13,13, 0, 0,
+        0, 0, 0, 0, 0, 0,12,12, 0, 0, 0,13,13, 0, 0, 0,
+        0, 0, 0, 0, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0,10,
+       10, 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0,14,13,
+        0, 0, 0, 0, 0, 0, 0, 0,13,12, 0, 0, 0,13,13, 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,
+        6, 6, 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, 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, 9, 9, 0, 0, 0,11,
+       11, 0, 0, 0,12,12, 0, 0, 0,12,12, 0, 0, 0, 0, 0,
+        0, 0, 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0,12,12, 0,
+        0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0,13,13, 0, 0,
+        0, 0, 0, 0, 0, 0,12,12, 0, 0, 0,12,12, 0, 0, 0,
+        0, 0, 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0,12,
+       12, 0, 0, 0,13,13, 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, 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, 9, 9, 0, 0, 0,11,11, 0, 0, 0,12,12,
+        0, 0, 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0,12,12, 0,
+        0, 0, 0, 0, 0, 0, 0,11,11, 0, 0, 0,14,14, 0, 0,
+        0, 0, 0, 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0,
+       12,12, 0, 0, 0,12,13, 0, 0, 0, 0, 0, 0, 0, 0,12,
+       12, 0, 0, 0, 0, 0, 0, 0, 0,11,11, 0, 0, 0,14,13,
+        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, 7, 7, 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, 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, 9, 9, 0, 0, 0,
+       11,11, 0, 0, 0,12,12, 0, 0, 0,13,13, 0, 0, 0, 0,
+        0, 0, 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0,12,12,
+        0, 0, 0,13,13, 0, 0, 0, 0, 0, 0, 0, 0,12,12, 0,
+        0, 0, 0, 0, 0, 0, 0,12,12, 0, 0, 0,14,14, 0, 0,
+        0, 0, 0, 0, 0, 0,14,14, 0, 0, 0, 0, 0, 0, 0, 0,
+       12,12, 0, 0, 0,13,13, 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, 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, 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, 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, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0,
+};
+
+static const static_codebook _44p2_p2_0 = {
+       5, 3125,
+       (long *)_vq_lengthlist__44p2_p2_0,
+       1, -533725184, 1611661312, 3, 0,
+       (long *)_vq_quantlist__44p2_p2_0,
+       0
+};
+
+static const long _vq_quantlist__44p2_p3_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p2_p3_0[] = {
+        1, 5, 5, 6, 7, 7, 0, 8, 8, 6, 9, 9, 8,11,11, 0,
+        8, 8, 0, 9, 9, 0,12,12, 0, 8, 8, 5, 7, 7, 7,10,
+       10, 0,12,12, 8,11,11, 9,12,12, 0,11,12, 0,12,12,
+        0,15,15, 0,12,12, 0, 6, 6, 0, 6, 6, 0, 7, 7, 0,
+        7, 7, 0,10,10, 0, 7, 7, 0, 8, 8, 0,11,11, 0, 7,
+        7, 6, 7, 7,10, 9, 9, 0,11,10,10, 9, 9,12,12,12,
+        0,10,10, 0,11,11, 0,13,13, 0,11,11, 7, 6, 6,10,
+       10,10, 0,11,11,11,11,11,12,12,12, 0,11,11, 0,12,
+       12, 0,15,15, 0,11,11, 0,11,11, 0,11,11, 0,12,12,
+        0,12,12, 0,14,14, 0,12,12, 0,12,12, 0,15,15, 0,
+       11,11, 0, 8, 8, 0,10,10, 0,11,11, 0,11,11, 0,12,
+       12, 0,12,12, 0,11,11, 0,15,15, 0,11,11, 0, 6, 6,
+        0,10,10, 0,12,12, 0,10,10, 0,13,13, 0,12,12, 0,
+       13,13, 0,14,14, 0,12,12, 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,
+};
+
+static const static_codebook _44p2_p3_0 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p2_p3_0,
+       1, -533200896, 1614282752, 2, 0,
+       (long *)_vq_quantlist__44p2_p3_0,
+       0
+};
+
+static const long _vq_quantlist__44p2_p3_1[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p2_p3_1[] = {
+        2, 3, 3, 0, 8, 8, 0, 8, 8, 0, 9, 9, 0, 9, 9, 0,
+        9, 9, 0, 9, 9, 0, 9, 9, 0, 8, 8, 0, 6, 6, 0, 7,
+        7, 0, 7, 7, 0, 8, 8, 0, 8, 8, 0, 8, 8, 0, 8, 8,
+        0, 8, 8, 0, 8, 8, 0, 6, 6, 0, 6, 6, 0, 6, 6, 0,
+        8, 8, 0, 9, 9, 0, 7, 7, 0, 8, 8, 0, 9, 9, 0, 6,
+        6, 0, 8, 8, 0, 9, 9, 0, 9, 9, 0,10,10, 0,10,10,
+        0,10,10, 0,10,10, 0,11,11, 0, 9, 9, 0, 7, 7, 0,
+       10,10, 0,10,10, 0,12,11, 0,12,12, 0,11,11, 0,11,
+       11, 0,12,12, 0,10,10, 0, 7, 7, 0,10,10, 0,10,10,
+        0,12,12, 0,11,12, 0,11,11, 0,11,11, 0,11,11, 0,
+       10,10, 0, 8, 8, 0, 9, 9, 0, 9, 9, 0,10,10, 0,10,
+       10, 0,10, 9, 0,10,10, 0,10,10, 0, 9, 9, 0, 6, 6,
+        0,10,10, 0,10,10, 0,11,11, 0,12,12, 0,11,11, 0,
+       11,11, 0,12,12, 0,11,11, 0, 7, 7, 0, 9, 9, 0, 9,
+        9, 0,11,11, 0,11,11, 0,10,10, 0,10,10, 0,11,11,
+        0, 9, 9,
+};
+
+static const static_codebook _44p2_p3_1 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p2_p3_1,
+       1, -535822336, 1611661312, 2, 0,
+       (long *)_vq_quantlist__44p2_p3_1,
+       0
+};
+
+static const long _vq_quantlist__44p2_p4_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p2_p4_0[] = {
+        1, 6, 6, 6, 7, 7, 7, 8, 8, 7, 8, 8,10,11,11, 9,
+        8, 8, 7, 8, 8,11,11,11, 9, 8, 8, 6, 7, 7, 9,11,
+       11, 9,11,11,10,11,11,12,13,13,11,12,12,10,11,11,
+       13,14,14,12,12,12, 6, 6, 6, 8, 6, 6, 8, 7, 7, 9,
+        7, 7,11,10,10,10, 6, 6, 9, 7, 7,12,10,10,11, 6,
+        7, 7, 7, 7,11,10,10,12,10,10,11,10,10,14,13,13,
+       13,10,10,12,11,11,15,13,13,14,10,10, 8, 7, 7,12,
+       11,11,12,11,11,11,11,11,14,14,14,13,12,12,12,11,
+       11,15,15,15,13,12,12, 0,10,10, 0,11,11, 0,11,11,
+        0,11,11, 0,14,14, 0,11,11, 0,11,11, 0,15,15, 0,
+       11,11, 7, 8, 8,12,10,10,12,10,10,12,11,11,15,13,
+       13,14,11,11,12,10,10,16,14,14,14,10,10, 8, 7, 7,
+       12,11,11,12,11,11,12,11,11,16,14,14,14,12,12,13,
+       12,12,15,14,14,15,12,12, 0,11,11, 0,12,12, 0,12,
+       12, 0,12,12, 0,15,15, 0,12,12, 0,12,12, 0,14,14,
+        0,12,12,
+};
+
+static const static_codebook _44p2_p4_0 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p2_p4_0,
+       1, -531365888, 1616117760, 2, 0,
+       (long *)_vq_quantlist__44p2_p4_0,
+       0
+};
+
+static const long _vq_quantlist__44p2_p4_1[] = {
+       2,
+       1,
+       3,
+       0,
+       4,
+};
+
+static const long _vq_lengthlist__44p2_p4_1[] = {
+        3, 4, 4, 8, 8,11, 9, 9,12,12,11,10,10,12,12,12,
+       10,10,11,11,12,12,12,12,12,12,11,11,13,13,12,12,
+       12,13,13,12,10,10,12,12,12,11,11,13,13,12,13,13,
+       13,13,12,11,11,13,13,12,12,12,13,13,12,10,10,12,
+       12,12,11,11,13,13,12,13,13,12,12,12,11,11,13,13,
+       12,13,13,13,13,12,11,11,12,12,12,11,11,12,12,12,
+       13,13,12,12,12,13,13,13,13,12,13,13,13,13,13,13,
+       13,12,12,12,13,13,13,13,12,13,13,12,12,11, 8, 8,
+       10,10,12,11,11,11,11,12,10,10,10,10,13,11,11,10,
+       10,13,11,11,10,10,13,12,12,12,12,13,11,11,11,11,
+       13,12,12,11,11,13,12,12,11,11,13,12,12,12,11,13,
+       12,12,12,12,13,11,11,11,11,13,12,12,11,11,13,11,
+       12,11,11,13,12,12,11,11,14,12,12,11,11,13,11,11,
+       11,11,14,12,12,11,11,13,11,12,10,10,14,12,12,11,
+       11,14,12,12,11,11,14,11,11,11,11,14,12,12,11,11,
+       13,12,12,11,11,14,12,12,11,11,11, 8, 8,10,10,12,
+        7, 7,10,10,12, 9, 9,11,11,13, 9, 9, 9, 9,13,13,
+       13,10,10,13, 9, 9,12,12,13,13,13,12,12,13, 9, 8,
+       11,11,13,10,10,12,12,14,13,13,11,11,13, 9, 9,11,
+       11,13,13,13,12,12,13, 9, 9,10,10,13,10,10,11,11,
+       13,13,13,10,10,14,10,10,11,11,14,14,14,12,12,13,
+        9, 9,10,10,13,10,10,11,11,14,13,14,10,10,14,14,
+       14,11,12,14,14,14,14,14,14,13,13,10,10,13,14,14,
+       11,11,14,14,14,10,10,14, 9, 9, 9, 9,14, 9, 9, 9,
+        9,14,10,10, 9, 9,14,10,10, 8, 8,14,11,11, 8, 8,
+       15,11,11,10,10,15,12,12,10,10,15,10,10,10,10,15,
+       11,11,10,10,15,13,13,10,10,15,11,11,10,10,15,12,
+       12,10,10,15,10,10,10,10,15,11,11,10,10,15,13,13,
+       10,10,15,11,11,10,10,15,12,12,10,10,15,11,11, 9,
+        9,15,11,11, 9, 9,15,13,13, 9, 9,15,13,13,10,10,
+       15,12,12,10,10,15,13,13,10,10,15,13,12, 9, 9,15,
+       13,13, 9, 9,14,12,12, 9, 9,14,13,13, 9, 9,14,13,
+       13, 9, 9,14,13,13, 7, 7,14,13,13, 8, 8,15,14,14,
+       10,10,15,14,14,10,10,15,14,14,10,10,15,14,14,10,
+       10,15,14,14, 9, 9,15,14,14,10,10,15,14,14,10,10,
+       14,14,14, 9, 9,15,14,14,10,10,14,14,14, 9, 9,15,
+       14,14,10,10,15,14,14,10,10,14,14,14, 9, 9,14,14,
+       14, 9, 9,14,14,14, 8, 8,15,14,14,10,10,15,14,14,
+       11,11,15,14,14, 9, 9,15,14,14, 9, 9,14,14,14, 8,
+        8,13, 9, 9,12,12,17,11,11,12,12,17,12,12,12,12,
+       17,12,12,11,11,18,15,15,12,12,17,12,12,12,12,17,
+       14,15,13,13,17,12,12,12,12,17,13,13,12,13,17,15,
+       15,12,12,18,13,13,13,13,18,15,15,13,13,18,12,12,
+       12,12,18,13,13,13,13,18,15,15,12,12,18,13,13,12,
+       12,18,15,15,13,13,18,13,13,12,12,17,13,13,12,12,
+       17,15,15,12,12,18,15,15,13,13,18,15,15,13,14,18,
+       15,16,12,12,18,15,15,12,12,18,16,16,12,12,13, 8,
+        8,10,10,14,15,14,11,11,14,15,15,12,12,15,14,14,
+       12,11,15,15,15,12,12,15,15,15,12,12,15,15,15,13,
+       13,15,15,15,12,12,15,15,15,13,13,15,15,15,13,13,
+       15,15,15,13,13,15,15,16,13,13,15,15,15,12,12,15,
+       15,15,13,13,15,15,15,13,13,15,15,15,13,13,15,15,
+       15,13,13,15,15,14,12,12,15,15,15,12,12,16,15,14,
+       12,12,16,15,15,13,13,16,16,16,13,13,16,15,15,12,
+       12,15,15,15,13,13,15,15,15,12,12,13,12,12,10,10,
+       14,14,14,11,11,15,14,14,12,12,15,14,14,11,11,15,
+       14,14,11,11,15,15,15,13,13,15,14,14,13,13,15,15,
+       15,12,12,15,14,15,13,13,16,15,15,12,12,15,15,15,
+       13,13,16,14,14,13,13,15,15,15,12,12,15,15,15,13,
+       13,16,15,15,12,12,16,15,15,12,12,16,14,14,13,13,
+       15,15,15,11,11,15,15,15,12,12,16,15,15,11,11,16,
+       15,15,13,13,16,14,15,14,14,16,15,15,12,12,16,15,
+       14,12,12,16,15,15,12,12,14,10,10, 9, 9,14,11,11,
+       12,12,14,12,12,13,13,14,12,12,12,12,15,14,14,13,
+       13,15,13,13,14,14,15,14,14,15,15,15,12,12,13,13,
+       15,13,13,14,14,15,14,14,13,13,15,13,13,13,14,15,
+       14,14,15,15,15,12,12,13,13,15,13,13,14,14,15,14,
+       14,13,13,15,13,13,14,14,15,14,14,15,15,15,13,13,
+       12,12,15,13,13,13,13,15,14,14,13,12,15,15,15,14,
+       15,15,15,14,20,20,15,14,14,13,13,15,14,14,13,13,
+       15,14,14,13,13,14,12,12, 9, 9,14,14,14,12,12,14,
+       13,13,12,13,14,14,14,12,12,15,14,14,12,12,15,14,
+       14,14,13,15,14,14,14,14,15,14,14,13,13,15,14,14,
+       13,13,15,15,15,14,14,15,14,14,13,13,15,14,14,14,
+       14,15,14,14,13,13,15,14,14,13,13,15,15,15,15,14,
+       15,15,15,13,13,15,14,14,14,14,15,14,14,13,13,15,
+       14,14,13,13,14,15,15,14,14,15,15,15,14,14,15,14,
+       14,14,14,15,15,15,14,14,15,14,14,13,14,15,15,15,
+       14,14,13,10,10,12,12,17,11,11,12,12,17,12,12,12,
+       12,17,12,12,11,11,17,15,15,12,11,18,13,13,13,13,
+       18,15,15,13,13,17,12,12,12,12,18,13,13,13,13,17,
+       15,15,12,12,17,12,12,12,12,17,15,15,13,13,17,12,
+       12,12,12,17,13,13,12,12,17,15,15,12,12,18,14,13,
+       12,12,18,15,15,13,13,18,13,13,12,12,18,13,13,12,
+       12,18,16,16,12,12,18,16,16,12,12,18,15,15,13,13,
+       18,16,16,12,12,17,15,15,12,12,17,16,16,12,12,13,
+        8, 8,10,10,14,14,15,12,12,14,15,15,12,12,15,14,
+       14,12,12,15,15,14,12,12,15,15,15,13,13,15,15,15,
+       13,13,15,15,15,12,12,16,15,15,13,13,16,15,15,13,
+       13,15,15,15,12,12,15,15,15,14,14,15,15,15,12,12,
+       15,15,15,13,13,16,15,15,13,13,15,15,15,13,13,16,
+       15,15,13,13,15,15,14,12,12,15,15,15,12,12,16,14,
+       15,13,13,16,15,15,13,13,15,16,15,13,13,16,15,14,
+       13,13,16,15,15,13,13,16,15,15,13,13,13,12,12,11,
+       11,14,14,14,11,11,14,14,14,12,12,15,14,14,11,11,
+       16,14,14,11,11,15,15,15,12,13,16,14,14,13,13,15,
+       15,15,12,12,15,14,14,13,13,16,15,15,12,12,15,15,
+       15,12,12,15,14,14,13,13,15,15,15,12,12,15,14,14,
+       12,12,16,15,15,12,12,16,15,15,12,12,16,14,14,13,
+       13,15,15,15,11,11,15,15,14,12,12,16,15,15,11,11,
+       16,15,15,12,12,16,14,14,13,13,16,15,15,11,11,16,
+       14,14,12,12,16,15,15,11,11,14,10,10, 9, 9,14,11,
+       11,12,12,14,12,12,13,14,14,12,12,12,12,14,14,14,
+       13,13,15,13,13,14,14,15,14,14,15,15,15,12,12,13,
+       13,15,13,13,14,14,15,15,15,14,14,15,13,13,14,14,
+       15,15,15,15,15,15,12,12,13,13,15,13,13,14,14,15,
+       14,14,13,13,15,13,13,14,14,15,14,14,15,15,15,12,
+       12,13,13,15,13,13,13,13,14,14,14,13,13,15,15,15,
+       14,15,15,15,15,21,19,15,14,14,13,13,15,14,14,14,
+       14,14,14,14,13,13,14,12,12, 9, 9,14,14,14,12,12,
+       14,14,13,13,13,14,14,14,12,12,14,14,14,12,12,15,
+       14,14,13,13,15,14,14,14,14,15,14,14,13,13,15,14,
+       14,13,13,15,15,15,15,15,15,14,14,13,13,15,14,14,
+       14,14,15,14,14,13,13,15,14,14,13,13,14,15,15,15,
+       15,15,14,15,13,13,15,14,14,14,14,15,14,14,13,13,
+       15,14,14,13,13,14,15,15,14,14,15,15,15,14,14,15,
+       14,14,14,14,15,15,15,15,15,15,14,14,14,13,14,15,
+       15,14,14,13,10,10,12,12,18,12,12,12,12,17,12,12,
+       12,12,18,13,13,11,11,18,15,14,11,11,17,13,13,13,
+       13,18,15,15,12,12,18,12,12,12,12,17,13,13,12,12,
+       18,15,15,12,12,18,13,13,13,12,18,15,15,13,13,18,
+       13,13,12,12,18,13,13,12,12,18,15,15,12,12,17,13,
+       13,12,12,17,15,15,12,12,17,12,12,11,11,17,13,13,
+       11,11,17,15,15,11,11,18,16,16,12,12,18,15,15,13,
+       13,18,15,15,11,11,17,15,15,12,12,18,15,15,11,11,
+       13, 8, 8,10,10,14,14,14,11,11,15,15,15,12,12,15,
+       14,14,11,11,16,14,14,12,12,15,15,15,12,12,15,15,
+       15,13,13,15,15,15,12,12,15,15,15,12,12,16,15,15,
+       13,13,15,15,15,12,12,15,15,15,13,13,16,15,15,12,
+       12,15,15,15,12,12,16,15,15,13,13,16,15,15,12,12,
+       15,15,15,13,13,15,14,14,12,12,15,15,15,12,12,16,
+       15,14,12,12,16,15,15,13,13,16,16,16,13,13,16,14,
+       15,13,13,15,15,15,13,13,16,15,15,12,12,13,12,12,
+       10,10,14,14,14,11,11,15,14,14,12,12,15,14,14,11,
+       11,16,14,14,11,11,15,14,15,12,12,15,14,14,13,13,
+       15,15,15,12,12,15,14,14,12,12,15,14,15,12,12,15,
+       15,15,12,12,16,14,14,13,13,15,15,15,11,12,16,14,
+       14,12,12,16,15,15,12,12,15,15,15,12,12,16,14,14,
+       12,12,15,15,15,11,11,15,14,14,11,12,15,15,14,11,
+       11,16,15,15,12,12,16,14,14,13,13,16,15,15,11,11,
+       16,14,14,12,12,16,15,15,11,11,13,10,10, 8, 8,14,
+       12,12,12,12,14,12,12,13,13,14,12,12,12,12,14,14,
+       14,13,13,15,13,13,14,14,15,15,14,15,15,15,13,13,
+       13,13,15,13,13,14,14,15,14,15,14,14,15,13,13,13,
+       13,15,15,15,15,15,15,12,12,13,12,15,13,13,14,14,
+       15,14,14,13,13,15,13,13,14,13,15,15,15,16,16,15,
+       13,13,12,12,15,13,13,13,13,14,14,14,12,12,15,15,
+       15,14,14,15,15,15,20,20,15,14,14,13,13,15,15,14,
+       14,14,15,14,14,13,13,13,12,12, 9, 9,14,13,13,12,
+       12,14,13,13,12,12,14,14,14,12,12,14,14,14,13,13,
+       15,14,14,13,13,15,14,14,14,14,15,15,14,12,12,15,
+       14,14,13,13,15,14,15,14,15,15,14,14,13,13,15,14,
+       14,14,14,15,14,14,12,12,15,14,14,13,13,14,15,14,
+       15,14,15,14,14,13,13,15,14,14,14,14,15,14,14,12,
+       12,15,14,14,13,13,15,15,15,14,14,15,15,15,14,14,
+       16,14,14,14,14,15,15,15,14,14,15,14,14,14,14,14,
+       15,15,14,14,13,13,13,12,13,17,15,15,12,12,17,15,
+       15,12,12,18,15,15,11,11,17,16,16,11,11,18,16,16,
+       13,13,18,17,16,13,13,18,16,16,12,12,18,16,16,12,
+       12,18,17,17,12,12,17,16,16,12,13,17,16,16,12,13,
+       17,16,16,12,12,17,16,16,12,12,18,17,16,12,12,18,
+       16,16,12,12,17,16,17,12,12,18,15,15,11,11,18,15,
+       15,12,12,17,17,17,11,11,17,17,17,12,12,17,16,16,
+       13,13,18,16,16,11,11,18,16,16,12,12,18,17,16,11,
+       11,14,14,14,10,10,16,15,14,11,11,16,15,15,12,12,
+       16,14,14,12,12,17,14,14,13,13,17,15,15,13,13,17,
+       15,15,14,14,16,15,15,12,12,16,15,15,13,13,18,15,
+       15,14,14,16,15,15,12,12,16,15,15,14,14,16,15,15,
+       12,12,16,15,15,13,13,17,15,15,13,13,17,15,15,13,
+       13,17,15,15,14,14,16,14,14,12,12,17,15,15,12,12,
+       18,15,15,13,13,17,15,15,14,14,17,16,16,15,15,17,
+       15,14,13,13,17,15,15,14,14,17,15,15,13,13,14,12,
+       12,11,11,15,14,14,12,12,16,14,14,12,12,16,14,14,
+       11,11,17,14,14,12,12,16,15,14,13,13,16,14,14,13,
+       13,16,15,15,12,12,16,14,14,13,13,17,15,15,13,13,
+       16,15,15,13,13,17,14,14,13,13,16,15,15,12,12,16,
+       14,14,12,12,16,15,15,12,12,17,15,15,12,12,17,14,
+       14,13,13,16,15,15,12,12,16,14,14,12,12,16,15,15,
+       12,12,17,15,15,13,13,17,14,14,13,13,17,15,15,12,
+       12,17,14,14,12,12,17,15,15,12,12,14,14,14, 8, 8,
+       14,14,14,13,13,14,15,15,14,14,14,14,14,14,14,15,
+       15,15,19,19,15,15,15,14,14,15,15,16,20,19,15,15,
+       15,14,14,15,16,16,15,15,15,15,15,19,19,15,15,15,
+       14,14,15,16,16,19,20,15,15,15,14,14,15,15,15,15,
+       15,15,15,15,19,19,15,15,15,15,15,15,15,16,19,20,
+       15,14,15,14,14,15,15,15,15,15,15,15,15,20,19,15,
+       15,15,21,19,15,16,16,20,20,15,15,14,19,19,15,15,
+       16,20,21,15,15,15,20,19,13,12,12, 9, 9,14,14,14,
+       12,12,14,13,13,13,13,14,14,14,13,13,15,14,14,20,
+       19,15,14,14,14,13,15,14,14,19,19,15,15,14,13,13,
+       15,14,14,14,14,15,15,15,19,20,15,14,14,13,13,15,
+       14,14,20,19,14,15,14,13,13,15,14,14,14,13,15,15,
+       15,19,20,15,15,14,14,14,15,14,14,21,19,15,15,15,
+       13,13,15,14,14,14,14,14,15,15,20,20,15,15,15,21,
+       20,15,14,14,19,20,15,15,15,20,20,15,14,14,19,20,
+       15,15,15,21,19,
+};
+
+static const static_codebook _44p2_p4_1 = {
+       5, 3125,
+       (long *)_vq_lengthlist__44p2_p4_1,
+       1, -533725184, 1611661312, 3, 0,
+       (long *)_vq_quantlist__44p2_p4_1,
+       0
+};
+
+static const long _vq_quantlist__44p2_p5_0[] = {
+       2,
+       1,
+       3,
+       0,
+       4,
+};
+
+static const long _vq_lengthlist__44p2_p5_0[] = {
+        2, 6, 6,14,14, 6, 7, 7,14,14, 7, 7, 7,15,15, 0,
+       13,13,16,16, 0,13,13,15,15, 7, 8, 8,15,15, 9,10,
+       10,17,16, 9, 8, 8,15,15, 0,13,13,18,17, 0,13,13,
+       16,16, 8, 8, 8,15,15,12,11,11,16,17, 9, 8, 8,14,
+       14, 0,13,13,18,17, 0,13,13,16,15, 0,14,14,18,17,
+        0,20,22,18,20, 0,12,12,16,16, 0,16,16,22,20, 0,
+       14,14,16,16, 0,14,14,17,17, 0,22,22,22,19, 0,12,
+       13,16,16, 0,17,17, 0, 0, 0,15,15,16,16, 5, 7, 7,
+       13,13, 9, 9, 9,15,14,10,10,10,14,14, 0,21,21,18,
+       17, 0,21,22,18,17, 9,10,10,14,14,12,12,12,17,17,
+       12,10,10,14,14, 0,19,21,18,17, 0,20,22,18,18,11,
+       10,10,14,14,14,13,13,18,17,12,11,11,14,14, 0,22,
+       19,17,18, 0,20, 0,18,17, 0,22,21,17,17, 0, 0, 0,
+        0, 0, 0,20,22,17,17, 0,22, 0,21,19, 0,22, 0,18,
+       18, 0, 0,22,18,19, 0, 0, 0, 0, 0, 0,19,21,17,17,
+        0, 0, 0,20,20, 0, 0, 0,18,18, 6, 6, 6,13,12, 8,
+        6, 6,11,11, 8, 6, 6,13,13, 0, 9, 9,11,11, 0,11,
+       11,14,14, 9, 7, 7,13,13,11, 9, 9,13,13,10, 6, 6,
+       13,13, 0,10,10,14,14, 0,10,10,13,13, 9, 7, 7,13,
+       14,13, 9, 9,13,13,10, 6, 6,13,12, 0,11,11,15,15,
+        0,10,10,13,13, 0,12,12,15,15, 0,19, 0,17,17, 0,
+        9, 9,13,13, 0,13,14,19,20, 0,11,11,13,13, 0,11,
+       11,14,14, 0,19,20,17,18, 0,10,10,13,13, 0,15,15,
+       21,19, 0,12,12,13,13, 0,10,10,12,13, 0,11,11,15,
+       15, 0,11,11,15,15, 0,15,15,22, 0, 0,16,17,22, 0,
+        0,11,11,15,15, 0,14,14,18,17, 0,11,11,15,16, 0,
+       15,15,22,21, 0,16,16, 0,20, 0,12,12,16,15, 0,15,
+       14,19,19, 0,11,11,16,16, 0,15,15,21, 0, 0,16,15,
+        0, 0, 0,16,16,22,21, 0, 0, 0, 0, 0, 0,15,15,20,
+       20, 0,18,18, 0, 0, 0,16,17, 0, 0, 0,17,17, 0,22,
+        0, 0, 0, 0, 0, 0,15,15,21,22, 0,20,18, 0, 0, 0,
+       18,17,22, 0, 0,10,10,12,11, 0,10,10,10,10, 0,11,
+       11,12,12, 0,11,11, 9, 9, 0,13,13,12,12, 0,11,11,
+       12,12, 0,13,13,12,12, 0,10,10,12,12, 0,13,12,13,
+       13, 0,12,12,12,12, 0,11,11,12,12, 0,13,13,12,12,
+        0,10,10,12,12, 0,13,13,13,14, 0,12,12,12,12, 0,
+       13,14,14,14, 0,20,21,15,15, 0,12,11,12,12, 0,15,
+       16,20,22, 0,13,12,11,11, 0,13,13,14,13, 0,20, 0,
+       16,15, 0,12,12,12,12, 0,16,16,22,21, 0,13,13,12,
+       12, 6, 7, 7,16,16,11, 9, 9,15,15,12, 9, 9,16,16,
+        0,13,13,14,14, 0,14,14,16,17,10, 9, 9,16,16,14,
+       12,12,16,16,12, 9, 9,15,15, 0,13,13,18,18, 0,13,
+       13,15,16,12,10,10,17,18,15,12,12,17,17,13, 9, 9,
+       16,16, 0,13,13,17,18, 0,14,14,16,16, 0,15,15,18,
+       18, 0,22, 0,20,20, 0,12,12,16,16, 0,16,16,20,22,
+        0,14,14,16,16, 0,15,14,18,18, 0, 0,22,19,21, 0,
+       13,13,16,17, 0,17,17,22,22, 0,15,15,16,16, 7, 7,
+        7,14,14,11,10,10,15,15,12,10,10,15,14, 0,22, 0,
+       18,18, 0, 0,21,17,18,11,10,10,15,15,14,12,12,17,
+       17,14,11,11,15,15, 0,22,20,18,18, 0, 0,20,18,17,
+       12,10,10,16,16,17,14,14,19,18,14,11,11,15,15, 0,
+       21,22,19,19, 0,21,22,18,18, 0,22, 0,19,21, 0, 0,
+        0, 0, 0, 0,22,22,18,17, 0, 0, 0,21,20, 0,22,22,
+       20,19, 0, 0,22,20,20, 0, 0, 0, 0, 0, 0,20,21,17,
+       17, 0, 0,22,21,21, 0, 0, 0,18,18,10, 9, 9,14,14,
+       13,10,10,13,13,13,10,11,14,14, 0,13,13,12,12, 0,
+       15,15,16,16,13,10,10,15,15,15,12,12,14,14,15,10,
+       10,14,15, 0,14,14,16,15, 0,14,14,15,15,13,10,10,
+       15,15,18,13,13,15,15,15,10,10,14,15, 0,14,14,16,
+       16, 0,14,14,15,15, 0,15,15,16,16, 0,22, 0,18,18,
+        0,12,13,14,14, 0,17,17,22, 0, 0,14,14,14,14, 0,
+       15,15,16,16, 0,22, 0,18,17, 0,13,13,14,14, 0,19,
+       18,21,22, 0,15,15,14,14, 0,11,11,13,13, 0,12,12,
+       16,16, 0,12,12,16,16, 0,15,16,21, 0, 0,16,17, 0,
+       22, 0,12,12,16,16, 0,14,14,17,18, 0,11,11,16,16,
+        0,15,15,21,22, 0,16,16, 0, 0, 0,12,12,16,16, 0,
+       15,15, 0,19, 0,12,12,16,17, 0,16,16,22, 0, 0,16,
+       16, 0,22, 0,17,17, 0,22, 0, 0, 0, 0, 0, 0,15,15,
+       20,19, 0,18,18, 0, 0, 0,17,18, 0, 0, 0,17,17, 0,
+        0, 0, 0, 0, 0, 0, 0,15,15, 0,22, 0,20,18, 0, 0,
+        0,18,18,22,22, 0,11,11,14,14, 0,12,12,14,14, 0,
+       12,12,15,15, 0,13,13,14,14, 0,14,14,17,16, 0,12,
+       12,16,16, 0,14,14,16,16, 0,11,11,15,15, 0,13,13,
+       16,16, 0,13,13,15,15, 0,12,12,15,15, 0,15,14,16,
+       16, 0,11,11,15,15, 0,14,14,17,17, 0,13,13,15,15,
+        0,15,15,17,17, 0, 0, 0,19,18, 0,13,12,15,15, 0,
+       16,16, 0, 0, 0,14,14,15,15, 0,14,14,16,17, 0,22,
+        0,18,18, 0,13,13,15,15, 0,17,17, 0, 0, 0,14,14,
+       15,15, 8, 8, 8,16,16,12,10,10,16,16,13, 9, 9,16,
+       16, 0,14,14,17,17, 0,14,14,17,16,12,10,10,18,17,
+       14,11,11,18,18,14, 9,10,16,16, 0,13,13,18,19, 0,
+       14,13,16,16,12, 9, 9,16,16,17,13,13,17,17,14, 9,
+        9,15,15, 0,14,14,19,20, 0,13,13,15,15, 0,15,15,
+       18,19, 0, 0,22,22,22, 0,13,13,17,17, 0,16,16,19,
+       21, 0,14,14,16,16, 0,14,14,18,18, 0, 0, 0, 0, 0,
+        0,13,13,16,16, 0,18,18, 0, 0, 0,15,15,16,16, 8,
+        7, 7,14,14,12,10,10,15,15,13,10,10,15,14, 0,22,
+        0,18,18, 0,22, 0,18,18,12,10,10,16,15,15,12,12,
+       17,17,14,11,11,15,15, 0,20,21,19,18, 0, 0, 0,17,
+       18,13,11,11,15,15,16,13,13,18,18,15,11,11,14,14,
+        0,22,21,19,19, 0,21,22,18,18, 0,22,22,20,18, 0,
+        0, 0, 0, 0, 0,22,19,17,17, 0, 0, 0,22,21, 0, 0,
+       22,19,17, 0, 0,22,19,19, 0, 0, 0, 0, 0, 0,22,21,
+       18,17, 0, 0, 0,22, 0, 0, 0, 0,19,19, 0,10,10,14,
+       14, 0,11,11,15,14, 0,11,11,15,15, 0,14,14,15,14,
+        0,15,15,16,16, 0,11,11,16,16, 0,13,13,16,16, 0,
+       11,11,15,15, 0,14,14,17,16, 0,14,14,15,15, 0,11,
+       11,16,16, 0,14,13,15,15, 0,11,11,15,15, 0,15,15,
+       17,17, 0,14,14,15,14, 0,16,16,17,17, 0, 0,22,18,
+       18, 0,13,13,15,15, 0,17,17,22, 0, 0,15,15,15,14,
+        0,15,16,16,17, 0, 0,22,18,19, 0,13,13,15,15, 0,
+       20,18,21, 0, 0,15,15,14,14, 0,11,11,13,13, 0,12,
+       12,16,16, 0,12,12,16,15, 0,15,16,22,22, 0,17,17,
+        0, 0, 0,12,12,16,16, 0,14,14,18,18, 0,11,11,16,
+       16, 0,15,16,22,20, 0,16,16, 0,22, 0,12,12,16,16,
+        0,15,15,18,20, 0,11,11,16,16, 0,15,15, 0, 0, 0,
+       16,16, 0, 0, 0,17,17,22, 0, 0, 0, 0, 0, 0, 0,15,
+       15, 0,21, 0,18,18, 0, 0, 0,17,16, 0, 0, 0,17,17,
+       22,22, 0, 0, 0, 0, 0, 0,15,15,21, 0, 0,20,22, 0,
+        0, 0,18,18, 0, 0, 0,12,12,15,15, 0,12,12,15,15,
+        0,12,12,16,16, 0,13,13,15,15, 0,15,15,17,17, 0,
+       13,12,16,16, 0,14,14,16,16, 0,12,11,16,16, 0,14,
+       14,17,17, 0,14,14,16,16, 0,12,12,16,16, 0,15,15,
+       17,16, 0,11,11,15,16, 0,14,14,17,17, 0,14,14,16,
+       16, 0,15,15,18,18, 0, 0, 0,22,19, 0,13,13,15,16,
+        0,16,17, 0, 0, 0,14,14,16,16, 0,15,15,18,17, 0,
+        0, 0,20,20, 0,13,13,16,15, 0,17,17,22,22, 0,14,
+       14,15,15, 0,11,11,16,16, 0,13,13,16,17, 0,13,13,
+       17,18, 0,16,16,17,17, 0,17,17,18,18, 0,12,12,17,
+       17, 0,16,15,18,18, 0,12,12,16,16, 0,16,16,18,18,
+        0,15,15,17,17, 0,12,12,17,17, 0,16,16,19,18, 0,
+       12,12,16,17, 0,16,16,19,19, 0,15,16,16,17, 0,16,
+       16,19,17, 0, 0, 0,20,22, 0,13,13,16,16, 0,19,18,
+       21, 0, 0,15,15,16,16, 0,16,16,18,18, 0, 0, 0,22,
+       21, 0,14,14,16,16, 0,21,19,21,22, 0,16,16,16,16,
+        0, 9, 9,14,14, 0,13,13,15,15, 0,14,14,15,15, 0,
+        0,20,18,19, 0, 0,22,18,18, 0,12,12,15,15, 0,15,
+       15,17,18, 0,14,13,14,14, 0,20, 0,18,18, 0,21, 0,
+       18,17, 0,13,13,15,16, 0,17,17,18,18, 0,14,14,15,
+       15, 0,22,22,20,19, 0,20,21,18,18, 0,20,22,19,19,
+        0, 0, 0, 0, 0, 0,20,20,17,17, 0, 0,22,22,21, 0,
+       22, 0,18,18, 0,20,22,19,19, 0, 0, 0, 0, 0, 0,21,
+       21,17,18, 0, 0, 0,21,20, 0, 0,22,19,18, 0,18,18,
+       15,15, 0,22,21,17,16, 0, 0,22,17,17, 0,20,22,18,
+       18, 0, 0,22,20,20, 0,21,19,16,16, 0,21,21,18,18,
+        0,19,19,17,17, 0, 0,22,19,19, 0,22,20,17,17, 0,
+       21,19,16,16, 0,22,22,19,18, 0,19,20,16,16, 0,22,
+       21,19,21, 0,21,22,17,18, 0,21,20,18,18, 0, 0, 0,
+       19,20, 0,20,19,16,16, 0,22,22, 0, 0, 0,21,21,17,
+       16, 0,22,20,19,18, 0, 0, 0,20,20, 0,20,19,16,16,
+        0, 0, 0, 0, 0, 0,21,22,17,17, 0,11,11,13,13, 0,
+       13,13,15,16, 0,13,13,16,16, 0,17,18,21, 0, 0,17,
+       18, 0, 0, 0,12,12,15,16, 0,15,15,19,18, 0,12,12,
+       16,16, 0,17,17,22, 0, 0,17,17, 0,22, 0,12,12,17,
+       16, 0,16,16,19,20, 0,12,12,16,16, 0,17,17, 0, 0,
+        0,17,17, 0,21, 0,17,16,22, 0, 0, 0, 0, 0, 0, 0,
+       15,15,20,22, 0,20,18, 0, 0, 0,18,18, 0, 0, 0,17,
+       17,21, 0, 0, 0, 0, 0, 0, 0,15,15,21,22, 0,19,20,
+       22, 0, 0,19,18, 0, 0, 0,14,14,18,18, 0,16,16,22,
+       20, 0,16,16,22,19, 0,17,17,20,22, 0,19,19, 0, 0,
+        0,15,15,20, 0, 0,18,21, 0,20, 0,15,15,21,20, 0,
+       18,17, 0, 0, 0,17,17, 0,22, 0,15,15,19,19, 0,19,
+       18, 0, 0, 0,15,15,20, 0, 0,18,18,22,22, 0,17,17,
+        0,20, 0,18,18, 0, 0, 0, 0,22, 0, 0, 0,15,15,19,
+       20, 0,20,19, 0, 0, 0,17,17,20,21, 0,17,18,20,22,
+        0, 0, 0, 0,22, 0,15,15,20,20, 0,22,20, 0, 0, 0,
+       17,18,20, 0, 0,12,12,17,16, 0,14,14,17,17, 0,13,
+       13,17,17, 0,16,16,18,18, 0,17,16,17,17, 0,13,13,
+       17,17, 0,15,16,18,18, 0,13,13,16,16, 0,16,16,18,
+       18, 0,16,16,17,16, 0,13,13,16,16, 0,17,17,18,17,
+        0,12,12,15,16, 0,17,17,19,19, 0,16,16,16,16, 0,
+       16,17,19,18, 0, 0, 0,21,22, 0,14,14,16,16, 0,18,
+       18, 0,22, 0,16,16,16,16, 0,16,16,18,17, 0, 0, 0,
+       21,20, 0,14,14,16,16, 0,21,22,22, 0, 0,16,16,16,
+       16, 0, 9, 9,14,13, 0,13,14,15,16, 0,14,13,15,14,
+        0,22, 0,18,18, 0,21, 0,17,18, 0,13,13,15,15, 0,
+       15,16,18,17, 0,14,14,15,14, 0,20,22,18,18, 0,22,
+       21,17,17, 0,13,13,15,15, 0,17,17,19,19, 0,14,14,
+       14,14, 0, 0,22,18,18, 0, 0,22,17,17, 0, 0,22,19,
+       20, 0, 0, 0, 0, 0, 0,21,20,17,16, 0, 0, 0,21,22,
+        0, 0, 0,18,19, 0, 0, 0,18,18, 0, 0, 0, 0, 0, 0,
+       22, 0,17,17, 0, 0, 0,20,22, 0, 0, 0,18,19, 0,18,
+       19,16,16, 0,22,20,17,17, 0,22,22,17,18, 0,22,22,
+       18,17, 0, 0,22,18,19, 0,20,20,17,18, 0, 0,22,19,
+       18, 0,22,22,17,17, 0,22, 0,19,19, 0, 0,22,18,18,
+        0,20,22,17,17, 0, 0,22,18,18, 0,19,20,17,17, 0,
+       22, 0,20,19, 0,22,21,17,17, 0, 0, 0,18,18, 0, 0,
+        0,22,19, 0,20, 0,17,17, 0,22, 0, 0,22, 0, 0,20,
+       17,18, 0,22, 0,19,19, 0, 0, 0, 0,19, 0,19,21,17,
+       17, 0, 0, 0, 0, 0, 0,20,21,17,16, 0,11,11,13,13,
+        0,13,13,16,16, 0,13,13,15,16, 0,17,17,21,22, 0,
+       17,18, 0, 0, 0,12,12,16,16, 0,15,15,18,18, 0,13,
+       13,16,16, 0,17,16,21,21, 0,17,17, 0, 0, 0,13,13,
+       16,16, 0,16,16,19,18, 0,13,13,16,16, 0,17,17, 0,
+       22, 0,17,18,20,22, 0,17,18, 0, 0, 0, 0, 0, 0, 0,
+        0,15,15,20, 0, 0,18,19, 0, 0, 0,17,17, 0, 0, 0,
+       18,17,22, 0, 0, 0, 0, 0, 0, 0,15,16,21,20, 0,20,
+       20, 0, 0, 0,18,19, 0, 0, 0,15,15,22,22, 0,17,16,
+       20,22, 0,17,17,20,22, 0,18,18, 0,21, 0,19,18, 0,
+        0, 0,16,16,20,20, 0,19,19,22, 0, 0,15,16,21,22,
+        0,18,19,22, 0, 0,17,18, 0, 0, 0,16,16,22, 0, 0,
+       19,19, 0,21, 0,15,16,20, 0, 0,18,18, 0,22, 0,18,
+       17, 0, 0, 0,18,18, 0, 0, 0, 0, 0, 0, 0, 0,16,16,
+       22,21, 0,20,21, 0, 0, 0,17,18,22, 0, 0,18,18, 0,
+        0, 0, 0, 0, 0, 0, 0,16,16,20,19, 0,22,21, 0, 0,
+        0,18,18,22,22,
+};
+
+static const static_codebook _44p2_p5_0 = {
+       5, 3125,
+       (long *)_vq_lengthlist__44p2_p5_0,
+       1, -528744448, 1616642048, 3, 0,
+       (long *)_vq_quantlist__44p2_p5_0,
+       0
+};
+
+static const long _vq_quantlist__44p2_p5_1[] = {
+       3,
+       2,
+       4,
+       1,
+       5,
+       0,
+       6,
+};
+
+static const long _vq_lengthlist__44p2_p5_1[] = {
+        2, 3, 3, 3, 3, 3, 3,
+};
+
+static const static_codebook _44p2_p5_1 = {
+       1, 7,
+       (long *)_vq_lengthlist__44p2_p5_1,
+       1, -533200896, 1611661312, 3, 0,
+       (long *)_vq_quantlist__44p2_p5_1,
+       0
+};
+
+static const long _vq_quantlist__44p2_p6_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p2_p6_0[] = {
+        1, 7, 7, 7, 8, 8, 7, 8, 8, 7, 9, 9,10,11,11, 9,
+        8, 8, 7, 8, 9,11,11,11, 9, 8, 8, 6, 7, 7,10,10,
+       10,10,10,10,10,10,10,14,14,14,12,11,11,10,11,11,
+       15,14,14,13,11,11, 6, 6, 6, 8, 5, 5, 8, 7, 7, 8,
+        7, 7,11,10,10, 9, 7, 7, 9, 7, 7,12,10,10,10, 7,
+        7, 6, 8, 7,12,10,10,12,10,10,11,10,10,15,14,13,
+       13,10,10,11,10,10,16,14,14,14,10,10, 7, 7, 7,12,
+       11,11,12,11,11,11,11,11,16,14,14,13,12,12,11,11,
+       11,17,15,15,14,12,12,10, 9, 9,13,11,11,13,11,11,
+       12,11,11,16,14,13,14,11,11,12,11,11,17,15,14,14,
+       11,11, 7, 8, 8,12,11,11,12,10,10,12,10,10,16,13,
+       14,13,10,10,11,10,10,17,14,14,14,10,10, 7, 7, 7,
+       12,11,11,12,11,11,12,11,11,15,14,15,14,12,12,12,
+       11,11,17,15,15,14,12,12,10,10, 9,13,11,11,13,11,
+       11,13,11,11,16,14,14,14,11,11,13,11,11,16,15,15,
+       15,11,11,
+};
+
+static const static_codebook _44p2_p6_0 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p2_p6_0,
+       1, -527106048, 1620377600, 2, 0,
+       (long *)_vq_quantlist__44p2_p6_0,
+       0
+};
+
+static const long _vq_quantlist__44p2_p6_1[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p2_p6_1[] = {
+        2, 6, 6, 7, 7, 7, 7, 7, 7, 7, 8, 8, 9, 9, 9, 8,
+        7, 7, 8, 8, 8, 9, 9, 9, 9, 8, 8, 6, 7, 7, 9, 8,
+        8, 9, 7, 7, 9, 8, 8,10, 8, 8,10, 8, 8,10, 8, 8,
+       10, 8, 9,10, 8, 8, 7, 6, 6, 8, 6, 6, 9, 6, 6, 9,
+        7, 7,10, 8, 8, 9, 6, 6, 9, 7, 7,10, 9, 8, 9, 7,
+        7, 7, 7, 7,11, 8, 8,11, 9, 9,10, 9, 9,12, 9, 9,
+       12, 8, 8,11, 9, 9,12, 9, 9,12, 8, 8, 8, 7, 7,10,
+        9, 9,10, 9, 9,10, 9, 9,11,10,11,11, 9, 9,11, 9,
+        9,11,11,11,11, 9, 9,10, 8, 8,11, 9, 9,10, 9, 9,
+       11, 9, 9,11,10,10,11, 9, 9,11, 9, 9,12,10,10,11,
+        9, 9, 8, 8, 8,11, 9, 9,12, 9, 9,11, 9, 9,12, 9,
+        9,12, 8, 8,12, 9, 9,12, 9,10,12, 8, 8, 9, 7, 7,
+       11, 9, 9,11,10,10,11, 9, 9,11,11,11,11, 9, 9,11,
+       10,10,12,11,11,11, 9,10,10, 9, 9,11, 9, 9,11,10,
+       10,11,10,10,11,11,11,11, 9, 9,11, 9,10,11,11,11,
+       11, 9, 9,
+};
+
+static const static_codebook _44p2_p6_1 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p2_p6_1,
+       1, -530841600, 1616642048, 2, 0,
+       (long *)_vq_quantlist__44p2_p6_1,
+       0
+};
+
+static const long _vq_quantlist__44p2_p7_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p2_p7_0[] = {
+        1, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9,
+};
+
+static const static_codebook _44p2_p7_0 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p2_p7_0,
+       1, -513979392, 1633504256, 2, 0,
+       (long *)_vq_quantlist__44p2_p7_0,
+       0
+};
+
+static const long _vq_quantlist__44p2_p7_1[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p2_p7_1[] = {
+        1, 9, 9, 6, 9, 9, 5, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9,10,10,10,10,10,10,10,10,10,10,10,10,10,
+       10,10,10,
+};
+
+static const static_codebook _44p2_p7_1 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p2_p7_1,
+       1, -516716544, 1630767104, 2, 0,
+       (long *)_vq_quantlist__44p2_p7_1,
+       0
+};
+
+static const long _vq_quantlist__44p2_p7_2[] = {
+       12,
+       11,
+       13,
+       10,
+       14,
+       9,
+       15,
+       8,
+       16,
+       7,
+       17,
+       6,
+       18,
+       5,
+       19,
+       4,
+       20,
+       3,
+       21,
+       2,
+       22,
+       1,
+       23,
+       0,
+       24,
+};
+
+static const long _vq_lengthlist__44p2_p7_2[] = {
+        1, 3, 2, 5, 4, 7, 7, 8, 8, 9, 9,10,10,11,11,12,
+       12,13,13,14,14,15,15,15,15,
+};
+
+static const static_codebook _44p2_p7_2 = {
+       1, 25,
+       (long *)_vq_lengthlist__44p2_p7_2,
+       1, -518864896, 1620639744, 5, 0,
+       (long *)_vq_quantlist__44p2_p7_2,
+       0
+};
+
+static const long _vq_quantlist__44p2_p7_3[] = {
+       12,
+       11,
+       13,
+       10,
+       14,
+       9,
+       15,
+       8,
+       16,
+       7,
+       17,
+       6,
+       18,
+       5,
+       19,
+       4,
+       20,
+       3,
+       21,
+       2,
+       22,
+       1,
+       23,
+       0,
+       24,
+};
+
+static const long _vq_lengthlist__44p2_p7_3[] = {
+        3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+        5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44p2_p7_3 = {
+       1, 25,
+       (long *)_vq_lengthlist__44p2_p7_3,
+       1, -529006592, 1611661312, 5, 0,
+       (long *)_vq_quantlist__44p2_p7_3,
+       0
+};
+
+static const long _huff_lengthlist__44p2_short[] = {
+        4, 4,12, 9, 8,12,15,17, 4, 2,11, 6, 5, 9,13,15,
+       11, 7, 8, 7, 7,10,14,13, 8, 5, 7, 5, 5, 8,12,12,
+        8, 4, 7, 4, 3, 6,11,12,11, 8, 9, 7, 6, 8,11,12,
+       15,13,14,12, 9, 7,10,13,16,12,17,12, 7, 5, 8,11,
+};
+
+static const static_codebook _huff_book__44p2_short = {
+       2, 64,
+       (long *)_huff_lengthlist__44p2_short,
+       0, 0, 0, 0, 0,
+       NULL,
+       0
+};
+
+static const long _vq_quantlist__44p3_l0_0[] = {
+       6,
+       5,
+       7,
+       4,
+       8,
+       3,
+       9,
+       2,
+       10,
+       1,
+       11,
+       0,
+       12,
+};
+
+static const long _vq_lengthlist__44p3_l0_0[] = {
+        1, 4, 4, 8, 8, 8, 8, 9, 9,10,10,10,10, 4, 6, 5,
+        8, 7, 9, 9, 9, 9,10, 9,11, 9, 4, 5, 6, 7, 8, 9,
+        9, 9, 9, 9,10, 9,10, 8, 9, 8, 9, 8,10, 9,11, 9,
+       12,10,12,10, 8, 8, 9, 8, 9, 9,10, 9,11,10,12,10,
+       12, 9,10,10,11,10,12,11,12,11,12,12,12,12, 9,10,
+       10,11,11,11,11,11,12,12,12,12,12,10,11,11,12,12,
+       12,12,12,12,12,12,12,12,10,11,11,12,12,12,12,12,
+       12,12,12,12,12,11,12,12,12,12,12,13,12,13,12,13,
+       12,12,11,12,12,12,12,12,12,13,12,12,12,12,12,12,
+       12,12,13,13,12,13,12,13,12,13,12,12,12,13,12,13,
+       12,13,12,13,12,13,12,12,12,
+};
+
+static const static_codebook _44p3_l0_0 = {
+       2, 169,
+       (long *)_vq_lengthlist__44p3_l0_0,
+       1, -526516224, 1616117760, 4, 0,
+       (long *)_vq_quantlist__44p3_l0_0,
+       0
+};
+
+static const long _vq_quantlist__44p3_l0_1[] = {
+       2,
+       1,
+       3,
+       0,
+       4,
+};
+
+static const long _vq_lengthlist__44p3_l0_1[] = {
+        3, 4, 4, 5, 5, 4, 4, 5, 5, 5, 4, 5, 4, 5, 5, 5,
+        5, 6, 5, 6, 5, 6, 5, 6, 5,
+};
+
+static const static_codebook _44p3_l0_1 = {
+       2, 25,
+       (long *)_vq_lengthlist__44p3_l0_1,
+       1, -533725184, 1611661312, 3, 0,
+       (long *)_vq_quantlist__44p3_l0_1,
+       0
+};
+
+static const long _vq_quantlist__44p3_l1_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p3_l1_0[] = {
+        1, 4, 4, 4, 4, 4, 4, 4, 4,
+};
+
+static const static_codebook _44p3_l1_0 = {
+       2, 9,
+       (long *)_vq_lengthlist__44p3_l1_0,
+       1, -516716544, 1630767104, 2, 0,
+       (long *)_vq_quantlist__44p3_l1_0,
+       0
+};
+
+static const long _huff_lengthlist__44p3_lfe[] = {
+        1, 3, 2, 3,
+};
+
+static const static_codebook _huff_book__44p3_lfe = {
+       2, 4,
+       (long *)_huff_lengthlist__44p3_lfe,
+       0, 0, 0, 0, 0,
+       NULL,
+       0
+};
+
+static const long _huff_lengthlist__44p3_long[] = {
+        3, 4,13, 9, 9,12,15,17, 4, 2,18, 5, 7,10,14,18,
+       11, 8, 6, 5, 6, 8,11,14, 8, 5, 5, 3, 5, 8,11,13,
+        9, 6, 7, 5, 5, 7, 9,10,11,10, 9, 8, 6, 6, 8,10,
+       14,14,11,11, 9, 8, 9,10,17,17,14,13,10, 9,10,10,
+};
+
+static const static_codebook _huff_book__44p3_long = {
+       2, 64,
+       (long *)_huff_lengthlist__44p3_long,
+       0, 0, 0, 0, 0,
+       NULL,
+       0
+};
+
+static const long _vq_quantlist__44p3_p1_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p3_p1_0[] = {
+        1, 2, 2, 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, 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,
+};
+
+static const static_codebook _44p3_p1_0 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p3_p1_0,
+       1, -535822336, 1611661312, 2, 0,
+       (long *)_vq_quantlist__44p3_p1_0,
+       0
+};
+
+static const long _vq_quantlist__44p3_p2_0[] = {
+       2,
+       1,
+       3,
+       0,
+       4,
+};
+
+static const long _vq_lengthlist__44p3_p2_0[] = {
+        3, 7, 7, 0, 0, 0, 8, 8, 0, 0, 0, 8, 8, 0, 0, 0,
+       11,11, 0, 0, 0, 0, 0, 0, 0, 0,10, 9, 0, 0, 0, 0,
+        0, 0, 0, 0, 9, 9, 0, 0, 0,10,11, 0, 0, 0, 0, 0,
+        0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0,
+        0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0,12,12, 0, 0,
+        0, 0, 0, 0, 0, 0,11,11, 0, 0, 0,12,12, 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, 7, 7,
+        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, 7, 7, 0, 0, 0,
+        5, 5, 0, 0, 0, 7, 7, 0, 0, 0, 9, 9, 0, 0, 0, 0,
+        0, 0, 0, 0, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5,
+        0, 0, 0, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 0,
+        0, 0, 0, 0, 0, 0, 0, 5, 6, 0, 0, 0, 7, 7, 0, 0,
+        0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0,
+        8, 8, 0, 0, 0, 9, 9, 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,11,11, 0, 0, 0, 9, 9, 0,
+        0, 0,10,10, 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0,
+        0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,
+       10,10, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0, 0, 0, 0,
+        0, 0, 0, 0, 9, 9, 0, 0, 0,10,10, 0, 0, 0, 0, 0,
+        0, 0, 0,11,12, 0, 0, 0, 0, 0, 0, 0, 0,11,11, 0,
+        0, 0,12,12, 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, 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, 9, 9, 0, 0, 0, 7, 7, 0, 0, 0, 8, 8, 0, 0,
+        0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0,
+        0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 9, 9, 0, 0, 0, 0,
+        0, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8,
+        0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0,
+        0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,11,11, 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, 5,
+        5, 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, 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, 9, 9, 0, 0, 0, 7, 7,
+        0, 0, 0, 9, 9, 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0,
+        0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 0,
+        0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,
+        0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 9, 9, 0, 0, 0, 0,
+        0, 0, 0, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9,
+        0, 0, 0,10,10, 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, 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, 9, 9, 0, 0, 0, 7, 7, 0, 0, 0, 8, 8, 0,
+        0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0,
+        0, 0, 0, 0, 0, 0, 8, 7, 0, 0, 0, 9, 9, 0, 0, 0,
+        0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 7,
+        7, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0,11,11,
+        0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,10,10, 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,
+        5, 5, 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, 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, 9, 9, 0, 0, 0, 7,
+        7, 0, 0, 0, 9, 9, 0, 0, 0,10,10, 0, 0, 0, 0, 0,
+        0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 0,
+        0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0,
+        0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 9, 9, 0, 0, 0,
+        0, 0, 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 9,
+        9, 0, 0, 0,11,11, 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, 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,10,10, 0, 0, 0, 9, 9, 0, 0, 0,10,10,
+        0, 0, 0,11,12, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0,
+        0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0,11,11, 0, 0,
+        0, 0, 0, 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0,
+        9, 9, 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0,11,
+       11, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,12,12,
+        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, 7, 7, 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, 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,10,10, 0, 0, 0,
+        9, 9, 0, 0, 0,10,10, 0, 0, 0,12,12, 0, 0, 0, 0,
+        0, 0, 0, 0,10,10, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9,
+        0, 0, 0,11,11, 0, 0, 0, 0, 0, 0, 0, 0,10,10, 0,
+        0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0,11,11, 0, 0,
+        0, 0, 0, 0, 0, 0,12,12, 0, 0, 0, 0, 0, 0, 0, 0,
+       10,10, 0, 0, 0,11,11, 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, 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, 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, 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, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0,
+};
+
+static const static_codebook _44p3_p2_0 = {
+       5, 3125,
+       (long *)_vq_lengthlist__44p3_p2_0,
+       1, -533725184, 1611661312, 3, 0,
+       (long *)_vq_quantlist__44p3_p2_0,
+       0
+};
+
+static const long _vq_quantlist__44p3_p3_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p3_p3_0[] = {
+        1, 5, 5, 5, 8, 8, 0, 8, 8, 6, 9, 9, 8,10,10, 0,
+        8, 8, 0, 9, 9, 0,12,12, 0, 8, 8, 4, 7, 7, 6,10,
+       10, 0,12,12, 7,11,11, 9,12,12, 0,12,12, 0,13,13,
+        0,15,15, 0,12,12, 0, 7, 7, 0, 7, 7, 0, 8, 8, 0,
+        8, 8, 0,10,10, 0, 7, 7, 0, 8, 8, 0,11,11, 0, 7,
+        7, 5, 7, 7, 9, 9, 9, 0,11,10, 9, 9, 9,11,12,12,
+        0,10,10, 0,11,11, 0,13,13, 0,11,11, 6, 7, 7, 9,
+       10,10, 0,12,12,10,11,11,11,12,12, 0,12,12, 0,13,
+       13, 0,15,15, 0,12,12, 0,10,10, 0,11,11, 0,11,11,
+        0,12,12, 0,13,13, 0,11,11, 0,12,12, 0,15,15, 0,
+       11,11, 0, 8, 8, 0,10,10, 0,12,12, 0,11,11, 0,12,
+       12, 0,12,12, 0,12,12, 0,15,15, 0,11,11, 0, 7, 7,
+        0,10,10, 0,12,12, 0,10,10, 0,12,13, 0,12,12, 0,
+       13,13, 0,14,14, 0,12,12, 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,
+};
+
+static const static_codebook _44p3_p3_0 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p3_p3_0,
+       1, -533200896, 1614282752, 2, 0,
+       (long *)_vq_quantlist__44p3_p3_0,
+       0
+};
+
+static const long _vq_quantlist__44p3_p3_1[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p3_p3_1[] = {
+        3, 4, 4, 0, 8, 8, 0, 8, 8, 0, 9, 9, 0,10,10, 0,
+        8, 8, 0, 9, 9, 0,10,10, 0, 8, 8, 0, 7, 7, 0, 8,
+        8, 0, 8, 8, 0, 8, 8, 0, 8, 8, 0, 8, 8, 0, 8, 8,
+        0, 8, 8, 0, 8, 8, 0, 7, 7, 0, 6, 6, 0, 7, 7, 0,
+        7, 7, 0,10,10, 0, 6, 6, 0, 7, 7, 0,10,10, 0, 6,
+        5, 0, 8, 8, 0, 7, 7, 0, 8, 8, 0, 8, 8, 0, 9, 9,
+        0, 7, 7, 0, 8, 8, 0, 9, 9, 0, 7, 7, 0, 6, 6, 0,
+        9,10, 0,10,10, 0,10,10, 0,11,11, 0, 9, 9, 0,10,
+       10, 0,11,11, 0, 9, 9, 0, 8, 8, 0, 8, 8, 0, 8, 8,
+        0, 9, 9, 0, 9, 9, 0, 8, 8, 0, 8, 8, 0, 9, 9, 0,
+        7, 7, 0, 8, 8, 0, 7, 7, 0, 7, 7, 0, 8, 8, 0, 9,
+        9, 0, 7, 7, 0, 7, 7, 0, 9, 9, 0, 6, 6, 0, 6, 6,
+        0,10,10, 0,10,10, 0,10,10, 0,12,12, 0, 9, 9, 0,
+       10,10, 0,12,12, 0, 9, 9, 0, 8, 8, 0, 7, 7, 0, 8,
+        8, 0, 8, 8, 0, 9, 9, 0, 7, 7, 0, 8, 8, 0, 9, 9,
+        0, 7, 7,
+};
+
+static const static_codebook _44p3_p3_1 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p3_p3_1,
+       1, -535822336, 1611661312, 2, 0,
+       (long *)_vq_quantlist__44p3_p3_1,
+       0
+};
+
+static const long _vq_quantlist__44p3_p4_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p3_p4_0[] = {
+        1, 6, 6, 7, 7, 7, 7, 7, 7, 7, 8, 8,10,11,11, 9,
+        8, 8, 8, 8, 8,11,11,11,10, 8, 8, 5, 7, 7, 9,11,
+       11,10,11,11,10,11,11,12,13,14,11,12,12,10,11,11,
+       13,14,14,12,12,12, 5, 6, 6, 8, 6, 6, 8, 7, 7, 8,
+        7, 7,11,10,10,10, 7, 7, 9, 7, 7,12,11,11,11, 7,
+        7, 7, 7, 7,11,10,10,12,10,10,11,10,10,15,13,13,
+       13,10,10,12,11,11,15,13,13,14,11,11, 7, 7, 7,11,
+       11,11,12,11,11,12,11,11,14,14,14,14,12,12,12,12,
+       12,16,15,15,14,12,12, 0,10,10, 0,11,11, 0,11,12,
+        0,11,11, 0,14,14, 0,11,11, 0,12,12, 0,15,15, 0,
+       11,11, 8, 8, 8,12,10,10,12,10,10,13,11,11,15,13,
+       13,14,11,11,12,10,10,16,14,14,14,10,10, 8, 7, 7,
+       12,11,11,13,11,11,12,11,11,15,14,14,14,12,12,13,
+       12,12,15,14,14,15,12,12, 0,11,11, 0,12,12, 0,12,
+       12, 0,12,12, 0,15,15, 0,12,12, 0,13,13, 0,14,15,
+        0,12,12,
+};
+
+static const static_codebook _44p3_p4_0 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p3_p4_0,
+       1, -531365888, 1616117760, 2, 0,
+       (long *)_vq_quantlist__44p3_p4_0,
+       0
+};
+
+static const long _vq_quantlist__44p3_p4_1[] = {
+       2,
+       1,
+       3,
+       0,
+       4,
+};
+
+static const long _vq_lengthlist__44p3_p4_1[] = {
+        3, 4, 5, 8, 8,12,10,10,12,12,12,10,10,12,12,13,
+       11,11,12,12,13,12,12,12,12,13,10,10,13,13,13,13,
+       13,13,13,13,10,10,13,13,13,11,11,13,13,14,13,13,
+       12,12,13,10,10,13,13,13,13,13,13,13,13,10,10,12,
+       12,13,11,11,13,13,13,13,13,12,12,13,12,12,13,13,
+       13,13,13,13,13,14,11,11,12,12,14,12,12,13,12,14,
+       14,14,12,12,13,14,14,13,13,14,13,13,13,13,14,14,
+       14,12,12,14,13,13,13,13,14,14,14,12,12,12, 8, 8,
+       11,11,12,12,12,11,11,12,11,11,10,10,13,12,12,10,
+       10,13,12,12,10,10,13,12,12,12,12,14,12,12,12,12,
+       13,13,13,11,11,14,12,12,11,11,14,12,12,12,12,14,
+       12,12,12,12,13,12,12,12,12,13,13,13,11,11,14,12,
+       12,11,11,14,12,12,12,12,14,13,13,12,12,14,12,12,
+       12,11,14,13,13,11,11,14,13,12,11,11,14,13,13,11,
+       11,14,13,13,12,12,14,12,12,12,12,15,13,13,12,12,
+       14,12,12,11,11,14,13,13,11,11,12, 9, 9,10,10,12,
+        7, 7,11,11,12, 9, 9,12,12,13,10,10,10,10,14,14,
+       14,11,11,13, 9, 9,12,12,14,14,14,12,12,13, 8, 8,
+       11,11,14, 9, 9,12,12,14,14,14,11,11,13, 9, 9,12,
+       12,14,14,14,12,12,14, 8, 8,11,11,14, 9, 9,12,12,
+       14,14,14,11,11,14,10,10,12,12,14,14,14,13,13,14,
+        9, 9,11,11,14,10,10,12,12,14,14,14,11,11,14,14,
+       15,12,12,15,14,14,14,14,15,14,14,11,11,14,14,14,
+       12,12,14,14,14,11,11,14,11,11,10,10,14,10,10,10,
+       10,14,10,10,10,10,15,11,11, 9, 9,14,12,12, 9, 9,
+       15,11,11,11,11,15,13,13,11,11,15,10,10,10,10,15,
+       11,11,10,10,15,13,13,11,11,15,11,11,11,11,15,13,
+       13,11,11,15,10,10,10,10,15,11,11,10,10,15,13,13,
+       11,11,15,12,12,11,11,15,13,13,11,11,15,11,11,10,
+       10,15,12,12,10,10,15,13,13,10,10,15,14,14,11,11,
+       15,13,13,11,11,15,14,14,10,11,15,13,13,10,10,15,
+       13,14,10,10,14,13,13,10,10,14,13,13,10,10,14,13,
+       13,10,10,14,13,13, 9, 9,14,14,14, 9, 9,15,14,14,
+       11,11,15,14,14,10,10,15,14,14,10,10,15,14,14,11,
+       11,15,14,14,10,10,15,14,14,11,11,15,14,14,10,10,
+       14,14,14,10,10,15,14,14,10,10,14,14,14,10,10,15,
+       14,14,11,11,15,14,14,11,11,14,14,14,10,10,15,14,
+       14,10,10,14,14,14, 9, 9,15,15,15,11,11,15,14,14,
+       12,12,15,15,14,10,10,15,14,14,10,10,14,15,15, 9,
+        9,14,10,10,12,12,17, 9, 9,12,12,17,10,10,13,13,
+       17,11,11,12,12,18,14,14,12,12,17,10,10,13,13,17,
+       14,14,12,12,17, 9, 9,12,12,17,11,11,12,12,17,14,
+       14,12,12,18,10,10,13,13,18,14,14,13,13,18, 9, 9,
+       12,12,18,10,10,13,13,18,14,14,12,12,18,11,11,13,
+       13,18,14,14,13,13,18,10,10,12,12,17,11,11,12,12,
+       17,14,14,12,12,18,15,15,13,13,18,14,14,14,14,18,
+       15,15,12,12,18,14,14,12,12,18,15,15,12,12,13, 7,
+        7,11,11,14,15,15,11,11,14,15,15,12,12,14,15,15,
+       11,11,15,15,15,11,11,14,15,15,12,12,14,15,15,12,
+       12,14,15,15,11,11,14,15,15,11,11,15,15,15,12,12,
+       14,15,15,12,12,14,15,15,12,12,14,15,15,11,11,14,
+       15,15,11,11,15,15,15,12,12,15,15,15,12,12,14,15,
+       15,12,12,14,15,14,12,12,14,15,15,11,11,15,14,14,
+       12,12,15,15,15,12,12,15,16,16,12,12,15,15,15,12,
+       12,15,15,15,12,12,15,15,15,12,12,13,13,13,11,10,
+       14,14,15,11,11,14,14,14,12,12,15,14,14,10,10,15,
+       15,15,11,11,14,15,15,12,12,14,14,14,11,11,14,15,
+       15,11,11,14,15,15,12,12,15,15,15,11,11,14,15,15,
+       12,12,14,14,14,12,12,14,15,15,11,11,14,15,15,12,
+       12,15,15,15,11,11,15,15,15,12,12,15,14,14,12,12,
+       14,15,15,11,11,14,15,15,11,11,15,15,15,10,10,15,
+       15,16,12,12,15,15,15,14,14,15,15,15,11,11,15,15,
+       15,12,12,15,15,15,11,11,14,11,11,10,10,15, 9, 9,
+       12,12,15,10,10,12,12,15,11,11,11,11,15,14,14,12,
+       12,15,10,10,13,13,15,14,14,12,12,15, 9, 9,12,12,
+       15,10,10,13,13,15,13,13,12,11,15,10,10,12,12,15,
+       14,14,12,12,15, 9, 9,11,11,15,11,11,12,12,15,13,
+       13,11,11,15,11,11,13,13,15,13,14,13,14,15,11,11,
+       11,11,15,11,11,12,12,15,14,14,11,11,15,14,14,13,
+       13,15,14,14,20,20,15,14,14,12,12,15,14,14,12,12,
+       15,14,14,11,11,14,13,13,10,10,14,13,13,12,12,14,
+       14,13,12,12,15,14,14,12,12,15,14,14,11,11,15,14,
+       14,12,12,15,14,14,13,13,15,14,14,12,11,15,14,14,
+       11,11,15,14,14,13,13,15,14,14,12,12,15,14,14,13,
+       13,15,14,14,12,11,15,14,14,12,12,15,14,14,13,13,
+       15,14,14,13,13,15,14,14,12,12,15,14,14,12,12,15,
+       14,14,12,12,15,15,15,13,13,15,15,15,13,13,15,14,
+       14,13,13,15,15,15,13,13,15,14,15,12,12,15,15,15,
+       13,13,14,10,10,12,13,17, 9, 9,12,12,17,10,10,13,
+       13,17,11,11,12,12,18,14,14,12,12,18,10,10,13,13,
+       18,14,14,12,12,17, 9, 9,12,12,18,10,11,13,13,18,
+       14,14,12,12,17,10,10,12,12,17,14,14,12,12,17, 9,
+        9,12,12,17,11,11,12,12,17,14,14,12,12,18,11,11,
+       12,12,18,14,14,13,13,18,11,11,12,12,18,11,11,12,
+       12,18,14,14,12,12,18,15,15,12,12,18,14,14,13,13,
+       18,15,15,12,12,17,14,14,12,12,17,15,15,12,12,13,
+        7, 7,11,11,14,15,15,11,11,14,15,15,11,11,14,15,
+       14,12,12,15,15,15,12,11,14,15,15,12,12,14,15,15,
+       12,12,14,15,15,11,11,14,15,15,11,11,15,15,15,13,
+       13,14,15,15,11,11,14,15,15,13,12,14,15,15,11,11,
+       14,15,15,11,11,15,15,15,13,13,14,15,15,12,12,15,
+       15,15,12,12,15,15,15,11,11,15,15,15,11,11,15,15,
+       15,12,12,15,15,15,13,13,15,16,16,12,12,15,15,15,
+       12,13,15,15,15,12,12,15,15,15,12,12,13,13,13,11,
+       11,14,14,14,11,11,14,14,14,12,12,14,14,14,10,10,
+       15,14,14,11,11,14,15,15,12,12,14,14,14,12,12,14,
+       15,15,11,11,14,15,14,12,12,15,14,14,11,11,14,15,
+       15,12,12,14,14,14,11,11,14,15,15,11,11,14,14,14,
+       12,12,15,15,14,11,11,15,15,15,12,12,15,14,14,12,
+       12,14,15,15,11,11,14,15,14,11,11,15,15,15,10,10,
+       15,15,15,12,12,15,14,14,14,13,15,15,15,11,11,15,
+       15,15,11,11,15,15,15,10,10,14,11,11,10,10,15, 9,
+        9,12,12,15,10,10,12,12,15,11,11,11,11,15,14,14,
+       12,12,15,10,10,13,13,15,13,13,12,12,15, 9, 9,12,
+       12,15,11,11,13,13,15,14,14,12,12,15,10,10,13,13,
+       15,13,14,12,12,15, 9, 9,12,12,15,10,10,13,13,15,
+       13,13,11,11,15,11,11,13,13,15,14,14,13,13,15,10,
+       10,11,11,15,11,11,12,12,15,14,14,11,11,15,14,14,
+       13,13,15,14,14,21,20,15,14,14,11,11,15,14,14,12,
+       12,15,14,14,11,11,14,13,13,10,10,14,13,13,11,11,
+       15,14,14,12,12,15,14,14,12,12,14,14,14,12,12,15,
+       14,14,12,12,15,14,14,13,13,14,14,14,11,11,15,14,
+       14,11,11,15,14,14,13,13,15,14,14,12,12,15,14,14,
+       13,13,14,14,14,11,11,15,14,14,11,11,14,14,14,13,
+       13,15,14,14,12,12,15,14,14,12,12,15,14,14,12,12,
+       15,14,14,12,12,14,14,14,13,13,15,15,15,13,13,16,
+       14,14,12,13,15,15,15,13,13,15,14,14,12,12,15,15,
+       15,13,13,15,11,11,13,12,18,10,10,12,12,17,11,11,
+       12,12,18,12,12,11,11,18,14,14,12,12,18,11,11,13,
+       13,17,14,14,12,12,18,10,10,12,12,18,12,12,12,12,
+       18,14,15,12,12,18,11,11,13,13,18,14,14,12,12,17,
+       10,10,12,12,18,11,11,12,12,18,15,14,12,12,17,12,
+       12,12,12,17,14,14,12,12,17,11,11,11,11,17,12,12,
+       12,11,17,15,15,11,11,18,15,15,12,12,18,14,15,13,
+       13,18,15,15,11,11,17,15,15,12,12,18,15,15,11,11,
+       14, 9, 9,11,11,14,15,15,11,11,15,15,15,11,11,15,
+       15,15,12,11,15,15,15,12,12,15,15,15,11,11,15,15,
+       15,13,13,14,15,15,11,11,15,15,15,11,11,15,15,15,
+       13,13,15,15,15,11,11,15,15,15,13,13,15,15,15,11,
+       11,15,15,15,11,11,15,15,15,13,13,15,15,15,12,12,
+       15,15,15,13,13,15,15,14,11,11,15,15,15,12,12,15,
+       15,15,12,12,16,15,15,13,13,15,16,16,13,13,16,15,
+       15,12,12,15,15,15,13,12,15,15,15,12,12,13,12,12,
+       11,11,14,14,14,11,11,14,14,14,12,12,15,14,14,11,
+       11,15,14,14,12,12,15,14,14,12,12,15,14,14,12,12,
+       14,15,15,11,11,15,14,14,12,12,15,14,14,11,11,15,
+       14,14,12,12,15,14,14,12,12,14,15,15,11,11,15,14,
+       14,12,12,15,14,14,11,11,15,15,15,12,12,15,14,14,
+       12,12,15,15,15,11,11,15,14,14,11,11,15,14,15,11,
+       11,15,15,15,12,12,15,14,14,13,13,16,15,15,11,11,
+       15,14,14,12,12,15,15,15,11,11,14,11,11, 9, 9,15,
+       10,10,12,12,14,11,11,12,12,15,12,12,12,12,15,14,
+       14,13,13,15,11,11,13,13,15,14,14,13,13,15,10,10,
+       12,12,15,12,12,13,13,15,14,14,13,13,15,11,11,12,
+       12,15,14,14,13,13,14,10,10,12,12,15,12,12,13,13,
+       15,14,14,12,12,15,12,12,13,13,15,14,14,15,15,15,
+       11,11,12,12,15,12,12,12,13,15,14,14,12,12,15,15,
+       15,14,14,15,14,14,20,20,15,14,14,12,12,15,14,14,
+       13,13,15,14,14,12,12,14,13,13,10,10,14,13,13,11,
+       11,14,13,13,12,12,14,14,14,12,12,15,14,14,13,13,
+       15,14,14,12,12,14,14,14,14,14,14,14,14,11,11,15,
+       14,14,12,12,15,14,14,14,14,15,14,14,12,12,14,14,
+       14,14,14,14,14,14,11,11,15,14,14,12,12,14,14,14,
+       14,14,15,14,14,12,12,15,14,14,13,13,15,14,14,12,
+       12,15,14,14,12,12,14,14,14,14,13,15,15,15,14,14,
+       15,14,14,13,13,15,15,15,14,14,15,14,14,13,13,15,
+       15,15,13,13,14,13,13,13,13,18,15,15,12,12,18,15,
+       15,13,12,18,15,16,11,11,18,16,17,12,12,18,15,15,
+       13,13,18,17,17,12,12,18,15,15,12,12,17,15,15,12,
+       12,18,17,17,12,12,18,15,15,13,13,18,16,17,12,12,
+       17,15,15,12,12,18,15,15,12,12,18,16,17,11,12,18,
+       16,16,12,12,17,16,17,12,12,18,15,15,11,11,18,15,
+       15,12,12,18,17,17,11,11,17,17,17,12,12,18,16,16,
+       13,13,18,17,17,11,11,18,16,16,12,12,18,17,17,11,
+       11,15,14,14,11,11,16,15,15,11,11,16,15,15,12,12,
+       16,15,15,12,12,17,15,15,14,13,16,15,15,12,12,17,
+       15,15,14,14,16,15,15,11,11,16,15,15,12,12,18,15,
+       15,13,13,16,15,15,11,11,17,15,15,14,14,16,15,15,
+       11,11,16,15,15,12,12,17,15,15,13,13,16,15,15,12,
+       12,17,16,15,14,14,16,14,15,12,12,16,15,15,12,12,
+       18,15,15,13,13,17,15,15,14,14,17,16,16,15,15,17,
+       15,15,13,13,17,15,15,14,14,18,15,15,13,13,15,12,
+       13,11,11,15,14,14,12,12,16,14,14,12,12,16,14,14,
+       12,12,16,14,14,12,12,16,14,14,13,12,17,14,14,13,
+       13,16,15,15,12,12,16,14,14,12,12,17,14,14,12,12,
+       16,14,14,12,12,17,14,14,13,13,15,15,15,12,12,16,
+       14,14,12,12,17,14,14,12,12,17,15,15,12,12,17,14,
+       14,13,13,16,15,15,12,12,16,14,14,12,12,17,15,15,
+       12,12,18,15,15,13,13,17,14,14,13,13,17,15,15,12,
+       12,17,14,14,12,12,17,15,15,12,12,14,15,15, 9, 9,
+       15,15,15,12,12,15,15,15,13,13,15,15,15,14,14,15,
+       15,15,19,19,15,15,16,13,13,15,15,16,19,20,15,15,
+       15,13,12,15,16,16,14,14,15,15,15,19,19,15,15,15,
+       13,13,15,16,15,20,19,14,15,15,13,13,15,15,15,14,
+       14,15,15,15,19,19,15,15,15,14,14,15,16,16,19,20,
+       15,15,15,14,14,15,15,15,14,14,15,15,15,19,19,15,
+       15,15,20,19,15,16,16,20,19,15,15,15,19,19,15,16,
+       16,20,20,15,15,15,19,20,14,13,13,10,10,14,14,14,
+       11,11,14,14,14,12,12,15,14,14,13,13,15,14,14,19,
+       20,15,14,14,12,12,14,14,14,20,19,14,14,14,11,11,
+       15,14,14,12,12,15,14,14,20,20,15,14,14,12,12,14,
+       14,14,20,19,14,14,14,11,11,15,14,14,12,12,15,14,
+       14,19,20,15,14,14,13,13,15,14,14,22,19,15,15,14,
+       12,12,15,14,14,13,13,14,15,15,22,20,15,15,15,20,
+       20,15,14,14,21,20,15,15,15,20,21,15,14,14,20,20,
+       14,15,15,20,20,
+};
+
+static const static_codebook _44p3_p4_1 = {
+       5, 3125,
+       (long *)_vq_lengthlist__44p3_p4_1,
+       1, -533725184, 1611661312, 3, 0,
+       (long *)_vq_quantlist__44p3_p4_1,
+       0
+};
+
+static const long _vq_quantlist__44p3_p5_0[] = {
+       2,
+       1,
+       3,
+       0,
+       4,
+};
+
+static const long _vq_lengthlist__44p3_p5_0[] = {
+        2, 6, 6,14,14, 6, 7, 7,14,14, 7, 7, 7,15,15, 0,
+       12,12,15,15, 0,13,13,15,15, 7, 8, 8,15,15,10,10,
+       10,16,16, 9, 8, 8,15,15, 0,13,13,18,17, 0,13,13,
+       16,16, 8, 8, 8,15,15,12,11,11,16,16, 9, 8, 8,15,
+       15, 0,13,13,18,18, 0,13,13,16,16, 0,14,14,17,17,
+        0,20, 0,19,20, 0,12,12,16,16, 0,16,16,20,22, 0,
+       14,14,16,16, 0,14,14,17,17, 0,20,22,20,19, 0,13,
+       13,15,16, 0,17,18, 0,21, 0,15,15,16,16, 5, 7, 7,
+       13,13, 8, 9, 9,14,14,10,10,10,14,14, 0,20,22,18,
+       18, 0,22,21,18,17, 9,10,10,14,14,12,12,12,17,17,
+       12,10,10,14,14, 0, 0,20,17,17, 0,22,21,17,18,11,
+       10,10,14,14,14,13,13,18,18,12,11,11,14,14, 0,22,
+       21,18,19, 0,20, 0,17,17, 0,22, 0,18,18, 0, 0, 0,
+        0, 0, 0,20,20,17,17, 0,22, 0,22,21, 0,21, 0,19,
+       18, 0,22,22,18,18, 0, 0, 0, 0, 0, 0,21, 0,17,17,
+        0,22, 0,20,20, 0, 0, 0,19,18, 6, 6, 6,12,12, 8,
+        6, 6,10,10, 8, 6, 6,13,12, 0,10,10,11,11, 0,11,
+       11,13,13, 8, 7, 7,13,13,11, 9, 9,13,13,10, 6, 6,
+       12,12, 0,10,10,14,14, 0,10,10,13,13, 9, 7, 7,13,
+       13,12,10,10,13,13,10, 6, 6,12,12, 0,11,11,15,15,
+        0,10,10,13,13, 0,12,12,15,14, 0,19,20,16,17, 0,
+        9, 9,13,13, 0,14,14,20,21, 0,12,11,13,12, 0,12,
+       12,15,14, 0,20,19,17,17, 0,10,10,12,13, 0,15,15,
+       22,21, 0,12,12,12,13, 0,10,10,12,12, 0,11,11,15,
+       15, 0,11,11,15,15, 0,15,15,22,22, 0,16,17, 0, 0,
+        0,11,11,15,15, 0,14,14,18,18, 0,11,11,16,16, 0,
+       16,15, 0,21, 0,16,16, 0, 0, 0,12,12,15,15, 0,14,
+       14,19,19, 0,11,11,15,15, 0,15,15,22, 0, 0,16,16,
+       22, 0, 0,16,16, 0,21, 0, 0, 0, 0, 0, 0,15,15,19,
+       20, 0,18,18, 0, 0, 0,17,17, 0, 0, 0,17,17, 0, 0,
+        0, 0, 0, 0, 0, 0,16,15,22,21, 0,20,20, 0, 0, 0,
+       18,18, 0, 0, 0,10,10,12,12, 0,10,10,11,11, 0,11,
+       11,12,12, 0,11,11, 9, 9, 0,13,12,12,12, 0,11,11,
+       13,13, 0,13,13,12,12, 0,10,10,12,12, 0,13,12,13,
+       13, 0,12,12,12,12, 0,11,11,13,13, 0,13,13,12,12,
+        0,10,10,12,12, 0,13,13,14,13, 0,12,12,12,12, 0,
+       14,13,13,14, 0,20,21,15,15, 0,11,11,12,12, 0,15,
+       16,20,20, 0,12,13,10,10, 0,13,13,14,13, 0,20,20,
+       15,15, 0,11,11,12,12, 0,16,17,21,21, 0,13,13,11,
+       11, 6, 7, 7,16,15,11, 9, 9,14,15,12, 9, 9,16,16,
+        0,13,13,15,15, 0,14,14,17,17,10, 9, 9,16,16,14,
+       12,12,16,16,12, 9, 9,15,15, 0,13,13,17,18, 0,13,
+       13,15,15,12,10,10,17,17,15,12,12,17,17,13, 9, 9,
+       16,16, 0,13,13,18,19, 0,14,14,16,16, 0,15,15,18,
+       18, 0, 0, 0,20,19, 0,12,12,17,16, 0,16,17, 0,21,
+        0,14,15,16,16, 0,15,15,18,18, 0, 0,22,19,21, 0,
+       13,13,16,16, 0,18,17,22,22, 0,15,15,16,16, 7, 7,
+        7,13,13,11,10,10,15,15,12,10,10,14,14, 0,21, 0,
+       18,17, 0,21,22,18,18,11,10,10,15,15,14,12,12,17,
+       17,14,11,11,14,14, 0,21,20,18,18, 0,22,21,18,17,
+       12,11,10,16,16,16,14,14,17,19,14,11,11,15,15, 0,
+        0,22,19,19, 0,21,22,18,18, 0,21, 0,18,19, 0, 0,
+        0,22, 0, 0,22,21,17,17, 0, 0, 0,20,22, 0, 0,21,
+       18,18, 0, 0, 0,19,20, 0, 0, 0, 0, 0, 0, 0,21,17,
+       17, 0, 0, 0,22,21, 0, 0, 0,19,19,10, 9, 9,14,13,
+       13,10,10,12,12,13,10,10,14,14, 0,13,13,12,12, 0,
+       15,14,16,15,13,10,10,14,14,15,12,12,14,14,15,10,
+       10,14,14, 0,14,14,15,15, 0,14,13,14,14,13,10,10,
+       15,15,17,13,13,15,15,14,10,10,14,14, 0,14,14,15,
+       16, 0,14,14,15,15, 0,15,15,16,16, 0,21,22,17,18,
+        0,12,12,14,14, 0,17,17,20,21, 0,14,14,14,14, 0,
+       15,15,16,16, 0,21,22,18,18, 0,13,13,14,14, 0,18,
+       18,22, 0, 0,15,15,14,14, 0,11,11,13,13, 0,12,12,
+       16,15, 0,12,12,16,16, 0,16,16, 0, 0, 0,16,17, 0,
+       22, 0,12,12,16,16, 0,14,14,17,18, 0,11,11,16,16,
+        0,15,15, 0,21, 0,16,16,21,22, 0,12,12,16,16, 0,
+       15,15,19,19, 0,12,12,17,16, 0,16,16,21,22, 0,16,
+       16, 0, 0, 0,17,17, 0,22, 0, 0, 0, 0, 0, 0,15,15,
+       19,20, 0,17,19, 0, 0, 0,17,17,22, 0, 0,17,17, 0,
+       22, 0, 0, 0, 0, 0, 0,15,15,21, 0, 0,19,20, 0, 0,
+        0,19,18,22, 0, 0,11,12,14,14, 0,11,11,14,14, 0,
+       12,12,15,15, 0,13,13,13,13, 0,14,14,16,16, 0,12,
+       12,15,15, 0,14,14,16,15, 0,11,11,15,15, 0,13,13,
+       16,16, 0,13,13,15,15, 0,12,12,15,15, 0,15,14,16,
+       16, 0,11,11,15,15, 0,14,14,17,17, 0,13,13,15,15,
+        0,15,15,16,16, 0, 0, 0,18,18, 0,12,12,14,14, 0,
+       16,16,22, 0, 0,14,14,15,15, 0,15,15,16,17, 0,21,
+       22,18,18, 0,13,13,15,14, 0,18,17,22, 0, 0,14,14,
+       15,15, 8, 8, 8,16,15,12,10,10,16,15,12,10,10,16,
+       16, 0,14,14,16,17, 0,14,14,17,16,12,10,10,17,18,
+       14,12,12,18,18,14,10,10,16,16, 0,14,14,18,18, 0,
+       14,14,16,16,12, 9, 9,16,16,17,13,13,16,17,14, 9,
+        9,15,15, 0,14,14,18,19, 0,13,13,15,15, 0,15,15,
+       18,19, 0, 0, 0,22,21, 0,13,13,16,16, 0,16,16,22,
+        0, 0,15,15,16,16, 0,14,14,18,17, 0, 0, 0,20, 0,
+        0,13,13,16,16, 0,18,18, 0, 0, 0,15,15,16,16, 8,
+        7, 7,13,13,12,10,10,15,15,12,10,10,14,14, 0,22,
+       22,19,18, 0, 0, 0,18,18,12,10,10,15,15,14,13,13,
+       17,17,14,11,11,15,15, 0,19,20,18,18, 0,22,21,17,
+       18,13,11,11,15,15,16,13,13,18,18,14,11,11,14,15,
+        0,22,21,20,19, 0,22,21,17,17, 0, 0,22,19,18, 0,
+        0, 0, 0, 0, 0,22,20,17,17, 0, 0, 0,21,20, 0, 0,
+        0,19,17, 0, 0,22,19,19, 0, 0, 0, 0, 0, 0,22,20,
+       18,17, 0, 0, 0, 0, 0, 0, 0, 0,18,18, 0,10,10,14,
+       14, 0,11,11,14,14, 0,11,11,15,15, 0,14,14,14,14,
+        0,15,15,16,16, 0,11,11,16,16, 0,13,13,16,16, 0,
+       11,11,15,15, 0,14,14,16,16, 0,14,14,15,15, 0,11,
+       11,15,15, 0,13,13,15,15, 0,10,10,15,15, 0,15,15,
+       17,17, 0,14,14,14,14, 0,16,16,16,16, 0, 0,22,19,
+       19, 0,13,13,14,14, 0,17,17, 0, 0, 0,15,15,14,14,
+        0,16,16,17,17, 0, 0,22,18,18, 0,13,13,14,14, 0,
+       21,18, 0, 0, 0,15,15,14,14, 0,11,11,13,13, 0,12,
+       12,15,15, 0,12,12,16,15, 0,16,16, 0, 0, 0,17,17,
+       22,22, 0,12,12,16,16, 0,14,14,18,18, 0,11,12,16,
+       16, 0,15,16, 0,21, 0,16,16,22,21, 0,12,12,16,16,
+        0,15,15,19,20, 0,11,12,16,16, 0,15,15,20,22, 0,
+       16,16, 0,22, 0,17,17,22, 0, 0, 0, 0, 0, 0, 0,15,
+       15,21,22, 0,19,18, 0, 0, 0,17,17, 0, 0, 0,17,17,
+        0,22, 0, 0, 0, 0, 0, 0,16,15,22, 0, 0,19,19, 0,
+        0, 0,17,18, 0, 0, 0,12,12,15,15, 0,12,12,15,15,
+        0,12,12,15,15, 0,13,13,14,14, 0,15,15,16,17, 0,
+       12,12,16,16, 0,14,14,16,16, 0,12,11,15,16, 0,14,
+       14,16,17, 0,14,14,16,16, 0,13,12,16,16, 0,15,15,
+       16,16, 0,11,11,15,15, 0,14,14,16,16, 0,14,14,15,
+       15, 0,15,15,18,17, 0, 0,22, 0,20, 0,13,13,15,15,
+        0,16,17,22,22, 0,14,14,15,15, 0,15,15,17,18, 0,
+       20, 0,19,19, 0,13,13,15,15, 0,18,18,22, 0, 0,14,
+       14,15,15, 0,11,11,16,16, 0,14,14,17,16, 0,13,13,
+       17,17, 0,16,16,17,17, 0,17,17,18,19, 0,12,12,16,
+       17, 0,15,15,18,18, 0,12,12,16,16, 0,16,16,19,18,
+        0,16,16,17,16, 0,12,13,17,17, 0,17,16,18,17, 0,
+       13,12,16,16, 0,16,16,18,19, 0,16,16,16,17, 0,16,
+       16,18,18, 0,22, 0,22,22, 0,13,13,16,16, 0,19,18,
+       22,20, 0,16,15,16,16, 0,16,17,18,18, 0, 0, 0,22,
+       20, 0,14,14,16,16, 0,19,19, 0, 0, 0,16,16,16,16,
+        0, 9, 9,13,13, 0,13,13,15,15, 0,14,14,15,15, 0,
+        0,22,17,18, 0,22, 0,18,19, 0,12,12,15,15, 0,15,
+       16,17,17, 0,14,14,14,14, 0,22, 0,18,18, 0,21,22,
+       17,17, 0,13,13,15,15, 0,17,17,17,18, 0,14,14,15,
+       15, 0,22,21,21,19, 0,20,21,17,17, 0,21,21,19,18,
+        0, 0, 0, 0, 0, 0,21,21,17,17, 0, 0, 0,22,22, 0,
+        0,22,19,18, 0, 0,21,19,18, 0, 0, 0, 0,22, 0,19,
+       20,17,17, 0, 0, 0, 0,22, 0, 0, 0,19,18, 0,19,19,
+       15,16, 0,21,19,16,17, 0, 0,21,17,17, 0, 0,22,17,
+       17, 0,22,22,18,19, 0,20,20,16,16, 0, 0,22,18,18,
+        0,20,19,16,17, 0,22,21,20,19, 0, 0,21,17,17, 0,
+       21,20,17,17, 0, 0, 0,18,18, 0,19,19,17,16, 0,22,
+        0,19,19, 0,21,22,17,18, 0, 0,22,19,18, 0, 0, 0,
+       19,20, 0,19,19,16,16, 0,22,22,22, 0, 0,20,22,16,
+       16, 0,22,20,18,19, 0, 0, 0,20,19, 0,20,20,16,16,
+        0, 0, 0, 0, 0, 0,22,20,17,16, 0,11,11,13,13, 0,
+       14,13,15,15, 0,13,13,16,15, 0,18,17,21, 0, 0,18,
+       18,21, 0, 0,12,12,15,15, 0,15,16,17,18, 0,12,12,
+       15,15, 0,17,17,22,20, 0,17,18,22, 0, 0,12,12,17,
+       16, 0,16,17,19,19, 0,13,13,16,16, 0,17,17, 0,22,
+        0,17,17, 0,21, 0,18,18,20,22, 0, 0, 0, 0, 0, 0,
+       15,15,21,20, 0,20,19, 0, 0, 0,18,18,22, 0, 0,17,
+       17,22, 0, 0, 0, 0, 0, 0, 0,15,16,20,22, 0,20,21,
+        0, 0, 0,19,18, 0, 0, 0,15,15,19,19, 0,17,16,20,
+       20, 0,16,17,20,21, 0,18,17, 0, 0, 0,19,19, 0, 0,
+        0,15,15,21,19, 0,19,19, 0, 0, 0,15,15,22,22, 0,
+       18,18, 0,22, 0,17,18,22,21, 0,15,15,20,19, 0,19,
+       19, 0, 0, 0,15,15,20,22, 0,18,19,20, 0, 0,18,17,
+       21,21, 0,18,18,19,22, 0, 0, 0, 0, 0, 0,15,15,20,
+       19, 0,19,19, 0, 0, 0,18,18,21,22, 0,18,18,22, 0,
+        0, 0, 0, 0, 0, 0,15,15,19,20, 0,21,21, 0, 0, 0,
+       17,17,20,20, 0,12,12,17,17, 0,14,14,16,17, 0,13,
+       14,17,17, 0,16,16,17,17, 0,17,17,17,19, 0,13,13,
+       17,17, 0,16,16,18,18, 0,13,13,16,16, 0,16,16,18,
+       18, 0,16,16,17,17, 0,13,13,17,17, 0,17,17,18,17,
+        0,12,12,15,16, 0,17,18,19,20, 0,16,16,16,16, 0,
+       17,16,18,19, 0, 0,22,21,22, 0,14,14,16,16, 0,19,
+       19, 0, 0, 0,16,16,16,16, 0,16,16,18,17, 0, 0,22,
+       21,21, 0,14,14,16,16, 0,22,20,22, 0, 0,16,16,15,
+       15, 0, 9, 9,13,13, 0,14,14,15,15, 0,14,14,14,14,
+        0,22,22,18,18, 0, 0,22,18,18, 0,12,12,15,15, 0,
+       16,16,18,17, 0,14,14,14,14, 0,20,21,18,18, 0,22,
+       21,17,17, 0,13,13,15,15, 0,17,17,18,18, 0,14,14,
+       14,14, 0, 0,21,18,19, 0, 0,22,17,17, 0,22,22,19,
+       18, 0, 0, 0, 0, 0, 0,19,21,17,17, 0, 0, 0,22,20,
+        0, 0,21,18,19, 0, 0,22,18,18, 0, 0, 0, 0,22, 0,
+       20,22,17,17, 0, 0, 0,20,22, 0, 0, 0,18,18, 0,19,
+       21,16,16, 0,20,22,16,17, 0,20, 0,17,17, 0,22, 0,
+       18,17, 0,21, 0,18,19, 0,20,20,17,17, 0,22, 0,18,
+       18, 0,21,20,17,17, 0, 0,20,20,19, 0, 0,21,18,17,
+        0,21,21,17,17, 0,22, 0,18,17, 0,19,19,17,17, 0,
+        0,22,20,21, 0, 0,21,17,17, 0,22, 0,18,18, 0, 0,
+        0,20,22, 0,20,19,16,16, 0, 0, 0, 0, 0, 0,22,22,
+       17,17, 0,22, 0,18,19, 0, 0, 0,21,20, 0,19,21,16,
+       17, 0, 0, 0, 0, 0, 0,22,22,17,16, 0,11,11,13,13,
+        0,13,13,15,15, 0,13,13,15,15, 0,17,17,22,21, 0,
+       18,18,22, 0, 0,12,13,16,15, 0,15,16,18,18, 0,13,
+       13,16,16, 0,17,17, 0,22, 0,17,17,22,22, 0,13,13,
+       16,16, 0,16,16,19,18, 0,13,13,16,16, 0,18,17, 0,
+       20, 0,18,17,20, 0, 0,17,17,21, 0, 0, 0, 0, 0, 0,
+        0,15,15,21,22, 0,19,20, 0, 0, 0,18,18, 0, 0, 0,
+       18,17, 0, 0, 0, 0, 0, 0, 0, 0,16,16,22,22, 0,20,
+       20, 0, 0, 0,21,19, 0, 0, 0,15,15,20,19, 0,16,16,
+       22,20, 0,17,17, 0,22, 0,18,18, 0,22, 0,19,17, 0,
+        0, 0,15,16,22,20, 0,18,19, 0, 0, 0,16,16,22,20,
+        0,18,18, 0,22, 0,18,18,22, 0, 0,16,16,21,20, 0,
+       19,20, 0,22, 0,16,16, 0,22, 0,18,18, 0,22, 0,18,
+       18, 0,21, 0,19,18, 0,22, 0, 0, 0, 0, 0, 0,16,16,
+       21,20, 0,20, 0, 0, 0, 0,18,18,21, 0, 0,18,18, 0,
+        0, 0, 0, 0, 0, 0, 0,16,16,21,19, 0, 0, 0, 0, 0,
+        0,18,18, 0,21,
+};
+
+static const static_codebook _44p3_p5_0 = {
+       5, 3125,
+       (long *)_vq_lengthlist__44p3_p5_0,
+       1, -528744448, 1616642048, 3, 0,
+       (long *)_vq_quantlist__44p3_p5_0,
+       0
+};
+
+static const long _vq_quantlist__44p3_p5_1[] = {
+       3,
+       2,
+       4,
+       1,
+       5,
+       0,
+       6,
+};
+
+static const long _vq_lengthlist__44p3_p5_1[] = {
+        2, 3, 3, 3, 3, 3, 3,
+};
+
+static const static_codebook _44p3_p5_1 = {
+       1, 7,
+       (long *)_vq_lengthlist__44p3_p5_1,
+       1, -533200896, 1611661312, 3, 0,
+       (long *)_vq_quantlist__44p3_p5_1,
+       0
+};
+
+static const long _vq_quantlist__44p3_p6_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p3_p6_0[] = {
+        1, 6, 6, 7, 7, 7, 7, 8, 8, 7, 9, 9,11,11,11, 9,
+        8, 8, 8, 9, 9,12,11,11, 9, 8, 8, 6, 7, 7,10,11,
+       10,10,10,10,11,11,10,14,13,14,12,11,11,11,11,11,
+       15,14,14,13,12,12, 5, 6, 6, 8, 5, 5, 8, 7, 7, 8,
+        8, 8,12,10,10, 9, 7, 7, 9, 7, 8,12,10,10,10, 7,
+        7, 7, 8, 8,12,10,10,12,10,10,11,10,10,15,13,13,
+       13,10,10,11,10,10,16,13,14,14,10,10, 7, 7, 7,12,
+       11,11,12,11,11,11,11,11,16,15,15,14,12,12,12,11,
+       11,16,15,16,14,12,12,10, 9, 9,14,11,11,13,11,11,
+       12,11,11,16,14,14,14,11,11,12,11,11,17,15,15,14,
+       11,11, 7, 8, 8,12,11,11,12,10,10,12,10,10,16,14,
+       13,14,10,10,12,10,10,17,14,14,14,10,10, 8, 7, 7,
+       13,11,11,12,11,11,12,11,11,16,15,14,14,12,12,12,
+       11,11,16,15,14,15,12,12,11,10,10,13,11,11,13,12,
+       11,13,11,11,17,14,14,14,11,11,13,11,11,17,14,15,
+       14,11,11,
+};
+
+static const static_codebook _44p3_p6_0 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p3_p6_0,
+       1, -527106048, 1620377600, 2, 0,
+       (long *)_vq_quantlist__44p3_p6_0,
+       0
+};
+
+static const long _vq_quantlist__44p3_p6_1[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p3_p6_1[] = {
+        2, 6, 6, 7, 7, 7, 7, 7, 7, 7, 8, 8, 9, 9, 9, 9,
+        7, 7, 8, 8, 8, 9, 9, 9, 9, 7, 8, 6, 7, 7, 8, 8,
+        8, 8, 8, 8, 9, 8, 8,10, 9, 9,10, 8, 8,10, 8, 8,
+       10, 9, 9,10, 8, 8, 6, 6, 6, 8, 6, 6, 8, 7, 7, 8,
+        7, 7,10, 8, 8, 9, 7, 7, 9, 7, 7,10, 8, 9, 9, 7,
+        7, 7, 7, 7,10, 8, 8,11, 8, 8,10, 8, 8,12, 9, 9,
+       12, 8, 8,11, 9, 9,12, 9, 9,11, 8, 8, 7, 7, 7,10,
+        9, 9,10, 9, 9,10, 9, 9,11,10,10,10, 9, 9,11, 9,
+        9,11,10,10,11, 9, 9, 9, 8, 8,10, 9, 9,10, 9, 9,
+       11, 9, 9,11,10,10,11, 9, 9,11, 9, 9,11,10,10,11,
+        9, 9, 8, 8, 8,11, 9, 9,11, 9, 9,11, 9, 9,12, 9,
+        9,12, 8, 8,12, 9, 9,12, 9, 9,12, 8, 8, 8, 7, 7,
+       10, 9, 9,10, 9, 9,11, 9, 9,11,11,11,11, 9, 9,11,
+       10,10,11,11,11,11, 9, 9,10, 9, 9,11, 9, 9,11, 9,
+       10,11,10, 9,11,10,10,11, 9, 9,11, 9,10,11,10,10,
+       11, 9, 9,
+};
+
+static const static_codebook _44p3_p6_1 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p3_p6_1,
+       1, -530841600, 1616642048, 2, 0,
+       (long *)_vq_quantlist__44p3_p6_1,
+       0
+};
+
+static const long _vq_quantlist__44p3_p7_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p3_p7_0[] = {
+        1, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9,
+};
+
+static const static_codebook _44p3_p7_0 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p3_p7_0,
+       1, -513979392, 1633504256, 2, 0,
+       (long *)_vq_quantlist__44p3_p7_0,
+       0
+};
+
+static const long _vq_quantlist__44p3_p7_1[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p3_p7_1[] = {
+        1, 9, 9, 6, 9, 9, 5, 9, 9, 8, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 8, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9,10,10,10,10,10,10,10,10,10,10,10,
+       10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
+       10,10,10,
+};
+
+static const static_codebook _44p3_p7_1 = {
+       5, 243,
+       (long *)_vq_lengthlist__44p3_p7_1,
+       1, -516716544, 1630767104, 2, 0,
+       (long *)_vq_quantlist__44p3_p7_1,
+       0
+};
+
+static const long _vq_quantlist__44p3_p7_2[] = {
+       12,
+       11,
+       13,
+       10,
+       14,
+       9,
+       15,
+       8,
+       16,
+       7,
+       17,
+       6,
+       18,
+       5,
+       19,
+       4,
+       20,
+       3,
+       21,
+       2,
+       22,
+       1,
+       23,
+       0,
+       24,
+};
+
+static const long _vq_lengthlist__44p3_p7_2[] = {
+        1, 3, 2, 5, 4, 7, 7, 8, 8, 9, 9,10,10,11,11,12,
+       12,13,13,14,14,15,15,15,15,
+};
+
+static const static_codebook _44p3_p7_2 = {
+       1, 25,
+       (long *)_vq_lengthlist__44p3_p7_2,
+       1, -518864896, 1620639744, 5, 0,
+       (long *)_vq_quantlist__44p3_p7_2,
+       0
+};
+
+static const long _vq_quantlist__44p3_p7_3[] = {
+       12,
+       11,
+       13,
+       10,
+       14,
+       9,
+       15,
+       8,
+       16,
+       7,
+       17,
+       6,
+       18,
+       5,
+       19,
+       4,
+       20,
+       3,
+       21,
+       2,
+       22,
+       1,
+       23,
+       0,
+       24,
+};
+
+static const long _vq_lengthlist__44p3_p7_3[] = {
+        4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+        5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+static const static_codebook _44p3_p7_3 = {
+       1, 25,
+       (long *)_vq_lengthlist__44p3_p7_3,
+       1, -529006592, 1611661312, 5, 0,
+       (long *)_vq_quantlist__44p3_p7_3,
+       0
+};
+
+static const long _huff_lengthlist__44p3_short[] = {
+        4, 5,16, 9, 9,12,17,18, 4, 2,18, 6, 5, 9,13,15,
+       10, 7, 7, 6, 7, 9,13,13, 8, 5, 6, 5, 5, 7,11,12,
+        8, 4, 7, 4, 3, 6,10,12,11, 8, 9, 7, 6, 8,11,12,
+       15,13,13,11, 9, 7,10,12,16,12,16,12, 6, 5, 8,11,
+};
+
+static const static_codebook _huff_book__44p3_short = {
+       2, 64,
+       (long *)_huff_lengthlist__44p3_short,
+       0, 0, 0, 0, 0,
+       NULL,
+       0
+};
+
+static const long _vq_quantlist__44p4_l0_0[] = {
+       6,
+       5,
+       7,
+       4,
+       8,
+       3,
+       9,
+       2,
+       10,
+       1,
+       11,
+       0,
+       12,
+};
+
+static const long _vq_lengthlist__44p4_l0_0[] = {
+        1, 4, 4, 8, 8, 9, 8, 9, 9,10,10,10,10, 4, 6, 5,
+        8, 7, 9, 9, 9, 9,10, 9,10,10, 4, 5, 6, 7, 8, 9,
+        9, 9, 9, 9,10, 9,10, 8, 9, 8, 9, 8,10, 9,11, 9,
+       12,10,11,10, 8, 8, 9, 8, 9, 9,10, 9,11,10,11,10,
+       12, 9,10,10,11,10,11,11,12,11,12,12,12,12, 9,10,
+       10,11,11,11,11,11,12,12,12,12,12,10,11,11,12,12,
+       12,12,12,12,12,12,12,12,10,11,11,12,12,12,12,12,
+       12,12,12,12,12,11,12,12,12,12,12,12,12,12,12,13,
+       12,12,11,12,11,12,12,12,12,12,12,12,12,12,12,12,
+       12,12,12,12,12,13,12,12,12,12,12,12,11,13,12,12,
+       12,13,12,12,12,12,12,12,12,
+};
+
+static const static_codebook _44p4_l0_0 = {
+       2, 169,
+       (long *)_vq_lengthlist__44p4_l0_0,
+       1, -526516224, 1616117760, 4, 0,
+       (long *)_vq_quantlist__44p4_l0_0,
+       0
+};
+
+static const long _vq_quantlist__44p4_l0_1[] = {
+       2,
+       1,
+       3,
+       0,
+       4,
+};
+
+static const long _vq_lengthlist__44p4_l0_1[] = {
+        3, 4, 4, 5, 5, 4, 4, 5, 5, 5, 4, 5, 4, 5, 5, 5,
+        5, 6, 5, 6, 5, 6, 5, 6, 5,
+};
+
+static const static_codebook _44p4_l0_1 = {
+       2, 25,
+       (long *)_vq_lengthlist__44p4_l0_1,
+       1, -533725184, 1611661312, 3, 0,
+       (long *)_vq_quantlist__44p4_l0_1,
+       0
+};
+
+static const long _vq_quantlist__44p4_l1_0[] = {
+       1,
+       0,
+       2,
+};
+
+static const long _vq_lengthlist__44p4_l1_0[] = {
+      &n