From eca89acee00faf6e9ef55d84780e6eeddf225e5c Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 18 Jul 2012 20:57:59 +0100
Subject: [PATCH 001/284] initial

---
 JQ.hs    | 157 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 Lexer.x  | 101 +++++++++++++++++++++++++++++++++++
 Main.hs  |  22 ++++++++
 Parser.y |  78 +++++++++++++++++++++++++++
 4 files changed, 358 insertions(+)
 create mode 100644 JQ.hs
 create mode 100644 Lexer.x
 create mode 100644 Main.hs
 create mode 100644 Parser.y

diff --git a/JQ.hs b/JQ.hs
new file mode 100644
index 00000000..ca8df794
--- /dev/null
+++ b/JQ.hs
@@ -0,0 +1,157 @@
+module JQ where
+import Text.JSON
+import Text.JSON.String
+import Data.Maybe
+import Data.List (sortBy,sort,groupBy)
+import Data.Function (on)
+import Data.Ord (comparing)
+import Control.Monad
+import Control.Monad.Writer
+import Control.Monad.List
+import Control.Monad.Reader
+
+type Path = [Either Int String]
+
+type Program = JSValue -> [(JSValue, Path)]
+
+type JQ = ReaderT JSValue (WriterT Path [])
+
+runJQ :: JQ a -> JSValue -> [a]
+runJQ prog val = map fst $ runWriterT $ runReaderT prog val
+
+(>|) :: JQ JSValue -> JQ a -> JQ a
+a >| b = do
+  val <- a
+  local (const val) b
+
+collect :: JQ a -> JQ [a]
+collect prog = do
+  arg <- ask
+  return $ runJQ prog arg
+  
+collectPaths :: JQ a -> JQ [(a,Path)]
+collectPaths prog = do
+  arg <- ask
+  return $ runWriterT $ runReaderT prog arg
+
+insert :: JSValue -> (JSValue, Path) -> JSValue
+insert base (replace, []) = replace
+insert (JSArray values) (replace, ((Left n):rest)) = JSArray values'
+    where
+      (left, (_:right)) = splitAt n values
+      values' = left ++ [replace] ++ right
+insert (JSObject obj) (replace, ((Right k):rest))= JSObject $ toJSObject obj'
+    where
+      withoutK = filter ((/= k) . fst) $ fromJSObject obj
+      obj' = (k, replace):withoutK
+
+
+eqj a b = JSBool $ a == b
+
+
+liftp :: (JSValue -> JSValue) -> JQ JSValue
+liftp f = liftM f ask
+
+idp = undefined
+failp t = []
+
+constp :: JSValue -> Program
+constp t t' = idp t
+
+anyj :: [JSValue] -> Bool
+anyj values = any isTrue values
+  where
+    isTrue (JSBool False) = False
+    isTrue (JSNull) = False
+    isTrue _ = True
+
+selectp prog = do
+  match <- collect prog
+  guard $ anyj match
+  ask
+
+constStr :: String -> JQ JSValue
+constStr = return . JSString . toJSString
+
+constInt :: Int -> JQ JSValue
+constInt = return . JSRational False . toRational
+
+updatep p = do
+  t <- ask
+  liftM (foldl insert t) $ collectPaths p
+
+arrayp prog = liftM JSArray $ collect prog
+
+
+childp' :: JSValue -> JQ JSValue
+childp' (JSArray values) = msum [tell [Left i] >> return v | (v,i) <- zip values [0..]]
+childp' (JSObject obj) = msum [tell [Right k] >> return v | (k,v) <- fromJSObject obj]
+childp' _ = mzero
+
+childp = ask >>= childp'
+
+--findp :: Program -> Program
+findp prog = do
+  found <- collect prog
+  if anyj found then ask else childp >| findp prog
+
+groupp prog = do
+  list <- ask
+  case list of
+    JSArray values -> do
+      marked <- forM values $ \v -> do 
+        m <- collect (return v >| prog)
+        return (m,v)
+      msum $
+        map (return . JSArray . map snd) $ 
+        groupBy ((==) `on` fst) $ 
+        sortBy (comparing fst) $ 
+        marked
+    _ -> return JSNull
+
+
+  
+
+withArray f (JSArray values) = JSArray $ f values
+withArray f x = x
+
+callp "select" [p] = selectp p
+callp "find" [p] = findp p
+callp "set" [p] = updatep p
+callp "sort" [] = liftp (withArray sort)
+callp "group" [p] = groupp p
+
+lookupj :: JSValue -> JSValue -> JQ JSValue
+lookupj (JSArray values) (JSRational _ n) = do
+  let idx = round n
+  tell [Left idx]
+  if idx >= 0 && idx < length values
+    then return $ values !! idx
+    else return $ JSNull
+lookupj (JSObject obj) (JSString s) = do
+  tell [Right (fromJSString s)]
+  case (lookup (fromJSString s) (fromJSObject obj)) of
+    Just x -> return x
+    Nothing -> return JSNull
+lookupj _ _ = mzero
+
+
+plusj (JSRational _ n1) (JSRational _ n2) = JSRational True (n1 + n2)
+plusj (JSString s1) (JSString s2) = JSString $ toJSString (fromJSString s1 ++ fromJSString s2)
+plusj (JSArray a1) (JSArray a2) = JSArray $ a1 ++ a2
+
+
+js :: JSON a => a -> JSValue
+js = showJSON
+
+index s = do
+  v <- ask
+  lookupj v (js s)
+
+
+dictp progs = do
+  liftM (JSObject . toJSObject) $ forM progs $ \(k,v) -> do
+    JSString k' <- k
+    v' <- v
+    return (fromJSString k', v')
+
diff --git a/Lexer.x b/Lexer.x
new file mode 100644
index 00000000..700c69e6
--- /dev/null
+++ b/Lexer.x
@@ -0,0 +1,101 @@
+{
+module Lexer where
+import Control.Monad.Error
+}
+
+%wrapper "monadUserState"
+
+$digit = 0-9
+$alpha = [a-zA-Z_]
+@reserved = "."|"["|"]"|","|":"|"("|")"|"{"|"}"|"|"|"=="|"+"
+@ident = $alpha [$alpha $digit]*
+@string = \" ($printable)* \"
+
+
+tokens :- 
+
+<0> $white+             ;
+<0> @reserved           { tok TRes }
+<0> @ident              { tok TIdent }
+<0> $digit+             { tok $ TInt . read }
+
+
+<0> \"                  { enterString }
+<string> \"             { leaveString }
+<string> ($printable # [\"\\]) { pushString id }
+<string> \\ [\"\\\/]    { pushString (drop 1) }
+<string> \\ [nrt]       { pushString (escape . drop 1) }
+--<string> \\ 'u' [0-9a-fA-F]{4}
+--                        { pushString (parseUnicode . drop 2) }
+
+-- @string { \s -> TString $ init $ tail s}
+
+
+{
+  
+escape :: String -> String
+escape "r" = "\r"
+escape "n" = "\n"
+escape "t" = "\t"
+
+getState :: Alex AlexState
+getState = Alex $ \s -> Right (s, s)
+
+getUserState :: Alex AlexUserState
+getUserState = liftM alex_ust getState
+
+setUserState :: AlexUserState -> Alex ()
+setUserState s' = Alex $ \s -> Right (s{alex_ust = s'}, ()) 
+
+alexEOF = return $ Nothing
+
+enterString input len = do
+  setUserState []
+  alexSetStartCode string
+  skip input len
+
+pushString f i@(p, _, s) len = do
+  buf <- getUserState
+  setUserState (buf ++ [f $ take len s])
+  skip i len
+  
+leaveString input len = do
+  s <- getUserState
+  alexSetStartCode 0
+  return $ Just $ TString $ concat s
+  
+
+tok f (p,_,s) len = return $ Just $ f (take len s)
+data Token = TRes String | TString String | TIdent String | TInt Int
+
+instance Show Token where
+  show (TRes t) = "token " ++ t
+  show (TString t) = "string " ++ t
+  show (TIdent t) = "identifier " ++ t
+  show (TInt t) = "integer " ++ show t
+
+
+type AlexUserState = [String]
+
+alexInitUserState = undefined
+
+wrapError (Alex scanner) = Alex $ \s -> case scanner s of
+  Left message -> Left (message ++ " at " ++ showpos (alex_pos s))
+    where
+      showpos (AlexPn off line col) = "line " ++ show line ++ ", column " ++ show col
+  x -> x
+
+scanner = do
+  tok <- wrapError alexMonadScan
+  case tok of
+    Nothing -> do
+      s <- getState
+      case alex_scd s of
+        0 -> return []
+        string -> alexError "Unterminated string literal"
+    Just tok -> liftM (tok:) scanner
+
+runLexer :: String -> Either String [Token]
+runLexer input = runAlex input scanner
+
+}
\ No newline at end of file
diff --git a/Main.hs b/Main.hs
new file mode 100644
index 00000000..695520cb
--- /dev/null
+++ b/Main.hs
@@ -0,0 +1,22 @@
+import Parser
+import Lexer
+import JQ
+import Text.JSON
+import Text.JSON.String
+import System.Environment
+import Control.Monad
+import System.IO
+
+
+parseJS :: String -> JSValue
+parseJS s = case runGetJSON readJSValue s of
+  Left err -> error err
+  Right val -> val
+
+  
+main = do
+  [program] <- getArgs
+  json <- liftM parseJS $ hGetContents stdin
+  case runLexer program >>= runParser of
+    Left err -> putStrLn err
+    Right program -> mapM_ (putStrLn . encode) (runJQ program json)
\ No newline at end of file
diff --git a/Parser.y b/Parser.y
new file mode 100644
index 00000000..544fe5b4
--- /dev/null
+++ b/Parser.y
@@ -0,0 +1,78 @@
+{
+module Parser where
+import Lexer
+import JQ
+import Text.JSON
+import Debug.Trace
+import Data.List
+import Control.Monad.Error
+import Control.Monad.Reader
+}
+
+%name runParser Exp
+%tokentype { Token }
+
+%monad { Either String }
+%error { \t -> fail $ "parse error: unexpected " ++ if null t then [] else (show $ head t) }
+
+%token
+  '|' { TRes "|" }
+  '.' { TRes "." }
+  '[' { TRes "[" }
+  ']' { TRes "]" }
+  '{' { TRes "{" }
+  '}' { TRes "}" }
+  '(' { TRes "(" }
+  ')' { TRes ")" }
+  ',' { TRes "," }
+  ':' { TRes ":" }
+  '==' { TRes "==" }
+  '+' { TRes "+" }
+  Ident { TIdent $$ }
+  String { TString $$ }
+  Int { TInt $$ }
+
+%left '|'
+%left ','
+%nonassoc '=='
+%left '+'
+
+%%
+
+Exp 
+  : Exp '|' Exp         { $1 >| $3 }
+  | Exp ',' Exp         { $1 `mplus` $3 }
+  | Exp '==' Exp        { liftM2 eqj $1 $3 }
+  | Exp '+' Exp         { liftM2 plusj $1 $3 }
+  | Term                { $1 }
+
+ExpD
+  : ExpD '|' ExpD       { $1 >| $3 }
+  | ExpD '==' ExpD      { liftM2 eqj $1 $3 }
+  | Term                { $1 }
+
+
+Term 
+  : '.'                 { ask }
+  | Term '.' Ident      { $1 >| index $3 }
+  | '.' Ident           { index $2 }
+  | String              { constStr $1 }
+  | Term '[' Exp ']'    { do {t <- $1; i <- $3; lookupj t i} }
+  | Term '[' ']'        { $1 >| childp }
+  | '(' Exp ')'         { $2 }
+  | '[' Exp ']'         { arrayp $2 }
+  | Int                 { constInt $1 }
+  | '{' MkDict '}'      { dictp $2 }
+  | Ident '(' Exp ')'   { callp $1 [$3] }
+  | Ident               { callp $1 [] }
+
+MkDict
+  :                     { [] }
+  | MkDictPair          { [$1] }
+  | MkDictPair ',' MkDict { $1:$3 }
+ 
+MkDictPair
+  : Ident ':' ExpD      { (constStr $1, $3) }
+  | Ident               { (constStr $1, index $1) }
+  | String ':' ExpD     { (constStr $1, $3) }
+  | '(' Exp ')' ':' ExpD{ ($2, $5) }

From 2002dc1a2f4c35478b55149bc1a731e65d9a4268 Mon Sep 17 00:00:00 2001
From: Stephen <stephen@polya.(none)>
Date: Thu, 16 Aug 2012 01:00:30 +0100
Subject: [PATCH 002/284] Most of a C implementation of jq

---
 c/Makefile         |  21 +++
 c/builtin.c        |  18 +++
 c/builtin.h        |   8 +
 c/bytecode.c       |  35 +++++
 c/bytecode.h       |  33 ++++
 c/compile.c        | 288 ++++++++++++++++++++++++++++++++++
 c/compile.h        |  34 ++++
 c/execute.c        | 376 +++++++++++++++++++++++++++++++++++++++++++++
 c/execute.h        |  14 ++
 c/forkable_stack.h |  94 ++++++++++++
 c/lexer.l          |  25 +++
 c/main.c           |  82 ++++++++++
 c/opcode.c         |  27 ++++
 c/opcode.h         |  36 +++++
 c/opcode_list.h    |  17 ++
 c/parser.y         | 162 +++++++++++++++++++
 16 files changed, 1270 insertions(+)
 create mode 100644 c/Makefile
 create mode 100644 c/builtin.c
 create mode 100644 c/builtin.h
 create mode 100644 c/bytecode.c
 create mode 100644 c/bytecode.h
 create mode 100644 c/compile.c
 create mode 100644 c/compile.h
 create mode 100644 c/execute.c
 create mode 100644 c/execute.h
 create mode 100644 c/forkable_stack.h
 create mode 100644 c/lexer.l
 create mode 100644 c/main.c
 create mode 100644 c/opcode.c
 create mode 100644 c/opcode.h
 create mode 100644 c/opcode_list.h
 create mode 100644 c/parser.y

diff --git a/c/Makefile b/c/Makefile
new file mode 100644
index 00000000..ca20397f
--- /dev/null
+++ b/c/Makefile
@@ -0,0 +1,21 @@
+CC=gcc -Wall -std=gnu99 -ggdb
+
+.PHONY: all clean
+all: parsertest
+
+clean:
+	make -Bnd | grep 'Must remake target' | \
+	sed 's/.*`\(.*\)'\''.*/\1/' | grep -v '^all$$' | \
+	xargs rm
+
+
+lexer.yy.c: lexer.l
+	flex -o lexer.yy.c --header-file=lexer.yy.h lexer.l
+lexer.yy.h: lexer.yy.c
+
+parser.tab.c: parser.y lexer.yy.h
+	bison -W -d parser.y
+parser.tab.h: parser.tab.c
+
+parsertest: parser.tab.c lexer.yy.c main.c opcode.c bytecode.c compile.c execute.c builtin.c
+	$(CC) -o $@ $^ -ljansson
diff --git a/c/builtin.c b/c/builtin.c
new file mode 100644
index 00000000..eba81994
--- /dev/null
+++ b/c/builtin.c
@@ -0,0 +1,18 @@
+#include "builtin.h"
+
+#include <jansson.h>
+
+
+void f_false(json_t* input[], json_t* output[]) {
+  output[0] = json_false();
+}
+
+void f_true(json_t* input[], json_t* output[]) {
+  output[0] = json_true();
+}
+
+struct cfunction function_list[] = {
+  {f_true, "true", CALL_BUILTIN_1_1},
+  {f_false, "false", CALL_BUILTIN_1_1},
+};
+struct symbol_table builtins = {function_list, sizeof(function_list)/sizeof(function_list[0])};
diff --git a/c/builtin.h b/c/builtin.h
new file mode 100644
index 00000000..5b0d3702
--- /dev/null
+++ b/c/builtin.h
@@ -0,0 +1,8 @@
+#ifndef BUILTIN_H
+#define BUILTIN_H
+
+#include "bytecode.h"
+
+extern struct symbol_table builtins;
+
+#endif
diff --git a/c/bytecode.c b/c/bytecode.c
new file mode 100644
index 00000000..477d3aa4
--- /dev/null
+++ b/c/bytecode.c
@@ -0,0 +1,35 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <jansson.h>
+#include "bytecode.h"
+#include "opcode.h"
+
+void dump_disassembly(struct bytecode* bc) {
+  int pc = 0;
+  while (pc < bc->codelen) {
+    dump_operation(bc, bc->code + pc);
+    printf("\n");
+    pc += opcode_length(bc->code[pc]);
+  }
+}
+
+void dump_operation(struct bytecode* bc, uint16_t* codeptr) {
+  int pc = codeptr - bc->code;
+  printf("%04d ", pc);
+  const struct opcode_description* op = opcode_describe(bc->code[pc++]);
+  printf("%s", op->name);
+  if (op->flags & OP_HAS_IMMEDIATE) {
+    uint16_t imm = bc->code[pc++];
+    printf(" ");
+    if (op->flags & OP_HAS_BRANCH) {
+      printf("%04d", pc + imm);
+    } else if (op->flags & OP_HAS_CONSTANT) {
+      json_dumpf(json_array_get(bc->constants, imm),
+                 stdout, JSON_ENCODE_ANY);
+    } else if (op->flags & OP_HAS_VARIABLE) {
+      printf("v%d", imm);
+    } else {
+      printf("%d", imm);
+    }
+  }  
+}
diff --git a/c/bytecode.h b/c/bytecode.h
new file mode 100644
index 00000000..ddf1105a
--- /dev/null
+++ b/c/bytecode.h
@@ -0,0 +1,33 @@
+#ifndef BYTECODE_H
+#define BYTECODE_H
+#include <jansson.h>
+#include <stdint.h>
+
+#include "opcode.h"
+
+typedef void (*cfunction_ptr)(json_t* input[], json_t* output[]);
+
+struct cfunction {
+  cfunction_ptr fptr;
+  const char* name;
+  opcode callop;
+};
+
+#define MAX_CFUNCTION_ARGS 10
+struct symbol_table {
+  struct cfunction* cfunctions;
+  int ncfunctions;
+};
+
+
+struct bytecode {
+  uint16_t* code;
+  int codelen;
+  int framesize;
+  json_t* constants;
+  struct symbol_table* globals;
+};
+
+void dump_disassembly(struct bytecode* code);
+void dump_operation(struct bytecode* bc, uint16_t* op);
+#endif
diff --git a/c/compile.c b/c/compile.c
new file mode 100644
index 00000000..cc344575
--- /dev/null
+++ b/c/compile.c
@@ -0,0 +1,288 @@
+#include <assert.h>
+#include <string.h>
+#include "opcode.h"
+#include "compile.h"
+
+
+struct inst {
+  struct inst* next;
+  struct inst* prev;
+
+  opcode op;
+  
+  union {
+    uint16_t intval;
+    struct inst* target;
+    json_t* constant;
+    char* symbol;
+  } imm;
+
+  struct inst* var_binding;
+  int var_frame_idx;
+
+  int bytecode_pos; // position just after this insn
+};
+
+static inst* inst_new(opcode op) {
+  inst* i = malloc(sizeof(inst));
+  i->next = i->prev = 0;
+  i->op = op;
+  i->bytecode_pos = -1;
+  i->var_binding = 0;
+  i->var_frame_idx = 0;
+  return i;
+}
+
+static void inst_free(struct inst* i) {
+  if (opcode_describe(i->op)->flags &
+      (OP_HAS_SYMBOL | OP_HAS_VARIABLE)) {
+    free(i->imm.symbol);
+  }
+  free(i);
+}
+
+static block inst_block(inst* i) {
+  block b = {i,i};
+  return b;
+}
+
+block gen_noop() {
+  block b = {0,0};
+  return b;
+}
+
+block gen_op_simple(opcode op) {
+  assert(!(opcode_describe(op)->flags & OP_HAS_IMMEDIATE));
+  return inst_block(inst_new(op));
+}
+
+
+block gen_op_const(opcode op, json_t* constant) {
+  assert(opcode_describe(op)->flags & OP_HAS_CONSTANT);
+  inst* i = inst_new(op);
+  i->imm.constant = constant;
+  return inst_block(i);
+}
+
+block gen_op_target(opcode op, block target) {
+  assert(opcode_describe(op)->flags & OP_HAS_BRANCH);
+  assert(target.last);
+  inst* i = inst_new(op);
+  i->imm.target = target.last;
+  return inst_block(i);
+}
+
+block gen_op_targetlater(opcode op) {
+  assert(opcode_describe(op)->flags & OP_HAS_BRANCH);
+  inst* i = inst_new(op);
+  i->imm.target = 0;
+  return inst_block(i);
+}
+void inst_set_target(block b, block target) {
+  assert(b.first);
+  assert(b.first == b.last);
+  assert(opcode_describe(b.first->op)->flags & OP_HAS_BRANCH);
+  assert(target.last);
+  b.first->imm.target = target.last;
+}
+
+block gen_op_var_unbound(opcode op, const char* name) {
+  assert(opcode_describe(op)->flags & OP_HAS_VARIABLE);
+  inst* i = inst_new(op);
+  i->imm.symbol = strdup(name);
+  return inst_block(i);
+}
+
+block gen_op_var_bound(opcode op, block binder) {
+  assert(binder.first);
+  assert(binder.first == binder.last);
+  block b = gen_op_var_unbound(op, binder.first->imm.symbol);
+  b.first->var_binding = binder.first;
+  return b;
+}
+
+block gen_op_symbol(opcode op, const char* sym) {
+  assert(opcode_describe(op)->flags & OP_HAS_SYMBOL);
+  inst* i = inst_new(op);
+  i->imm.symbol = strdup(sym);
+  return inst_block(i);
+}
+
+static void inst_join(inst* a, inst* b) {
+  assert(a && b);
+  assert(!a->next);
+  assert(!b->prev);
+  a->next = b;
+  b->prev = a;
+}
+
+void block_append(block* b, block b2) {
+  if (b2.first) {
+    if (b->last) {
+      inst_join(b->last, b2.first);
+    } else {
+      b->first = b2.first;
+    }
+    b->last = b2.last;
+  }
+}
+
+block block_join(block a, block b) {
+  block c = a;
+  block_append(&c, b);
+  return c;
+}
+
+block block_bind(block binder, block body) {
+  assert(binder.first);
+  assert(binder.first == binder.last);
+  assert(opcode_describe(binder.first->op)->flags & OP_HAS_VARIABLE);
+  assert(binder.first->imm.symbol);
+  assert(binder.first->var_binding == 0);
+
+  binder.first->var_binding = binder.first;
+  for (inst* i = body.first; i; i = i->next) {
+    if (opcode_describe(i->op)->flags & OP_HAS_VARIABLE &&
+        i->var_binding == 0 &&
+        !strcmp(i->imm.symbol, binder.first->imm.symbol)) {
+      // bind this variable
+      i->var_binding = binder.first;
+    }
+  }
+  return block_join(binder, body);
+}
+
+
+block gen_subexp(block a) {
+  block c = gen_noop();
+  block_append(&c, gen_op_simple(DUP));
+  block_append(&c, a);
+  block_append(&c, gen_op_simple(SWAP));
+  return c;
+}
+
+block gen_both(block a, block b) {
+  block c = gen_noop();
+  block jump = gen_op_targetlater(JUMP);
+  block fork = gen_op_targetlater(FORK);
+  block_append(&c, fork);
+  block_append(&c, a);
+  block_append(&c, jump);
+  inst_set_target(fork, c);
+  block_append(&c, b);
+  inst_set_target(jump, c);
+  return c;
+}
+
+
+block gen_collect(block expr) {
+  block c = gen_noop();
+  block_append(&c, gen_op_simple(DUP));
+  block_append(&c, gen_op_const(LOADK, json_array()));
+  block array_var = block_bind(gen_op_var_unbound(STOREV, "collect"),
+                               gen_noop());
+  block_append(&c, array_var);
+
+  block tail = {0};
+  block_append(&tail, gen_op_simple(DUP));
+  block_append(&tail, gen_op_var_bound(LOADV, array_var));
+  block_append(&tail, gen_op_simple(SWAP));
+  block_append(&tail, gen_op_simple(APPEND));
+  block_append(&tail, gen_op_var_bound(STOREV, array_var));
+  block_append(&tail, gen_op_simple(BACKTRACK));
+
+  block_append(&c, gen_op_target(FORK, tail));
+  block_append(&c, expr);
+  block_append(&c, tail);
+
+  block_append(&c, gen_op_var_bound(LOADV, array_var));
+
+  return c;
+}
+
+block gen_else(block a, block b) {
+  assert(0);
+}
+
+
+struct bytecode* block_compile(struct symbol_table* syms, block b) {
+  inst* curr = b.first;
+  int pos = 0;
+  int var_frame_idx = 0;
+  for (; curr; curr = curr->next) {
+    if (!curr->next) assert(curr == b.last);
+    pos += opcode_length(curr->op);
+    curr->bytecode_pos = pos;
+    if (opcode_describe(curr->op)->flags & OP_HAS_VARIABLE) {
+      assert(curr->var_binding && "unbound variable");
+      if (curr->var_binding == curr) {
+        curr->var_frame_idx = var_frame_idx++;
+      }
+    }
+  }
+  struct bytecode* bc = malloc(sizeof(struct bytecode));
+  bc->codelen = pos;
+  uint16_t* code = malloc(sizeof(uint16_t) * bc->codelen);
+  bc->code = code;
+  int* stack_height = malloc(sizeof(int) * (bc->codelen + 1));
+  for (int i = 0; i<bc->codelen + 1; i++) stack_height[i] = -1;
+  pos = 0;
+  json_t* constant_pool = json_array();
+  int maxvar = -1;
+  int curr_stack_height = 1;
+  for (curr = b.first; curr; curr = curr->next) {
+    const struct opcode_description* op = opcode_describe(curr->op);
+    if (curr_stack_height < op->stack_in) {
+      printf("Stack underflow at %04d\n", curr->bytecode_pos);
+    }
+    if (stack_height[curr->bytecode_pos] != -1 &&
+        stack_height[curr->bytecode_pos] != curr_stack_height) {
+      // FIXME: not sure this is right at all :(
+      printf("Inconsistent stack heights at %04d %s\n", curr->bytecode_pos, op->name);
+    }
+    curr_stack_height -= op->stack_in;
+    curr_stack_height += op->stack_out;
+    code[pos++] = curr->op;
+    int opflags = op->flags;
+    if (opflags & OP_HAS_CONSTANT) {
+      code[pos++] = json_array_size(constant_pool);
+      json_array_append(constant_pool, curr->imm.constant);
+    } else if (opflags & OP_HAS_VARIABLE) {
+      uint16_t var = (uint16_t)curr->var_binding->var_frame_idx;
+      code[pos++] = var;
+      if (var > maxvar) maxvar = var;
+    } else if (opflags & OP_HAS_BRANCH) {
+      assert(curr->imm.target->bytecode_pos != -1);
+      assert(curr->imm.target->bytecode_pos > pos); // only forward branches
+      code[pos] = curr->imm.target->bytecode_pos - (pos + 1);
+      stack_height[curr->imm.target->bytecode_pos] = curr_stack_height;
+      pos++;
+    } else if (opflags & OP_HAS_CFUNC) {
+      assert(curr->imm.symbol);
+      int found = 0;
+      for (int i=0; i<syms->ncfunctions; i++) {
+        if (!strcmp(curr->imm.symbol, syms->cfunctions[i].name)) {
+          code[pos++] = i;
+          found = 1;
+          break;
+        }
+      }
+      assert(found);
+    } else if (opflags & OP_HAS_IMMEDIATE) {
+      code[pos++] = curr->imm.intval;
+    }
+  }
+  free(stack_height);
+  bc->constants = constant_pool;
+  bc->framesize = maxvar + 2; // FIXME: frames of size zero?
+  bc->globals = syms;
+  return bc;
+}
+
+void block_free(block b) {
+  struct inst* next;
+  for (struct inst* curr = b.first; curr; curr = next) {
+    next = curr->next;
+    inst_free(curr);
+  }
+}
diff --git a/c/compile.h b/c/compile.h
new file mode 100644
index 00000000..0ba54f15
--- /dev/null
+++ b/c/compile.h
@@ -0,0 +1,34 @@
+#include <stdint.h>
+#include "bytecode.h"
+#include "opcode.h"
+
+struct inst;
+typedef struct inst inst;
+
+
+typedef struct block {
+  inst* first;
+  inst* last;
+} block;
+
+block gen_noop();
+block gen_op_simple(opcode op);
+block gen_op_const(opcode op, json_t* constant);
+block gen_op_target(opcode op, block target);
+block gen_op_var_unbound(opcode op, const char* name);
+block gen_op_var_bound(opcode op, block binder);
+block gen_op_symbol(opcode op, const char* name);
+
+block gen_subexp(block a);
+block gen_both(block a, block b);
+block gen_collect(block expr);
+block gen_else(block a, block b);
+
+
+void block_append(block* b, block b2);
+block block_join(block a, block b);
+block block_bind(block binder, block body);
+
+struct bytecode* block_compile(struct symbol_table*, block);
+
+void block_free(block);
diff --git a/c/execute.c b/c/execute.c
new file mode 100644
index 00000000..c06ed124
--- /dev/null
+++ b/c/execute.c
@@ -0,0 +1,376 @@
+#include <jansson.h>
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+
+#include "opcode.h"
+#include "bytecode.h"
+#include "compile.h"
+
+#include "forkable_stack.h"
+
+
+typedef struct {
+  json_t* value;
+  int pathidx;
+} stackval;
+
+
+json_t** pathbuf;
+int pathsize; // number of allocated elements
+
+
+int path_push(stackval sv, json_t* val) {
+  int pos = sv.pathidx;
+  assert(pos <= pathsize);
+  assert(pos >= 0);
+  if (pos == pathsize) {
+    pathsize = pathsize ? pathsize * 2 : 100;
+    pathbuf = realloc(pathbuf, sizeof(pathbuf[0]) * pathsize);
+  }
+  pathbuf[pos] = val;
+  return pos + 1;
+}
+
+stackval stackval_replace(stackval value, json_t* newjs) {
+  stackval s = {newjs, value.pathidx};
+  return s;
+}
+
+
+// Probably all uses of this function are bugs
+stackval stackval_root(json_t* v) {
+  stackval s = {v, 0};
+  return s;
+}
+
+struct forkable_stack data_stk;
+typedef struct {
+  FORKABLE_STACK_HEADER;
+  stackval sv;
+} data_stk_elem;
+
+data_stk_elem* stk_push_frame(int n) {
+  return forkable_stack_push(&data_stk, sizeof(data_stk_elem) * n);
+}
+
+void stk_pop_frame(int n) {
+  forkable_stack_pop(&data_stk, sizeof(data_stk_elem) * n);
+}
+
+void stk_push(stackval val) {
+  data_stk_elem* s = stk_push_frame(1);
+  s->sv = val;
+}
+
+stackval stk_pop() {
+  data_stk_elem* s = forkable_stack_peek(&data_stk, sizeof(data_stk_elem));
+  stackval sv = s->sv;
+  forkable_stack_pop(&data_stk, sizeof(data_stk_elem));
+  return sv;
+}
+
+
+typedef struct {
+  FORKABLE_STACK_HEADER;
+  struct bytecode* bc;
+  data_stk_elem* fp;
+  uint16_t* pc;
+} call_stk_elem;
+struct forkable_stack call_stk;
+
+
+struct forkpoint {
+  FORKABLE_STACK_HEADER;
+  struct forkable_stack_state saved_data_stack;
+  struct forkable_stack_state saved_call_stack;
+};
+
+struct forkable_stack fork_stk;
+
+void stack_save(){
+  struct forkpoint* fork = forkable_stack_push(&fork_stk, sizeof(struct forkpoint));
+  forkable_stack_save(&data_stk, &fork->saved_data_stack);
+  forkable_stack_save(&call_stk, &fork->saved_call_stack);
+}
+
+void stack_switch() {
+  struct forkpoint* fork = forkable_stack_peek(&fork_stk, sizeof(struct forkpoint));
+  forkable_stack_switch(&data_stk, &fork->saved_data_stack);
+  forkable_stack_switch(&call_stk, &fork->saved_call_stack);
+}
+
+void stack_restore(){
+  struct forkpoint* fork = forkable_stack_peek(&fork_stk, sizeof(struct forkpoint));
+  forkable_stack_restore(&data_stk, &fork->saved_data_stack);
+  forkable_stack_restore(&call_stk, &fork->saved_call_stack);
+  forkable_stack_pop(&fork_stk, sizeof(struct forkpoint));
+}
+
+#define stack_push stk_push
+#define stack_pop stk_pop
+
+#define ON_BACKTRACK(op) ((op)+NUM_OPCODES)
+
+json_t* jq_next() {
+  assert(!forkable_stack_empty(&call_stk));
+  call_stk_elem* ctx = forkable_stack_peek(&call_stk, sizeof(call_stk_elem));
+  struct bytecode* bc = ctx->bc;
+  uint16_t* pc = ctx->pc;
+  data_stk_elem* fp = ctx->fp;
+  json_t* cpool = bc->constants;
+
+  json_t* cfunc_input[MAX_CFUNCTION_ARGS] = {0};
+  json_t* cfunc_output[MAX_CFUNCTION_ARGS] = {0};
+  int backtracking = 0;
+  while (1) {
+
+    dump_operation(bc, pc);
+
+    uint16_t opcode = *pc++;
+
+    printf("\t");
+    const struct opcode_description* opdesc = opcode_describe(opcode);
+    data_stk_elem* param = forkable_stack_peek(&data_stk, sizeof(data_stk_elem));
+    for (int i=0; i<opdesc->stack_in; i++) {
+      json_dumpf(param->sv.value, stdout, JSON_ENCODE_ANY);
+      if (i < opdesc->stack_in-1) printf(" | ");
+      param = forkable_stack_peek_next(&data_stk, param, sizeof(data_stk_elem));
+    }
+
+    if (backtracking) {
+      printf("\t<backtracking>");
+      opcode = ON_BACKTRACK(opcode);
+      backtracking = 0;
+    }
+
+    printf("\n");
+
+    switch (opcode) {
+    default: assert(0 && "invalid instruction");
+
+    case LOADK: {
+      json_t* v = json_array_get(cpool, *pc++);
+      assert(v);
+      stack_push(stackval_replace(stack_pop(), v));
+      break;
+    }
+
+    case DUP: {
+      stackval v = stack_pop();
+      stack_push(v);
+      stack_push(v);
+      break;
+    }
+
+    case SWAP: {
+      stackval a = stack_pop();
+      stackval b = stack_pop();
+      stack_push(a);
+      stack_push(b);
+      break;
+    }
+      
+    case POP: {
+      stack_pop();
+      break;
+    }
+
+    case APPEND: {
+      // FIXME paths
+      json_t* v = stack_pop().value;
+      json_t* array = stack_pop().value;
+      array = json_copy(array);
+      json_array_append(array, v);
+      stack_push(stackval_root(array));
+      break;
+    }
+
+    case INSERT: {
+      stackval stktop = stack_pop();
+      json_t* v = stack_pop().value;
+      json_t* k = stack_pop().value;
+      stackval objv = stack_pop();
+      assert(json_is_string(k));
+      assert(json_is_object(objv.value));
+      json_t* obj = json_copy(objv.value);
+      json_object_set(obj, json_string_value(k), v);
+      assert(json_is_object(obj));
+      stack_push(stackval_replace(objv, obj));
+      stack_push(stktop);
+      break;
+    }
+
+    case LOADV: {
+      uint16_t v = *pc++;
+      stack_push(stackval_replace(stack_pop(), fp[v].sv.value));
+      break;
+    }
+
+    case STOREV: {
+      uint16_t v = *pc++;
+      stackval val = stack_pop();
+      printf("V%d = ", v);
+      json_dumpf(val.value, stdout, JSON_ENCODE_ANY);
+      printf("\n");
+      fp[v].sv.value = val.value;
+      break;
+    }
+
+#if 0
+    case DISPLAY: {
+      stackval sv = stack_pop();
+      if (sv.value) {
+        json_dumpf(sv.value, stdout, JSON_ENCODE_ANY);
+      } else {
+        printf("#ERROR");
+      }
+      printf(" - ");
+      for (int i = 0; i < sv.pathidx; i++) {
+        printf("/");
+        json_dumpf(pathbuf[i], stdout, JSON_ENCODE_ANY);
+      }
+      printf("\n");
+      return;
+    }
+#endif
+
+    case INDEX: {
+      stackval t = stack_pop();
+      json_t* k = stack_pop().value;
+      stackval v;
+      if (json_is_string(k)) {
+        v.value = json_object_get(t.value, json_string_value(k));
+      } else if (json_is_integer(k)) {
+        v.value = json_array_get(t.value, json_integer_value(k));
+      } else {
+        assert(0 && "key neither string nor int");
+      }
+      if (v.value) {
+        v.pathidx = path_push(t, k);
+        stack_push(v);
+      } else {
+        assert(0 && "bad lookup");
+      }
+      break;
+    }
+
+
+    case JUMP: {
+      uint16_t offset = *pc++;
+      pc += offset;
+      break;
+    }
+
+    case EACH: 
+      stack_push(stackval_root(json_integer(0)));
+      // fallthrough
+    case ON_BACKTRACK(EACH): {
+      json_t* idxj = stack_pop().value;
+      int idx = json_integer_value(idxj);
+      stackval array = stack_pop();
+      if (idx >= json_array_size(array.value)) {
+        goto do_backtrack;
+      } else {
+        stack_save();
+        stack_push(array);
+        stack_push(stackval_root(json_integer(idx+1)));
+        call_stk_elem* ctx = forkable_stack_push(&call_stk, sizeof(call_stk_elem));
+        ctx->bc = bc;
+        ctx->fp = fp;
+        ctx->pc = pc - 1;
+        stack_switch();
+        
+        stackval sv = {json_array_get(array.value, idx), 
+                       path_push(array, json_integer(idx))};
+        stack_push(sv);
+      }
+      break;
+    }
+
+    do_backtrack:
+    case BACKTRACK: {
+      if (forkable_stack_empty(&fork_stk)) {
+        return 0;
+      }
+      stack_restore();
+      call_stk_elem* ctx = forkable_stack_peek(&call_stk, sizeof(call_stk_elem));
+      bc = ctx->bc;
+      pc = ctx->pc;
+      fp = ctx->fp;
+      cpool = bc->constants;
+      forkable_stack_pop(&call_stk, sizeof(call_stk_elem));
+      backtracking = 1;
+      break;
+    }
+
+    case FORK: {
+      stack_save();
+      call_stk_elem* ctx = forkable_stack_push(&call_stk, sizeof(call_stk_elem));
+      ctx->bc = bc;
+      ctx->fp = fp;
+      ctx->pc = pc - 1;
+      stack_switch();
+      pc++; // skip offset this time
+      break;
+    }
+    case ON_BACKTRACK(FORK): {
+      uint16_t offset = *pc++;
+      pc += offset;
+      break;
+    }
+
+    case YIELD: {
+      json_t* value = stack_pop().value;
+      call_stk_elem* ctx = forkable_stack_push(&call_stk, sizeof(call_stk_elem));
+      ctx->bc = bc;
+      ctx->fp = fp;
+      ctx->pc = pc;
+      return value;
+    }
+      
+    case CALL_BUILTIN_1_1: {
+      stackval top = stack_pop();
+      cfunc_input[0] = top.value;
+      struct cfunction* func = &bc->globals->cfunctions[*pc++];
+      printf(" call %s\n", func->name);
+      func->fptr(cfunc_input, cfunc_output);
+      stack_push(stackval_replace(top, cfunc_output[0]));
+      break;
+    }
+      
+      
+    }
+  }
+}
+
+
+void jq_init(struct bytecode* bc, json_t* input) {
+  forkable_stack_init(&data_stk, sizeof(stackval) * 100); // FIXME: lower this number, see if it breaks
+  forkable_stack_init(&call_stk, 1024); // FIXME: lower this number, see if it breaks
+  forkable_stack_init(&fork_stk, 1024); // FIXME: lower this number, see if it breaks
+  
+  data_stk_elem* frame = stk_push_frame(bc->framesize);
+  
+  stack_push(stackval_root(input));
+  call_stk_elem* ctx = forkable_stack_push(&call_stk, sizeof(call_stk_elem));
+  ctx->pc = bc->code;
+  ctx->bc = bc;
+  ctx->fp = frame;
+}
+
+void run_program(struct bytecode* bc) {
+  jq_init(bc, json_loadf(stdin, 0, 0));
+  json_t* result;
+  while ((result = jq_next())) {
+    json_dumpf(result, stdout, JSON_ENCODE_ANY);
+    printf("\n");
+  }
+  printf("end of results\n");
+
+  //assert(frame == stack_top_frame(bc->framesize));
+  //stk_pop_frame(bc->framesize);
+  //assert(stackpos == 0);
+}
diff --git a/c/execute.h b/c/execute.h
new file mode 100644
index 00000000..b978a8e4
--- /dev/null
+++ b/c/execute.h
@@ -0,0 +1,14 @@
+#include "opcode.h"
+#define MAX_CFUNCTION_PARAM 10
+typedef struct {
+  json_t* value;
+  int pathidx;
+} stackval;
+
+typedef void (*cfunction_ptr)(stackval* input, stackval* output);
+
+struct cfunction {
+  cfunction_ptr fptr;
+  const char* name;
+  opcode callop;
+};
diff --git a/c/forkable_stack.h b/c/forkable_stack.h
new file mode 100644
index 00000000..8043c426
--- /dev/null
+++ b/c/forkable_stack.h
@@ -0,0 +1,94 @@
+#include <stdlib.h>
+#include <stddef.h>
+#include <assert.h>
+
+struct forkable_stack_header {
+  int next;
+};
+
+#define FORKABLE_STACK_HEADER struct forkable_stack_header fk_header_
+
+struct forkable_stack {
+  char* stk;
+
+  // stk+length is just past end of allocated area
+  int length;
+
+  // stk+pos is just past top-of-stack item
+  int pos;
+
+  // everything before stk+savedlimit must be preserved
+  int savedlimit;
+};
+
+static void forkable_stack_check(struct forkable_stack* s) {
+  assert(s->stk);
+  assert(s->length > 0);
+  assert(s->pos >= 0 && s->pos <= s->length);
+  assert(s->savedlimit >= 0 && s->savedlimit <= s->length);
+}
+
+static int forkable_stack_empty(struct forkable_stack* s) {
+  return s->pos == 0;
+}
+
+static void forkable_stack_init(struct forkable_stack* s, size_t sz) {
+  s->stk = malloc(sz);
+  s->length = sz;
+  s->pos = 0;
+  s->savedlimit = 0;
+  forkable_stack_check(s);
+}
+
+static void* forkable_stack_push(struct forkable_stack* s, size_t size) {
+  forkable_stack_check(s);
+  int curr = s->pos > s->savedlimit ? s->pos : s->savedlimit;
+  if (curr + size > s->length) {
+    s->length = (size + s->length + 1024) * 2;
+    s->stk = realloc(s->stk, s->length);
+  }
+  void* ret = (void*)(s->stk + curr);
+  ((struct forkable_stack_header*)ret)->next = s->pos;
+  s->pos = curr + size;
+  return ret;
+}
+
+static void* forkable_stack_peek(struct forkable_stack* s, size_t size) {
+  assert(!forkable_stack_empty(s));
+  return (void*)(s->stk + s->pos - size);
+}
+
+static void* forkable_stack_peek_next(struct forkable_stack* s, void* top, size_t size) {
+  struct forkable_stack_header* elem = top;
+  return (void*)(s->stk + elem->next - size);
+}
+
+static void forkable_stack_pop(struct forkable_stack* s, size_t size) {
+  struct forkable_stack_header* elem = forkable_stack_peek(s, size);
+  s->pos = elem->next;
+}
+
+struct forkable_stack_state {
+  int prevpos, prevlimit;
+};
+
+static void forkable_stack_save(struct forkable_stack* s, struct forkable_stack_state* state) {
+  state->prevpos = s->pos;
+  state->prevlimit = s->savedlimit;
+  if (s->pos > s->savedlimit) s->savedlimit = s->pos;
+}
+
+static void forkable_stack_switch(struct forkable_stack* s, struct forkable_stack_state* state) {
+  int curr_pos = s->pos;
+  s->pos = state->prevpos;
+  state->prevpos = curr_pos;
+
+  int curr_limit = s->savedlimit;
+  if (curr_pos > curr_limit) s->savedlimit = curr_pos;
+  state->prevlimit = curr_limit;
+}
+
+static void forkable_stack_restore(struct forkable_stack* s, struct forkable_stack_state* state) {
+  s->pos = state->prevpos;
+  s->savedlimit = state->prevlimit;
+}
diff --git a/c/lexer.l b/c/lexer.l
new file mode 100644
index 00000000..42103c40
--- /dev/null
+++ b/c/lexer.l
@@ -0,0 +1,25 @@
+%{
+#include "compile.h"
+#include "parser.tab.h"  /* Generated by bison. */
+%}
+
+%option noyywrap nounput noinput nodefault
+%option reentrant
+%option bison-bridge bison-locations
+
+%%
+
+"==" { return EQ; }
+"as" { return AS; }
+"."|"="|";"|"["|"]"|","|":"|"("|")"|"{"|"}"|"|"|"+"|"\$" { return yytext[0];}
+
+[[:digit:]]+  { yylval->num = atoi(yytext);   return NUMBER;}
+[[:alnum:]]+  { yylval->str = strdup(yytext); return IDENT;}
+[ \n\t]+  {}
+%%
+/* perhaps these should be calls... */
+/*
+"true" { return TRUE; }
+"false" { return FALSE; }
+"null" { return NULL; }
+*/
diff --git a/c/main.c b/c/main.c
new file mode 100644
index 00000000..5017d9fa
--- /dev/null
+++ b/c/main.c
@@ -0,0 +1,82 @@
+#include <stdio.h>
+#include "compile.h"
+#include "parser.tab.h"
+#include "builtin.h"
+
+block compile(const char* str);
+
+void jq_init(struct bytecode* bc, json_t* value);
+json_t* jq_next();
+
+void run_program(struct bytecode* bc);
+
+int skipline(const char* buf) {
+  int p = 0;
+  while (buf[p] == ' ' || buf[p] == '\t') p++;
+  if (buf[p] == '#' || buf[p] == '\n' || buf[p] == 0) return 1;
+  return 0;
+}
+
+void run_tests() {
+  FILE* testdata = fopen("testdata","r");
+  char buf[4096];
+  int tests = 0, passed = 0;
+
+  while (1) {
+    if (!fgets(buf, sizeof(buf), testdata)) break;
+    if (skipline(buf)) continue;
+    printf("Testing %s\n", buf);
+    int pass = 1;
+    block program = compile(buf);
+    block_append(&program, gen_op_simple(YIELD));
+    block_append(&program, gen_op_simple(BACKTRACK));
+    struct bytecode* bc = block_compile(&builtins, program);
+    block_free(program);
+    fgets(buf, sizeof(buf), testdata);
+    json_t* input = json_loads(buf, JSON_DECODE_ANY, 0);
+    jq_init(bc, input);
+
+    while (fgets(buf, sizeof(buf), testdata)) {
+      if (skipline(buf)) break;
+      json_t* expected = json_loads(buf, JSON_DECODE_ANY, 0);
+      json_t* actual = jq_next();
+      if (!actual) {
+        printf("Insufficient results\n");
+        pass = 0;
+        break;
+      } else if (!json_equal(expected, actual)) {
+        printf("Expected ");
+        json_dumpf(expected, stdout, JSON_ENCODE_ANY);
+        printf(", but got ");
+        json_dumpf(actual, stdout, JSON_ENCODE_ANY);
+        printf("\n");
+        pass = 0;
+        break;
+      }
+    }
+    if (pass) {
+      json_t* extra = jq_next();
+      if (extra) {
+        printf("Superfluous result: ");
+        json_dumpf(extra, stdout, JSON_ENCODE_ANY);
+        printf("\n");
+        pass = 0;
+      }
+    }
+    tests++;
+    passed+=pass;
+  }
+  fclose(testdata);
+  printf("%d of %d tests passed\n", passed,tests);
+}
+
+int main(int argc, char* argv[]) {
+  if (argc == 1) { run_tests(); return 0; }
+  block blk = compile(argv[1]);
+  block_append(&blk, block_join(gen_op_simple(YIELD), gen_op_simple(BACKTRACK)));
+  struct bytecode* bc = block_compile(&builtins, blk);
+  block_free(blk);
+  dump_disassembly(bc);
+  printf("\n");
+  run_program(bc);
+}
diff --git a/c/opcode.c b/c/opcode.c
new file mode 100644
index 00000000..b14e0db6
--- /dev/null
+++ b/c/opcode.c
@@ -0,0 +1,27 @@
+#include "opcode.h"
+
+#define NONE 0
+#define CONSTANT (OP_HAS_IMMEDIATE | OP_HAS_CONSTANT)
+#define VARIABLE (OP_HAS_IMMEDIATE | OP_HAS_VARIABLE)
+#define BRANCH (OP_HAS_IMMEDIATE | OP_HAS_BRANCH)
+#define CFUNC (OP_HAS_IMMEDIATE | OP_HAS_SYMBOL | OP_HAS_CFUNC)
+
+#define OP(name, imm, in, out) \
+  {name, #name, imm, in, out},
+
+static const struct opcode_description opcode_descriptions[] = {
+#include "opcode_list.h"
+};
+
+static const struct opcode_description invalid_opcode_description = {
+  -1, "#INVALID", 0, 0, 0
+};
+
+
+const struct opcode_description* opcode_describe(opcode op) {
+  if ((int)op >= 0 && (int)op < NUM_OPCODES) {
+    return &opcode_descriptions[op];
+  } else {
+    return &invalid_opcode_description;
+  }
+}
diff --git a/c/opcode.h b/c/opcode.h
new file mode 100644
index 00000000..797e6a96
--- /dev/null
+++ b/c/opcode.h
@@ -0,0 +1,36 @@
+#ifndef OPCODE_H
+#define OPCODE_H
+typedef enum {
+#define OP(name, imm, in, out) name,
+#include "opcode_list.h"
+#undef OP
+} opcode;
+
+enum {
+  NUM_OPCODES = 
+#define OP(name, imm, in, out) +1
+#include "opcode_list.h"
+#undef OP
+};
+
+enum {
+  OP_HAS_IMMEDIATE = 1,
+  OP_HAS_CONSTANT = 2,
+  OP_HAS_VARIABLE = 4,
+  OP_HAS_BRANCH = 8,
+  OP_HAS_SYMBOL = 16,
+  OP_HAS_CFUNC = 32
+};
+struct opcode_description {
+  opcode op;
+  const char* name;
+  int flags;
+  int stack_in, stack_out;
+};
+
+const struct opcode_description* opcode_describe(opcode op);
+
+static inline int opcode_length(opcode op) {
+  return 1 + (opcode_describe(op)->flags & OP_HAS_IMMEDIATE ? 1 : 0);
+}
+#endif
diff --git a/c/opcode_list.h b/c/opcode_list.h
new file mode 100644
index 00000000..d88381b7
--- /dev/null
+++ b/c/opcode_list.h
@@ -0,0 +1,17 @@
+OP(LOADK, CONSTANT, 1, 1)
+OP(DUP,   NONE,     1, 2)
+OP(SWAP,  NONE,     2, 2)
+OP(POP,   NONE,     1, 0)
+OP(LOADV, VARIABLE, 1, 1)
+OP(STOREV, VARIABLE, 1, 0)
+OP(INDEX, NONE,     2, 1)
+//OP(DISPLAY, NONE,   1, 0)
+OP(YIELD, NONE, 1, 0)
+OP(EACH,  NONE,     1, 1)
+OP(FORK,  BRANCH,   0, 0)
+OP(JUMP,  BRANCH,   0, 0)
+OP(BACKTRACK, NONE, 0, 0)
+OP(APPEND, NONE,    2, 1)
+OP(INSERT, NONE,    4, 2)
+
+OP(CALL_BUILTIN_1_1, CFUNC, 1, 1)
diff --git a/c/parser.y b/c/parser.y
new file mode 100644
index 00000000..e8721a17
--- /dev/null
+++ b/c/parser.y
@@ -0,0 +1,162 @@
+%{
+#include <stdio.h>
+#include <string.h>
+#include "compile.h"
+%}
+
+%locations
+%define api.pure
+%union {
+  int num;
+  char* str;
+  block blk;
+}
+
+%parse-param {block* answer}
+%parse-param {yyscan_t lexer}
+%lex-param {yyscan_t lexer}
+
+
+%token <str> IDENT
+%token <num> NUMBER
+
+%left '|'
+%left ','
+%token EQ "=="
+%token AS "as"
+%nonassoc EQ
+%left '+'
+
+%type <blk> Exp Term MkDict MkDictPair ExpD
+
+%{
+#include "lexer.yy.h"
+void yyerror(YYLTYPE* loc, block* answer, yyscan_t lexer, const char *s){
+  printf("ERROR: %s\n", s); 
+}
+
+static block gen_dictpair(block k, block v) {
+  block b = gen_subexp(k);
+  block_append(&b, gen_subexp(v));
+  block_append(&b, gen_op_simple(INSERT));
+  return b;
+}
+
+static block gen_string(const char* str) {
+  return gen_op_const(LOADK, json_string(str));
+}
+
+static block gen_index(block obj, block key) {
+  return block_join(obj, block_join(gen_subexp(key), gen_op_simple(INDEX)));
+}
+
+%}
+
+%%
+program: Exp { *answer = $1; }
+
+
+Exp:
+Term "as" '$' IDENT '|' Exp {
+  $$ = gen_op_simple(DUP);
+  block_append(&$$, $1);
+  block_append(&$$, block_bind(gen_op_var_unbound(STOREV, $4), $6));
+} |
+
+Exp '|' Exp { 
+  $$ = block_join($1, $3); 
+} |
+
+Exp ',' Exp { 
+  $$ = gen_both($1, $3); 
+} |
+
+Term { 
+  $$ = $1; 
+}
+
+
+ExpD:
+ExpD '|' ExpD { 
+  $$ = block_join($1, $3);
+} |
+
+Term {
+  $$ = $1;
+}
+
+
+Term:
+'.' {
+  $$ = gen_noop(); 
+} |
+Term '.' IDENT {
+  $$ = gen_index($1, gen_string($3)); 
+} |
+'.' IDENT { 
+  $$ = gen_index(gen_noop(), gen_string($2)); 
+} |
+/* FIXME: string literals */
+Term '[' Exp ']' {
+  $$ = gen_index($1, $3); 
+} |
+Term '[' ']' {
+  $$ = block_join($1, gen_op_simple(EACH)); 
+} |
+NUMBER {
+  $$ = gen_op_const(LOADK, json_integer($1)); 
+} |
+'(' Exp ')' { 
+  $$ = $2; 
+} | 
+'[' Exp ']' { 
+  $$ = gen_collect($2); 
+} |
+'[' ']' { 
+  $$ = gen_op_const(LOADK, json_array()); 
+} |
+'{' MkDict '}' { 
+  $$ = gen_subexp(gen_op_const(LOADK, json_object()));
+  block_append(&$$, $2);
+  block_append(&$$, gen_op_simple(POP));
+} |
+IDENT {
+  $$ = gen_op_symbol(CALL_BUILTIN_1_1, $1);
+} |
+'$' IDENT {
+  $$ = gen_op_var_unbound(LOADV, $2); 
+}
+
+MkDict:
+{ 
+  $$=gen_noop(); 
+}
+|
+MkDictPair
+{ $$ = $1; }
+| MkDictPair ',' MkDict { $$=block_join($1, $3); }
+
+MkDictPair
+: IDENT ':' ExpD { 
+  $$ = gen_dictpair(gen_string($1), $3);
+ }
+| IDENT {
+  $$ = gen_dictpair(gen_string($1),
+                    gen_index(gen_noop(), gen_string($1)));
+  }
+| '(' Exp ')' ':' ExpD {
+  $$ = gen_dictpair($2, $5);
+  }
+%%
+
+block compile(const char* str) {
+  yyscan_t scanner;
+  YY_BUFFER_STATE buf;
+  block answer = gen_noop();
+  yylex_init(&scanner);
+  buf = yy_scan_string(str, scanner);
+  yyparse(&answer, scanner);
+  yy_delete_buffer(buf, scanner);
+  yylex_destroy(scanner);
+  return answer;
+}

From fd738bfaced523da61875ca3e6cf80651247572c Mon Sep 17 00:00:00 2001
From: Stephen <stephen@polya.(none)>
Date: Thu, 16 Aug 2012 01:16:08 +0100
Subject: [PATCH 003/284] an addition operator, of sorts

---
 c/builtin.c     | 20 ++++++++++++++++++--
 c/execute.c     | 14 ++++++++++++++
 c/opcode_list.h |  1 +
 c/parser.y      |  7 +++++++
 4 files changed, 40 insertions(+), 2 deletions(-)

diff --git a/c/builtin.c b/c/builtin.c
index eba81994..ef37c28c 100644
--- a/c/builtin.c
+++ b/c/builtin.c
@@ -3,16 +3,32 @@
 #include <jansson.h>
 
 
-void f_false(json_t* input[], json_t* output[]) {
+static void f_false(json_t* input[], json_t* output[]) {
   output[0] = json_false();
 }
 
-void f_true(json_t* input[], json_t* output[]) {
+static void f_true(json_t* input[], json_t* output[]) {
   output[0] = json_true();
 }
 
+
+static void f_plus(json_t* input[], json_t* output[]) {
+  json_t* a = input[2];
+  json_t* b = input[1];
+  if (json_is_number(a) && json_is_number(b)) {
+    output[0] = json_real(json_number_value(a) + 
+                          json_number_value(b));
+  } else if (json_is_array(a) && json_is_array(b)) {
+    output[0] = json_copy(a);
+    json_array_extend(output[0], b);
+  } else {
+    output[0] = json_string("wtf gaize");
+  }
+}
+
 struct cfunction function_list[] = {
   {f_true, "true", CALL_BUILTIN_1_1},
   {f_false, "false", CALL_BUILTIN_1_1},
+  {f_plus, "_plus", CALL_BUILTIN_3_1},
 };
 struct symbol_table builtins = {function_list, sizeof(function_list)/sizeof(function_list[0])};
diff --git a/c/execute.c b/c/execute.c
index c06ed124..44aaab3a 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -340,6 +340,20 @@ json_t* jq_next() {
       stack_push(stackval_replace(top, cfunc_output[0]));
       break;
     }
+
+    case CALL_BUILTIN_3_1: {
+      stackval top = stack_pop();
+      json_t* a = stack_pop().value;
+      json_t* b = stack_pop().value;
+      cfunc_input[0] = top.value;
+      cfunc_input[1] = a;
+      cfunc_input[2] = b;
+      struct cfunction* func = &bc->globals->cfunctions[*pc++];
+      printf(" call %s\n", func->name);
+      func->fptr(cfunc_input, cfunc_output);
+      stack_push(stackval_replace(top, cfunc_output[0]));
+      break;
+    }
       
       
     }
diff --git a/c/opcode_list.h b/c/opcode_list.h
index d88381b7..2fe3f8a8 100644
--- a/c/opcode_list.h
+++ b/c/opcode_list.h
@@ -15,3 +15,4 @@ OP(APPEND, NONE,    2, 1)
 OP(INSERT, NONE,    4, 2)
 
 OP(CALL_BUILTIN_1_1, CFUNC, 1, 1)
+OP(CALL_BUILTIN_3_1, CFUNC, 3, 1)
diff --git a/c/parser.y b/c/parser.y
index e8721a17..393f7a83 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -71,6 +71,13 @@ Exp ',' Exp {
   $$ = gen_both($1, $3); 
 } |
 
+Exp '+' Exp {
+  $$ = gen_noop();
+  block_append(&$$, gen_subexp($1));
+  block_append(&$$, gen_subexp($3));
+  block_append(&$$, gen_op_symbol(CALL_BUILTIN_3_1, "_plus"));
+} |
+
 Term { 
   $$ = $1; 
 }

From 15ad640202ee6de5f442bdf22d5207618210d0ec Mon Sep 17 00:00:00 2001
From: Stephen <stephen@polya.(none)>
Date: Mon, 20 Aug 2012 15:53:20 +0100
Subject: [PATCH 004/284] Stacks grow down now

---
 c/forkable_stack.h | 50 +++++++++++++++++++++++++++++++++-------------
 1 file changed, 36 insertions(+), 14 deletions(-)

diff --git a/c/forkable_stack.h b/c/forkable_stack.h
index 8043c426..5b8ec8ad 100644
--- a/c/forkable_stack.h
+++ b/c/forkable_stack.h
@@ -1,6 +1,7 @@
 #include <stdlib.h>
 #include <stddef.h>
 #include <assert.h>
+#include <string.h>
 
 struct forkable_stack_header {
   int next;
@@ -9,15 +10,18 @@ struct forkable_stack_header {
 #define FORKABLE_STACK_HEADER struct forkable_stack_header fk_header_
 
 struct forkable_stack {
+  // Stack grows down from stk+length
+
   char* stk;
 
   // stk+length is just past end of allocated area
+  // stk = malloc(length)
   int length;
 
-  // stk+pos is just past top-of-stack item
+  // stk+pos is header of top object, or stk+length if empty
   int pos;
 
-  // everything before stk+savedlimit must be preserved
+  // everything after-or-including stk+savedlimit must be preserved
   int savedlimit;
 };
 
@@ -29,66 +33,84 @@ static void forkable_stack_check(struct forkable_stack* s) {
 }
 
 static int forkable_stack_empty(struct forkable_stack* s) {
-  return s->pos == 0;
+  return s->pos == s->length;
 }
 
 static void forkable_stack_init(struct forkable_stack* s, size_t sz) {
   s->stk = malloc(sz);
   s->length = sz;
-  s->pos = 0;
-  s->savedlimit = 0;
+  s->pos = s->length;
+  s->savedlimit = s->length;
   forkable_stack_check(s);
 }
 
 static void* forkable_stack_push(struct forkable_stack* s, size_t size) {
   forkable_stack_check(s);
-  int curr = s->pos > s->savedlimit ? s->pos : s->savedlimit;
-  if (curr + size > s->length) {
-    s->length = (size + s->length + 1024) * 2;
+  int curr = s->pos < s->savedlimit ? s->pos : s->savedlimit;
+  if (curr - size < 0) {
+    assert(0);
+    int oldlen = s->length;
+    s->length = (size + oldlen + 1024) * 2;
     s->stk = realloc(s->stk, s->length);
+    int shift = s->length - oldlen;
+    memmove(s->stk + shift, s->stk, oldlen);
+    s->pos += shift;
+    s->savedlimit += shift;
+    curr += shift;
   }
-  void* ret = (void*)(s->stk + curr);
+  void* ret = (void*)(s->stk + curr - size);
   ((struct forkable_stack_header*)ret)->next = s->pos;
-  s->pos = curr + size;
+  s->pos = curr - size;
+  forkable_stack_check(s);
   return ret;
 }
 
 static void* forkable_stack_peek(struct forkable_stack* s, size_t size) {
   assert(!forkable_stack_empty(s));
-  return (void*)(s->stk + s->pos - size);
+  forkable_stack_check(s);
+  return (void*)(s->stk + s->pos);
 }
 
 static void* forkable_stack_peek_next(struct forkable_stack* s, void* top, size_t size) {
+  forkable_stack_check(s);
   struct forkable_stack_header* elem = top;
-  return (void*)(s->stk + elem->next - size);
+  return (void*)(s->stk + elem->next);
 }
 
 static void forkable_stack_pop(struct forkable_stack* s, size_t size) {
+  forkable_stack_check(s);
   struct forkable_stack_header* elem = forkable_stack_peek(s, size);
   s->pos = elem->next;
 }
 
+
+
 struct forkable_stack_state {
   int prevpos, prevlimit;
 };
 
 static void forkable_stack_save(struct forkable_stack* s, struct forkable_stack_state* state) {
+  forkable_stack_check(s);
   state->prevpos = s->pos;
   state->prevlimit = s->savedlimit;
-  if (s->pos > s->savedlimit) s->savedlimit = s->pos;
+  if (s->pos < s->savedlimit) s->savedlimit = s->pos;
 }
 
 static void forkable_stack_switch(struct forkable_stack* s, struct forkable_stack_state* state) {
+  forkable_stack_check(s);
   int curr_pos = s->pos;
   s->pos = state->prevpos;
   state->prevpos = curr_pos;
 
   int curr_limit = s->savedlimit;
-  if (curr_pos > curr_limit) s->savedlimit = curr_pos;
+  if (curr_pos < curr_limit) s->savedlimit = curr_pos;
   state->prevlimit = curr_limit;
+  forkable_stack_check(s);
 }
 
 static void forkable_stack_restore(struct forkable_stack* s, struct forkable_stack_state* state) {
+  forkable_stack_check(s);
   s->pos = state->prevpos;
   s->savedlimit = state->prevlimit;
+  forkable_stack_check(s);
 }

From dd0d340ebafbafe92f43bbb77a96ea8531ac1307 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 21 Aug 2012 12:35:36 +0100
Subject: [PATCH 005/284] frame layout refactor

---
 c/bytecode.h       |   9 +++-
 c/compile.c        |   3 +-
 c/execute.c        | 110 ++++++++++++++++++---------------------------
 c/forkable_stack.h |  11 +++--
 c/frame_layout.h   |  81 +++++++++++++++++++++++++++++++++
 c/opcode.c         |   1 +
 c/opcode.h         |   3 +-
 c/opcode_list.h    |   2 +
 8 files changed, 147 insertions(+), 73 deletions(-)
 create mode 100644 c/frame_layout.h

diff --git a/c/bytecode.h b/c/bytecode.h
index ddf1105a..a7141e4b 100644
--- a/c/bytecode.h
+++ b/c/bytecode.h
@@ -23,11 +23,18 @@ struct symbol_table {
 struct bytecode {
   uint16_t* code;
   int codelen;
-  int framesize;
+
+  int nlocals;
+  int nclosures;
+
   json_t* constants;
   struct symbol_table* globals;
+
+  struct bytecode* subfunctions;
+  int nsubfunctions;
 };
 
 void dump_disassembly(struct bytecode* code);
 void dump_operation(struct bytecode* bc, uint16_t* op);
+
 #endif
diff --git a/c/compile.c b/c/compile.c
index cc344575..b102eeeb 100644
--- a/c/compile.c
+++ b/c/compile.c
@@ -274,7 +274,8 @@ struct bytecode* block_compile(struct symbol_table* syms, block b) {
   }
   free(stack_height);
   bc->constants = constant_pool;
-  bc->framesize = maxvar + 2; // FIXME: frames of size zero?
+  bc->nlocals = maxvar + 2; // FIXME: frames of size zero?
+  bc->nclosures = 0;
   bc->globals = syms;
   return bc;
 }
diff --git a/c/execute.c b/c/execute.c
index 44aaab3a..a97d80f2 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -10,6 +10,7 @@
 #include "compile.h"
 
 #include "forkable_stack.h"
+#include "frame_layout.h"
 
 
 typedef struct {
@@ -52,34 +53,19 @@ typedef struct {
   stackval sv;
 } data_stk_elem;
 
-data_stk_elem* stk_push_frame(int n) {
-  return forkable_stack_push(&data_stk, sizeof(data_stk_elem) * n);
-}
-
-void stk_pop_frame(int n) {
-  forkable_stack_pop(&data_stk, sizeof(data_stk_elem) * n);
-}
-
 void stk_push(stackval val) {
-  data_stk_elem* s = stk_push_frame(1);
+  data_stk_elem* s = forkable_stack_push(&data_stk, sizeof(data_stk_elem));
   s->sv = val;
 }
 
 stackval stk_pop() {
-  data_stk_elem* s = forkable_stack_peek(&data_stk, sizeof(data_stk_elem));
+  data_stk_elem* s = forkable_stack_peek(&data_stk);
   stackval sv = s->sv;
-  forkable_stack_pop(&data_stk, sizeof(data_stk_elem));
+  forkable_stack_pop(&data_stk);
   return sv;
 }
 
-
-typedef struct {
-  FORKABLE_STACK_HEADER;
-  struct bytecode* bc;
-  data_stk_elem* fp;
-  uint16_t* pc;
-} call_stk_elem;
-struct forkable_stack call_stk;
+struct forkable_stack frame_stk;
 
 
 struct forkpoint {
@@ -93,20 +79,20 @@ struct forkable_stack fork_stk;
 void stack_save(){
   struct forkpoint* fork = forkable_stack_push(&fork_stk, sizeof(struct forkpoint));
   forkable_stack_save(&data_stk, &fork->saved_data_stack);
-  forkable_stack_save(&call_stk, &fork->saved_call_stack);
+  forkable_stack_save(&frame_stk, &fork->saved_call_stack);
 }
 
 void stack_switch() {
-  struct forkpoint* fork = forkable_stack_peek(&fork_stk, sizeof(struct forkpoint));
+  struct forkpoint* fork = forkable_stack_peek(&fork_stk);
   forkable_stack_switch(&data_stk, &fork->saved_data_stack);
-  forkable_stack_switch(&call_stk, &fork->saved_call_stack);
+  forkable_stack_switch(&frame_stk, &fork->saved_call_stack);
 }
 
 void stack_restore(){
-  struct forkpoint* fork = forkable_stack_peek(&fork_stk, sizeof(struct forkpoint));
+  struct forkpoint* fork = forkable_stack_peek(&fork_stk);
   forkable_stack_restore(&data_stk, &fork->saved_data_stack);
-  forkable_stack_restore(&call_stk, &fork->saved_call_stack);
-  forkable_stack_pop(&fork_stk, sizeof(struct forkpoint));
+  forkable_stack_restore(&frame_stk, &fork->saved_call_stack);
+  forkable_stack_pop(&fork_stk);
 }
 
 #define stack_push stk_push
@@ -115,29 +101,31 @@ void stack_restore(){
 #define ON_BACKTRACK(op) ((op)+NUM_OPCODES)
 
 json_t* jq_next() {
-  assert(!forkable_stack_empty(&call_stk));
-  call_stk_elem* ctx = forkable_stack_peek(&call_stk, sizeof(call_stk_elem));
-  struct bytecode* bc = ctx->bc;
-  uint16_t* pc = ctx->pc;
-  data_stk_elem* fp = ctx->fp;
-  json_t* cpool = bc->constants;
-
   json_t* cfunc_input[MAX_CFUNCTION_ARGS] = {0};
   json_t* cfunc_output[MAX_CFUNCTION_ARGS] = {0};
+
+
+  assert(!forkable_stack_empty(&frame_stk));
+  uint16_t* pc = *frame_current_pc(&frame_stk);
+
   int backtracking = 0;
   while (1) {
-
-    dump_operation(bc, pc);
+    *frame_current_pc(&frame_stk) = pc;
+    dump_operation(frame_current_bytecode(&frame_stk), pc);
 
     uint16_t opcode = *pc++;
 
     printf("\t");
     const struct opcode_description* opdesc = opcode_describe(opcode);
-    data_stk_elem* param = forkable_stack_peek(&data_stk, sizeof(data_stk_elem));
+    data_stk_elem* param;
     for (int i=0; i<opdesc->stack_in; i++) {
+      if (i == 0) {
+        param = forkable_stack_peek(&data_stk);
+      } else {
+        param = forkable_stack_peek_next(&data_stk, param);
+      }
       json_dumpf(param->sv.value, stdout, JSON_ENCODE_ANY);
       if (i < opdesc->stack_in-1) printf(" | ");
-      param = forkable_stack_peek_next(&data_stk, param, sizeof(data_stk_elem));
     }
 
     if (backtracking) {
@@ -152,7 +140,7 @@ json_t* jq_next() {
     default: assert(0 && "invalid instruction");
 
     case LOADK: {
-      json_t* v = json_array_get(cpool, *pc++);
+      json_t* v = json_array_get(frame_current_bytecode(&frame_stk)->constants, *pc++);
       assert(v);
       stack_push(stackval_replace(stack_pop(), v));
       break;
@@ -205,17 +193,19 @@ json_t* jq_next() {
 
     case LOADV: {
       uint16_t v = *pc++;
-      stack_push(stackval_replace(stack_pop(), fp[v].sv.value));
+      json_t** var = frame_local_var(frame_current(&frame_stk), v);
+      stack_push(stackval_replace(stack_pop(), *var));
       break;
     }
 
     case STOREV: {
       uint16_t v = *pc++;
+      json_t** var = frame_local_var(frame_current(&frame_stk), v);
       stackval val = stack_pop();
       printf("V%d = ", v);
       json_dumpf(val.value, stdout, JSON_ENCODE_ANY);
       printf("\n");
-      fp[v].sv.value = val.value;
+      *var = val.value;
       break;
     }
 
@@ -277,10 +267,7 @@ json_t* jq_next() {
         stack_save();
         stack_push(array);
         stack_push(stackval_root(json_integer(idx+1)));
-        call_stk_elem* ctx = forkable_stack_push(&call_stk, sizeof(call_stk_elem));
-        ctx->bc = bc;
-        ctx->fp = fp;
-        ctx->pc = pc - 1;
+        frame_push_backtrack(&frame_stk, frame_current_bytecode(&frame_stk), pc - 1);
         stack_switch();
         
         stackval sv = {json_array_get(array.value, idx), 
@@ -296,22 +283,15 @@ json_t* jq_next() {
         return 0;
       }
       stack_restore();
-      call_stk_elem* ctx = forkable_stack_peek(&call_stk, sizeof(call_stk_elem));
-      bc = ctx->bc;
-      pc = ctx->pc;
-      fp = ctx->fp;
-      cpool = bc->constants;
-      forkable_stack_pop(&call_stk, sizeof(call_stk_elem));
+      pc = *frame_current_pc(&frame_stk);
+      frame_pop(&frame_stk);
       backtracking = 1;
       break;
     }
 
     case FORK: {
       stack_save();
-      call_stk_elem* ctx = forkable_stack_push(&call_stk, sizeof(call_stk_elem));
-      ctx->bc = bc;
-      ctx->fp = fp;
-      ctx->pc = pc - 1;
+      frame_push_backtrack(&frame_stk, frame_current_bytecode(&frame_stk), pc - 1);
       stack_switch();
       pc++; // skip offset this time
       break;
@@ -324,17 +304,14 @@ json_t* jq_next() {
 
     case YIELD: {
       json_t* value = stack_pop().value;
-      call_stk_elem* ctx = forkable_stack_push(&call_stk, sizeof(call_stk_elem));
-      ctx->bc = bc;
-      ctx->fp = fp;
-      ctx->pc = pc;
+      *frame_current_pc(&frame_stk) = pc;
       return value;
     }
       
     case CALL_BUILTIN_1_1: {
       stackval top = stack_pop();
       cfunc_input[0] = top.value;
-      struct cfunction* func = &bc->globals->cfunctions[*pc++];
+      struct cfunction* func = &frame_current_bytecode(&frame_stk)->globals->cfunctions[*pc++];
       printf(" call %s\n", func->name);
       func->fptr(cfunc_input, cfunc_output);
       stack_push(stackval_replace(top, cfunc_output[0]));
@@ -348,13 +325,19 @@ json_t* jq_next() {
       cfunc_input[0] = top.value;
       cfunc_input[1] = a;
       cfunc_input[2] = b;
-      struct cfunction* func = &bc->globals->cfunctions[*pc++];
+      struct cfunction* func = &frame_current_bytecode(&frame_stk)->globals->cfunctions[*pc++];
       printf(" call %s\n", func->name);
       func->fptr(cfunc_input, cfunc_output);
       stack_push(stackval_replace(top, cfunc_output[0]));
       break;
     }
+
+      /*
+    case CALL_1_1: {
+      uint16_t nargs = *pc++;
       
+    }
+      */
       
     }
   }
@@ -363,16 +346,11 @@ json_t* jq_next() {
 
 void jq_init(struct bytecode* bc, json_t* input) {
   forkable_stack_init(&data_stk, sizeof(stackval) * 100); // FIXME: lower this number, see if it breaks
-  forkable_stack_init(&call_stk, 1024); // FIXME: lower this number, see if it breaks
+  forkable_stack_init(&frame_stk, 1024); // FIXME: lower this number, see if it breaks
   forkable_stack_init(&fork_stk, 1024); // FIXME: lower this number, see if it breaks
   
-  data_stk_elem* frame = stk_push_frame(bc->framesize);
-  
   stack_push(stackval_root(input));
-  call_stk_elem* ctx = forkable_stack_push(&call_stk, sizeof(call_stk_elem));
-  ctx->pc = bc->code;
-  ctx->bc = bc;
-  ctx->fp = frame;
+  frame_push(&frame_stk, bc);
 }
 
 void run_program(struct bytecode* bc) {
diff --git a/c/forkable_stack.h b/c/forkable_stack.h
index 5b8ec8ad..88a280f2 100644
--- a/c/forkable_stack.h
+++ b/c/forkable_stack.h
@@ -1,3 +1,5 @@
+#ifndef FORKABLE_STACK_H
+#define FORKABLE_STACK_H
 #include <stdlib.h>
 #include <stddef.h>
 #include <assert.h>
@@ -65,21 +67,21 @@ static void* forkable_stack_push(struct forkable_stack* s, size_t size) {
   return ret;
 }
 
-static void* forkable_stack_peek(struct forkable_stack* s, size_t size) {
+static void* forkable_stack_peek(struct forkable_stack* s) {
   assert(!forkable_stack_empty(s));
   forkable_stack_check(s);
   return (void*)(s->stk + s->pos);
 }
 
-static void* forkable_stack_peek_next(struct forkable_stack* s, void* top, size_t size) {
+static void* forkable_stack_peek_next(struct forkable_stack* s, void* top) {
   forkable_stack_check(s);
   struct forkable_stack_header* elem = top;
   return (void*)(s->stk + elem->next);
 }
 
-static void forkable_stack_pop(struct forkable_stack* s, size_t size) {
+static void forkable_stack_pop(struct forkable_stack* s) {
   forkable_stack_check(s);
-  struct forkable_stack_header* elem = forkable_stack_peek(s, size);
+  struct forkable_stack_header* elem = forkable_stack_peek(s);
   s->pos = elem->next;
 }
 
@@ -114,3 +116,4 @@ static void forkable_stack_restore(struct forkable_stack* s, struct forkable_sta
   s->savedlimit = state->prevlimit;
   forkable_stack_check(s);
 }
+#endif
diff --git a/c/frame_layout.h b/c/frame_layout.h
new file mode 100644
index 00000000..55919f8a
--- /dev/null
+++ b/c/frame_layout.h
@@ -0,0 +1,81 @@
+#ifndef FRAME_LAYOUT_H
+#include "forkable_stack.h"
+#include "bytecode.h"
+#include <jansson.h>
+
+struct closure {
+  struct bytecode* bc;
+  uint16_t* pc;
+};
+
+typedef union frame_elem {
+  FORKABLE_STACK_HEADER;
+  struct closure closure;
+  json_t* jsonval;
+} *frame_ptr;
+
+/*
+ * Frame layout
+ * fr[0] - FORKABLE_STACK_HEADER (next pointer)
+ * fr[1] - self (used to store return addresses, etc)
+ * fr[2...nclosures+2] - closure params
+ * fr[nclosures+2..nclosures+nlocals+2] - local variables
+ */
+
+static int frame_size(struct bytecode* bc) {
+  return sizeof(union frame_elem) * (bc->nclosures + bc->nlocals + 2);
+}
+
+static struct closure* frame_self(frame_ptr fr) {
+  return &fr[1].closure;
+}
+
+static struct closure* frame_closure_arg(frame_ptr fr, int closure) {
+  assert(closure >= 0);
+  assert(closure < frame_self(fr)->bc->nclosures);
+  return &fr[2+closure].closure;
+}
+
+static json_t** frame_local_var(frame_ptr fr, int var) {
+  assert(var >= 0);
+  assert(var < frame_self(fr)->bc->nlocals);
+  return &fr[2 + frame_self(fr)->bc->nclosures + var].jsonval;
+}
+
+
+static frame_ptr frame_current(struct forkable_stack* stk) {
+  frame_ptr fp = forkable_stack_peek(stk);
+  struct bytecode* bc = frame_self(fp)->bc;
+  assert(frame_self(fp)->pc >= bc->code && frame_self(fp)->pc < bc->code + bc->codelen);
+  return fp;
+}
+
+static struct bytecode* frame_current_bytecode(struct forkable_stack* stk) {
+  return frame_self(frame_current(stk))->bc;
+}
+static uint16_t** frame_current_pc(struct forkable_stack* stk) {
+  return &frame_self(frame_current(stk))->pc;
+}
+
+
+
+
+static void frame_push(struct forkable_stack* stk, struct bytecode* bc) {
+  frame_ptr fp = forkable_stack_push(stk, frame_size(bc));
+  frame_self(fp)->bc = bc;
+  frame_self(fp)->pc = bc->code;
+}
+
+static void frame_push_backtrack(struct forkable_stack* stk, 
+                                      struct bytecode* bc, uint16_t* pc) {
+  frame_ptr fp = forkable_stack_push(stk, sizeof(union frame_elem) * 2);
+  frame_self(fp)->bc = bc;
+  frame_self(fp)->pc = pc;
+}
+
+
+static void frame_pop(struct forkable_stack* stk) {
+  forkable_stack_pop(stk);
+}
+
+#endif
diff --git a/c/opcode.c b/c/opcode.c
index b14e0db6..92bbcd29 100644
--- a/c/opcode.c
+++ b/c/opcode.c
@@ -5,6 +5,7 @@
 #define VARIABLE (OP_HAS_IMMEDIATE | OP_HAS_VARIABLE)
 #define BRANCH (OP_HAS_IMMEDIATE | OP_HAS_BRANCH)
 #define CFUNC (OP_HAS_IMMEDIATE | OP_HAS_SYMBOL | OP_HAS_CFUNC)
+#define UFUNC (OP_HAS_IMMEDIATE | OP_HAS_UFUNC)
 
 #define OP(name, imm, in, out) \
   {name, #name, imm, in, out},
diff --git a/c/opcode.h b/c/opcode.h
index 797e6a96..36d41920 100644
--- a/c/opcode.h
+++ b/c/opcode.h
@@ -19,7 +19,8 @@ enum {
   OP_HAS_VARIABLE = 4,
   OP_HAS_BRANCH = 8,
   OP_HAS_SYMBOL = 16,
-  OP_HAS_CFUNC = 32
+  OP_HAS_CFUNC = 32,
+  OP_HAS_UFUNC = 64,
 };
 struct opcode_description {
   opcode op;
diff --git a/c/opcode_list.h b/c/opcode_list.h
index 2fe3f8a8..d3bfb983 100644
--- a/c/opcode_list.h
+++ b/c/opcode_list.h
@@ -16,3 +16,5 @@ OP(INSERT, NONE,    4, 2)
 
 OP(CALL_BUILTIN_1_1, CFUNC, 1, 1)
 OP(CALL_BUILTIN_3_1, CFUNC, 3, 1)
+
+OP(CALL_1_1, UFUNC, 1, 1)

From c128c2029e863a6f06dbf90a811e221a8ffdccaa Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 21 Aug 2012 18:14:13 +0100
Subject: [PATCH 006/284] First pass at functions + tests

---
 c/Makefile         |   2 +-
 c/bytecode.c       |  43 ++++++++--
 c/bytecode.h       |  13 ++-
 c/compile.c        | 208 +++++++++++++++++++++++++++++++++------------
 c/compile.h        |   5 +-
 c/execute.c        |  42 +++++++--
 c/forkable_stack.h |  15 ++++
 c/frame_layout.h   |  43 +++++++---
 c/lexer.l          |   1 +
 c/main.c           |   5 +-
 c/opcode.c         |   6 +-
 c/opcode.h         |   4 +
 c/opcode_list.h    |   5 ++
 c/parser.y         |  15 +++-
 c/testdata         | 143 +++++++++++++++++++++++++++++++
 15 files changed, 461 insertions(+), 89 deletions(-)
 create mode 100644 c/testdata

diff --git a/c/Makefile b/c/Makefile
index ca20397f..01c3b540 100644
--- a/c/Makefile
+++ b/c/Makefile
@@ -14,7 +14,7 @@ lexer.yy.c: lexer.l
 lexer.yy.h: lexer.yy.c
 
 parser.tab.c: parser.y lexer.yy.h
-	bison -W -d parser.y
+	bison -W -d parser.y -v --report-file=parser.info
 parser.tab.h: parser.tab.c
 
 parsertest: parser.tab.c lexer.yy.c main.c opcode.c bytecode.c compile.c execute.c builtin.c
diff --git a/c/bytecode.c b/c/bytecode.c
index 477d3aa4..82e38f4c 100644
--- a/c/bytecode.c
+++ b/c/bytecode.c
@@ -4,12 +4,29 @@
 #include "bytecode.h"
 #include "opcode.h"
 
-void dump_disassembly(struct bytecode* bc) {
+static int bytecode_operation_length(uint16_t* codeptr) {
+  if (opcode_describe(*codeptr)->flags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
+    return 2 + codeptr[1] * 2;
+  } else {
+    return opcode_length(*codeptr);
+  }
+}
+
+void dump_disassembly(int indent, struct bytecode* bc) {
+  dump_code(indent, bc);
+  for (int i=0; i<bc->nsubfunctions; i++) {
+    printf("%*ssubfn[%d]:\n", indent, "", i);
+    dump_disassembly(indent+2, bc->subfunctions[i]);
+  }
+}
+
+void dump_code(int indent, struct bytecode* bc) {
   int pc = 0;
   while (pc < bc->codelen) {
+    printf("%*s", indent, "");
     dump_operation(bc, bc->code + pc);
     printf("\n");
-    pc += opcode_length(bc->code[pc]);
+    pc += bytecode_operation_length(bc->code + pc);
   }
 }
 
@@ -20,16 +37,28 @@ void dump_operation(struct bytecode* bc, uint16_t* codeptr) {
   printf("%s", op->name);
   if (op->flags & OP_HAS_IMMEDIATE) {
     uint16_t imm = bc->code[pc++];
-    printf(" ");
-    if (op->flags & OP_HAS_BRANCH) {
-      printf("%04d", pc + imm);
+    if (op->flags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
+      for (int i=0; i<imm; i++) {
+        uint16_t level = bc->code[pc++];
+        uint16_t idx = bc->code[pc++];
+        if (idx & ARG_NEWCLOSURE) {
+          printf(" subfn[%d]", idx & ~ARG_NEWCLOSURE);
+        } else {
+          printf(" param[%d]", idx);
+        }
+        if (level) {
+          printf("^%d", level);
+        }
+      }
+    } else if (op->flags & OP_HAS_BRANCH) {
+      printf(" %04d", pc + imm);
     } else if (op->flags & OP_HAS_CONSTANT) {
       json_dumpf(json_array_get(bc->constants, imm),
                  stdout, JSON_ENCODE_ANY);
     } else if (op->flags & OP_HAS_VARIABLE) {
-      printf("v%d", imm);
+      printf(" v%d", imm);
     } else {
-      printf("%d", imm);
+      printf(" %d", imm);
     }
   }  
 }
diff --git a/c/bytecode.h b/c/bytecode.h
index a7141e4b..b1146ad7 100644
--- a/c/bytecode.h
+++ b/c/bytecode.h
@@ -19,6 +19,12 @@ struct symbol_table {
   int ncfunctions;
 };
 
+// The bytecode format matters in:
+//   execute.c  - interpreter
+//   compile.c  - compiler
+//   bytecode.c - disassembler
+
+#define ARG_NEWCLOSURE 0x1000
 
 struct bytecode {
   uint16_t* code;
@@ -30,11 +36,14 @@ struct bytecode {
   json_t* constants;
   struct symbol_table* globals;
 
-  struct bytecode* subfunctions;
+  struct bytecode** subfunctions;
   int nsubfunctions;
+
+  struct bytecode* parent;
 };
 
-void dump_disassembly(struct bytecode* code);
+void dump_disassembly(int, struct bytecode* code);
+void dump_code(int, struct bytecode* code);
 void dump_operation(struct bytecode* bc, uint16_t* op);
 
 #endif
diff --git a/c/compile.c b/c/compile.c
index b102eeeb..89446330 100644
--- a/c/compile.c
+++ b/c/compile.c
@@ -14,11 +14,23 @@ struct inst {
     uint16_t intval;
     struct inst* target;
     json_t* constant;
-    char* symbol;
   } imm;
 
-  struct inst* var_binding;
-  int var_frame_idx;
+  // Binding
+  // An instruction requiring binding (for parameters/variables)
+  // is in one of three states:
+  //   bound_by = NULL  - Unbound free variable
+  //   bound_by = self  - This instruction binds a variable
+  //   bound_by = other - Uses variable bound by other instruction
+  // The immediate field is generally not meaningful until instructions
+  // are bound, and even then only for instructions which bind.
+  struct inst* bound_by;
+  char* symbol;
+  block subfn;
+
+  // This instruction is compiled as part of which function?
+  // (only used during block_compile)
+  struct bytecode* compiled;
 
   int bytecode_pos; // position just after this insn
 };
@@ -28,15 +40,16 @@ static inst* inst_new(opcode op) {
   i->next = i->prev = 0;
   i->op = op;
   i->bytecode_pos = -1;
-  i->var_binding = 0;
-  i->var_frame_idx = 0;
+  i->bound_by = 0;
+  i->symbol = 0;
+  i->subfn = gen_noop();
   return i;
 }
 
 static void inst_free(struct inst* i) {
-  if (opcode_describe(i->op)->flags &
-      (OP_HAS_SYMBOL | OP_HAS_VARIABLE)) {
-    free(i->imm.symbol);
+  free(i->symbol);
+  if (opcode_describe(i->op)->flags & OP_HAS_BLOCK) {
+    block_free(i->subfn);
   }
   free(i);
 }
@@ -89,25 +102,56 @@ void inst_set_target(block b, block target) {
 block gen_op_var_unbound(opcode op, const char* name) {
   assert(opcode_describe(op)->flags & OP_HAS_VARIABLE);
   inst* i = inst_new(op);
-  i->imm.symbol = strdup(name);
+  i->symbol = strdup(name);
   return inst_block(i);
 }
 
 block gen_op_var_bound(opcode op, block binder) {
+  assert(opcode_describe(op)->flags & OP_HAS_VARIABLE);
   assert(binder.first);
   assert(binder.first == binder.last);
-  block b = gen_op_var_unbound(op, binder.first->imm.symbol);
-  b.first->var_binding = binder.first;
+  block b = gen_op_var_unbound(op, binder.first->symbol);
+  b.first->bound_by = binder.first;
   return b;
 }
 
 block gen_op_symbol(opcode op, const char* sym) {
   assert(opcode_describe(op)->flags & OP_HAS_SYMBOL);
   inst* i = inst_new(op);
-  i->imm.symbol = strdup(sym);
+  i->symbol = strdup(sym);
   return inst_block(i);
 }
 
+block gen_op_block_defn(opcode op, const char* name, block block) {
+  assert(opcode_describe(op)->flags & OP_IS_CALL_PSEUDO);
+  assert(opcode_describe(op)->flags & OP_HAS_BLOCK);
+  inst* i = inst_new(op);
+  i->subfn = block;
+  i->symbol = strdup(name);
+  return inst_block(i);
+}
+
+block gen_op_block_unbound(opcode op, const char* name) {
+  assert(opcode_describe(op)->flags & OP_IS_CALL_PSEUDO);
+  inst* i = inst_new(op);
+  i->symbol = strdup(name);
+  return inst_block(i);
+}
+
+
+block gen_op_call(opcode op, block arglist) {
+  assert(opcode_describe(op)->flags & OP_HAS_VARIABLE_LENGTH_ARGLIST);
+  inst* i = inst_new(op);
+  int nargs = 0;
+  for (inst* curr = arglist.first; curr; curr = curr->next) {
+    assert(opcode_describe(curr->op)->flags & OP_IS_CALL_PSEUDO);
+    nargs++;
+  }
+  assert(nargs < 100); //FIXME
+  i->imm.intval = nargs;
+  return block_join(inst_block(i), arglist);
+}
+
 static void inst_join(inst* a, inst* b) {
   assert(a && b);
   assert(!a->next);
@@ -133,22 +177,31 @@ block block_join(block a, block b) {
   return c;
 }
 
-block block_bind(block binder, block body) {
+static void block_bind_subblock(block binder, block body, int bindflags) {
   assert(binder.first);
   assert(binder.first == binder.last);
-  assert(opcode_describe(binder.first->op)->flags & OP_HAS_VARIABLE);
-  assert(binder.first->imm.symbol);
-  assert(binder.first->var_binding == 0);
+  assert((opcode_describe(binder.first->op)->flags & bindflags) == bindflags);
+  assert(binder.first->symbol);
+  assert(binder.first->bound_by == 0 || binder.first->bound_by == binder.first);
 
-  binder.first->var_binding = binder.first;
+  binder.first->bound_by = binder.first;
   for (inst* i = body.first; i; i = i->next) {
-    if (opcode_describe(i->op)->flags & OP_HAS_VARIABLE &&
-        i->var_binding == 0 &&
-        !strcmp(i->imm.symbol, binder.first->imm.symbol)) {
-      // bind this variable
-      i->var_binding = binder.first;
+    int flags = opcode_describe(i->op)->flags;
+    if ((flags & bindflags) == bindflags &&
+        i->bound_by == 0 &&
+        !strcmp(i->symbol, binder.first->symbol)) {
+      // bind this instruction
+      i->bound_by = binder.first;
+    }
+    if (flags & OP_HAS_BLOCK) {
+      block_bind_subblock(binder, i->subfn, bindflags);
     }
   }
+}
+
+block block_bind(block binder, block body, int bindflags) {
+  bindflags |= OP_HAS_BINDING;
+  block_bind_subblock(binder, body, bindflags);
   return block_join(binder, body);
 }
 
@@ -180,7 +233,7 @@ block gen_collect(block expr) {
   block_append(&c, gen_op_simple(DUP));
   block_append(&c, gen_op_const(LOADK, json_array()));
   block array_var = block_bind(gen_op_var_unbound(STOREV, "collect"),
-                               gen_noop());
+                               gen_noop(), OP_HAS_VARIABLE);
   block_append(&c, array_var);
 
   block tail = {0};
@@ -204,64 +257,108 @@ block gen_else(block a, block b) {
   assert(0);
 }
 
+static uint16_t nesting_level(struct bytecode* bc, inst* target) {
+  uint16_t level = 0;
+  assert(bc && target->compiled);
+  while (bc && target->compiled != bc) {
+    level++;
+    bc = bc->parent;
+  }
+  assert(bc && bc == target->compiled);
+  return level;
+}
 
-struct bytecode* block_compile(struct symbol_table* syms, block b) {
-  inst* curr = b.first;
+static void compile(struct bytecode* bc, block b) {
   int pos = 0;
   int var_frame_idx = 0;
-  for (; curr; curr = curr->next) {
+  bc->nsubfunctions = 0;
+  for (inst* curr = b.first; curr; curr = curr->next) {
     if (!curr->next) assert(curr == b.last);
     pos += opcode_length(curr->op);
     curr->bytecode_pos = pos;
-    if (opcode_describe(curr->op)->flags & OP_HAS_VARIABLE) {
-      assert(curr->var_binding && "unbound variable");
-      if (curr->var_binding == curr) {
-        curr->var_frame_idx = var_frame_idx++;
-      }
+    curr->compiled = bc;
+
+    int opflags = opcode_describe(curr->op)->flags;
+    if (opflags & OP_HAS_BINDING) {
+      assert(curr->bound_by && "unbound term");
+    }
+    if ((opflags & OP_HAS_VARIABLE) &&
+        curr->bound_by == curr) {
+      curr->imm.intval = var_frame_idx++;
+    }
+    if (opflags & OP_HAS_BLOCK) {
+      assert(curr->bound_by == curr);
+      curr->imm.intval = bc->nsubfunctions++;
     }
   }
-  struct bytecode* bc = malloc(sizeof(struct bytecode));
+  if (bc->nsubfunctions) {
+    bc->subfunctions = malloc(sizeof(struct bytecode*) * bc->nsubfunctions);
+    for (inst* curr = b.first; curr; curr = curr->next) {
+      if (!(opcode_describe(curr->op)->flags & OP_HAS_BLOCK))
+        continue;
+      struct bytecode* subfn = malloc(sizeof(struct bytecode));
+      bc->subfunctions[curr->imm.intval] = subfn;
+      subfn->globals = bc->globals;
+      subfn->parent = bc;
+      compile(subfn, curr->subfn);
+    }
+  } else {
+    bc->subfunctions = 0;
+  }
   bc->codelen = pos;
   uint16_t* code = malloc(sizeof(uint16_t) * bc->codelen);
   bc->code = code;
-  int* stack_height = malloc(sizeof(int) * (bc->codelen + 1));
-  for (int i = 0; i<bc->codelen + 1; i++) stack_height[i] = -1;
   pos = 0;
   json_t* constant_pool = json_array();
   int maxvar = -1;
-  int curr_stack_height = 1;
-  for (curr = b.first; curr; curr = curr->next) {
+  for (inst* curr = b.first; curr; curr = curr->next) {
+    if (curr->op == CLOSURE_CREATE) {
+      // CLOSURE_CREATE opcodes define closures for use later in the
+      // codestream. They generate no code.
+
+      // FIXME: make the above true :)
+      code[pos++] = DUP;
+      code[pos++] = POP;
+      continue;
+    }
     const struct opcode_description* op = opcode_describe(curr->op);
-    if (curr_stack_height < op->stack_in) {
-      printf("Stack underflow at %04d\n", curr->bytecode_pos);
-    }
-    if (stack_height[curr->bytecode_pos] != -1 &&
-        stack_height[curr->bytecode_pos] != curr_stack_height) {
-      // FIXME: not sure this is right at all :(
-      printf("Inconsistent stack heights at %04d %s\n", curr->bytecode_pos, op->name);
-    }
-    curr_stack_height -= op->stack_in;
-    curr_stack_height += op->stack_out;
     code[pos++] = curr->op;
     int opflags = op->flags;
-    if (opflags & OP_HAS_CONSTANT) {
+    assert(!(op->flags & OP_IS_CALL_PSEUDO));
+    if (opflags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
+      int nargs = curr->imm.intval;
+      assert(nargs > 0);
+      code[pos++] = (uint16_t)nargs;
+      for (int i=0; i<nargs; i++) {
+        curr = curr->next;
+        assert(curr && opcode_describe(curr->op)->flags & OP_IS_CALL_PSEUDO);
+        code[pos++] = nesting_level(bc, curr->bound_by);
+        switch (curr->bound_by->op) {
+        default: assert(0 && "Unknown type of argument");
+        case CLOSURE_CREATE:
+          code[pos++] = curr->bound_by->imm.intval | ARG_NEWCLOSURE;
+          break;
+        }
+      }
+    } else if (opflags & OP_HAS_CONSTANT) {
       code[pos++] = json_array_size(constant_pool);
       json_array_append(constant_pool, curr->imm.constant);
     } else if (opflags & OP_HAS_VARIABLE) {
-      uint16_t var = (uint16_t)curr->var_binding->var_frame_idx;
+      // no closing over variables yet
+      assert(curr->bound_by->compiled == bc);
+      uint16_t var = (uint16_t)curr->bound_by->imm.intval;
       code[pos++] = var;
       if (var > maxvar) maxvar = var;
     } else if (opflags & OP_HAS_BRANCH) {
       assert(curr->imm.target->bytecode_pos != -1);
       assert(curr->imm.target->bytecode_pos > pos); // only forward branches
       code[pos] = curr->imm.target->bytecode_pos - (pos + 1);
-      stack_height[curr->imm.target->bytecode_pos] = curr_stack_height;
       pos++;
     } else if (opflags & OP_HAS_CFUNC) {
-      assert(curr->imm.symbol);
+      assert(curr->symbol);
       int found = 0;
-      for (int i=0; i<syms->ncfunctions; i++) {
-        if (!strcmp(curr->imm.symbol, syms->cfunctions[i].name)) {
+      for (int i=0; i<bc->globals->ncfunctions; i++) {
+        if (!strcmp(curr->symbol, bc->globals->cfunctions[i].name)) {
           code[pos++] = i;
           found = 1;
           break;
@@ -272,11 +369,16 @@ struct bytecode* block_compile(struct symbol_table* syms, block b) {
       code[pos++] = curr->imm.intval;
     }
   }
-  free(stack_height);
   bc->constants = constant_pool;
   bc->nlocals = maxvar + 2; // FIXME: frames of size zero?
   bc->nclosures = 0;
+}
+
+struct bytecode* block_compile(struct symbol_table* syms, block b) {
+  struct bytecode* bc = malloc(sizeof(struct bytecode));
+  bc->parent = 0;
   bc->globals = syms;
+  compile(bc, b);
   return bc;
 }
 
diff --git a/c/compile.h b/c/compile.h
index 0ba54f15..d72ddcef 100644
--- a/c/compile.h
+++ b/c/compile.h
@@ -17,6 +17,9 @@ block gen_op_const(opcode op, json_t* constant);
 block gen_op_target(opcode op, block target);
 block gen_op_var_unbound(opcode op, const char* name);
 block gen_op_var_bound(opcode op, block binder);
+block gen_op_block_defn(opcode op, const char* name, block block);
+block gen_op_block_unbound(opcode op, const char* name);
+block gen_op_call(opcode op, block arglist);
 block gen_op_symbol(opcode op, const char* name);
 
 block gen_subexp(block a);
@@ -27,7 +30,7 @@ block gen_else(block a, block b);
 
 void block_append(block* b, block b2);
 block block_join(block a, block b);
-block block_bind(block binder, block body);
+block block_bind(block binder, block body, int bindflags);
 
 struct bytecode* block_compile(struct symbol_table*, block);
 
diff --git a/c/execute.c b/c/execute.c
index a97d80f2..8bd8ec3c 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -95,6 +95,18 @@ void stack_restore(){
   forkable_stack_pop(&fork_stk);
 }
 
+static struct closure make_closure(struct forkable_stack* stk, frame_ptr fr, uint16_t* pc) {
+  uint16_t level = *pc++;
+  uint16_t idx = *pc++;
+  fr = frame_get_level(stk, fr, level);
+  if (idx & ARG_NEWCLOSURE) {
+    int subfn_idx = idx & ~ARG_NEWCLOSURE;
+    assert(subfn_idx < frame_self(fr)->bc->nsubfunctions);
+    return closure_new(stk, frame_self(fr)->bc->subfunctions[subfn_idx]);
+  } else {
+    return *frame_closure_arg(fr, idx);
+  }
+}
 #define stack_push stk_push
 #define stack_pop stk_pop
 
@@ -267,7 +279,7 @@ json_t* jq_next() {
         stack_save();
         stack_push(array);
         stack_push(stackval_root(json_integer(idx+1)));
-        frame_push_backtrack(&frame_stk, frame_current_bytecode(&frame_stk), pc - 1);
+        frame_push_backtrack(&frame_stk, pc - 1);
         stack_switch();
         
         stackval sv = {json_array_get(array.value, idx), 
@@ -291,7 +303,7 @@ json_t* jq_next() {
 
     case FORK: {
       stack_save();
-      frame_push_backtrack(&frame_stk, frame_current_bytecode(&frame_stk), pc - 1);
+      frame_push_backtrack(&frame_stk, pc - 1);
       stack_switch();
       pc++; // skip offset this time
       break;
@@ -332,13 +344,27 @@ json_t* jq_next() {
       break;
     }
 
-      /*
     case CALL_1_1: {
-      uint16_t nargs = *pc++;
-      
+      uint16_t nclosures = *pc++;
+      *frame_current_pc(&frame_stk) = pc + nclosures * 2;
+      frame_ptr new_frame = frame_push(&frame_stk, 
+                                       make_closure(&frame_stk, frame_current(&frame_stk), pc));
+      pc += 2;
+      frame_ptr old_frame = forkable_stack_peek_next(&frame_stk, new_frame);
+      for (int i=0; i<nclosures-1; i++) {
+        *frame_closure_arg(new_frame, i) = make_closure(&frame_stk, old_frame, pc);
+        pc += 2;
+      }
+
+      pc = *frame_current_pc(&frame_stk);
+      break;
+    }
+
+    case RET: {
+      frame_pop(&frame_stk);
+      pc = *frame_current_pc(&frame_stk);
+      break;
     }
-      */
-      
     }
   }
 }
@@ -350,7 +376,7 @@ void jq_init(struct bytecode* bc, json_t* input) {
   forkable_stack_init(&fork_stk, 1024); // FIXME: lower this number, see if it breaks
   
   stack_push(stackval_root(input));
-  frame_push(&frame_stk, bc);
+  frame_push(&frame_stk, closure_new_toplevel(bc));
 }
 
 void run_program(struct bytecode* bc) {
diff --git a/c/forkable_stack.h b/c/forkable_stack.h
index 88a280f2..3de9f3e0 100644
--- a/c/forkable_stack.h
+++ b/c/forkable_stack.h
@@ -116,4 +116,19 @@ static void forkable_stack_restore(struct forkable_stack* s, struct forkable_sta
   s->savedlimit = state->prevlimit;
   forkable_stack_check(s);
 }
+
+typedef int stack_idx;
+
+static stack_idx forkable_stack_to_idx(struct forkable_stack* s, void* ptr) {
+  char* item = ptr;
+  int pos = item - s->stk;
+  assert(pos >= 0 && pos < s->length);
+  return s->length - pos;
+}
+
+static void* forkable_stack_from_idx(struct forkable_stack* s, stack_idx idx) {
+  assert(idx >= 1 && idx <= s->length);
+  return &s->stk[s->length - idx];
+}
+
 #endif
diff --git a/c/frame_layout.h b/c/frame_layout.h
index 55919f8a..373c2b86 100644
--- a/c/frame_layout.h
+++ b/c/frame_layout.h
@@ -6,6 +6,7 @@
 struct closure {
   struct bytecode* bc;
   uint16_t* pc;
+  stack_idx env;
 };
 
 typedef union frame_elem {
@@ -57,23 +58,41 @@ static uint16_t** frame_current_pc(struct forkable_stack* stk) {
   return &frame_self(frame_current(stk))->pc;
 }
 
-
-
-
-static void frame_push(struct forkable_stack* stk, struct bytecode* bc) {
-  frame_ptr fp = forkable_stack_push(stk, frame_size(bc));
-  frame_self(fp)->bc = bc;
-  frame_self(fp)->pc = bc->code;
+static frame_ptr frame_get_parent(struct forkable_stack* stk, frame_ptr fr) {
+  return forkable_stack_from_idx(stk, frame_self(fr)->env);
 }
 
-static void frame_push_backtrack(struct forkable_stack* stk, 
-                                      struct bytecode* bc, uint16_t* pc) {
+static frame_ptr frame_get_level(struct forkable_stack* stk, frame_ptr fr, int level) {
+  for (int i=0; i<level; i++) {
+    fr = frame_get_parent(stk, fr);
+  }
+  return fr;
+}
+
+static struct closure closure_new_toplevel(struct bytecode* bc) {
+  struct closure cl = {bc, bc->code, -1};
+  return cl;
+}
+static struct closure closure_new(struct forkable_stack* stk, struct bytecode* bc) {
+  struct closure cl = {bc, bc->code, 
+                       forkable_stack_to_idx(stk, frame_current(stk))};
+  return cl;
+}
+
+static frame_ptr frame_push(struct forkable_stack* stk, struct closure cl) {
+  frame_ptr fp = forkable_stack_push(stk, frame_size(cl.bc));
+  *frame_self(fp) = cl;
+  return fp;
+}
+
+static frame_ptr frame_push_backtrack(struct forkable_stack* stk, uint16_t* pc) {
+  struct closure curr = *frame_self(frame_current(stk));
   frame_ptr fp = forkable_stack_push(stk, sizeof(union frame_elem) * 2);
-  frame_self(fp)->bc = bc;
-  frame_self(fp)->pc = pc;
+  curr.pc = pc;
+  *frame_self(fp) = curr;
+  return fp;
 }
 
-
 static void frame_pop(struct forkable_stack* stk) {
   forkable_stack_pop(stk);
 }
diff --git a/c/lexer.l b/c/lexer.l
index 42103c40..abf33263 100644
--- a/c/lexer.l
+++ b/c/lexer.l
@@ -11,6 +11,7 @@
 
 "==" { return EQ; }
 "as" { return AS; }
+"def" { return DEF; }
 "."|"="|";"|"["|"]"|","|":"|"("|")"|"{"|"}"|"|"|"+"|"\$" { return yytext[0];}
 
 [[:digit:]]+  { yylval->num = atoi(yytext);   return NUMBER;}
diff --git a/c/main.c b/c/main.c
index 5017d9fa..f8ea2149 100644
--- a/c/main.c
+++ b/c/main.c
@@ -32,6 +32,9 @@ void run_tests() {
     block_append(&program, gen_op_simple(BACKTRACK));
     struct bytecode* bc = block_compile(&builtins, program);
     block_free(program);
+    printf("Disassembly:\n");
+    dump_disassembly(2, bc);
+    printf("\n");
     fgets(buf, sizeof(buf), testdata);
     json_t* input = json_loads(buf, JSON_DECODE_ANY, 0);
     jq_init(bc, input);
@@ -76,7 +79,7 @@ int main(int argc, char* argv[]) {
   block_append(&blk, block_join(gen_op_simple(YIELD), gen_op_simple(BACKTRACK)));
   struct bytecode* bc = block_compile(&builtins, blk);
   block_free(blk);
-  dump_disassembly(bc);
+  dump_disassembly(0, bc);
   printf("\n");
   run_program(bc);
 }
diff --git a/c/opcode.c b/c/opcode.c
index 92bbcd29..ff41f86c 100644
--- a/c/opcode.c
+++ b/c/opcode.c
@@ -2,10 +2,12 @@
 
 #define NONE 0
 #define CONSTANT (OP_HAS_IMMEDIATE | OP_HAS_CONSTANT)
-#define VARIABLE (OP_HAS_IMMEDIATE | OP_HAS_VARIABLE)
+#define VARIABLE (OP_HAS_IMMEDIATE | OP_HAS_VARIABLE | OP_HAS_BINDING)
 #define BRANCH (OP_HAS_IMMEDIATE | OP_HAS_BRANCH)
 #define CFUNC (OP_HAS_IMMEDIATE | OP_HAS_SYMBOL | OP_HAS_CFUNC)
-#define UFUNC (OP_HAS_IMMEDIATE | OP_HAS_UFUNC)
+#define UFUNC (OP_HAS_IMMEDIATE | OP_HAS_UFUNC | OP_HAS_VARIABLE_LENGTH_ARGLIST)
+#define CLOSURE_DEFINE (OP_HAS_IMMEDIATE | OP_HAS_BLOCK | OP_IS_CALL_PSEUDO | OP_HAS_BINDING)
+#define CLOSURE_REF (OP_HAS_IMMEDIATE | OP_IS_CALL_PSEUDO | OP_HAS_BINDING)
 
 #define OP(name, imm, in, out) \
   {name, #name, imm, in, out},
diff --git a/c/opcode.h b/c/opcode.h
index 36d41920..262ecb3b 100644
--- a/c/opcode.h
+++ b/c/opcode.h
@@ -21,6 +21,10 @@ enum {
   OP_HAS_SYMBOL = 16,
   OP_HAS_CFUNC = 32,
   OP_HAS_UFUNC = 64,
+  OP_IS_CALL_PSEUDO = 128,
+  OP_HAS_VARIABLE_LENGTH_ARGLIST = 256,
+  OP_HAS_BLOCK = 512,
+  OP_HAS_BINDING = 1024,
 };
 struct opcode_description {
   opcode op;
diff --git a/c/opcode_list.h b/c/opcode_list.h
index d3bfb983..c54e1fda 100644
--- a/c/opcode_list.h
+++ b/c/opcode_list.h
@@ -18,3 +18,8 @@ OP(CALL_BUILTIN_1_1, CFUNC, 1, 1)
 OP(CALL_BUILTIN_3_1, CFUNC, 3, 1)
 
 OP(CALL_1_1, UFUNC, 1, 1)
+OP(RET, NONE, 1, 1)
+
+OP(CLOSURE_PARAM, CLOSURE_REF, 0, 0)
+OP(CLOSURE_REF, CLOSURE_REF, 0, 0)
+OP(CLOSURE_CREATE, CLOSURE_DEFINE, 0, 0)
diff --git a/c/parser.y b/c/parser.y
index 393f7a83..ca82fcd5 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -20,10 +20,14 @@
 %token <str> IDENT
 %token <num> NUMBER
 
+ /* revolting hack */
+%left ';'
+
 %left '|'
 %left ','
 %token EQ "=="
 %token AS "as"
+%token DEF "def"
 %nonassoc EQ
 %left '+'
 
@@ -55,12 +59,16 @@ static block gen_index(block obj, block key) {
 %%
 program: Exp { *answer = $1; }
 
-
 Exp:
+"def" IDENT ':' Exp ';' Exp {
+  block body = block_join($4, gen_op_simple(RET));
+  $$ = block_bind(gen_op_block_defn(CLOSURE_CREATE, $2, body), $6, OP_IS_CALL_PSEUDO);
+} |
+
 Term "as" '$' IDENT '|' Exp {
   $$ = gen_op_simple(DUP);
   block_append(&$$, $1);
-  block_append(&$$, block_bind(gen_op_var_unbound(STOREV, $4), $6));
+  block_append(&$$, block_bind(gen_op_var_unbound(STOREV, $4), $6, OP_HAS_VARIABLE));
 } |
 
 Exp '|' Exp { 
@@ -132,6 +140,9 @@ IDENT {
 } |
 '$' IDENT {
   $$ = gen_op_var_unbound(LOADV, $2); 
+} | 
+'$' '$' IDENT {
+  $$ = gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, $3));
 }
 
 MkDict:
diff --git a/c/testdata b/c/testdata
new file mode 100644
index 00000000..cc4d17bc
--- /dev/null
+++ b/c/testdata
@@ -0,0 +1,143 @@
+# Tests are groups of three lines: program, input, expected output
+# Blank lines and lines starting with # are ignored
+
+#
+# Simple value tests to check parser. Input is irrelevant
+#
+
+true
+null
+true
+
+false
+null
+false
+
+# null
+# 42
+# null
+
+1
+null
+1
+
+# FIXME: much more number testing needed
+
+{}
+null
+{}
+
+[]
+null
+[]
+
+# FIXME: string literals
+
+#
+# Dictionary construction syntax
+#
+
+{a: 1}
+null
+{"a":1}
+
+# FIXME: string literals
+
+#
+# Field access, piping
+#
+
+.foo
+{"foo": 42, "bar": 43}
+42
+
+.foo | .bar
+{"foo": {"bar": 42}, "bar": "badvalue"}
+42
+
+.foo.bar
+{"foo": {"bar": 42}, "bar": "badvalue"}
+42
+
+
+# FIXME strings
+# .["foo"].bar
+# {"foo": {"bar": 42}, "bar": "badvalue"}
+# 42
+
+
+#
+# Multiple outputs, iteration
+#
+
+.[]
+[1,2,3]
+1
+2
+3
+
+[(.,1),((.,.[]),(2,3))]
+["a","b"]
+[["a","b"],1,["a","b"],"a","b",2,3]
+
+[([5,5][]),.,.[]]
+[1,2,3]
+[5,5,[1,2,3],1,2,3]
+
+{x: (1,2)},{x:3} | .x
+null
+1
+2
+3
+
+#
+# Variables
+#
+
+1 as $x | 2 as $y | [$x,$y,$x]
+null
+[1,2,1]
+
+[1,2,3][] as $x | [[4,5,6,7][$x]]
+null
+[5]
+[6]
+[7]
+
+1 as $x | [$x,$x,$x as $x | $x]
+null
+[1,1,1]
+
+# [.,(.[] | {x:.},.),.,.[]]
+
+#
+# Builtin functions
+#
+
+# FIXME: floats vs. integer
+
+1+1
+null
+2.0
+
+.+4
+15
+19.0
+
+[1,2,3] + [.]
+null
+[1,2,3,null]
+
+#
+# User-defined functions
+# Oh god.
+#
+
+def f: . + 1; def g: def g: . + 100; $$f | $$g | $$f; ($$f | $$g), $$g
+3.0
+106.0
+105.0
+
+[[100,200][] as $x | def f: . + $x; $$f | $$f | $$f]
+1
+[300.0, 600.0]
\ No newline at end of file

From 79d81f4beef13612241be3fe16c29a65272a4bf6 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 21 Aug 2012 18:24:38 +0100
Subject: [PATCH 007/284] Closures over variables

---
 c/bytecode.c | 9 +++++++--
 c/compile.c  | 3 +--
 c/execute.c  | 8 ++++++--
 c/opcode.c   | 2 +-
 c/opcode.h   | 5 ++++-
 c/testdata   | 2 +-
 6 files changed, 20 insertions(+), 9 deletions(-)

diff --git a/c/bytecode.c b/c/bytecode.c
index 82e38f4c..08d7fff3 100644
--- a/c/bytecode.c
+++ b/c/bytecode.c
@@ -35,7 +35,7 @@ void dump_operation(struct bytecode* bc, uint16_t* codeptr) {
   printf("%04d ", pc);
   const struct opcode_description* op = opcode_describe(bc->code[pc++]);
   printf("%s", op->name);
-  if (op->flags & OP_HAS_IMMEDIATE) {
+  if (op->flags & OP_HAS_IMMEDIATE || op->flags & OP_HAS_DOUBLE_IMMEDIATE) {
     uint16_t imm = bc->code[pc++];
     if (op->flags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
       for (int i=0; i<imm; i++) {
@@ -53,10 +53,15 @@ void dump_operation(struct bytecode* bc, uint16_t* codeptr) {
     } else if (op->flags & OP_HAS_BRANCH) {
       printf(" %04d", pc + imm);
     } else if (op->flags & OP_HAS_CONSTANT) {
+      printf(" ");
       json_dumpf(json_array_get(bc->constants, imm),
                  stdout, JSON_ENCODE_ANY);
     } else if (op->flags & OP_HAS_VARIABLE) {
-      printf(" v%d", imm);
+      uint16_t v = bc->code[pc++];
+      printf(" v%d", v);
+      if (imm) {
+        printf("^%d", imm);
+      }
     } else {
       printf(" %d", imm);
     }
diff --git a/c/compile.c b/c/compile.c
index 89446330..cf5834b2 100644
--- a/c/compile.c
+++ b/c/compile.c
@@ -344,8 +344,7 @@ static void compile(struct bytecode* bc, block b) {
       code[pos++] = json_array_size(constant_pool);
       json_array_append(constant_pool, curr->imm.constant);
     } else if (opflags & OP_HAS_VARIABLE) {
-      // no closing over variables yet
-      assert(curr->bound_by->compiled == bc);
+      code[pos++] = nesting_level(bc, curr->bound_by);
       uint16_t var = (uint16_t)curr->bound_by->imm.intval;
       code[pos++] = var;
       if (var > maxvar) maxvar = var;
diff --git a/c/execute.c b/c/execute.c
index 8bd8ec3c..5245682b 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -204,15 +204,19 @@ json_t* jq_next() {
     }
 
     case LOADV: {
+      uint16_t level = *pc++;
       uint16_t v = *pc++;
-      json_t** var = frame_local_var(frame_current(&frame_stk), v);
+      frame_ptr fp = frame_get_level(&frame_stk, frame_current(&frame_stk), level);
+      json_t** var = frame_local_var(fp, v);
       stack_push(stackval_replace(stack_pop(), *var));
       break;
     }
 
     case STOREV: {
+      uint16_t level = *pc++;
       uint16_t v = *pc++;
-      json_t** var = frame_local_var(frame_current(&frame_stk), v);
+      frame_ptr fp = frame_get_level(&frame_stk, frame_current(&frame_stk), level);
+      json_t** var = frame_local_var(fp, v);
       stackval val = stack_pop();
       printf("V%d = ", v);
       json_dumpf(val.value, stdout, JSON_ENCODE_ANY);
diff --git a/c/opcode.c b/c/opcode.c
index ff41f86c..87179a51 100644
--- a/c/opcode.c
+++ b/c/opcode.c
@@ -2,7 +2,7 @@
 
 #define NONE 0
 #define CONSTANT (OP_HAS_IMMEDIATE | OP_HAS_CONSTANT)
-#define VARIABLE (OP_HAS_IMMEDIATE | OP_HAS_VARIABLE | OP_HAS_BINDING)
+#define VARIABLE (OP_HAS_DOUBLE_IMMEDIATE | OP_HAS_VARIABLE | OP_HAS_BINDING)
 #define BRANCH (OP_HAS_IMMEDIATE | OP_HAS_BRANCH)
 #define CFUNC (OP_HAS_IMMEDIATE | OP_HAS_SYMBOL | OP_HAS_CFUNC)
 #define UFUNC (OP_HAS_IMMEDIATE | OP_HAS_UFUNC | OP_HAS_VARIABLE_LENGTH_ARGLIST)
diff --git a/c/opcode.h b/c/opcode.h
index 262ecb3b..87d24349 100644
--- a/c/opcode.h
+++ b/c/opcode.h
@@ -25,6 +25,7 @@ enum {
   OP_HAS_VARIABLE_LENGTH_ARGLIST = 256,
   OP_HAS_BLOCK = 512,
   OP_HAS_BINDING = 1024,
+  OP_HAS_DOUBLE_IMMEDIATE = 2048,
 };
 struct opcode_description {
   opcode op;
@@ -36,6 +37,8 @@ struct opcode_description {
 const struct opcode_description* opcode_describe(opcode op);
 
 static inline int opcode_length(opcode op) {
-  return 1 + (opcode_describe(op)->flags & OP_HAS_IMMEDIATE ? 1 : 0);
+  return 1 + 
+    (opcode_describe(op)->flags & OP_HAS_IMMEDIATE ? 1 : 0) +
+    (opcode_describe(op)->flags & OP_HAS_DOUBLE_IMMEDIATE ? 2 : 0);
 }
 #endif
diff --git a/c/testdata b/c/testdata
index cc4d17bc..cefc4b04 100644
--- a/c/testdata
+++ b/c/testdata
@@ -140,4 +140,4 @@ def f: . + 1; def g: def g: . + 100; $$f | $$g | $$f; ($$f | $$g), $$g
 
 [[100,200][] as $x | def f: . + $x; $$f | $$f | $$f]
 1
-[300.0, 600.0]
\ No newline at end of file
+[301.0, 601.0]

From 2086e59ab16bf5c370421c967dd5b4596e170456 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 22 Aug 2012 19:05:53 +0100
Subject: [PATCH 008/284] bugfix for backtracking over RET insns, and a truly
 evil testcase

---
 c/bytecode.c       |  2 +-
 c/compile.c        |  6 +++---
 c/execute.c        | 29 ++++++++++++++++-------------
 c/forkable_stack.h |  6 +++++-
 c/frame_layout.h   | 44 +++++++++++++++++++++++++++++---------------
 c/main.c           |  1 -
 c/opcode.c         | 19 ++++++++++---------
 c/opcode.h         | 14 +++++++++-----
 c/opcode_list.h    |  4 ++--
 c/testdata         | 11 ++++++++---
 10 files changed, 83 insertions(+), 53 deletions(-)

diff --git a/c/bytecode.c b/c/bytecode.c
index 08d7fff3..c85be804 100644
--- a/c/bytecode.c
+++ b/c/bytecode.c
@@ -35,7 +35,7 @@ void dump_operation(struct bytecode* bc, uint16_t* codeptr) {
   printf("%04d ", pc);
   const struct opcode_description* op = opcode_describe(bc->code[pc++]);
   printf("%s", op->name);
-  if (op->flags & OP_HAS_IMMEDIATE || op->flags & OP_HAS_DOUBLE_IMMEDIATE) {
+  if (op->length > 1) {
     uint16_t imm = bc->code[pc++];
     if (op->flags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
       for (int i=0; i<imm; i++) {
diff --git a/c/compile.c b/c/compile.c
index cf5834b2..913cebca 100644
--- a/c/compile.c
+++ b/c/compile.c
@@ -65,7 +65,7 @@ block gen_noop() {
 }
 
 block gen_op_simple(opcode op) {
-  assert(!(opcode_describe(op)->flags & OP_HAS_IMMEDIATE));
+  assert(opcode_describe(op)->length == 1);
   return inst_block(inst_new(op));
 }
 
@@ -364,8 +364,8 @@ static void compile(struct bytecode* bc, block b) {
         }
       }
       assert(found);
-    } else if (opflags & OP_HAS_IMMEDIATE) {
-      code[pos++] = curr->imm.intval;
+    } else if (op->length > 1) {
+      assert(0 && "codegen not implemented for this operation");
     }
   }
   bc->constants = constant_pool;
diff --git a/c/execute.c b/c/execute.c
index 5245682b..a8dfc5e7 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -104,6 +104,7 @@ static struct closure make_closure(struct forkable_stack* stk, frame_ptr fr, uin
     assert(subfn_idx < frame_self(fr)->bc->nsubfunctions);
     return closure_new(stk, frame_self(fr)->bc->subfunctions[subfn_idx]);
   } else {
+    // FIXME: set pc
     return *frame_closure_arg(fr, idx);
   }
 }
@@ -116,13 +117,14 @@ json_t* jq_next() {
   json_t* cfunc_input[MAX_CFUNCTION_ARGS] = {0};
   json_t* cfunc_output[MAX_CFUNCTION_ARGS] = {0};
 
-
   assert(!forkable_stack_empty(&frame_stk));
-  uint16_t* pc = *frame_current_pc(&frame_stk);
+  uint16_t* pc = *frame_current_retaddr(&frame_stk);
+  frame_pop(&frame_stk);
+  
+  assert(!forkable_stack_empty(&frame_stk));
 
   int backtracking = 0;
   while (1) {
-    *frame_current_pc(&frame_stk) = pc;
     dump_operation(frame_current_bytecode(&frame_stk), pc);
 
     uint16_t opcode = *pc++;
@@ -299,7 +301,7 @@ json_t* jq_next() {
         return 0;
       }
       stack_restore();
-      pc = *frame_current_pc(&frame_stk);
+      pc = *frame_current_retaddr(&frame_stk);
       frame_pop(&frame_stk);
       backtracking = 1;
       break;
@@ -320,7 +322,7 @@ json_t* jq_next() {
 
     case YIELD: {
       json_t* value = stack_pop().value;
-      *frame_current_pc(&frame_stk) = pc;
+      frame_push_backtrack(&frame_stk, pc);
       return value;
     }
       
@@ -350,9 +352,9 @@ json_t* jq_next() {
 
     case CALL_1_1: {
       uint16_t nclosures = *pc++;
-      *frame_current_pc(&frame_stk) = pc + nclosures * 2;
       frame_ptr new_frame = frame_push(&frame_stk, 
-                                       make_closure(&frame_stk, frame_current(&frame_stk), pc));
+                                       make_closure(&frame_stk, frame_current(&frame_stk), pc),
+                                       pc + nclosures * 2);
       pc += 2;
       frame_ptr old_frame = forkable_stack_peek_next(&frame_stk, new_frame);
       for (int i=0; i<nclosures-1; i++) {
@@ -360,13 +362,13 @@ json_t* jq_next() {
         pc += 2;
       }
 
-      pc = *frame_current_pc(&frame_stk);
+      pc = frame_current_bytecode(&frame_stk)->code;
       break;
     }
 
     case RET: {
+      pc = *frame_current_retaddr(&frame_stk);
       frame_pop(&frame_stk);
-      pc = *frame_current_pc(&frame_stk);
       break;
     }
     }
@@ -375,12 +377,13 @@ json_t* jq_next() {
 
 
 void jq_init(struct bytecode* bc, json_t* input) {
-  forkable_stack_init(&data_stk, sizeof(stackval) * 100); // FIXME: lower this number, see if it breaks
-  forkable_stack_init(&frame_stk, 1024); // FIXME: lower this number, see if it breaks
-  forkable_stack_init(&fork_stk, 1024); // FIXME: lower this number, see if it breaks
+  forkable_stack_init(&data_stk, sizeof(stackval) * 1000); // FIXME: lower this number, see if it breaks
+  forkable_stack_init(&frame_stk, 10240); // FIXME: lower this number, see if it breaks
+  forkable_stack_init(&fork_stk, 10240); // FIXME: lower this number, see if it breaks
   
   stack_push(stackval_root(input));
-  frame_push(&frame_stk, closure_new_toplevel(bc));
+  frame_push(&frame_stk, closure_new_toplevel(bc), 0);
+  frame_push_backtrack(&frame_stk, bc->code);
 }
 
 void run_program(struct bytecode* bc) {
diff --git a/c/forkable_stack.h b/c/forkable_stack.h
index 3de9f3e0..971b4ec0 100644
--- a/c/forkable_stack.h
+++ b/c/forkable_stack.h
@@ -76,7 +76,11 @@ static void* forkable_stack_peek(struct forkable_stack* s) {
 static void* forkable_stack_peek_next(struct forkable_stack* s, void* top) {
   forkable_stack_check(s);
   struct forkable_stack_header* elem = top;
-  return (void*)(s->stk + elem->next);
+  if (elem->next < s->length) {
+    return (void*)(s->stk + elem->next);
+  } else {
+    return 0;
+  }
 }
 
 static void forkable_stack_pop(struct forkable_stack* s) {
diff --git a/c/frame_layout.h b/c/frame_layout.h
index 373c2b86..b2e590eb 100644
--- a/c/frame_layout.h
+++ b/c/frame_layout.h
@@ -5,12 +5,18 @@
 
 struct closure {
   struct bytecode* bc;
-  uint16_t* pc;
   stack_idx env;
 };
 
+struct continuation {
+  struct bytecode* bc;
+  stack_idx env;
+  uint16_t* retaddr;
+};
+
 typedef union frame_elem {
   FORKABLE_STACK_HEADER;
+  struct continuation cont;
   struct closure closure;
   json_t* jsonval;
 } *frame_ptr;
@@ -27,8 +33,8 @@ static int frame_size(struct bytecode* bc) {
   return sizeof(union frame_elem) * (bc->nclosures + bc->nlocals + 2);
 }
 
-static struct closure* frame_self(frame_ptr fr) {
-  return &fr[1].closure;
+static struct continuation* frame_self(frame_ptr fr) {
+  return &fr[1].cont;
 }
 
 static struct closure* frame_closure_arg(frame_ptr fr, int closure) {
@@ -46,16 +52,20 @@ static json_t** frame_local_var(frame_ptr fr, int var) {
 
 static frame_ptr frame_current(struct forkable_stack* stk) {
   frame_ptr fp = forkable_stack_peek(stk);
-  struct bytecode* bc = frame_self(fp)->bc;
-  assert(frame_self(fp)->pc >= bc->code && frame_self(fp)->pc < bc->code + bc->codelen);
+  if (forkable_stack_peek_next(stk, fp)) {
+    struct bytecode* bc = frame_self(forkable_stack_peek_next(stk, fp))->bc;
+    assert(frame_self(fp)->retaddr >= bc->code && frame_self(fp)->retaddr < bc->code + bc->codelen);
+  } else {
+    assert(frame_self(fp)->retaddr == 0);
+  }
   return fp;
 }
 
 static struct bytecode* frame_current_bytecode(struct forkable_stack* stk) {
   return frame_self(frame_current(stk))->bc;
 }
-static uint16_t** frame_current_pc(struct forkable_stack* stk) {
-  return &frame_self(frame_current(stk))->pc;
+static uint16_t** frame_current_retaddr(struct forkable_stack* stk) {
+  return &frame_self(frame_current(stk))->retaddr;
 }
 
 static frame_ptr frame_get_parent(struct forkable_stack* stk, frame_ptr fr) {
@@ -70,26 +80,30 @@ static frame_ptr frame_get_level(struct forkable_stack* stk, frame_ptr fr, int l
 }
 
 static struct closure closure_new_toplevel(struct bytecode* bc) {
-  struct closure cl = {bc, bc->code, -1};
+  struct closure cl = {bc, -1};
   return cl;
 }
+
 static struct closure closure_new(struct forkable_stack* stk, struct bytecode* bc) {
-  struct closure cl = {bc, bc->code, 
+  struct closure cl = {bc, 
                        forkable_stack_to_idx(stk, frame_current(stk))};
   return cl;
 }
 
-static frame_ptr frame_push(struct forkable_stack* stk, struct closure cl) {
+static frame_ptr frame_push(struct forkable_stack* stk, struct closure cl, uint16_t* retaddr) {
   frame_ptr fp = forkable_stack_push(stk, frame_size(cl.bc));
-  *frame_self(fp) = cl;
+  struct continuation* cc = frame_self(fp);
+  cc->bc = cl.bc;
+  cc->env = cl.env;
+  cc->retaddr = retaddr;
   return fp;
 }
 
-static frame_ptr frame_push_backtrack(struct forkable_stack* stk, uint16_t* pc) {
-  struct closure curr = *frame_self(frame_current(stk));
+static frame_ptr frame_push_backtrack(struct forkable_stack* stk, uint16_t* retaddr) {
+  struct continuation cc = *frame_self(frame_current(stk));
   frame_ptr fp = forkable_stack_push(stk, sizeof(union frame_elem) * 2);
-  curr.pc = pc;
-  *frame_self(fp) = curr;
+  cc.retaddr = retaddr;
+  *frame_self(fp) = cc;
   return fp;
 }
 
diff --git a/c/main.c b/c/main.c
index f8ea2149..66984842 100644
--- a/c/main.c
+++ b/c/main.c
@@ -54,7 +54,6 @@ void run_tests() {
         json_dumpf(actual, stdout, JSON_ENCODE_ANY);
         printf("\n");
         pass = 0;
-        break;
       }
     }
     if (pass) {
diff --git a/c/opcode.c b/c/opcode.c
index 87179a51..8e107236 100644
--- a/c/opcode.c
+++ b/c/opcode.c
@@ -1,13 +1,14 @@
 #include "opcode.h"
 
-#define NONE 0
-#define CONSTANT (OP_HAS_IMMEDIATE | OP_HAS_CONSTANT)
-#define VARIABLE (OP_HAS_DOUBLE_IMMEDIATE | OP_HAS_VARIABLE | OP_HAS_BINDING)
-#define BRANCH (OP_HAS_IMMEDIATE | OP_HAS_BRANCH)
-#define CFUNC (OP_HAS_IMMEDIATE | OP_HAS_SYMBOL | OP_HAS_CFUNC)
-#define UFUNC (OP_HAS_IMMEDIATE | OP_HAS_UFUNC | OP_HAS_VARIABLE_LENGTH_ARGLIST)
-#define CLOSURE_DEFINE (OP_HAS_IMMEDIATE | OP_HAS_BLOCK | OP_IS_CALL_PSEUDO | OP_HAS_BINDING)
-#define CLOSURE_REF (OP_HAS_IMMEDIATE | OP_IS_CALL_PSEUDO | OP_HAS_BINDING)
+// flags, length
+#define NONE 0, 1
+#define CONSTANT OP_HAS_CONSTANT, 2
+#define VARIABLE (OP_HAS_VARIABLE | OP_HAS_BINDING), 3
+#define BRANCH OP_HAS_BRANCH, 2
+#define CFUNC (OP_HAS_SYMBOL | OP_HAS_CFUNC), 2
+#define UFUNC (OP_HAS_UFUNC | OP_HAS_VARIABLE_LENGTH_ARGLIST), 2
+#define CLOSURE_DEFINE (OP_HAS_BLOCK | OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 2
+#define CLOSURE_ACCESS (OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 2
 
 #define OP(name, imm, in, out) \
   {name, #name, imm, in, out},
@@ -17,7 +18,7 @@ static const struct opcode_description opcode_descriptions[] = {
 };
 
 static const struct opcode_description invalid_opcode_description = {
-  -1, "#INVALID", 0, 0, 0
+  -1, "#INVALID", 0, 0, 0, 0
 };
 
 
diff --git a/c/opcode.h b/c/opcode.h
index 87d24349..73948cd5 100644
--- a/c/opcode.h
+++ b/c/opcode.h
@@ -1,5 +1,7 @@
 #ifndef OPCODE_H
 #define OPCODE_H
+#include <assert.h>
+
 typedef enum {
 #define OP(name, imm, in, out) name,
 #include "opcode_list.h"
@@ -14,7 +16,6 @@ enum {
 };
 
 enum {
-  OP_HAS_IMMEDIATE = 1,
   OP_HAS_CONSTANT = 2,
   OP_HAS_VARIABLE = 4,
   OP_HAS_BRANCH = 8,
@@ -25,20 +26,23 @@ enum {
   OP_HAS_VARIABLE_LENGTH_ARGLIST = 256,
   OP_HAS_BLOCK = 512,
   OP_HAS_BINDING = 1024,
-  OP_HAS_DOUBLE_IMMEDIATE = 2048,
 };
 struct opcode_description {
   opcode op;
   const char* name;
+
   int flags;
+
+  // length in 16-bit units
+  int length;
+
   int stack_in, stack_out;
 };
 
 const struct opcode_description* opcode_describe(opcode op);
 
 static inline int opcode_length(opcode op) {
-  return 1 + 
-    (opcode_describe(op)->flags & OP_HAS_IMMEDIATE ? 1 : 0) +
-    (opcode_describe(op)->flags & OP_HAS_DOUBLE_IMMEDIATE ? 2 : 0);
+  return opcode_describe(op)->length;
 }
+
 #endif
diff --git a/c/opcode_list.h b/c/opcode_list.h
index c54e1fda..497ae88a 100644
--- a/c/opcode_list.h
+++ b/c/opcode_list.h
@@ -20,6 +20,6 @@ OP(CALL_BUILTIN_3_1, CFUNC, 3, 1)
 OP(CALL_1_1, UFUNC, 1, 1)
 OP(RET, NONE, 1, 1)
 
-OP(CLOSURE_PARAM, CLOSURE_REF, 0, 0)
-OP(CLOSURE_REF, CLOSURE_REF, 0, 0)
+OP(CLOSURE_PARAM, CLOSURE_ACCESS, 0, 0)
+OP(CLOSURE_REF, CLOSURE_ACCESS, 0, 0)
 OP(CLOSURE_CREATE, CLOSURE_DEFINE, 0, 0)
diff --git a/c/testdata b/c/testdata
index cefc4b04..e22f09ce 100644
--- a/c/testdata
+++ b/c/testdata
@@ -138,6 +138,11 @@ def f: . + 1; def g: def g: . + 100; $$f | $$g | $$f; ($$f | $$g), $$g
 106.0
 105.0
 
-[[100,200][] as $x | def f: . + $x; $$f | $$f | $$f]
-1
-[301.0, 601.0]
+def f: (1000,2000); $$f
+123412345
+1000
+2000
+
+[[20,10][1,0] as $x | def f: (100,200) as $y | def g: [$x + $y, .]; . + $x | $$g; $$f[0] | [$$f][0][1] | $$f]
+"woo, testing!"
+[[110.0, 130.0], [210.0, 130.0], [110.0, 230.0], [210.0, 230.0], [120.0, 160.0], [220.0, 160.0], [120.0, 260.0], [220.0, 260.0]]

From befb103a12dbc9f2a566c41cdb86b517ec4094bd Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 22 Aug 2012 19:21:35 +0100
Subject: [PATCH 009/284] Fix a revolting hack

---
 c/compile.c | 11 ++---------
 c/opcode.c  |  2 +-
 2 files changed, 3 insertions(+), 10 deletions(-)

diff --git a/c/compile.c b/c/compile.c
index 913cebca..71988c4a 100644
--- a/c/compile.c
+++ b/c/compile.c
@@ -312,16 +312,9 @@ static void compile(struct bytecode* bc, block b) {
   json_t* constant_pool = json_array();
   int maxvar = -1;
   for (inst* curr = b.first; curr; curr = curr->next) {
-    if (curr->op == CLOSURE_CREATE) {
-      // CLOSURE_CREATE opcodes define closures for use later in the
-      // codestream. They generate no code.
-
-      // FIXME: make the above true :)
-      code[pos++] = DUP;
-      code[pos++] = POP;
-      continue;
-    }
     const struct opcode_description* op = opcode_describe(curr->op);
+    if (op->length == 0)
+      continue;
     code[pos++] = curr->op;
     int opflags = op->flags;
     assert(!(op->flags & OP_IS_CALL_PSEUDO));
diff --git a/c/opcode.c b/c/opcode.c
index 8e107236..5a7bfb2c 100644
--- a/c/opcode.c
+++ b/c/opcode.c
@@ -7,7 +7,7 @@
 #define BRANCH OP_HAS_BRANCH, 2
 #define CFUNC (OP_HAS_SYMBOL | OP_HAS_CFUNC), 2
 #define UFUNC (OP_HAS_UFUNC | OP_HAS_VARIABLE_LENGTH_ARGLIST), 2
-#define CLOSURE_DEFINE (OP_HAS_BLOCK | OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 2
+#define CLOSURE_DEFINE (OP_HAS_BLOCK | OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 0
 #define CLOSURE_ACCESS (OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 2
 
 #define OP(name, imm, in, out) \

From a847d2250f9ac16847414ddc2fed796a9b989f27 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 26 Aug 2012 14:25:56 +0100
Subject: [PATCH 010/284] 2nd order functions

---
 c/bytecode.c    |  3 +++
 c/compile.c     | 62 +++++++++++++++++++++++++++++++++++++++++--------
 c/execute.c     |  1 +
 c/opcode.c      |  5 ++--
 c/opcode_list.h |  6 ++---
 c/parser.y      | 13 +++++++++++
 c/testdata      |  7 ++++++
 7 files changed, 82 insertions(+), 15 deletions(-)

diff --git a/c/bytecode.c b/c/bytecode.c
index c85be804..ef585bd7 100644
--- a/c/bytecode.c
+++ b/c/bytecode.c
@@ -13,6 +13,9 @@ static int bytecode_operation_length(uint16_t* codeptr) {
 }
 
 void dump_disassembly(int indent, struct bytecode* bc) {
+  if (bc->nclosures > 0) {
+    printf("%*s[params: %d]\n", indent, "", bc->nclosures);
+  }
   dump_code(indent, bc);
   for (int i=0; i<bc->nsubfunctions; i++) {
     printf("%*ssubfn[%d]:\n", indent, "", i);
diff --git a/c/compile.c b/c/compile.c
index 71988c4a..d2b9cee7 100644
--- a/c/compile.c
+++ b/c/compile.c
@@ -59,6 +59,24 @@ static block inst_block(inst* i) {
   return b;
 }
 
+static int block_is_single(block b) {
+  return b.first && b.first == b.last;
+}
+
+static inst* block_take(block* b) {
+  if (b->first == 0) return 0;
+  inst* i = b->first;
+  if (i->next) {
+    i->next->prev = 0;
+    b->first = i->next;
+    i->next = 0;
+  } else {
+    b->first = 0;
+    b->last = 0;
+  }
+  return i;
+}
+
 block gen_noop() {
   block b = {0,0};
   return b;
@@ -92,8 +110,7 @@ block gen_op_targetlater(opcode op) {
   return inst_block(i);
 }
 void inst_set_target(block b, block target) {
-  assert(b.first);
-  assert(b.first == b.last);
+  assert(block_is_single(b));
   assert(opcode_describe(b.first->op)->flags & OP_HAS_BRANCH);
   assert(target.last);
   b.first->imm.target = target.last;
@@ -107,9 +124,7 @@ block gen_op_var_unbound(opcode op, const char* name) {
 }
 
 block gen_op_var_bound(opcode op, block binder) {
-  assert(opcode_describe(op)->flags & OP_HAS_VARIABLE);
-  assert(binder.first);
-  assert(binder.first == binder.last);
+  assert(block_is_single(binder));
   block b = gen_op_var_unbound(op, binder.first->symbol);
   b.first->bound_by = binder.first;
   return b;
@@ -138,18 +153,38 @@ block gen_op_block_unbound(opcode op, const char* name) {
   return inst_block(i);
 }
 
+block gen_op_block_bound(opcode op, block binder) {
+  assert(block_is_single(binder));
+  block b = gen_op_block_unbound(op, binder.first->symbol);
+  b.first->bound_by = binder.first;
+  return b;
+}
 
 block gen_op_call(opcode op, block arglist) {
   assert(opcode_describe(op)->flags & OP_HAS_VARIABLE_LENGTH_ARGLIST);
   inst* i = inst_new(op);
+  block prelude = gen_noop();
+  block call = inst_block(i);
   int nargs = 0;
-  for (inst* curr = arglist.first; curr; curr = curr->next) {
+  inst* curr = 0;
+  while ((curr = block_take(&arglist))) {
     assert(opcode_describe(curr->op)->flags & OP_IS_CALL_PSEUDO);
+    block bcurr = inst_block(curr);
+    switch (curr->op) {
+    default: assert(0 && "Unknown type of parameter"); break;
+    case CLOSURE_REF:
+      block_append(&call, bcurr);
+      break;
+    case CLOSURE_CREATE:
+      block_append(&prelude, bcurr);
+      block_append(&call, gen_op_block_bound(CLOSURE_REF, bcurr));
+      break;
+    }
     nargs++;
   }
   assert(nargs < 100); //FIXME
   i->imm.intval = nargs;
-  return block_join(inst_block(i), arglist);
+  return block_join(prelude, call);
 }
 
 static void inst_join(inst* a, inst* b) {
@@ -178,8 +213,7 @@ block block_join(block a, block b) {
 }
 
 static void block_bind_subblock(block binder, block body, int bindflags) {
-  assert(binder.first);
-  assert(binder.first == binder.last);
+  assert(block_is_single(binder));
   assert((opcode_describe(binder.first->op)->flags & bindflags) == bindflags);
   assert(binder.first->symbol);
   assert(binder.first->bound_by == 0 || binder.first->bound_by == binder.first);
@@ -194,6 +228,7 @@ static void block_bind_subblock(block binder, block body, int bindflags) {
       i->bound_by = binder.first;
     }
     if (flags & OP_HAS_BLOCK) {
+      // binding recurses into closures
       block_bind_subblock(binder, i->subfn, bindflags);
     }
   }
@@ -272,6 +307,7 @@ static void compile(struct bytecode* bc, block b) {
   int pos = 0;
   int var_frame_idx = 0;
   bc->nsubfunctions = 0;
+  bc->nclosures = 0;
   for (inst* curr = b.first; curr; curr = curr->next) {
     if (!curr->next) assert(curr == b.last);
     pos += opcode_length(curr->op);
@@ -290,6 +326,10 @@ static void compile(struct bytecode* bc, block b) {
       assert(curr->bound_by == curr);
       curr->imm.intval = bc->nsubfunctions++;
     }
+    if (curr->op == CLOSURE_PARAM) {
+      assert(curr->bound_by == curr);
+      curr->imm.intval = bc->nclosures++;
+    }
   }
   if (bc->nsubfunctions) {
     bc->subfunctions = malloc(sizeof(struct bytecode*) * bc->nsubfunctions);
@@ -331,6 +371,9 @@ static void compile(struct bytecode* bc, block b) {
         case CLOSURE_CREATE:
           code[pos++] = curr->bound_by->imm.intval | ARG_NEWCLOSURE;
           break;
+        case CLOSURE_PARAM:
+          code[pos++] = curr->bound_by->imm.intval;
+          break;
         }
       }
     } else if (opflags & OP_HAS_CONSTANT) {
@@ -363,7 +406,6 @@ static void compile(struct bytecode* bc, block b) {
   }
   bc->constants = constant_pool;
   bc->nlocals = maxvar + 2; // FIXME: frames of size zero?
-  bc->nclosures = 0;
 }
 
 struct bytecode* block_compile(struct symbol_table* syms, block b) {
diff --git a/c/execute.c b/c/execute.c
index a8dfc5e7..9d952d6b 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -357,6 +357,7 @@ json_t* jq_next() {
                                        pc + nclosures * 2);
       pc += 2;
       frame_ptr old_frame = forkable_stack_peek_next(&frame_stk, new_frame);
+      assert(nclosures - 1 == frame_self(new_frame)->bc->nclosures);
       for (int i=0; i<nclosures-1; i++) {
         *frame_closure_arg(new_frame, i) = make_closure(&frame_stk, old_frame, pc);
         pc += 2;
diff --git a/c/opcode.c b/c/opcode.c
index 5a7bfb2c..62624c92 100644
--- a/c/opcode.c
+++ b/c/opcode.c
@@ -7,8 +7,9 @@
 #define BRANCH OP_HAS_BRANCH, 2
 #define CFUNC (OP_HAS_SYMBOL | OP_HAS_CFUNC), 2
 #define UFUNC (OP_HAS_UFUNC | OP_HAS_VARIABLE_LENGTH_ARGLIST), 2
-#define CLOSURE_DEFINE (OP_HAS_BLOCK | OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 0
-#define CLOSURE_ACCESS (OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 2
+#define CLOSURE_PARAM_IMM (OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 0
+#define CLOSURE_CREATE_IMM (OP_HAS_BLOCK | OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 0
+#define CLOSURE_REF_IMM (OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 2
 
 #define OP(name, imm, in, out) \
   {name, #name, imm, in, out},
diff --git a/c/opcode_list.h b/c/opcode_list.h
index 497ae88a..1d6d2773 100644
--- a/c/opcode_list.h
+++ b/c/opcode_list.h
@@ -20,6 +20,6 @@ OP(CALL_BUILTIN_3_1, CFUNC, 3, 1)
 OP(CALL_1_1, UFUNC, 1, 1)
 OP(RET, NONE, 1, 1)
 
-OP(CLOSURE_PARAM, CLOSURE_ACCESS, 0, 0)
-OP(CLOSURE_REF, CLOSURE_ACCESS, 0, 0)
-OP(CLOSURE_CREATE, CLOSURE_DEFINE, 0, 0)
+OP(CLOSURE_PARAM, CLOSURE_PARAM_IMM, 0, 0)
+OP(CLOSURE_REF, CLOSURE_REF_IMM, 0, 0)
+OP(CLOSURE_CREATE, CLOSURE_CREATE_IMM, 0, 0)
diff --git a/c/parser.y b/c/parser.y
index ca82fcd5..ebc90a32 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -65,6 +65,11 @@ Exp:
   $$ = block_bind(gen_op_block_defn(CLOSURE_CREATE, $2, body), $6, OP_IS_CALL_PSEUDO);
 } |
 
+"def" IDENT '(' IDENT ')' ':' Exp ';' Exp {
+  block body = block_bind(gen_op_block_unbound(CLOSURE_PARAM, $4), block_join($7, gen_op_simple(RET)), OP_IS_CALL_PSEUDO);
+  $$ = block_bind(gen_op_block_defn(CLOSURE_CREATE, $2, body), $9, OP_IS_CALL_PSEUDO);
+} |
+
 Term "as" '$' IDENT '|' Exp {
   $$ = gen_op_simple(DUP);
   block_append(&$$, $1);
@@ -143,6 +148,14 @@ IDENT {
 } | 
 '$' '$' IDENT {
   $$ = gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, $3));
+} |
+'$' '$' IDENT '(' Exp ')' {
+  $$ = gen_op_call(CALL_1_1, 
+                   block_join(gen_op_block_unbound(CLOSURE_REF, $3),
+                              block_bind(gen_op_block_defn(CLOSURE_CREATE,
+                                                "lambda",
+                                                           block_join($5, gen_op_simple(RET))),
+                                         gen_noop(), OP_IS_CALL_PSEUDO)));
 }
 
 MkDict:
diff --git a/c/testdata b/c/testdata
index e22f09ce..f2bd4ee3 100644
--- a/c/testdata
+++ b/c/testdata
@@ -146,3 +146,10 @@ def f: (1000,2000); $$f
 [[20,10][1,0] as $x | def f: (100,200) as $y | def g: [$x + $y, .]; . + $x | $$g; $$f[0] | [$$f][0][1] | $$f]
 "woo, testing!"
 [[110.0, 130.0], [210.0, 130.0], [110.0, 230.0], [210.0, 230.0], [120.0, 160.0], [220.0, 160.0], [120.0, 260.0], [220.0, 260.0]]
+
+def f(x): $$x | $$x; $$f([.], . + [42])
+[1,2,3]
+[[[1,2,3]]]
+[[1,2,3],42]
+[[1,2,3,42]]
+[1,2,3,42,42]

From 6c8b55793a6eeb94a4c6cd63ce452cf6d4a68215 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 27 Aug 2012 10:11:55 +0100
Subject: [PATCH 011/284] first pass at assignment

---
 c/compile.c     | 19 +++++++++++++++++++
 c/compile.h     |  1 +
 c/execute.c     | 44 +++++++++++++++++++++++++++++++++-----------
 c/jv.h          | 41 +++++++++++++++++++++++++++++++++++++++++
 c/lexer.l       |  1 +
 c/opcode_list.h |  3 +++
 c/parser.y      | 18 ++++++++++++++++++
 c/testdata      |  1 +
 8 files changed, 117 insertions(+), 11 deletions(-)
 create mode 100644 c/jv.h

diff --git a/c/compile.c b/c/compile.c
index d2b9cee7..93f71888 100644
--- a/c/compile.c
+++ b/c/compile.c
@@ -288,6 +288,25 @@ block gen_collect(block expr) {
   return c;
 }
 
+block gen_assign(block expr) {
+  block c = gen_noop();
+  block_append(&c, gen_op_simple(DUP));
+  block result_var = block_bind(gen_op_var_unbound(STOREV, "result"),
+                                gen_noop(), OP_HAS_VARIABLE);
+  block_append(&c, result_var);
+
+  block loop = gen_noop();
+  block_append(&loop, gen_op_simple(DUP));
+  block_append(&loop, expr);
+  block_append(&loop, gen_op_var_bound(ASSIGN, result_var));
+  block_append(&loop, gen_op_simple(BACKTRACK));
+
+  block_append(&c, gen_op_target(FORK, loop));
+  block_append(&c, loop);
+  block_append(&c, gen_op_var_bound(LOADV, result_var));
+  return c;
+}
+
 block gen_else(block a, block b) {
   assert(0);
 }
diff --git a/c/compile.h b/c/compile.h
index d72ddcef..2ce02c0e 100644
--- a/c/compile.h
+++ b/c/compile.h
@@ -25,6 +25,7 @@ block gen_op_symbol(opcode op, const char* name);
 block gen_subexp(block a);
 block gen_both(block a, block b);
 block gen_collect(block expr);
+block gen_assign(block expr);
 block gen_else(block a, block b);
 
 
diff --git a/c/execute.c b/c/execute.c
index 9d952d6b..f9e2570c 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -12,6 +12,8 @@
 #include "forkable_stack.h"
 #include "frame_layout.h"
 
+#include "jv.h"
+
 
 typedef struct {
   json_t* value;
@@ -108,6 +110,8 @@ static struct closure make_closure(struct forkable_stack* stk, frame_ptr fr, uin
     return *frame_closure_arg(fr, idx);
   }
 }
+
+
 #define stack_push stk_push
 #define stack_pop stk_pop
 
@@ -245,20 +249,37 @@ json_t* jq_next() {
     }
 #endif
 
+    case ASSIGN_DBG: {
+      stackval replacement = stack_pop();
+      stackval path_end = stack_pop();
+      stackval path_start = stack_pop();
+      json_t* obj = jv_insert(path_start.value, replacement.value, pathbuf + path_start.pathidx, path_end.pathidx - path_start.pathidx);
+      stack_push(stackval_replace(path_start, obj));
+      break;
+    }
+
+    case ASSIGN: {
+      stackval replacement = stack_pop();
+      stackval path_end = stack_pop();
+      stackval path_start = stack_pop();
+
+      uint16_t level = *pc++;
+      uint16_t v = *pc++;
+      frame_ptr fp = frame_get_level(&frame_stk, frame_current(&frame_stk), level);
+      json_t** var = frame_local_var(fp, v);
+      *var = jv_insert(*var, replacement.value, pathbuf + path_start.pathidx, path_end.pathidx - path_start.pathidx);
+      break;
+    }
+
     case INDEX: {
       stackval t = stack_pop();
       json_t* k = stack_pop().value;
-      stackval v;
-      if (json_is_string(k)) {
-        v.value = json_object_get(t.value, json_string_value(k));
-      } else if (json_is_integer(k)) {
-        v.value = json_array_get(t.value, json_integer_value(k));
-      } else {
-        assert(0 && "key neither string nor int");
-      }
-      if (v.value) {
-        v.pathidx = path_push(t, k);
-        stack_push(v);
+      json_t* v = jv_lookup(t.value, k);
+      if (v) {
+        stackval sv;
+        sv.value = v;
+        sv.pathidx = path_push(t, k);
+        stack_push(sv);
       } else {
         assert(0 && "bad lookup");
       }
@@ -314,6 +335,7 @@ json_t* jq_next() {
       pc++; // skip offset this time
       break;
     }
+
     case ON_BACKTRACK(FORK): {
       uint16_t offset = *pc++;
       pc += offset;
diff --git a/c/jv.h b/c/jv.h
new file mode 100644
index 00000000..fc964fa9
--- /dev/null
+++ b/c/jv.h
@@ -0,0 +1,41 @@
+#ifndef JV_H
+#define JV_H
+
+#include <jansson.h>
+
+static json_t* jv_lookup(json_t* t, json_t* k) {
+  json_t* v;
+  if (json_is_object(t) && json_is_string(k)) {
+    v = json_object_get(t, json_string_value(k));
+  } else if (json_is_array(t) && json_is_number(k)) {
+    v = json_array_get(t, json_integer_value(k));
+  } else {
+    assert(0&&"bad lookup");
+  }
+  if (v) 
+    return v;
+  else
+    return json_null();
+}
+
+static json_t* jv_modify(json_t* t, json_t* k, json_t* v) {
+  t = json_copy(t);
+  if (json_is_object(t) && json_is_string(k)) {
+    json_object_set(t, json_string_value(k), v);
+  } else if (json_is_array(t) && json_is_number(k)) {
+    json_array_set(t, json_integer_value(k), v);
+  } else {
+    assert(0 && "bad mod");
+  }
+  return t;
+}
+
+static json_t* jv_insert(json_t* root, json_t* value, json_t** path, int pathlen) {
+  if (pathlen == 0) {
+    return value;
+  }
+  return jv_modify(root, *path, jv_insert(jv_lookup(root, *path), value, path+1, pathlen-1));
+}
+
+
+#endif
diff --git a/c/lexer.l b/c/lexer.l
index abf33263..e4ffafce 100644
--- a/c/lexer.l
+++ b/c/lexer.l
@@ -12,6 +12,7 @@
 "==" { return EQ; }
 "as" { return AS; }
 "def" { return DEF; }
+"|=" { return SETPIPE; }
 "."|"="|";"|"["|"]"|","|":"|"("|")"|"{"|"}"|"|"|"+"|"\$" { return yytext[0];}
 
 [[:digit:]]+  { yylval->num = atoi(yytext);   return NUMBER;}
diff --git a/c/opcode_list.h b/c/opcode_list.h
index 1d6d2773..dde07226 100644
--- a/c/opcode_list.h
+++ b/c/opcode_list.h
@@ -14,6 +14,9 @@ OP(BACKTRACK, NONE, 0, 0)
 OP(APPEND, NONE,    2, 1)
 OP(INSERT, NONE,    4, 2)
 
+OP(ASSIGN_DBG, NONE, 3, 1)
+OP(ASSIGN, VARIABLE, 3, 0)
+
 OP(CALL_BUILTIN_1_1, CFUNC, 1, 1)
 OP(CALL_BUILTIN_3_1, CFUNC, 3, 1)
 
diff --git a/c/parser.y b/c/parser.y
index ebc90a32..31c70865 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -28,6 +28,8 @@
 %token EQ "=="
 %token AS "as"
 %token DEF "def"
+%token SETPIPE "|="
+%nonassoc '=' SETPIPE
 %nonassoc EQ
 %left '+'
 
@@ -76,6 +78,22 @@ Term "as" '$' IDENT '|' Exp {
   block_append(&$$, block_bind(gen_op_var_unbound(STOREV, $4), $6, OP_HAS_VARIABLE));
 } |
 
+Exp '=' Exp {
+  block assign = gen_op_simple(DUP);
+  block_append(&assign, $3);
+  block_append(&assign, gen_op_simple(SWAP));
+  block_append(&assign, $1);
+  block_append(&assign, gen_op_simple(SWAP));
+  $$ = gen_assign(assign);
+} |
+
+Exp "|=" Exp {
+  block assign = $1;
+  block_append(&assign, gen_op_simple(DUP));
+  block_append(&assign, $3);
+  $$ = gen_assign(assign);
+} |
+
 Exp '|' Exp { 
   $$ = block_join($1, $3); 
 } |
diff --git a/c/testdata b/c/testdata
index f2bd4ee3..1d8420d6 100644
--- a/c/testdata
+++ b/c/testdata
@@ -153,3 +153,4 @@ def f(x): $$x | $$x; $$f([.], . + [42])
 [[1,2,3],42]
 [[1,2,3,42]]
 [1,2,3,42,42]
+

From dc6cf2fb58b8ec2d27fcbdb564295547c183e09d Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 27 Aug 2012 11:19:42 +0100
Subject: [PATCH 012/284] Remove syntax distinction between builtin and user
 calls

---
 c/compile.c     | 45 +++++++++++++++++++++++++++++++++++++++++++--
 c/compile.h     |  5 ++++-
 c/execute.c     |  6 ++++++
 c/main.c        |  4 ++--
 c/opcode.c      |  3 ++-
 c/opcode_list.h |  1 +
 c/parser.y      | 15 ++++++---------
 c/testdata      |  8 ++++----
 8 files changed, 68 insertions(+), 19 deletions(-)

diff --git a/c/compile.c b/c/compile.c
index 93f71888..f9f738d8 100644
--- a/c/compile.c
+++ b/c/compile.c
@@ -14,6 +14,7 @@ struct inst {
     uint16_t intval;
     struct inst* target;
     json_t* constant;
+    struct cfunction* cfunc;
   } imm;
 
   // Binding
@@ -311,6 +312,16 @@ block gen_else(block a, block b) {
   assert(0);
 }
 
+block gen_cbinding(struct symbol_table* t, block code) {
+  for (int cfunc=0; cfunc<t->ncfunctions; cfunc++) {
+    inst* i = inst_new(CLOSURE_CREATE_C);
+    i->imm.cfunc = &t->cfunctions[cfunc];
+    i->symbol = strdup(i->imm.cfunc->name);
+    code = block_bind(inst_block(i), code, OP_IS_CALL_PSEUDO);
+  }
+  return code;
+}
+
 static uint16_t nesting_level(struct bytecode* bc, inst* target) {
   uint16_t level = 0;
   assert(bc && target->compiled);
@@ -322,6 +333,16 @@ static uint16_t nesting_level(struct bytecode* bc, inst* target) {
   return level;
 }
 
+static int count_cfunctions(block b) {
+  int n = 0;
+  for (inst* i = b.first; i; i = i->next) {
+    if (i->op == CLOSURE_CREATE_C) n++;
+    if (opcode_describe(i->op)->flags & OP_HAS_BLOCK)
+      n += count_cfunctions(i->subfn);
+  }
+  return n;
+}
+
 static void compile(struct bytecode* bc, block b) {
   int pos = 0;
   int var_frame_idx = 0;
@@ -349,6 +370,12 @@ static void compile(struct bytecode* bc, block b) {
       assert(curr->bound_by == curr);
       curr->imm.intval = bc->nclosures++;
     }
+    if (curr->op == CLOSURE_CREATE_C) {
+      assert(curr->bound_by == curr);
+      int idx = bc->globals->ncfunctions++;
+      bc->globals->cfunctions[idx] = *curr->imm.cfunc;
+      curr->imm.intval = idx;
+    }
   }
   if (bc->nsubfunctions) {
     bc->subfunctions = malloc(sizeof(struct bytecode*) * bc->nsubfunctions);
@@ -374,6 +401,7 @@ static void compile(struct bytecode* bc, block b) {
     const struct opcode_description* op = opcode_describe(curr->op);
     if (op->length == 0)
       continue;
+    uint16_t* opcode_rewrite = &code[pos];
     code[pos++] = curr->op;
     int opflags = op->flags;
     assert(!(op->flags & OP_IS_CALL_PSEUDO));
@@ -381,6 +409,7 @@ static void compile(struct bytecode* bc, block b) {
       int nargs = curr->imm.intval;
       assert(nargs > 0);
       code[pos++] = (uint16_t)nargs;
+      int desired_params;
       for (int i=0; i<nargs; i++) {
         curr = curr->next;
         assert(curr && opcode_describe(curr->op)->flags & OP_IS_CALL_PSEUDO);
@@ -389,12 +418,20 @@ static void compile(struct bytecode* bc, block b) {
         default: assert(0 && "Unknown type of argument");
         case CLOSURE_CREATE:
           code[pos++] = curr->bound_by->imm.intval | ARG_NEWCLOSURE;
+          if (i == 0) desired_params = bc->subfunctions[curr->bound_by->imm.intval]->nclosures;
           break;
         case CLOSURE_PARAM:
           code[pos++] = curr->bound_by->imm.intval;
+          if (i == 0) desired_params = 0;
+          break;
+        case CLOSURE_CREATE_C:
+          code[pos++] = curr->bound_by->imm.intval;
+          *opcode_rewrite = bc->globals->cfunctions[curr->bound_by->imm.intval].callop;
+          if (i == 0) desired_params = 0;
           break;
         }
       }
+      assert(nargs - 1 == desired_params);
     } else if (opflags & OP_HAS_CONSTANT) {
       code[pos++] = json_array_size(constant_pool);
       json_array_append(constant_pool, curr->imm.constant);
@@ -427,11 +464,15 @@ static void compile(struct bytecode* bc, block b) {
   bc->nlocals = maxvar + 2; // FIXME: frames of size zero?
 }
 
-struct bytecode* block_compile(struct symbol_table* syms, block b) {
+struct bytecode* block_compile(block b) {
   struct bytecode* bc = malloc(sizeof(struct bytecode));
   bc->parent = 0;
-  bc->globals = syms;
+  bc->globals = malloc(sizeof(struct symbol_table));
+  int ncfunc = count_cfunctions(b);
+  bc->globals->ncfunctions = 0;
+  bc->globals->cfunctions = malloc(sizeof(struct cfunction) * ncfunc);
   compile(bc, b);
+  assert(bc->globals->ncfunctions == ncfunc);
   return bc;
 }
 
diff --git a/c/compile.h b/c/compile.h
index 2ce02c0e..4c0a3a17 100644
--- a/c/compile.h
+++ b/c/compile.h
@@ -28,11 +28,14 @@ block gen_collect(block expr);
 block gen_assign(block expr);
 block gen_else(block a, block b);
 
+block gen_cbinding(struct symbol_table* functions, block b);
 
 void block_append(block* b, block b2);
 block block_join(block a, block b);
 block block_bind(block binder, block body, int bindflags);
 
-struct bytecode* block_compile(struct symbol_table*, block);
+struct bytecode* block_compile(block);
 
 void block_free(block);
+
+
diff --git a/c/execute.c b/c/execute.c
index f9e2570c..75aaec09 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -349,6 +349,9 @@ json_t* jq_next() {
     }
       
     case CALL_BUILTIN_1_1: {
+      assert(*pc == 1); // no closure args allowed
+      pc++; // skip nclosures
+      pc++; // skip level
       stackval top = stack_pop();
       cfunc_input[0] = top.value;
       struct cfunction* func = &frame_current_bytecode(&frame_stk)->globals->cfunctions[*pc++];
@@ -359,6 +362,9 @@ json_t* jq_next() {
     }
 
     case CALL_BUILTIN_3_1: {
+      assert(*pc == 1); // no closure args allowed
+      pc++; // skip nclosures
+      pc++; // skip level
       stackval top = stack_pop();
       json_t* a = stack_pop().value;
       json_t* b = stack_pop().value;
diff --git a/c/main.c b/c/main.c
index 66984842..c03b5a99 100644
--- a/c/main.c
+++ b/c/main.c
@@ -30,7 +30,7 @@ void run_tests() {
     block program = compile(buf);
     block_append(&program, gen_op_simple(YIELD));
     block_append(&program, gen_op_simple(BACKTRACK));
-    struct bytecode* bc = block_compile(&builtins, program);
+    struct bytecode* bc = block_compile(gen_cbinding(&builtins, program));
     block_free(program);
     printf("Disassembly:\n");
     dump_disassembly(2, bc);
@@ -76,7 +76,7 @@ int main(int argc, char* argv[]) {
   if (argc == 1) { run_tests(); return 0; }
   block blk = compile(argv[1]);
   block_append(&blk, block_join(gen_op_simple(YIELD), gen_op_simple(BACKTRACK)));
-  struct bytecode* bc = block_compile(&builtins, blk);
+  struct bytecode* bc = block_compile(gen_cbinding(&builtins, blk));
   block_free(blk);
   dump_disassembly(0, bc);
   printf("\n");
diff --git a/c/opcode.c b/c/opcode.c
index 62624c92..bc259c22 100644
--- a/c/opcode.c
+++ b/c/opcode.c
@@ -5,10 +5,11 @@
 #define CONSTANT OP_HAS_CONSTANT, 2
 #define VARIABLE (OP_HAS_VARIABLE | OP_HAS_BINDING), 3
 #define BRANCH OP_HAS_BRANCH, 2
-#define CFUNC (OP_HAS_SYMBOL | OP_HAS_CFUNC), 2
+#define CFUNC (OP_HAS_SYMBOL | OP_HAS_CFUNC | OP_HAS_VARIABLE_LENGTH_ARGLIST), 2
 #define UFUNC (OP_HAS_UFUNC | OP_HAS_VARIABLE_LENGTH_ARGLIST), 2
 #define CLOSURE_PARAM_IMM (OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 0
 #define CLOSURE_CREATE_IMM (OP_HAS_BLOCK | OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 0
+#define CLOSURE_CREATE_C_IMM (OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 0
 #define CLOSURE_REF_IMM (OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 2
 
 #define OP(name, imm, in, out) \
diff --git a/c/opcode_list.h b/c/opcode_list.h
index dde07226..268025e8 100644
--- a/c/opcode_list.h
+++ b/c/opcode_list.h
@@ -26,3 +26,4 @@ OP(RET, NONE, 1, 1)
 OP(CLOSURE_PARAM, CLOSURE_PARAM_IMM, 0, 0)
 OP(CLOSURE_REF, CLOSURE_REF_IMM, 0, 0)
 OP(CLOSURE_CREATE, CLOSURE_CREATE_IMM, 0, 0)
+OP(CLOSURE_CREATE_C, CLOSURE_CREATE_C_IMM, 0, 0)
diff --git a/c/parser.y b/c/parser.y
index 31c70865..5ec03892 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -106,7 +106,7 @@ Exp '+' Exp {
   $$ = gen_noop();
   block_append(&$$, gen_subexp($1));
   block_append(&$$, gen_subexp($3));
-  block_append(&$$, gen_op_symbol(CALL_BUILTIN_3_1, "_plus"));
+  block_append(&$$, gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, "_plus")));
 } |
 
 Term { 
@@ -158,21 +158,18 @@ NUMBER {
   block_append(&$$, $2);
   block_append(&$$, gen_op_simple(POP));
 } |
-IDENT {
-  $$ = gen_op_symbol(CALL_BUILTIN_1_1, $1);
-} |
 '$' IDENT {
   $$ = gen_op_var_unbound(LOADV, $2); 
 } | 
-'$' '$' IDENT {
-  $$ = gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, $3));
+IDENT {
+  $$ = gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, $1));
 } |
-'$' '$' IDENT '(' Exp ')' {
+IDENT '(' Exp ')' {
   $$ = gen_op_call(CALL_1_1, 
-                   block_join(gen_op_block_unbound(CLOSURE_REF, $3),
+                   block_join(gen_op_block_unbound(CLOSURE_REF, $1),
                               block_bind(gen_op_block_defn(CLOSURE_CREATE,
                                                 "lambda",
-                                                           block_join($5, gen_op_simple(RET))),
+                                                           block_join($3, gen_op_simple(RET))),
                                          gen_noop(), OP_IS_CALL_PSEUDO)));
 }
 
diff --git a/c/testdata b/c/testdata
index 1d8420d6..6e40b9ae 100644
--- a/c/testdata
+++ b/c/testdata
@@ -133,21 +133,21 @@ null
 # Oh god.
 #
 
-def f: . + 1; def g: def g: . + 100; $$f | $$g | $$f; ($$f | $$g), $$g
+def f: . + 1; def g: def g: . + 100; f | g | f; (f | g), g
 3.0
 106.0
 105.0
 
-def f: (1000,2000); $$f
+def f: (1000,2000); f
 123412345
 1000
 2000
 
-[[20,10][1,0] as $x | def f: (100,200) as $y | def g: [$x + $y, .]; . + $x | $$g; $$f[0] | [$$f][0][1] | $$f]
+[[20,10][1,0] as $x | def f: (100,200) as $y | def g: [$x + $y, .]; . + $x | g; f[0] | [f][0][1] | f]
 "woo, testing!"
 [[110.0, 130.0], [210.0, 130.0], [110.0, 230.0], [210.0, 230.0], [120.0, 160.0], [220.0, 160.0], [120.0, 260.0], [220.0, 260.0]]
 
-def f(x): $$x | $$x; $$f([.], . + [42])
+def f(x): x | x; f([.], . + [42])
 [1,2,3]
 [[[1,2,3]]]
 [[1,2,3],42]

From 463b175cdbe29f2741478b69646b65647278f46f Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 28 Aug 2012 18:09:43 +0100
Subject: [PATCH 013/284] Reference-counted copy-on-write JSON library.

Comes with tests and, presumably, bugs.
---
 c/Makefile   |  12 +-
 c/jv.c       | 764 +++++++++++++++++++++++++++++++++++++++++++++++++++
 c/jv.h       | 100 +++++++
 c/jv_print.c |  45 +++
 c/jvtest.c   | 135 +++++++++
 5 files changed, 1055 insertions(+), 1 deletion(-)
 create mode 100644 c/jv.c
 create mode 100644 c/jv_print.c
 create mode 100644 c/jvtest.c

diff --git a/c/Makefile b/c/Makefile
index 01c3b540..b77971da 100644
--- a/c/Makefile
+++ b/c/Makefile
@@ -1,4 +1,4 @@
-CC=gcc -Wall -std=gnu99 -ggdb
+CC=gcc -Wall -std=gnu99 -ggdb -Wno-unused-function
 
 .PHONY: all clean
 all: parsertest
@@ -19,3 +19,13 @@ parser.tab.h: parser.tab.c
 
 parsertest: parser.tab.c lexer.yy.c main.c opcode.c bytecode.c compile.c execute.c builtin.c
 	$(CC) -o $@ $^ -ljansson
+
+jvtest: jvtest.c jv.c jv_print.c
+	$(CC) -o $@ $^ -ljansson
+
+test: jvtest
+	valgrind --error-exitcode=1 -q --leak-check=full ./jvtest
+
+jsparse: jsparse.l jv.c
+	flex -o jsparse.c jsparse.l
+	gcc -o jsparse jsparse.c -ljansson
\ No newline at end of file
diff --git a/c/jv.c b/c/jv.c
new file mode 100644
index 00000000..09b600d8
--- /dev/null
+++ b/c/jv.c
@@ -0,0 +1,764 @@
+#include <stdint.h>
+#include <stddef.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "jv.h"
+
+/*
+ * Internal refcounting helpers
+ */
+
+static void jvp_refcnt_init(jv_complex* c) {
+  c->ptr->count = 1;
+}
+
+static void jvp_refcnt_inc(jv_complex* c) {
+  c->ptr->count++;
+}
+
+static int jvp_refcnt_dec(jv_complex* c) {
+  c->ptr->count--;
+  return c->ptr->count == 0;
+}
+
+static int jvp_refcnt_unshared(jv_complex* c) {
+  assert(c->ptr->count > 0);
+  return c->ptr->count == 1;
+}
+
+/*
+ * Simple values (true, false, null)
+ */
+
+jv_kind jv_get_kind(jv x) {
+  return x.kind;
+}
+
+static const jv JV_NULL = {JV_KIND_NULL, {0}};
+static const jv JV_FALSE = {JV_KIND_FALSE, {0}};
+static const jv JV_TRUE = {JV_KIND_TRUE, {0}};
+
+jv jv_true() {
+  return JV_TRUE;
+}
+
+jv jv_false() {
+  return JV_FALSE;
+}
+
+jv jv_null() {
+  return JV_NULL;
+}
+
+/*
+ * Numbers
+ */
+
+jv jv_number(double x) {
+  jv j;
+  j.kind = JV_KIND_NUMBER;
+  j.val.number = x;
+  return j;
+}
+
+double jv_number_value(jv j) {
+  assert(jv_get_kind(j) == JV_KIND_NUMBER);
+  return j.val.number;
+}
+
+
+/*
+ * Arrays (internal helpers)
+ */
+
+#define ARRAY_SIZE_ROUND_UP(n) (((n)*3)/2)
+
+static int imax(int a, int b) {
+  if (a>b) return a;
+  else return b;
+}
+
+//FIXME signed vs unsigned
+typedef struct {
+  jv_refcnt refcnt;
+  int length, alloc_length;
+  jv elements[];
+} jvp_array;
+
+static jvp_array* jvp_array_ptr(jv_complex* a) {
+  return (jvp_array*)a->ptr;
+}
+
+static jvp_array* jvp_array_alloc(unsigned size) {
+  jvp_array* a = malloc(sizeof(jvp_array) + sizeof(jv) * size);
+  a->refcnt.count = 1;
+  a->length = 0;
+  a->alloc_length = size;
+  return a;
+}
+
+static jv_complex jvp_array_new(unsigned size) {
+  jv_complex r = {&jvp_array_alloc(size)->refcnt, {0, 0}};
+  return r;
+}
+
+static void jvp_array_free(jv_complex* a) {
+  if (jvp_refcnt_dec(a)) {
+    jvp_array* array = jvp_array_ptr(a);
+    for (int i=0; i<array->length; i++) {
+      jv_free(array->elements[i]);
+    }
+    free(array);
+  }
+}
+
+static int jvp_array_length(jv_complex* a) {
+  return a->i[1] - a->i[0];
+}
+
+static jv* jvp_array_read(jv_complex* a, int i) {
+  assert(i >= 0 && i < jvp_array_length(a));
+  jvp_array* array = jvp_array_ptr(a);
+  assert(i + a->i[0] < array->length);
+  return &array->elements[i + a->i[0]];
+}
+
+static jv* jvp_array_write(jv_complex* a, int i) {
+  assert(i >= 0);
+  jvp_array* array = jvp_array_ptr(a);
+
+  int pos = i + a->i[0];
+  if (pos < array->alloc_length) {
+    // maybe we can update it in-place
+    // FIXME: this "optimisation" can cause circular references
+    #if 0
+    int can_write_past_end = 
+      array->length <= pos && /* the end of this array has never been used */
+      a->i[1] == array->length; /* the current slice sees the end of the array */
+    #endif
+    int can_write_past_end = 0;
+    if (can_write_past_end || jvp_refcnt_unshared(a)) {
+      // extend the array
+      for (int j = array->length; j <= pos; j++) {
+        array->elements[j] = JV_NULL;
+      }
+      array->length = imax(pos + 1, array->length);
+      a->i[1] = imax(pos + 1, array->length);
+      return &array->elements[pos];
+    }
+  }
+  
+  
+  int new_length = imax(i + 1, jvp_array_length(a));
+  jvp_array* new_array = jvp_array_alloc(ARRAY_SIZE_ROUND_UP(new_length));
+  int j;
+  for (j = 0; j < jvp_array_length(a); j++) {
+    new_array->elements[j] = jv_copy(array->elements[j + a->i[0]]);
+  }
+  for (; j < new_length; j++) {
+    new_array->elements[j] = JV_NULL;
+  }
+  new_array->length = new_length;
+  jvp_array_free(a);
+  a->ptr = &new_array->refcnt;
+  a->i[0] = 0;
+  a->i[1] = new_length;
+  return &new_array->elements[i];
+}
+
+static int jvp_array_equal(jv_complex* a, jv_complex* b) {
+  if (jvp_array_length(a) != jvp_array_length(b)) 
+    return 0;
+  if (jvp_array_ptr(a) == jvp_array_ptr(b) &&
+      a->i[0] == b->i[0]) 
+    return 1;
+  for (int i=0; i<jvp_array_length(a); i++) {
+    if (!jv_equal(jv_copy(*jvp_array_read(a, i)), 
+                  jv_copy(*jvp_array_read(b,i))))
+      return 0;
+  }
+  return 1;
+}
+
+static jv_complex jvp_array_slice(jv_complex* a, int start, int end) {
+  // FIXME: maybe slice should reallocate if the slice is small enough
+  assert(start <= end);
+  jvp_array* array = jvp_array_ptr(a);
+  assert(a->i[1] + end < array->length);
+  jv_complex slice = *a;
+  slice.i[0] += start;
+  slice.i[1] = slice.i[0] + (end - start);
+  return slice;
+}
+
+/*
+ * Arrays (public interface)
+ */
+
+jv jv_array_sized(int n) {
+  jv j;
+  j.kind = JV_KIND_ARRAY;
+  j.val.complex = jvp_array_new(n);
+  return j;
+}
+
+jv jv_array() {
+  return jv_array_sized(16);
+}
+
+int jv_array_length(jv j) {
+  assert(jv_get_kind(j) == JV_KIND_ARRAY);
+  int len = jvp_array_length(&j.val.complex);
+  jv_free(j);
+  return len;
+}
+
+jv jv_array_get(jv j, int idx) {
+  assert(jv_get_kind(j) == JV_KIND_ARRAY);
+  jv val = jv_copy(*jvp_array_read(&j.val.complex, idx));
+  jv_free(j);
+  return val;
+}
+
+jv jv_array_set(jv j, int idx, jv val) {
+  assert(jv_get_kind(j) == JV_KIND_ARRAY);
+  // copy/free of val,j coalesced
+  *jvp_array_write(&j.val.complex, idx) = val;
+  return j;
+}
+
+jv jv_array_append(jv j, jv val) {
+  // copy/free of val,j coalesced
+  return jv_array_set(j, jv_array_length(jv_copy(j)), val);
+}
+
+jv jv_array_concat(jv a, jv b) {
+  assert(jv_get_kind(a) == JV_KIND_ARRAY);
+  assert(jv_get_kind(b) == JV_KIND_ARRAY);
+
+  // FIXME: could be much faster
+  for (int i=0; i<jv_array_length(b); i++) {
+    a = jv_array_append(a, jv_array_get(jv_copy(b), i));
+  }
+  jv_free(b);
+  return a;
+}
+
+jv jv_array_slice(jv a, int start, int end) {
+  assert(jv_get_kind(a) == JV_KIND_ARRAY);
+  // copy/free of a coalesced
+  a.val.complex = jvp_array_slice(&a.val.complex, start, end);
+  return a;
+}
+
+
+/*
+ * Strings (internal helpers)
+ */
+
+typedef struct {
+  jv_refcnt refcnt;
+  uint32_t hash;
+  // high 31 bits are length, low bit is a flag 
+  // indicating whether hash has been computed.
+  uint32_t length_hashed;
+  char data[];
+} jvp_string;
+
+static jvp_string* jvp_string_ptr(jv_complex* a) {
+  return (jvp_string*)a->ptr;
+}
+
+static jvp_string* jvp_string_alloc(uint32_t size) {
+  jvp_string* s = malloc(sizeof(jvp_string) + size + 1);
+  s->refcnt.count = 1;
+  s->length_hashed = size << 1;
+  return s;
+}
+
+static jv_complex jvp_string_new(char* data, uint32_t length) {
+  jvp_string* s = jvp_string_alloc(length);
+  memcpy(s->data, data, length);
+  s->data[length] = 0;
+  jv_complex r = {&s->refcnt, {0,0}};
+  return r;
+}
+
+static void jvp_string_free(jv_complex* s) {
+  if (jvp_refcnt_dec(s)) {
+    jvp_string* str = jvp_string_ptr(s);
+    free(str);
+  }
+}
+
+static void jvp_string_free_p(jvp_string* s) {
+  jv_complex p = {&s->refcnt,{0,0}};
+  jvp_string_free(&p);
+}
+
+static jvp_string* jvp_string_copy_p(jvp_string* s) {
+  jv_complex p = {&s->refcnt,{0,0}};
+  jvp_refcnt_inc(&p);
+  return s;
+}
+
+static uint32_t jvp_string_length(jvp_string* s) {
+  return s->length_hashed >> 1;
+}
+
+static const uint32_t HASH_SEED = 0x432A9843;
+
+static uint32_t rotl32 (uint32_t x, int8_t r){
+  return (x << r) | (x >> (32 - r));
+}
+
+static uint32_t jvp_string_hash(jvp_string* str) {
+  if (str->length_hashed & 1) 
+    return str->hash;
+
+  /* The following is based on MurmurHash3.
+     MurmurHash3 was written by Austin Appleby, and is placed
+     in the public domain. */
+
+  const uint8_t* data = (const uint8_t*)str->data;
+  int len = (int)jvp_string_length(str);
+  const int nblocks = len / 4;
+
+  uint32_t h1 = HASH_SEED;
+
+  const uint32_t c1 = 0xcc9e2d51;
+  const uint32_t c2 = 0x1b873593;
+  const uint32_t* blocks = (const uint32_t *)(data + nblocks*4);
+
+  for(int i = -nblocks; i; i++) {
+    uint32_t k1 = blocks[i]; //FIXME: endianness/alignment
+    
+    k1 *= c1;
+    k1 = rotl32(k1,15);
+    k1 *= c2;
+    
+    h1 ^= k1;
+    h1 = rotl32(h1,13); 
+    h1 = h1*5+0xe6546b64;
+  }
+
+  const uint8_t* tail = (const uint8_t*)(data + nblocks*4);
+
+  uint32_t k1 = 0;
+
+  switch(len & 3) {
+  case 3: k1 ^= tail[2] << 16;
+  case 2: k1 ^= tail[1] << 8;
+  case 1: k1 ^= tail[0];
+          k1 *= c1; k1 = rotl32(k1,15); k1 *= c2; h1 ^= k1;
+  }
+
+  h1 ^= len;
+
+  h1 ^= h1 >> 16;
+  h1 *= 0x85ebca6b;
+  h1 ^= h1 >> 13;
+  h1 *= 0xc2b2ae35;
+  h1 ^= h1 >> 16;
+
+  str->length_hashed |= 1;
+  str->hash = h1;
+
+  return h1;
+}
+
+static int jvp_string_equal_hashed(jvp_string* a, jvp_string* b) {
+  assert(a->length_hashed & 1);
+  assert(b->length_hashed & 1);
+  if (a == b) return 1;
+  if (a->hash != b->hash) return 0;
+  if (a->length_hashed != b->length_hashed) return 0;
+  return memcmp(a->data, b->data, jvp_string_length(a)) == 0;
+}
+
+static int jvp_string_equal(jv_complex* a, jv_complex* b) {
+  jvp_string* stra = jvp_string_ptr(a);
+  jvp_string* strb = jvp_string_ptr(b);
+  if (jvp_string_length(stra) != jvp_string_length(strb)) return 0;
+  return memcmp(stra->data, strb->data, jvp_string_length(stra)) == 0;
+}
+
+/*
+ * Strings (public API)
+ */
+
+jv jv_string_sized(char* str, int len) {
+  jv j;
+  j.kind = JV_KIND_STRING;
+  j.val.complex = jvp_string_new(str, len);
+  return j;
+}
+
+jv jv_string(char* str) {
+  return jv_string_sized(str, strlen(str));
+}
+
+int jv_string_length(jv j) {
+  assert(jv_get_kind(j) == JV_KIND_STRING);
+  int r = jvp_string_length(jvp_string_ptr(&j.val.complex));
+  jv_free(j);
+  return r;
+}
+
+uint32_t jv_string_hash(jv j) {
+  assert(jv_get_kind(j) == JV_KIND_STRING);
+  uint32_t hash = jvp_string_hash(jvp_string_ptr(&j.val.complex));
+  jv_free(j);
+  return hash;
+}
+
+const char* jv_string_value(jv j) {
+  assert(jv_get_kind(j) == JV_KIND_STRING);
+  return jvp_string_ptr(&j.val.complex)->data;
+}
+
+/*
+ * Objects (internal helpers)
+ */
+
+struct object_slot {
+  int next;
+  jvp_string* string;
+  uint32_t hash;
+  jv value;
+};
+
+typedef struct {
+  jv_refcnt refcnt;
+  int first_free;
+  struct object_slot elements[];
+} jvp_object;
+
+
+/* warning: complex justification of alignment */
+static jv_complex jvp_object_new(int size) {
+  // Allocates an object of (size) slots and (size*2) hash buckets.
+
+  // size must be a power of two
+  assert(size > 0 && (size & (size - 1)) == 0);
+  jvp_object* obj = malloc(sizeof(jvp_object) + 
+                           sizeof(struct object_slot) * size +
+                           sizeof(int) * (size * 2));
+  obj->refcnt.count = 1;
+  for (int i=0; i<size; i++) {
+    obj->elements[i].next = i - 1;
+    obj->elements[i].string = 0;
+    obj->elements[i].hash = 0;
+    obj->elements[i].value = JV_NULL;
+  }
+  obj->first_free = size - 1;
+  int* hashbuckets = (int*)(&obj->elements[size]);
+  jv_complex r = {&obj->refcnt, 
+                  {size*2 - 1, (char*)hashbuckets - (char*)obj}};
+  for (int i=0; i<size*2; i++) {
+    hashbuckets[i] = -1;
+  }
+  return r;
+}
+
+static jvp_object* jvp_object_ptr(jv_complex* o) {
+  return (jvp_object*)o->ptr;
+}
+
+static uint32_t jvp_object_mask(jv_complex* o) {
+  return o->i[0];
+}
+
+static int jvp_object_size(jv_complex* o) {
+  return (o->i[0] + 1) >> 1;
+}
+
+static int* jvp_object_buckets(jv_complex* o) {
+  int* buckets = (int*)((char*)o->ptr + o->i[1]);
+  assert(buckets == (int*)&jvp_object_ptr(o)->elements[jvp_object_size(o)]);
+  return buckets;
+}
+
+static int* jvp_object_find_bucket(jv_complex* object, jvp_string* key) {
+  return jvp_object_buckets(object) + (jvp_object_mask(object) & jvp_string_hash(key));
+}
+
+static struct object_slot* jvp_object_get_slot(jv_complex* object, int slot) {
+  assert(slot == -1 || (slot >= 0 && slot < jvp_object_size(object)));
+  if (slot == -1) return 0;
+  else return &jvp_object_ptr(object)->elements[slot];
+}
+
+static struct object_slot* jvp_object_next_slot(jv_complex* object, struct object_slot* slot) {
+  return jvp_object_get_slot(object, slot->next);
+}
+
+static struct object_slot* jvp_object_find_slot(jv_complex* object, jvp_string* keystr, int* bucket) {
+  for (struct object_slot* curr = jvp_object_get_slot(object, *bucket); 
+       curr; 
+       curr = jvp_object_next_slot(object, curr)) {
+    if (jvp_string_equal_hashed(keystr, curr->string)) {
+      return curr;
+    }
+  }
+  return 0;
+}
+
+static struct object_slot* jvp_object_add_slot(jv_complex* object, jvp_string* key, int* bucket) {
+  jvp_object* o = jvp_object_ptr(object);
+  int newslot_idx = o->first_free;
+  struct object_slot* newslot = jvp_object_get_slot(object, newslot_idx);
+  if (newslot == 0) return 0;
+  o->first_free = newslot->next;
+  newslot->next = *bucket;
+  *bucket = newslot_idx;
+  newslot->hash = jvp_string_hash(key);
+  newslot->string = key;
+  return newslot;
+}
+
+static void jvp_object_free_slot(jv_complex* object, struct object_slot* slot) {
+  jvp_object* o = jvp_object_ptr(object);
+  slot->next = o->first_free;
+  assert(slot->string);
+  jvp_string_free_p(slot->string);
+  slot->string = 0;
+  jv_free(slot->value);
+  o->first_free = slot - jvp_object_get_slot(object, 0);
+}
+
+static jv* jvp_object_read(jv_complex* object, jvp_string* key) {
+  int* bucket = jvp_object_find_bucket(object, key);
+  struct object_slot* slot = jvp_object_find_slot(object, key, bucket);
+  if (slot == 0) return 0;
+  else return &slot->value;
+}
+
+static void jvp_object_free(jv_complex* o) {
+  if (jvp_refcnt_dec(o)) {
+    for (int i=0; i<jvp_object_size(o); i++) {
+      struct object_slot* slot = jvp_object_get_slot(o, i);
+      if (slot->string) {
+        jvp_string_free_p(slot->string);
+        jv_free(slot->value);
+      }
+    }
+    free(jvp_object_ptr(o));
+  }
+}
+
+static void jvp_object_rehash(jv_complex* object) {
+  assert(jvp_refcnt_unshared(object));
+  int size = jvp_object_size(object);
+  jv_complex new_object = jvp_object_new(size * 2);
+  for (int i=0; i<size; i++) {
+    struct object_slot* slot = jvp_object_get_slot(object, i);
+    if (!slot->string) continue;
+    
+    int* new_bucket = jvp_object_find_bucket(&new_object, slot->string);
+    assert(!jvp_object_find_slot(&new_object, slot->string, new_bucket));
+    struct object_slot* new_slot = jvp_object_add_slot(&new_object, slot->string, new_bucket);
+    assert(new_slot);
+    new_slot->value = slot->value;
+  }
+  // references are transported, just drop the old table
+  free(jvp_object_ptr(object));
+  *object = new_object;
+}
+
+static void jvp_object_unshare(jv_complex* object) {
+  if (jvp_refcnt_unshared(object))
+    return;
+
+  jv_complex new_object = jvp_object_new(jvp_object_size(object));
+  jvp_object_ptr(&new_object)->first_free = jvp_object_ptr(object)->first_free;
+  for (int i=0; i<jvp_object_size(&new_object); i++) {
+    struct object_slot* old_slot = jvp_object_get_slot(object, i);
+    struct object_slot* new_slot = jvp_object_get_slot(&new_object, i);
+    *new_slot = *old_slot;
+    if (old_slot->string) {
+      new_slot->string = jvp_string_copy_p(old_slot->string);
+      new_slot->value = jv_copy(old_slot->value);
+    }
+  }
+
+  int* old_buckets = jvp_object_buckets(object);
+  int* new_buckets = jvp_object_buckets(&new_object);
+  memcpy(new_buckets, old_buckets, sizeof(int) * jvp_object_size(&new_object)*2);
+
+  jvp_object_free(object);
+  *object = new_object;
+  assert(jvp_refcnt_unshared(object));
+}
+
+static jv* jvp_object_write(jv_complex* object, jvp_string* key) {
+  jvp_object_unshare(object);
+  int* bucket = jvp_object_find_bucket(object, key);
+  struct object_slot* slot = jvp_object_find_slot(object, key, bucket);
+  if (slot) {
+    // already has the key
+    jvp_string_free_p(key);
+  } else {
+    slot = jvp_object_add_slot(object, key, bucket);
+  }
+  if (slot == 0) {
+    jvp_object_rehash(object);
+    bucket = jvp_object_find_bucket(object, key);
+    assert(!jvp_object_find_slot(object, key, bucket));
+    slot = jvp_object_add_slot(object, key, bucket);
+    assert(slot);
+  }
+  return &slot->value;
+}
+
+static int jvp_object_delete(jv_complex* object, jvp_string* key) {
+  jvp_object_unshare(object);
+  int* bucket = jvp_object_find_bucket(object, key);
+  int* prev_ptr = bucket;
+  for (struct object_slot* curr = jvp_object_get_slot(object, *bucket); 
+       curr; 
+       curr = jvp_object_next_slot(object, curr)) {
+    if (jvp_string_equal_hashed(key, curr->string)) {
+      *prev_ptr = curr->next;
+      jvp_object_free_slot(object, curr);
+      return 1;
+    }
+    prev_ptr = &curr->next;
+  }
+  return 0;
+}
+
+/*
+ * Objects (public interface)
+ */
+#define DEFAULT_OBJECT_SIZE 8
+jv jv_object() {
+  jv j;
+  j.kind = JV_KIND_OBJECT;
+  j.val.complex = jvp_object_new(8);
+  return j;
+}
+
+jv jv_object_get(jv object, jv key) {
+  assert(jv_get_kind(object) == JV_KIND_OBJECT);
+  assert(jv_get_kind(key) == JV_KIND_STRING);
+  jv val = jv_copy(*jvp_object_read(&object.val.complex, jvp_string_ptr(&key.val.complex)));
+  jv_free(object);
+  jv_free(key);
+  return val;
+}
+
+jv jv_object_set(jv object, jv key, jv value) {
+  assert(jv_get_kind(object) == JV_KIND_OBJECT);
+  assert(jv_get_kind(key) == JV_KIND_STRING);
+  // copy/free of object, key, value coalesced
+  *jvp_object_write(&object.val.complex, jvp_string_ptr(&key.val.complex)) = value;
+  return object;
+}
+
+jv jv_object_delete(jv object, jv key) {
+  assert(jv_get_kind(object) == JV_KIND_OBJECT);
+  assert(jv_get_kind(key) == JV_KIND_STRING);
+  jvp_object_delete(&object.val.complex, jvp_string_ptr(&key.val.complex));
+  jv_free(key);
+  return object;
+}
+
+/*
+ * Object iteration (internal helpers)
+ */
+
+enum { ITER_FINISHED = -2 };
+
+int jv_object_iter_valid(jv object, int i) {
+  return i != ITER_FINISHED;
+}
+
+int jv_object_iter(jv object) {
+  assert(jv_get_kind(object) == JV_KIND_OBJECT);
+  return jv_object_iter_next(object, -1);
+}
+
+int jv_object_iter_next(jv object, int iter) {
+  assert(jv_get_kind(object) == JV_KIND_OBJECT);
+  assert(iter != ITER_FINISHED);
+  jv_complex* o = &object.val.complex;
+  struct object_slot* slot;
+  do {
+    iter++;
+    if (iter >= jvp_object_size(o)) 
+      return ITER_FINISHED;
+    slot = jvp_object_get_slot(o, iter);
+  } while (!slot->string);
+  return iter;
+}
+
+jv jv_object_iter_key(jv object, int iter) {
+  jvp_string* s = jvp_object_get_slot(&object.val.complex, iter)->string;
+  assert(s);
+  jv j;
+  j.kind = JV_KIND_STRING;
+  j.val.complex.ptr = &s->refcnt;
+  j.val.complex.i[0] = 0;
+  j.val.complex.i[1] = 0;
+  return jv_copy(j);
+}
+
+jv jv_object_iter_value(jv object, int iter) {
+  return jv_copy(jvp_object_get_slot(&object.val.complex, iter)->value);
+}
+
+/*
+ * Memory management
+ */
+jv jv_copy(jv j) {
+  if (jv_get_kind(j) == JV_KIND_ARRAY || 
+      jv_get_kind(j) == JV_KIND_STRING || 
+      jv_get_kind(j) == JV_KIND_OBJECT) {
+    jvp_refcnt_inc(&j.val.complex);
+  }
+  return j;
+}
+
+void jv_free(jv j) {
+  if (jv_get_kind(j) == JV_KIND_ARRAY) {
+    jvp_array_free(&j.val.complex);
+  } else if (jv_get_kind(j) == JV_KIND_STRING) {
+    jvp_string_free(&j.val.complex);
+  } else if (jv_get_kind(j) == JV_KIND_OBJECT) {
+    jvp_object_free(&j.val.complex);
+  }
+}
+
+/*
+ * Higher-level operations
+ */
+
+int jv_equal(jv a, jv b) {
+  int r;
+  if (jv_get_kind(a) != jv_get_kind(b)) {
+    r = 0;
+  } else {
+    switch (jv_get_kind(a)) {
+    case JV_KIND_NUMBER:
+      r = jv_number_value(a) == jv_number_value(b);
+      break;
+    case JV_KIND_ARRAY: {
+      r = jvp_array_equal(&a.val.complex, &b.val.complex);
+      break;
+    }
+    case JV_KIND_STRING: {
+      r = jvp_string_equal(&a.val.complex, &b.val.complex);
+      break;
+    }    
+    default:
+      r = 1;
+      break;
+    }
+  }
+  jv_free(a);
+  jv_free(b);
+  return r;
+}
diff --git a/c/jv.h b/c/jv.h
index fc964fa9..52158b72 100644
--- a/c/jv.h
+++ b/c/jv.h
@@ -2,6 +2,8 @@
 #define JV_H
 
 #include <jansson.h>
+#include <stdint.h>
+#include <assert.h>
 
 static json_t* jv_lookup(json_t* t, json_t* k) {
   json_t* v;
@@ -38,4 +40,102 @@ static json_t* jv_insert(json_t* root, json_t* value, json_t** path, int pathlen
 }
 
 
+
+
+typedef enum {
+  JV_KIND_NULL,
+  JV_KIND_FALSE,
+  JV_KIND_TRUE,
+  JV_KIND_NUMBER,
+  JV_KIND_STRING,
+  JV_KIND_OBJECT,
+  JV_KIND_ARRAY
+} jv_kind;
+
+typedef struct {
+  size_t count;
+} jv_refcnt;
+
+typedef struct{
+  jv_refcnt* ptr;
+  int i[2];
+} jv_complex;
+
+typedef struct {
+  jv_kind kind;
+  union {
+    double number;
+    jv_complex complex;
+  } val;
+} jv;
+
+/*
+ * All jv_* functions consume (decref) input and produce (incref) output
+ * Except jv_copy
+ */
+
+jv_kind jv_get_kind(jv);
+
+jv jv_copy(jv);
+void jv_free(jv);
+
+int jv_equal(jv, jv);
+
+jv jv_null();
+jv jv_true();
+jv jv_false();
+
+jv jv_number(double);
+double jv_number_value(jv);
+
+jv jv_array();
+jv jv_array_sized(int);
+int jv_array_length(jv);
+jv jv_array_get(jv, int);
+jv jv_array_set(jv, int, jv);
+jv jv_array_append(jv, jv);
+jv jv_array_concat(jv, jv);
+jv jv_array_slice(jv, int, int);
+
+
+jv jv_string(char*);
+jv jv_string_sized(char*, int);
+int jv_string_length(jv);
+uint32_t jv_string_hash(jv);
+const char* jv_string_value(jv);
+
+jv jv_object();
+jv jv_object_get(jv object, jv key);
+jv jv_object_set(jv object, jv key, jv value);
+jv jv_object_delete(jv object, jv key);
+
+int jv_object_iter(jv);
+int jv_object_iter_next(jv, int);
+int jv_object_iter_valid(jv, int);
+jv jv_object_iter_key(jv, int);
+jv jv_object_iter_value(jv, int);
+
+
 #endif
+
+
+/*
+
+true/false/null:
+check kind
+
+number:
+introduce/eliminate jv
+to integer
+
+array:
+copy
+free
+slice
+index
+update
+
+updateslice?
+
+
+ */
diff --git a/c/jv_print.c b/c/jv_print.c
new file mode 100644
index 00000000..b26d0b36
--- /dev/null
+++ b/c/jv_print.c
@@ -0,0 +1,45 @@
+#include "jv.h"
+#include <stdio.h>
+
+void jv_dump(jv x) {
+  switch (jv_get_kind(x)) {
+  case JV_KIND_NULL:
+    printf("null");
+    break;
+  case JV_KIND_FALSE:
+    printf("false");
+    break;
+  case JV_KIND_TRUE:
+    printf("true");
+    break;
+  case JV_KIND_NUMBER:
+    printf("%f", jv_number_value(x));
+    break;
+  case JV_KIND_STRING:
+    // FIXME: all sorts of broken
+    printf("\"%s\"", jv_string_value(x));
+    break;
+  case JV_KIND_ARRAY: {
+    printf("[");
+    for (int i=0; i<jv_array_length(jv_copy(x)); i++) {
+      if (i!=0) printf(", ");
+      jv_dump(jv_array_get(jv_copy(x), i));
+    }
+    printf("]");
+    break;
+  }
+  case JV_KIND_OBJECT: {
+    printf("{");
+    int first = 1;
+    for (int i = jv_object_iter(x); jv_object_iter_valid(x,i); i = jv_object_iter_next(x,i)) {
+      if (!first) printf(", ");
+      first = 0;
+      jv_dump(jv_object_iter_key(x, i));
+      printf(": ");
+      jv_dump(jv_object_iter_value(x, i));
+    }
+    printf("}");
+  }
+  }
+  jv_free(x);
+}
diff --git a/c/jvtest.c b/c/jvtest.c
new file mode 100644
index 00000000..667d706b
--- /dev/null
+++ b/c/jvtest.c
@@ -0,0 +1,135 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include "jv.h"
+
+void jv_dump(jv);
+
+int main(){
+  /// Arrays and numbers
+  {
+    jv a = jv_array();
+    assert(jv_get_kind(a) == JV_KIND_ARRAY);
+    assert(jv_array_length(jv_copy(a)) == 0);
+    assert(jv_array_length(jv_copy(a)) == 0);
+  
+    a = jv_array_append(a, jv_number(42));
+    assert(jv_array_length(jv_copy(a)) == 1);
+    assert(jv_number_value(jv_array_get(jv_copy(a), 0)) == 42);
+
+    jv a2 = jv_array_append(jv_array(), jv_number(42));
+    assert(jv_equal(jv_copy(a), jv_copy(a)));
+    assert(jv_equal(jv_copy(a2), jv_copy(a2)));
+    assert(jv_equal(jv_copy(a), jv_copy(a2)));
+    assert(jv_equal(jv_copy(a2), jv_copy(a)));
+    jv_free(a2);
+
+    a2 = jv_array_append(jv_array(), jv_number(19));
+    assert(!jv_equal(jv_copy(a), jv_copy(a2)));
+    assert(!jv_equal(jv_copy(a2), jv_copy(a)));
+    jv_free(a2);
+
+
+    assert(a.val.complex.ptr->count == 1);
+    a = jv_array_append(a, jv_copy(a));
+    assert(a.val.complex.ptr->count == 1);
+
+    assert(jv_array_length(jv_copy(a)) == 2);
+    assert(jv_number_value(jv_array_get(jv_copy(a), 0)) == 42);
+
+    for (int i=0; i<10; i++) {
+      jv subarray = jv_array_get(jv_copy(a), 1);
+      assert(jv_get_kind(subarray) == JV_KIND_ARRAY);
+      assert(jv_array_length(jv_copy(subarray)) == 1);
+      assert(jv_number_value(jv_array_get(jv_copy(subarray), 0)) == 42);
+      jv_free(subarray);
+    }
+
+
+    jv subarray = jv_array_get(jv_copy(a), 1);
+    assert(jv_get_kind(subarray) == JV_KIND_ARRAY);
+    assert(jv_array_length(jv_copy(subarray)) == 1);
+    assert(jv_number_value(jv_array_get(jv_copy(subarray), 0)) == 42);
+
+    jv sub2 = jv_copy(subarray);
+    sub2 = jv_array_append(sub2, jv_number(19));
+
+    assert(jv_get_kind(sub2) == JV_KIND_ARRAY);
+    assert(jv_array_length(jv_copy(sub2)) == 2);
+    assert(jv_number_value(jv_array_get(jv_copy(sub2), 0)) == 42);
+    assert(jv_number_value(jv_array_get(jv_copy(sub2), 1)) == 19);
+
+    assert(jv_get_kind(subarray) == JV_KIND_ARRAY);
+    assert(jv_array_length(jv_copy(subarray)) == 1);
+    assert(jv_number_value(jv_array_get(jv_copy(subarray), 0)) == 42);
+
+    jv_free(subarray);
+
+    void* before = sub2.val.complex.ptr;
+    sub2 = jv_array_append(sub2, jv_number(200));
+    void* after = sub2.val.complex.ptr;
+    assert(before == after);
+    jv_free(sub2);
+
+    jv a3 = jv_array_append(jv_copy(a), jv_number(19));
+    assert(jv_array_length(jv_copy(a3)) == 3);
+    assert(jv_number_value(jv_array_get(jv_copy(a3), 0)) == 42);
+    assert(jv_array_length(jv_array_get(jv_copy(a3), 1)) == 1);
+    assert(jv_number_value(jv_array_get(jv_copy(a3), 2)) == 19);
+    jv_free(a3);
+
+
+    assert(jv_array_length(jv_copy(a)) == 2);
+    assert(jv_number_value(jv_array_get(jv_copy(a), 0)) == 42);
+    assert(jv_array_length(jv_array_get(jv_copy(a), 1)) == 1);
+
+
+    jv_dump(jv_copy(a)); printf("\n");
+    jv_free(a);
+  }
+
+
+  /// Strings
+  {
+    assert(jv_equal(jv_string("foo"), jv_string_sized("foo", 3)));
+    char nasty[] = "foo\0";
+    jv shortstr = jv_string(nasty), longstr = jv_string_sized(nasty, sizeof(nasty));
+    assert(jv_string_length(shortstr) == strlen(nasty));
+    assert(jv_string_length(longstr) == sizeof(nasty));
+
+  
+    char a1s[] = "hello", a2s[] = "hello", bs[] = "goodbye";
+    jv a1 = jv_string(a1s), a2 = jv_string(a2s), b = jv_string(bs);
+    assert(jv_equal(jv_copy(a1), jv_copy(a2)));
+    assert(jv_equal(jv_copy(a2), jv_copy(a1)));
+    assert(!jv_equal(jv_copy(a1), jv_copy(b)));
+    
+    assert(jv_string_hash(jv_copy(a1)) == jv_string_hash(jv_copy(a1)));
+    assert(jv_string_hash(jv_copy(a1)) == jv_string_hash(jv_copy(a2)));
+    assert(jv_string_hash(jv_copy(b)) != jv_string_hash(jv_copy(a1)));
+    jv_free(a1);
+    jv_free(a2);
+    jv_free(b);
+  }
+
+  /// Objects
+  {
+    jv o1 = jv_object();
+    o1 = jv_object_set(o1, jv_string("foo"), jv_number(42));
+    o1 = jv_object_set(o1, jv_string("bar"), jv_number(24));
+    assert(jv_number_value(jv_object_get(jv_copy(o1), jv_string("foo"))) == 42);
+    assert(jv_number_value(jv_object_get(jv_copy(o1), jv_string("bar"))) == 24);
+
+    jv o2 = jv_object_set(jv_copy(o1), jv_string("foo"), jv_number(420));
+    o2 = jv_object_set(o2, jv_string("bar"), jv_number(240));
+    assert(jv_number_value(jv_object_get(jv_copy(o1), jv_string("foo"))) == 42);
+    assert(jv_number_value(jv_object_get(jv_copy(o1), jv_string("bar"))) == 24);
+    assert(jv_number_value(jv_object_get(jv_copy(o2), jv_string("foo"))) == 420);
+    jv_free(o1);
+    assert(jv_number_value(jv_object_get(jv_copy(o2), jv_string("bar"))) == 240);
+
+    jv_dump(jv_copy(o2)); printf("\n");
+
+    jv_free(o2);
+  }
+}

From f25cb16e6b889c5398391dbbf7179ce49c8a555a Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 28 Aug 2012 18:38:30 +0100
Subject: [PATCH 014/284] Fix a bug in lexical scoping, add tests

---
 c/compile.c      |  5 ++++-
 c/execute.c      | 11 ++++++++---
 c/frame_layout.h | 11 -----------
 c/testdata       |  6 ++++++
 4 files changed, 18 insertions(+), 15 deletions(-)

diff --git a/c/compile.c b/c/compile.c
index f9f738d8..dc90aed3 100644
--- a/c/compile.c
+++ b/c/compile.c
@@ -418,7 +418,10 @@ static void compile(struct bytecode* bc, block b) {
         default: assert(0 && "Unknown type of argument");
         case CLOSURE_CREATE:
           code[pos++] = curr->bound_by->imm.intval | ARG_NEWCLOSURE;
-          if (i == 0) desired_params = bc->subfunctions[curr->bound_by->imm.intval]->nclosures;
+          if (i == 0) {
+            inst* i = curr->bound_by;
+            desired_params = i->compiled->subfunctions[i->imm.intval]->nclosures;
+          }
           break;
         case CLOSURE_PARAM:
           code[pos++] = curr->bound_by->imm.intval;
diff --git a/c/execute.c b/c/execute.c
index 75aaec09..9aa85b29 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -104,9 +104,10 @@ static struct closure make_closure(struct forkable_stack* stk, frame_ptr fr, uin
   if (idx & ARG_NEWCLOSURE) {
     int subfn_idx = idx & ~ARG_NEWCLOSURE;
     assert(subfn_idx < frame_self(fr)->bc->nsubfunctions);
-    return closure_new(stk, frame_self(fr)->bc->subfunctions[subfn_idx]);
+    struct closure cl = {frame_self(fr)->bc->subfunctions[subfn_idx],
+                         forkable_stack_to_idx(stk, fr)};
+    return cl;
   } else {
-    // FIXME: set pc
     return *frame_closure_arg(fr, idx);
   }
 }
@@ -214,6 +215,9 @@ json_t* jq_next() {
       uint16_t v = *pc++;
       frame_ptr fp = frame_get_level(&frame_stk, frame_current(&frame_stk), level);
       json_t** var = frame_local_var(fp, v);
+      printf("V%d = ", v);
+      json_dumpf(*var, stdout, JSON_ENCODE_ANY);
+      printf("\n");
       stack_push(stackval_replace(stack_pop(), *var));
       break;
     }
@@ -411,7 +415,8 @@ void jq_init(struct bytecode* bc, json_t* input) {
   forkable_stack_init(&fork_stk, 10240); // FIXME: lower this number, see if it breaks
   
   stack_push(stackval_root(input));
-  frame_push(&frame_stk, closure_new_toplevel(bc), 0);
+  struct closure top = {bc, -1};
+  frame_push(&frame_stk, top, 0);
   frame_push_backtrack(&frame_stk, bc->code);
 }
 
diff --git a/c/frame_layout.h b/c/frame_layout.h
index b2e590eb..fcbd1dc3 100644
--- a/c/frame_layout.h
+++ b/c/frame_layout.h
@@ -79,17 +79,6 @@ static frame_ptr frame_get_level(struct forkable_stack* stk, frame_ptr fr, int l
   return fr;
 }
 
-static struct closure closure_new_toplevel(struct bytecode* bc) {
-  struct closure cl = {bc, -1};
-  return cl;
-}
-
-static struct closure closure_new(struct forkable_stack* stk, struct bytecode* bc) {
-  struct closure cl = {bc, 
-                       forkable_stack_to_idx(stk, frame_current(stk))};
-  return cl;
-}
-
 static frame_ptr frame_push(struct forkable_stack* stk, struct closure cl, uint16_t* retaddr) {
   frame_ptr fp = forkable_stack_push(stk, frame_size(cl.bc));
   struct continuation* cc = frame_self(fp);
diff --git a/c/testdata b/c/testdata
index 6e40b9ae..95e40781 100644
--- a/c/testdata
+++ b/c/testdata
@@ -143,6 +143,8 @@ def f: (1000,2000); f
 1000
 2000
 
+# test backtracking through function calls and returns
+# this test is *evil*
 [[20,10][1,0] as $x | def f: (100,200) as $y | def g: [$x + $y, .]; . + $x | g; f[0] | [f][0][1] | f]
 "woo, testing!"
 [[110.0, 130.0], [210.0, 130.0], [110.0, 230.0], [210.0, 230.0], [120.0, 160.0], [220.0, 160.0], [120.0, 260.0], [220.0, 260.0]]
@@ -154,3 +156,7 @@ def f(x): x | x; f([.], . + [42])
 [[1,2,3,42]]
 [1,2,3,42,42]
 
+# test closures and lexical scoping
+def id(x):x; 2000 as $x | def f(x):1 as $x | id([$x, x, x]); def g(x): 100 as $x | f($x,$x+x); g($x)
+"more testing"
+[1,100,2100.0,100,2100.0]

From 9e544c55dc82780161c93665099bad6dffab3cf7 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sat, 1 Sep 2012 16:50:25 +0100
Subject: [PATCH 015/284] Import a copy of David Gay's dtoa.c

---
 c/dtoa.c | 4357 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 4357 insertions(+)
 create mode 100644 c/dtoa.c

diff --git a/c/dtoa.c b/c/dtoa.c
new file mode 100644
index 00000000..41ed6982
--- /dev/null
+++ b/c/dtoa.c
@@ -0,0 +1,4357 @@
+/****************************************************************
+ *
+ * The author of this software is David M. Gay.
+ *
+ * Copyright (c) 1991, 2000, 2001 by Lucent Technologies.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ *
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHOR NOR LUCENT MAKES ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ *
+ ***************************************************************/
+
+/* Please send bug reports to David M. Gay (dmg at acm dot org,
+ * with " at " changed at "@" and " dot " changed to ".").	*/
+
+/* On a machine with IEEE extended-precision registers, it is
+ * necessary to specify double-precision (53-bit) rounding precision
+ * before invoking strtod or dtoa.  If the machine uses (the equivalent
+ * of) Intel 80x87 arithmetic, the call
+ *	_control87(PC_53, MCW_PC);
+ * does this with many compilers.  Whether this or another call is
+ * appropriate depends on the compiler; for this to work, it may be
+ * necessary to #include "float.h" or another system-dependent header
+ * file.
+ */
+
+/* strtod for IEEE-, VAX-, and IBM-arithmetic machines.
+ * (Note that IEEE arithmetic is disabled by gcc's -ffast-math flag.)
+ *
+ * This strtod returns a nearest machine number to the input decimal
+ * string (or sets errno to ERANGE).  With IEEE arithmetic, ties are
+ * broken by the IEEE round-even rule.  Otherwise ties are broken by
+ * biased rounding (add half and chop).
+ *
+ * Inspired loosely by William D. Clinger's paper "How to Read Floating
+ * Point Numbers Accurately" [Proc. ACM SIGPLAN '90, pp. 92-101].
+ *
+ * Modifications:
+ *
+ *	1. We only require IEEE, IBM, or VAX double-precision
+ *		arithmetic (not IEEE double-extended).
+ *	2. We get by with floating-point arithmetic in a case that
+ *		Clinger missed -- when we're computing d * 10^n
+ *		for a small integer d and the integer n is not too
+ *		much larger than 22 (the maximum integer k for which
+ *		we can represent 10^k exactly), we may be able to
+ *		compute (d*10^k) * 10^(e-k) with just one roundoff.
+ *	3. Rather than a bit-at-a-time adjustment of the binary
+ *		result in the hard case, we use floating-point
+ *		arithmetic to determine the adjustment to within
+ *		one bit; only in really hard cases do we need to
+ *		compute a second residual.
+ *	4. Because of 3., we don't need a large table of powers of 10
+ *		for ten-to-e (just some small tables, e.g. of 10^k
+ *		for 0 <= k <= 22).
+ */
+
+/*
+ * #define IEEE_8087 for IEEE-arithmetic machines where the least
+ *	significant byte has the lowest address.
+ * #define IEEE_MC68k for IEEE-arithmetic machines where the most
+ *	significant byte has the lowest address.
+ * #define Long int on machines with 32-bit ints and 64-bit longs.
+ * #define IBM for IBM mainframe-style floating-point arithmetic.
+ * #define VAX for VAX-style floating-point arithmetic (D_floating).
+ * #define No_leftright to omit left-right logic in fast floating-point
+ *	computation of dtoa.  This will cause dtoa modes 4 and 5 to be
+ *	treated the same as modes 2 and 3 for some inputs.
+ * #define Honor_FLT_ROUNDS if FLT_ROUNDS can assume the values 2 or 3
+ *	and strtod and dtoa should round accordingly.  Unless Trust_FLT_ROUNDS
+ *	is also #defined, fegetround() will be queried for the rounding mode.
+ *	Note that both FLT_ROUNDS and fegetround() are specified by the C99
+ *	standard (and are specified to be consistent, with fesetround()
+ *	affecting the value of FLT_ROUNDS), but that some (Linux) systems
+ *	do not work correctly in this regard, so using fegetround() is more
+ *	portable than using FLT_ROUNDS directly.
+ * #define Check_FLT_ROUNDS if FLT_ROUNDS can assume the values 2 or 3
+ *	and Honor_FLT_ROUNDS is not #defined.
+ * #define RND_PRODQUOT to use rnd_prod and rnd_quot (assembly routines
+ *	that use extended-precision instructions to compute rounded
+ *	products and quotients) with IBM.
+ * #define ROUND_BIASED for IEEE-format with biased rounding and arithmetic
+ *	that rounds toward +Infinity.
+ * #define ROUND_BIASED_without_Round_Up for IEEE-format with biased
+ *	rounding when the underlying floating-point arithmetic uses
+ *	unbiased rounding.  This prevent using ordinary floating-point
+ *	arithmetic when the result could be computed with one rounding error.
+ * #define Inaccurate_Divide for IEEE-format with correctly rounded
+ *	products but inaccurate quotients, e.g., for Intel i860.
+ * #define NO_LONG_LONG on machines that do not have a "long long"
+ *	integer type (of >= 64 bits).  On such machines, you can
+ *	#define Just_16 to store 16 bits per 32-bit Long when doing
+ *	high-precision integer arithmetic.  Whether this speeds things
+ *	up or slows things down depends on the machine and the number
+ *	being converted.  If long long is available and the name is
+ *	something other than "long long", #define Llong to be the name,
+ *	and if "unsigned Llong" does not work as an unsigned version of
+ *	Llong, #define #ULLong to be the corresponding unsigned type.
+ * #define KR_headers for old-style C function headers.
+ * #define Bad_float_h if your system lacks a float.h or if it does not
+ *	define some or all of DBL_DIG, DBL_MAX_10_EXP, DBL_MAX_EXP,
+ *	FLT_RADIX, FLT_ROUNDS, and DBL_MAX.
+ * #define MALLOC your_malloc, where your_malloc(n) acts like malloc(n)
+ *	if memory is available and otherwise does something you deem
+ *	appropriate.  If MALLOC is undefined, malloc will be invoked
+ *	directly -- and assumed always to succeed.  Similarly, if you
+ *	want something other than the system's free() to be called to
+ *	recycle memory acquired from MALLOC, #define FREE to be the
+ *	name of the alternate routine.  (FREE or free is only called in
+ *	pathological cases, e.g., in a dtoa call after a dtoa return in
+ *	mode 3 with thousands of digits requested.)
+ * #define Omit_Private_Memory to omit logic (added Jan. 1998) for making
+ *	memory allocations from a private pool of memory when possible.
+ *	When used, the private pool is PRIVATE_MEM bytes long:  2304 bytes,
+ *	unless #defined to be a different length.  This default length
+ *	suffices to get rid of MALLOC calls except for unusual cases,
+ *	such as decimal-to-binary conversion of a very long string of
+ *	digits.  The longest string dtoa can return is about 751 bytes
+ *	long.  For conversions by strtod of strings of 800 digits and
+ *	all dtoa conversions in single-threaded executions with 8-byte
+ *	pointers, PRIVATE_MEM >= 7400 appears to suffice; with 4-byte
+ *	pointers, PRIVATE_MEM >= 7112 appears adequate.
+ * #define NO_INFNAN_CHECK if you do not wish to have INFNAN_CHECK
+ *	#defined automatically on IEEE systems.  On such systems,
+ *	when INFNAN_CHECK is #defined, strtod checks
+ *	for Infinity and NaN (case insensitively).  On some systems
+ *	(e.g., some HP systems), it may be necessary to #define NAN_WORD0
+ *	appropriately -- to the most significant word of a quiet NaN.
+ *	(On HP Series 700/800 machines, -DNAN_WORD0=0x7ff40000 works.)
+ *	When INFNAN_CHECK is #defined and No_Hex_NaN is not #defined,
+ *	strtod also accepts (case insensitively) strings of the form
+ *	NaN(x), where x is a string of hexadecimal digits and spaces;
+ *	if there is only one string of hexadecimal digits, it is taken
+ *	for the 52 fraction bits of the resulting NaN; if there are two
+ *	or more strings of hex digits, the first is for the high 20 bits,
+ *	the second and subsequent for the low 32 bits, with intervening
+ *	white space ignored; but if this results in none of the 52
+ *	fraction bits being on (an IEEE Infinity symbol), then NAN_WORD0
+ *	and NAN_WORD1 are used instead.
+ * #define MULTIPLE_THREADS if the system offers preemptively scheduled
+ *	multiple threads.  In this case, you must provide (or suitably
+ *	#define) two locks, acquired by ACQUIRE_DTOA_LOCK(n) and freed
+ *	by FREE_DTOA_LOCK(n) for n = 0 or 1.  (The second lock, accessed
+ *	in pow5mult, ensures lazy evaluation of only one copy of high
+ *	powers of 5; omitting this lock would introduce a small
+ *	probability of wasting memory, but would otherwise be harmless.)
+ *	You must also invoke freedtoa(s) to free the value s returned by
+ *	dtoa.  You may do so whether or not MULTIPLE_THREADS is #defined.
+ * #define NO_IEEE_Scale to disable new (Feb. 1997) logic in strtod that
+ *	avoids underflows on inputs whose result does not underflow.
+ *	If you #define NO_IEEE_Scale on a machine that uses IEEE-format
+ *	floating-point numbers and flushes underflows to zero rather
+ *	than implementing gradual underflow, then you must also #define
+ *	Sudden_Underflow.
+ * #define USE_LOCALE to use the current locale's decimal_point value.
+ * #define SET_INEXACT if IEEE arithmetic is being used and extra
+ *	computation should be done to set the inexact flag when the
+ *	result is inexact and avoid setting inexact when the result
+ *	is exact.  In this case, dtoa.c must be compiled in
+ *	an environment, perhaps provided by #include "dtoa.c" in a
+ *	suitable wrapper, that defines two functions,
+ *		int get_inexact(void);
+ *		void clear_inexact(void);
+ *	such that get_inexact() returns a nonzero value if the
+ *	inexact bit is already set, and clear_inexact() sets the
+ *	inexact bit to 0.  When SET_INEXACT is #defined, strtod
+ *	also does extra computations to set the underflow and overflow
+ *	flags when appropriate (i.e., when the result is tiny and
+ *	inexact or when it is a numeric value rounded to +-infinity).
+ * #define NO_ERRNO if strtod should not assign errno = ERANGE when
+ *	the result overflows to +-Infinity or underflows to 0.
+ * #define NO_HEX_FP to omit recognition of hexadecimal floating-point
+ *	values by strtod.
+ * #define NO_STRTOD_BIGCOMP (on IEEE-arithmetic systems only for now)
+ *	to disable logic for "fast" testing of very long input strings
+ *	to strtod.  This testing proceeds by initially truncating the
+ *	input string, then if necessary comparing the whole string with
+ *	a decimal expansion to decide close cases. This logic is only
+ *	used for input more than STRTOD_DIGLIM digits long (default 40).
+ */
+
+#ifndef Long
+#define Long long
+#endif
+#ifndef ULong
+typedef unsigned Long ULong;
+#endif
+
+#ifdef DEBUG
+#include "stdio.h"
+#define Bug(x) {fprintf(stderr, "%s\n", x); exit(1);}
+#endif
+
+#include "stdlib.h"
+#include "string.h"
+
+#ifdef USE_LOCALE
+#include "locale.h"
+#endif
+
+#ifdef Honor_FLT_ROUNDS
+#ifndef Trust_FLT_ROUNDS
+#include <fenv.h>
+#endif
+#endif
+
+#ifdef MALLOC
+#ifdef KR_headers
+extern char *MALLOC();
+#else
+extern void *MALLOC(size_t);
+#endif
+#else
+#define MALLOC malloc
+#endif
+
+#ifndef Omit_Private_Memory
+#ifndef PRIVATE_MEM
+#define PRIVATE_MEM 2304
+#endif
+#define PRIVATE_mem ((PRIVATE_MEM+sizeof(double)-1)/sizeof(double))
+static double private_mem[PRIVATE_mem], *pmem_next = private_mem;
+#endif
+
+#undef IEEE_Arith
+#undef Avoid_Underflow
+#ifdef IEEE_MC68k
+#define IEEE_Arith
+#endif
+#ifdef IEEE_8087
+#define IEEE_Arith
+#endif
+
+#ifdef IEEE_Arith
+#ifndef NO_INFNAN_CHECK
+#undef INFNAN_CHECK
+#define INFNAN_CHECK
+#endif
+#else
+#undef INFNAN_CHECK
+#define NO_STRTOD_BIGCOMP
+#endif
+
+#include "errno.h"
+
+#ifdef Bad_float_h
+
+#ifdef IEEE_Arith
+#define DBL_DIG 15
+#define DBL_MAX_10_EXP 308
+#define DBL_MAX_EXP 1024
+#define FLT_RADIX 2
+#endif /*IEEE_Arith*/
+
+#ifdef IBM
+#define DBL_DIG 16
+#define DBL_MAX_10_EXP 75
+#define DBL_MAX_EXP 63
+#define FLT_RADIX 16
+#define DBL_MAX 7.2370055773322621e+75
+#endif
+
+#ifdef VAX
+#define DBL_DIG 16
+#define DBL_MAX_10_EXP 38
+#define DBL_MAX_EXP 127
+#define FLT_RADIX 2
+#define DBL_MAX 1.7014118346046923e+38
+#endif
+
+#ifndef LONG_MAX
+#define LONG_MAX 2147483647
+#endif
+
+#else /* ifndef Bad_float_h */
+#include "float.h"
+#endif /* Bad_float_h */
+
+#ifndef __MATH_H__
+#include "math.h"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef CONST
+#ifdef KR_headers
+#define CONST /* blank */
+#else
+#define CONST const
+#endif
+#endif
+
+#if defined(IEEE_8087) + defined(IEEE_MC68k) + defined(VAX) + defined(IBM) != 1
+Exactly one of IEEE_8087, IEEE_MC68k, VAX, or IBM should be defined.
+#endif
+
+typedef union { double d; ULong L[2]; } U;
+
+#ifdef IEEE_8087
+#define word0(x) (x)->L[1]
+#define word1(x) (x)->L[0]
+#else
+#define word0(x) (x)->L[0]
+#define word1(x) (x)->L[1]
+#endif
+#define dval(x) (x)->d
+
+#ifndef STRTOD_DIGLIM
+#define STRTOD_DIGLIM 40
+#endif
+
+#ifdef DIGLIM_DEBUG
+extern int strtod_diglim;
+#else
+#define strtod_diglim STRTOD_DIGLIM
+#endif
+
+/* The following definition of Storeinc is appropriate for MIPS processors.
+ * An alternative that might be better on some machines is
+ * #define Storeinc(a,b,c) (*a++ = b << 16 | c & 0xffff)
+ */
+#if defined(IEEE_8087) + defined(VAX)
+#define Storeinc(a,b,c) (((unsigned short *)a)[1] = (unsigned short)b, \
+((unsigned short *)a)[0] = (unsigned short)c, a++)
+#else
+#define Storeinc(a,b,c) (((unsigned short *)a)[0] = (unsigned short)b, \
+((unsigned short *)a)[1] = (unsigned short)c, a++)
+#endif
+
+/* #define P DBL_MANT_DIG */
+/* Ten_pmax = floor(P*log(2)/log(5)) */
+/* Bletch = (highest power of 2 < DBL_MAX_10_EXP) / 16 */
+/* Quick_max = floor((P-1)*log(FLT_RADIX)/log(10) - 1) */
+/* Int_max = floor(P*log(FLT_RADIX)/log(10) - 1) */
+
+#ifdef IEEE_Arith
+#define Exp_shift  20
+#define Exp_shift1 20
+#define Exp_msk1    0x100000
+#define Exp_msk11   0x100000
+#define Exp_mask  0x7ff00000
+#define P 53
+#define Nbits 53
+#define Bias 1023
+#define Emax 1023
+#define Emin (-1022)
+#define Exp_1  0x3ff00000
+#define Exp_11 0x3ff00000
+#define Ebits 11
+#define Frac_mask  0xfffff
+#define Frac_mask1 0xfffff
+#define Ten_pmax 22
+#define Bletch 0x10
+#define Bndry_mask  0xfffff
+#define Bndry_mask1 0xfffff
+#define LSB 1
+#define Sign_bit 0x80000000
+#define Log2P 1
+#define Tiny0 0
+#define Tiny1 1
+#define Quick_max 14
+#define Int_max 14
+#ifndef NO_IEEE_Scale
+#define Avoid_Underflow
+#ifdef Flush_Denorm	/* debugging option */
+#undef Sudden_Underflow
+#endif
+#endif
+
+#ifndef Flt_Rounds
+#ifdef FLT_ROUNDS
+#define Flt_Rounds FLT_ROUNDS
+#else
+#define Flt_Rounds 1
+#endif
+#endif /*Flt_Rounds*/
+
+#ifdef Honor_FLT_ROUNDS
+#undef Check_FLT_ROUNDS
+#define Check_FLT_ROUNDS
+#else
+#define Rounding Flt_Rounds
+#endif
+
+#else /* ifndef IEEE_Arith */
+#undef Check_FLT_ROUNDS
+#undef Honor_FLT_ROUNDS
+#undef SET_INEXACT
+#undef  Sudden_Underflow
+#define Sudden_Underflow
+#ifdef IBM
+#undef Flt_Rounds
+#define Flt_Rounds 0
+#define Exp_shift  24
+#define Exp_shift1 24
+#define Exp_msk1   0x1000000
+#define Exp_msk11  0x1000000
+#define Exp_mask  0x7f000000
+#define P 14
+#define Nbits 56
+#define Bias 65
+#define Emax 248
+#define Emin (-260)
+#define Exp_1  0x41000000
+#define Exp_11 0x41000000
+#define Ebits 8	/* exponent has 7 bits, but 8 is the right value in b2d */
+#define Frac_mask  0xffffff
+#define Frac_mask1 0xffffff
+#define Bletch 4
+#define Ten_pmax 22
+#define Bndry_mask  0xefffff
+#define Bndry_mask1 0xffffff
+#define LSB 1
+#define Sign_bit 0x80000000
+#define Log2P 4
+#define Tiny0 0x100000
+#define Tiny1 0
+#define Quick_max 14
+#define Int_max 15
+#else /* VAX */
+#undef Flt_Rounds
+#define Flt_Rounds 1
+#define Exp_shift  23
+#define Exp_shift1 7
+#define Exp_msk1    0x80
+#define Exp_msk11   0x800000
+#define Exp_mask  0x7f80
+#define P 56
+#define Nbits 56
+#define Bias 129
+#define Emax 126
+#define Emin (-129)
+#define Exp_1  0x40800000
+#define Exp_11 0x4080
+#define Ebits 8
+#define Frac_mask  0x7fffff
+#define Frac_mask1 0xffff007f
+#define Ten_pmax 24
+#define Bletch 2
+#define Bndry_mask  0xffff007f
+#define Bndry_mask1 0xffff007f
+#define LSB 0x10000
+#define Sign_bit 0x8000
+#define Log2P 1
+#define Tiny0 0x80
+#define Tiny1 0
+#define Quick_max 15
+#define Int_max 15
+#endif /* IBM, VAX */
+#endif /* IEEE_Arith */
+
+#ifndef IEEE_Arith
+#define ROUND_BIASED
+#else
+#ifdef ROUND_BIASED_without_Round_Up
+#undef  ROUND_BIASED
+#define ROUND_BIASED
+#endif
+#endif
+
+#ifdef RND_PRODQUOT
+#define rounded_product(a,b) a = rnd_prod(a, b)
+#define rounded_quotient(a,b) a = rnd_quot(a, b)
+#ifdef KR_headers
+extern double rnd_prod(), rnd_quot();
+#else
+extern double rnd_prod(double, double), rnd_quot(double, double);
+#endif
+#else
+#define rounded_product(a,b) a *= b
+#define rounded_quotient(a,b) a /= b
+#endif
+
+#define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1))
+#define Big1 0xffffffff
+
+#ifndef Pack_32
+#define Pack_32
+#endif
+
+typedef struct BCinfo BCinfo;
+ struct
+BCinfo { int dp0, dp1, dplen, dsign, e0, inexact, nd, nd0, rounding, scale, uflchk; };
+
+#ifdef KR_headers
+#define FFFFFFFF ((((unsigned long)0xffff)<<16)|(unsigned long)0xffff)
+#else
+#define FFFFFFFF 0xffffffffUL
+#endif
+
+#ifdef NO_LONG_LONG
+#undef ULLong
+#ifdef Just_16
+#undef Pack_32
+/* When Pack_32 is not defined, we store 16 bits per 32-bit Long.
+ * This makes some inner loops simpler and sometimes saves work
+ * during multiplications, but it often seems to make things slightly
+ * slower.  Hence the default is now to store 32 bits per Long.
+ */
+#endif
+#else	/* long long available */
+#ifndef Llong
+#define Llong long long
+#endif
+#ifndef ULLong
+#define ULLong unsigned Llong
+#endif
+#endif /* NO_LONG_LONG */
+
+#ifndef MULTIPLE_THREADS
+#define ACQUIRE_DTOA_LOCK(n)	/*nothing*/
+#define FREE_DTOA_LOCK(n)	/*nothing*/
+#endif
+
+#define Kmax 7
+
+#ifdef __cplusplus
+extern "C" double strtod(const char *s00, char **se);
+extern "C" char *dtoa(double d, int mode, int ndigits,
+			int *decpt, int *sign, char **rve);
+#endif
+
+ struct
+Bigint {
+	struct Bigint *next;
+	int k, maxwds, sign, wds;
+	ULong x[1];
+	};
+
+ typedef struct Bigint Bigint;
+
+ static Bigint *freelist[Kmax+1];
+
+ static Bigint *
+Balloc
+#ifdef KR_headers
+	(k) int k;
+#else
+	(int k)
+#endif
+{
+	int x;
+	Bigint *rv;
+#ifndef Omit_Private_Memory
+	unsigned int len;
+#endif
+
+	ACQUIRE_DTOA_LOCK(0);
+	/* The k > Kmax case does not need ACQUIRE_DTOA_LOCK(0), */
+	/* but this case seems very unlikely. */
+	if (k <= Kmax && (rv = freelist[k]))
+		freelist[k] = rv->next;
+	else {
+		x = 1 << k;
+#ifdef Omit_Private_Memory
+		rv = (Bigint *)MALLOC(sizeof(Bigint) + (x-1)*sizeof(ULong));
+#else
+		len = (sizeof(Bigint) + (x-1)*sizeof(ULong) + sizeof(double) - 1)
+			/sizeof(double);
+		if (k <= Kmax && pmem_next - private_mem + len <= PRIVATE_mem) {
+			rv = (Bigint*)pmem_next;
+			pmem_next += len;
+			}
+		else
+			rv = (Bigint*)MALLOC(len*sizeof(double));
+#endif
+		rv->k = k;
+		rv->maxwds = x;
+		}
+	FREE_DTOA_LOCK(0);
+	rv->sign = rv->wds = 0;
+	return rv;
+	}
+
+ static void
+Bfree
+#ifdef KR_headers
+	(v) Bigint *v;
+#else
+	(Bigint *v)
+#endif
+{
+	if (v) {
+		if (v->k > Kmax)
+#ifdef FREE
+			FREE((void*)v);
+#else
+			free((void*)v);
+#endif
+		else {
+			ACQUIRE_DTOA_LOCK(0);
+			v->next = freelist[v->k];
+			freelist[v->k] = v;
+			FREE_DTOA_LOCK(0);
+			}
+		}
+	}
+
+#define Bcopy(x,y) memcpy((char *)&x->sign, (char *)&y->sign, \
+y->wds*sizeof(Long) + 2*sizeof(int))
+
+ static Bigint *
+multadd
+#ifdef KR_headers
+	(b, m, a) Bigint *b; int m, a;
+#else
+	(Bigint *b, int m, int a)	/* multiply by m and add a */
+#endif
+{
+	int i, wds;
+#ifdef ULLong
+	ULong *x;
+	ULLong carry, y;
+#else
+	ULong carry, *x, y;
+#ifdef Pack_32
+	ULong xi, z;
+#endif
+#endif
+	Bigint *b1;
+
+	wds = b->wds;
+	x = b->x;
+	i = 0;
+	carry = a;
+	do {
+#ifdef ULLong
+		y = *x * (ULLong)m + carry;
+		carry = y >> 32;
+		*x++ = y & FFFFFFFF;
+#else
+#ifdef Pack_32
+		xi = *x;
+		y = (xi & 0xffff) * m + carry;
+		z = (xi >> 16) * m + (y >> 16);
+		carry = z >> 16;
+		*x++ = (z << 16) + (y & 0xffff);
+#else
+		y = *x * m + carry;
+		carry = y >> 16;
+		*x++ = y & 0xffff;
+#endif
+#endif
+		}
+		while(++i < wds);
+	if (carry) {
+		if (wds >= b->maxwds) {
+			b1 = Balloc(b->k+1);
+			Bcopy(b1, b);
+			Bfree(b);
+			b = b1;
+			}
+		b->x[wds++] = carry;
+		b->wds = wds;
+		}
+	return b;
+	}
+
+ static Bigint *
+s2b
+#ifdef KR_headers
+	(s, nd0, nd, y9, dplen) CONST char *s; int nd0, nd, dplen; ULong y9;
+#else
+	(const char *s, int nd0, int nd, ULong y9, int dplen)
+#endif
+{
+	Bigint *b;
+	int i, k;
+	Long x, y;
+
+	x = (nd + 8) / 9;
+	for(k = 0, y = 1; x > y; y <<= 1, k++) ;
+#ifdef Pack_32
+	b = Balloc(k);
+	b->x[0] = y9;
+	b->wds = 1;
+#else
+	b = Balloc(k+1);
+	b->x[0] = y9 & 0xffff;
+	b->wds = (b->x[1] = y9 >> 16) ? 2 : 1;
+#endif
+
+	i = 9;
+	if (9 < nd0) {
+		s += 9;
+		do b = multadd(b, 10, *s++ - '0');
+			while(++i < nd0);
+		s += dplen;
+		}
+	else
+		s += dplen + 9;
+	for(; i < nd; i++)
+		b = multadd(b, 10, *s++ - '0');
+	return b;
+	}
+
+ static int
+hi0bits
+#ifdef KR_headers
+	(x) ULong x;
+#else
+	(ULong x)
+#endif
+{
+	int k = 0;
+
+	if (!(x & 0xffff0000)) {
+		k = 16;
+		x <<= 16;
+		}
+	if (!(x & 0xff000000)) {
+		k += 8;
+		x <<= 8;
+		}
+	if (!(x & 0xf0000000)) {
+		k += 4;
+		x <<= 4;
+		}
+	if (!(x & 0xc0000000)) {
+		k += 2;
+		x <<= 2;
+		}
+	if (!(x & 0x80000000)) {
+		k++;
+		if (!(x & 0x40000000))
+			return 32;
+		}
+	return k;
+	}
+
+ static int
+lo0bits
+#ifdef KR_headers
+	(y) ULong *y;
+#else
+	(ULong *y)
+#endif
+{
+	int k;
+	ULong x = *y;
+
+	if (x & 7) {
+		if (x & 1)
+			return 0;
+		if (x & 2) {
+			*y = x >> 1;
+			return 1;
+			}
+		*y = x >> 2;
+		return 2;
+		}
+	k = 0;
+	if (!(x & 0xffff)) {
+		k = 16;
+		x >>= 16;
+		}
+	if (!(x & 0xff)) {
+		k += 8;
+		x >>= 8;
+		}
+	if (!(x & 0xf)) {
+		k += 4;
+		x >>= 4;
+		}
+	if (!(x & 0x3)) {
+		k += 2;
+		x >>= 2;
+		}
+	if (!(x & 1)) {
+		k++;
+		x >>= 1;
+		if (!x)
+			return 32;
+		}
+	*y = x;
+	return k;
+	}
+
+ static Bigint *
+i2b
+#ifdef KR_headers
+	(i) int i;
+#else
+	(int i)
+#endif
+{
+	Bigint *b;
+
+	b = Balloc(1);
+	b->x[0] = i;
+	b->wds = 1;
+	return b;
+	}
+
+ static Bigint *
+mult
+#ifdef KR_headers
+	(a, b) Bigint *a, *b;
+#else
+	(Bigint *a, Bigint *b)
+#endif
+{
+	Bigint *c;
+	int k, wa, wb, wc;
+	ULong *x, *xa, *xae, *xb, *xbe, *xc, *xc0;
+	ULong y;
+#ifdef ULLong
+	ULLong carry, z;
+#else
+	ULong carry, z;
+#ifdef Pack_32
+	ULong z2;
+#endif
+#endif
+
+	if (a->wds < b->wds) {
+		c = a;
+		a = b;
+		b = c;
+		}
+	k = a->k;
+	wa = a->wds;
+	wb = b->wds;
+	wc = wa + wb;
+	if (wc > a->maxwds)
+		k++;
+	c = Balloc(k);
+	for(x = c->x, xa = x + wc; x < xa; x++)
+		*x = 0;
+	xa = a->x;
+	xae = xa + wa;
+	xb = b->x;
+	xbe = xb + wb;
+	xc0 = c->x;
+#ifdef ULLong
+	for(; xb < xbe; xc0++) {
+		if ((y = *xb++)) {
+			x = xa;
+			xc = xc0;
+			carry = 0;
+			do {
+				z = *x++ * (ULLong)y + *xc + carry;
+				carry = z >> 32;
+				*xc++ = z & FFFFFFFF;
+				}
+				while(x < xae);
+			*xc = carry;
+			}
+		}
+#else
+#ifdef Pack_32
+	for(; xb < xbe; xb++, xc0++) {
+		if (y = *xb & 0xffff) {
+			x = xa;
+			xc = xc0;
+			carry = 0;
+			do {
+				z = (*x & 0xffff) * y + (*xc & 0xffff) + carry;
+				carry = z >> 16;
+				z2 = (*x++ >> 16) * y + (*xc >> 16) + carry;
+				carry = z2 >> 16;
+				Storeinc(xc, z2, z);
+				}
+				while(x < xae);
+			*xc = carry;
+			}
+		if (y = *xb >> 16) {
+			x = xa;
+			xc = xc0;
+			carry = 0;
+			z2 = *xc;
+			do {
+				z = (*x & 0xffff) * y + (*xc >> 16) + carry;
+				carry = z >> 16;
+				Storeinc(xc, z, z2);
+				z2 = (*x++ >> 16) * y + (*xc & 0xffff) + carry;
+				carry = z2 >> 16;
+				}
+				while(x < xae);
+			*xc = z2;
+			}
+		}
+#else
+	for(; xb < xbe; xc0++) {
+		if (y = *xb++) {
+			x = xa;
+			xc = xc0;
+			carry = 0;
+			do {
+				z = *x++ * y + *xc + carry;
+				carry = z >> 16;
+				*xc++ = z & 0xffff;
+				}
+				while(x < xae);
+			*xc = carry;
+			}
+		}
+#endif
+#endif
+	for(xc0 = c->x, xc = xc0 + wc; wc > 0 && !*--xc; --wc) ;
+	c->wds = wc;
+	return c;
+	}
+
+ static Bigint *p5s;
+
+ static Bigint *
+pow5mult
+#ifdef KR_headers
+	(b, k) Bigint *b; int k;
+#else
+	(Bigint *b, int k)
+#endif
+{
+	Bigint *b1, *p5, *p51;
+	int i;
+	static int p05[3] = { 5, 25, 125 };
+
+	if ((i = k & 3))
+		b = multadd(b, p05[i-1], 0);
+
+	if (!(k >>= 2))
+		return b;
+	if (!(p5 = p5s)) {
+		/* first time */
+#ifdef MULTIPLE_THREADS
+		ACQUIRE_DTOA_LOCK(1);
+		if (!(p5 = p5s)) {
+			p5 = p5s = i2b(625);
+			p5->next = 0;
+			}
+		FREE_DTOA_LOCK(1);
+#else
+		p5 = p5s = i2b(625);
+		p5->next = 0;
+#endif
+		}
+	for(;;) {
+		if (k & 1) {
+			b1 = mult(b, p5);
+			Bfree(b);
+			b = b1;
+			}
+		if (!(k >>= 1))
+			break;
+		if (!(p51 = p5->next)) {
+#ifdef MULTIPLE_THREADS
+			ACQUIRE_DTOA_LOCK(1);
+			if (!(p51 = p5->next)) {
+				p51 = p5->next = mult(p5,p5);
+				p51->next = 0;
+				}
+			FREE_DTOA_LOCK(1);
+#else
+			p51 = p5->next = mult(p5,p5);
+			p51->next = 0;
+#endif
+			}
+		p5 = p51;
+		}
+	return b;
+	}
+
+ static Bigint *
+lshift
+#ifdef KR_headers
+	(b, k) Bigint *b; int k;
+#else
+	(Bigint *b, int k)
+#endif
+{
+	int i, k1, n, n1;
+	Bigint *b1;
+	ULong *x, *x1, *xe, z;
+
+#ifdef Pack_32
+	n = k >> 5;
+#else
+	n = k >> 4;
+#endif
+	k1 = b->k;
+	n1 = n + b->wds + 1;
+	for(i = b->maxwds; n1 > i; i <<= 1)
+		k1++;
+	b1 = Balloc(k1);
+	x1 = b1->x;
+	for(i = 0; i < n; i++)
+		*x1++ = 0;
+	x = b->x;
+	xe = x + b->wds;
+#ifdef Pack_32
+	if (k &= 0x1f) {
+		k1 = 32 - k;
+		z = 0;
+		do {
+			*x1++ = *x << k | z;
+			z = *x++ >> k1;
+			}
+			while(x < xe);
+		if ((*x1 = z))
+			++n1;
+		}
+#else
+	if (k &= 0xf) {
+		k1 = 16 - k;
+		z = 0;
+		do {
+			*x1++ = *x << k  & 0xffff | z;
+			z = *x++ >> k1;
+			}
+			while(x < xe);
+		if (*x1 = z)
+			++n1;
+		}
+#endif
+	else do
+		*x1++ = *x++;
+		while(x < xe);
+	b1->wds = n1 - 1;
+	Bfree(b);
+	return b1;
+	}
+
+ static int
+cmp
+#ifdef KR_headers
+	(a, b) Bigint *a, *b;
+#else
+	(Bigint *a, Bigint *b)
+#endif
+{
+	ULong *xa, *xa0, *xb, *xb0;
+	int i, j;
+
+	i = a->wds;
+	j = b->wds;
+#ifdef DEBUG
+	if (i > 1 && !a->x[i-1])
+		Bug("cmp called with a->x[a->wds-1] == 0");
+	if (j > 1 && !b->x[j-1])
+		Bug("cmp called with b->x[b->wds-1] == 0");
+#endif
+	if (i -= j)
+		return i;
+	xa0 = a->x;
+	xa = xa0 + j;
+	xb0 = b->x;
+	xb = xb0 + j;
+	for(;;) {
+		if (*--xa != *--xb)
+			return *xa < *xb ? -1 : 1;
+		if (xa <= xa0)
+			break;
+		}
+	return 0;
+	}
+
+ static Bigint *
+diff
+#ifdef KR_headers
+	(a, b) Bigint *a, *b;
+#else
+	(Bigint *a, Bigint *b)
+#endif
+{
+	Bigint *c;
+	int i, wa, wb;
+	ULong *xa, *xae, *xb, *xbe, *xc;
+#ifdef ULLong
+	ULLong borrow, y;
+#else
+	ULong borrow, y;
+#ifdef Pack_32
+	ULong z;
+#endif
+#endif
+
+	i = cmp(a,b);
+	if (!i) {
+		c = Balloc(0);
+		c->wds = 1;
+		c->x[0] = 0;
+		return c;
+		}
+	if (i < 0) {
+		c = a;
+		a = b;
+		b = c;
+		i = 1;
+		}
+	else
+		i = 0;
+	c = Balloc(a->k);
+	c->sign = i;
+	wa = a->wds;
+	xa = a->x;
+	xae = xa + wa;
+	wb = b->wds;
+	xb = b->x;
+	xbe = xb + wb;
+	xc = c->x;
+	borrow = 0;
+#ifdef ULLong
+	do {
+		y = (ULLong)*xa++ - *xb++ - borrow;
+		borrow = y >> 32 & (ULong)1;
+		*xc++ = y & FFFFFFFF;
+		}
+		while(xb < xbe);
+	while(xa < xae) {
+		y = *xa++ - borrow;
+		borrow = y >> 32 & (ULong)1;
+		*xc++ = y & FFFFFFFF;
+		}
+#else
+#ifdef Pack_32
+	do {
+		y = (*xa & 0xffff) - (*xb & 0xffff) - borrow;
+		borrow = (y & 0x10000) >> 16;
+		z = (*xa++ >> 16) - (*xb++ >> 16) - borrow;
+		borrow = (z & 0x10000) >> 16;
+		Storeinc(xc, z, y);
+		}
+		while(xb < xbe);
+	while(xa < xae) {
+		y = (*xa & 0xffff) - borrow;
+		borrow = (y & 0x10000) >> 16;
+		z = (*xa++ >> 16) - borrow;
+		borrow = (z & 0x10000) >> 16;
+		Storeinc(xc, z, y);
+		}
+#else
+	do {
+		y = *xa++ - *xb++ - borrow;
+		borrow = (y & 0x10000) >> 16;
+		*xc++ = y & 0xffff;
+		}
+		while(xb < xbe);
+	while(xa < xae) {
+		y = *xa++ - borrow;
+		borrow = (y & 0x10000) >> 16;
+		*xc++ = y & 0xffff;
+		}
+#endif
+#endif
+	while(!*--xc)
+		wa--;
+	c->wds = wa;
+	return c;
+	}
+
+ static double
+ulp
+#ifdef KR_headers
+	(x) U *x;
+#else
+	(U *x)
+#endif
+{
+	Long L;
+	U u;
+
+	L = (word0(x) & Exp_mask) - (P-1)*Exp_msk1;
+#ifndef Avoid_Underflow
+#ifndef Sudden_Underflow
+	if (L > 0) {
+#endif
+#endif
+#ifdef IBM
+		L |= Exp_msk1 >> 4;
+#endif
+		word0(&u) = L;
+		word1(&u) = 0;
+#ifndef Avoid_Underflow
+#ifndef Sudden_Underflow
+		}
+	else {
+		L = -L >> Exp_shift;
+		if (L < Exp_shift) {
+			word0(&u) = 0x80000 >> L;
+			word1(&u) = 0;
+			}
+		else {
+			word0(&u) = 0;
+			L -= Exp_shift;
+			word1(&u) = L >= 31 ? 1 : 1 << 31 - L;
+			}
+		}
+#endif
+#endif
+	return dval(&u);
+	}
+
+ static double
+b2d
+#ifdef KR_headers
+	(a, e) Bigint *a; int *e;
+#else
+	(Bigint *a, int *e)
+#endif
+{
+	ULong *xa, *xa0, w, y, z;
+	int k;
+	U d;
+#ifdef VAX
+	ULong d0, d1;
+#else
+#define d0 word0(&d)
+#define d1 word1(&d)
+#endif
+
+	xa0 = a->x;
+	xa = xa0 + a->wds;
+	y = *--xa;
+#ifdef DEBUG
+	if (!y) Bug("zero y in b2d");
+#endif
+	k = hi0bits(y);
+	*e = 32 - k;
+#ifdef Pack_32
+	if (k < Ebits) {
+		d0 = Exp_1 | y >> (Ebits - k);
+		w = xa > xa0 ? *--xa : 0;
+		d1 = y << ((32-Ebits) + k) | w >> (Ebits - k);
+		goto ret_d;
+		}
+	z = xa > xa0 ? *--xa : 0;
+	if (k -= Ebits) {
+		d0 = Exp_1 | y << k | z >> (32 - k);
+		y = xa > xa0 ? *--xa : 0;
+		d1 = z << k | y >> (32 - k);
+		}
+	else {
+		d0 = Exp_1 | y;
+		d1 = z;
+		}
+#else
+	if (k < Ebits + 16) {
+		z = xa > xa0 ? *--xa : 0;
+		d0 = Exp_1 | y << k - Ebits | z >> Ebits + 16 - k;
+		w = xa > xa0 ? *--xa : 0;
+		y = xa > xa0 ? *--xa : 0;
+		d1 = z << k + 16 - Ebits | w << k - Ebits | y >> 16 + Ebits - k;
+		goto ret_d;
+		}
+	z = xa > xa0 ? *--xa : 0;
+	w = xa > xa0 ? *--xa : 0;
+	k -= Ebits + 16;
+	d0 = Exp_1 | y << k + 16 | z << k | w >> 16 - k;
+	y = xa > xa0 ? *--xa : 0;
+	d1 = w << k + 16 | y << k;
+#endif
+ ret_d:
+#ifdef VAX
+	word0(&d) = d0 >> 16 | d0 << 16;
+	word1(&d) = d1 >> 16 | d1 << 16;
+#else
+#undef d0
+#undef d1
+#endif
+	return dval(&d);
+	}
+
+ static Bigint *
+d2b
+#ifdef KR_headers
+	(d, e, bits) U *d; int *e, *bits;
+#else
+	(U *d, int *e, int *bits)
+#endif
+{
+	Bigint *b;
+	int de, k;
+	ULong *x, y, z;
+#ifndef Sudden_Underflow
+	int i;
+#endif
+#ifdef VAX
+	ULong d0, d1;
+	d0 = word0(d) >> 16 | word0(d) << 16;
+	d1 = word1(d) >> 16 | word1(d) << 16;
+#else
+#define d0 word0(d)
+#define d1 word1(d)
+#endif
+
+#ifdef Pack_32
+	b = Balloc(1);
+#else
+	b = Balloc(2);
+#endif
+	x = b->x;
+
+	z = d0 & Frac_mask;
+	d0 &= 0x7fffffff;	/* clear sign bit, which we ignore */
+#ifdef Sudden_Underflow
+	de = (int)(d0 >> Exp_shift);
+#ifndef IBM
+	z |= Exp_msk11;
+#endif
+#else
+	if ((de = (int)(d0 >> Exp_shift)))
+		z |= Exp_msk1;
+#endif
+#ifdef Pack_32
+	if ((y = d1)) {
+		if ((k = lo0bits(&y))) {
+			x[0] = y | z << (32 - k);
+			z >>= k;
+			}
+		else
+			x[0] = y;
+#ifndef Sudden_Underflow
+		i =
+#endif
+		    b->wds = (x[1] = z) ? 2 : 1;
+		}
+	else {
+		k = lo0bits(&z);
+		x[0] = z;
+#ifndef Sudden_Underflow
+		i =
+#endif
+		    b->wds = 1;
+		k += 32;
+		}
+#else
+	if (y = d1) {
+		if (k = lo0bits(&y))
+			if (k >= 16) {
+				x[0] = y | z << 32 - k & 0xffff;
+				x[1] = z >> k - 16 & 0xffff;
+				x[2] = z >> k;
+				i = 2;
+				}
+			else {
+				x[0] = y & 0xffff;
+				x[1] = y >> 16 | z << 16 - k & 0xffff;
+				x[2] = z >> k & 0xffff;
+				x[3] = z >> k+16;
+				i = 3;
+				}
+		else {
+			x[0] = y & 0xffff;
+			x[1] = y >> 16;
+			x[2] = z & 0xffff;
+			x[3] = z >> 16;
+			i = 3;
+			}
+		}
+	else {
+#ifdef DEBUG
+		if (!z)
+			Bug("Zero passed to d2b");
+#endif
+		k = lo0bits(&z);
+		if (k >= 16) {
+			x[0] = z;
+			i = 0;
+			}
+		else {
+			x[0] = z & 0xffff;
+			x[1] = z >> 16;
+			i = 1;
+			}
+		k += 32;
+		}
+	while(!x[i])
+		--i;
+	b->wds = i + 1;
+#endif
+#ifndef Sudden_Underflow
+	if (de) {
+#endif
+#ifdef IBM
+		*e = (de - Bias - (P-1) << 2) + k;
+		*bits = 4*P + 8 - k - hi0bits(word0(d) & Frac_mask);
+#else
+		*e = de - Bias - (P-1) + k;
+		*bits = P - k;
+#endif
+#ifndef Sudden_Underflow
+		}
+	else {
+		*e = de - Bias - (P-1) + 1 + k;
+#ifdef Pack_32
+		*bits = 32*i - hi0bits(x[i-1]);
+#else
+		*bits = (i+2)*16 - hi0bits(x[i]);
+#endif
+		}
+#endif
+	return b;
+	}
+#undef d0
+#undef d1
+
+ static double
+ratio
+#ifdef KR_headers
+	(a, b) Bigint *a, *b;
+#else
+	(Bigint *a, Bigint *b)
+#endif
+{
+	U da, db;
+	int k, ka, kb;
+
+	dval(&da) = b2d(a, &ka);
+	dval(&db) = b2d(b, &kb);
+#ifdef Pack_32
+	k = ka - kb + 32*(a->wds - b->wds);
+#else
+	k = ka - kb + 16*(a->wds - b->wds);
+#endif
+#ifdef IBM
+	if (k > 0) {
+		word0(&da) += (k >> 2)*Exp_msk1;
+		if (k &= 3)
+			dval(&da) *= 1 << k;
+		}
+	else {
+		k = -k;
+		word0(&db) += (k >> 2)*Exp_msk1;
+		if (k &= 3)
+			dval(&db) *= 1 << k;
+		}
+#else
+	if (k > 0)
+		word0(&da) += k*Exp_msk1;
+	else {
+		k = -k;
+		word0(&db) += k*Exp_msk1;
+		}
+#endif
+	return dval(&da) / dval(&db);
+	}
+
+ static CONST double
+tens[] = {
+		1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
+		1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
+		1e20, 1e21, 1e22
+#ifdef VAX
+		, 1e23, 1e24
+#endif
+		};
+
+ static CONST double
+#ifdef IEEE_Arith
+bigtens[] = { 1e16, 1e32, 1e64, 1e128, 1e256 };
+static CONST double tinytens[] = { 1e-16, 1e-32, 1e-64, 1e-128,
+#ifdef Avoid_Underflow
+		9007199254740992.*9007199254740992.e-256
+		/* = 2^106 * 1e-256 */
+#else
+		1e-256
+#endif
+		};
+/* The factor of 2^53 in tinytens[4] helps us avoid setting the underflow */
+/* flag unnecessarily.  It leads to a song and dance at the end of strtod. */
+#define Scale_Bit 0x10
+#define n_bigtens 5
+#else
+#ifdef IBM
+bigtens[] = { 1e16, 1e32, 1e64 };
+static CONST double tinytens[] = { 1e-16, 1e-32, 1e-64 };
+#define n_bigtens 3
+#else
+bigtens[] = { 1e16, 1e32 };
+static CONST double tinytens[] = { 1e-16, 1e-32 };
+#define n_bigtens 2
+#endif
+#endif
+
+#undef Need_Hexdig
+#ifdef INFNAN_CHECK
+#ifndef No_Hex_NaN
+#define Need_Hexdig
+#endif
+#endif
+
+#ifndef Need_Hexdig
+#ifndef NO_HEX_FP
+#define Need_Hexdig
+#endif
+#endif
+
+#ifdef Need_Hexdig /*{*/
+static unsigned char hexdig[256];
+
+ static void
+#ifdef KR_headers
+htinit(h, s, inc) unsigned char *h; unsigned char *s; int inc;
+#else
+htinit(unsigned char *h, unsigned char *s, int inc)
+#endif
+{
+	int i, j;
+	for(i = 0; (j = s[i]) !=0; i++)
+		h[j] = i + inc;
+	}
+
+ static void
+#ifdef KR_headers
+hexdig_init()
+#else
+hexdig_init(void)
+#endif
+{
+#define USC (unsigned char *)
+	htinit(hexdig, USC "0123456789", 0x10);
+	htinit(hexdig, USC "abcdef", 0x10 + 10);
+	htinit(hexdig, USC "ABCDEF", 0x10 + 10);
+	}
+#endif /* } Need_Hexdig */
+
+#ifdef INFNAN_CHECK
+
+#ifndef NAN_WORD0
+#define NAN_WORD0 0x7ff80000
+#endif
+
+#ifndef NAN_WORD1
+#define NAN_WORD1 0
+#endif
+
+ static int
+match
+#ifdef KR_headers
+	(sp, t) char **sp, *t;
+#else
+	(const char **sp, const char *t)
+#endif
+{
+	int c, d;
+	CONST char *s = *sp;
+
+	while((d = *t++)) {
+		if ((c = *++s) >= 'A' && c <= 'Z')
+			c += 'a' - 'A';
+		if (c != d)
+			return 0;
+		}
+	*sp = s + 1;
+	return 1;
+	}
+
+#ifndef No_Hex_NaN
+ static void
+hexnan
+#ifdef KR_headers
+	(rvp, sp) U *rvp; CONST char **sp;
+#else
+	(U *rvp, const char **sp)
+#endif
+{
+	ULong c, x[2];
+	CONST char *s;
+	int c1, havedig, udx0, xshift;
+
+	if (!hexdig['0'])
+		hexdig_init();
+	x[0] = x[1] = 0;
+	havedig = xshift = 0;
+	udx0 = 1;
+	s = *sp;
+	/* allow optional initial 0x or 0X */
+	while((c = *(CONST unsigned char*)(s+1)) && c <= ' ')
+		++s;
+	if (s[1] == '0' && (s[2] == 'x' || s[2] == 'X'))
+		s += 2;
+	while((c = *(CONST unsigned char*)++s)) {
+		if ((c1 = hexdig[c]))
+			c  = c1 & 0xf;
+		else if (c <= ' ') {
+			if (udx0 && havedig) {
+				udx0 = 0;
+				xshift = 1;
+				}
+			continue;
+			}
+#ifdef GDTOA_NON_PEDANTIC_NANCHECK
+		else if (/*(*/ c == ')' && havedig) {
+			*sp = s + 1;
+			break;
+			}
+		else
+			return;	/* invalid form: don't change *sp */
+#else
+		else {
+			do {
+				if (/*(*/ c == ')') {
+					*sp = s + 1;
+					break;
+					}
+				} while((c = *++s));
+			break;
+			}
+#endif
+		havedig = 1;
+		if (xshift) {
+			xshift = 0;
+			x[0] = x[1];
+			x[1] = 0;
+			}
+		if (udx0)
+			x[0] = (x[0] << 4) | (x[1] >> 28);
+		x[1] = (x[1] << 4) | c;
+		}
+	if ((x[0] &= 0xfffff) || x[1]) {
+		word0(rvp) = Exp_mask | x[0];
+		word1(rvp) = x[1];
+		}
+	}
+#endif /*No_Hex_NaN*/
+#endif /* INFNAN_CHECK */
+
+#ifdef Pack_32
+#define ULbits 32
+#define kshift 5
+#define kmask 31
+#else
+#define ULbits 16
+#define kshift 4
+#define kmask 15
+#endif
+
+#if !defined(NO_HEX_FP) || defined(Honor_FLT_ROUNDS) /*{*/
+ static Bigint *
+#ifdef KR_headers
+increment(b) Bigint *b;
+#else
+increment(Bigint *b)
+#endif
+{
+	ULong *x, *xe;
+	Bigint *b1;
+
+	x = b->x;
+	xe = x + b->wds;
+	do {
+		if (*x < (ULong)0xffffffffL) {
+			++*x;
+			return b;
+			}
+		*x++ = 0;
+		} while(x < xe);
+	{
+		if (b->wds >= b->maxwds) {
+			b1 = Balloc(b->k+1);
+			Bcopy(b1,b);
+			Bfree(b);
+			b = b1;
+			}
+		b->x[b->wds++] = 1;
+		}
+	return b;
+	}
+
+#endif /*}*/
+
+#ifndef NO_HEX_FP /*{*/
+
+ static void
+#ifdef KR_headers
+rshift(b, k) Bigint *b; int k;
+#else
+rshift(Bigint *b, int k)
+#endif
+{
+	ULong *x, *x1, *xe, y;
+	int n;
+
+	x = x1 = b->x;
+	n = k >> kshift;
+	if (n < b->wds) {
+		xe = x + b->wds;
+		x += n;
+		if (k &= kmask) {
+			n = 32 - k;
+			y = *x++ >> k;
+			while(x < xe) {
+				*x1++ = (y | (*x << n)) & 0xffffffff;
+				y = *x++ >> k;
+				}
+			if ((*x1 = y) !=0)
+				x1++;
+			}
+		else
+			while(x < xe)
+				*x1++ = *x++;
+		}
+	if ((b->wds = x1 - b->x) == 0)
+		b->x[0] = 0;
+	}
+
+ static ULong
+#ifdef KR_headers
+any_on(b, k) Bigint *b; int k;
+#else
+any_on(Bigint *b, int k)
+#endif
+{
+	int n, nwds;
+	ULong *x, *x0, x1, x2;
+
+	x = b->x;
+	nwds = b->wds;
+	n = k >> kshift;
+	if (n > nwds)
+		n = nwds;
+	else if (n < nwds && (k &= kmask)) {
+		x1 = x2 = x[n];
+		x1 >>= k;
+		x1 <<= k;
+		if (x1 != x2)
+			return 1;
+		}
+	x0 = x;
+	x += n;
+	while(x > x0)
+		if (*--x)
+			return 1;
+	return 0;
+	}
+
+enum {	/* rounding values: same as FLT_ROUNDS */
+	Round_zero = 0,
+	Round_near = 1,
+	Round_up = 2,
+	Round_down = 3
+	};
+
+ void
+#ifdef KR_headers
+gethex(sp, rvp, rounding, sign)
+	CONST char **sp; U *rvp; int rounding, sign;
+#else
+gethex( CONST char **sp, U *rvp, int rounding, int sign)
+#endif
+{
+	Bigint *b;
+	CONST unsigned char *decpt, *s0, *s, *s1;
+	Long e, e1;
+	ULong L, lostbits, *x;
+	int big, denorm, esign, havedig, k, n, nbits, up, zret;
+#ifdef IBM
+	int j;
+#endif
+	enum {
+#ifdef IEEE_Arith /*{{*/
+		emax = 0x7fe - Bias - P + 1,
+		emin = Emin - P + 1
+#else /*}{*/
+		emin = Emin - P,
+#ifdef VAX
+		emax = 0x7ff - Bias - P + 1
+#endif
+#ifdef IBM
+		emax = 0x7f - Bias - P
+#endif
+#endif /*}}*/
+		};
+#ifdef USE_LOCALE
+	int i;
+#ifdef NO_LOCALE_CACHE
+	const unsigned char *decimalpoint = (unsigned char*)
+		localeconv()->decimal_point;
+#else
+	const unsigned char *decimalpoint;
+	static unsigned char *decimalpoint_cache;
+	if (!(s0 = decimalpoint_cache)) {
+		s0 = (unsigned char*)localeconv()->decimal_point;
+		if ((decimalpoint_cache = (unsigned char*)
+				MALLOC(strlen((CONST char*)s0) + 1))) {
+			strcpy((char*)decimalpoint_cache, (CONST char*)s0);
+			s0 = decimalpoint_cache;
+			}
+		}
+	decimalpoint = s0;
+#endif
+#endif
+
+	if (!hexdig['0'])
+		hexdig_init();
+	havedig = 0;
+	s0 = *(CONST unsigned char **)sp + 2;
+	while(s0[havedig] == '0')
+		havedig++;
+	s0 += havedig;
+	s = s0;
+	decpt = 0;
+	zret = 0;
+	e = 0;
+	if (hexdig[*s])
+		havedig++;
+	else {
+		zret = 1;
+#ifdef USE_LOCALE
+		for(i = 0; decimalpoint[i]; ++i) {
+			if (s[i] != decimalpoint[i])
+				goto pcheck;
+			}
+		decpt = s += i;
+#else
+		if (*s != '.')
+			goto pcheck;
+		decpt = ++s;
+#endif
+		if (!hexdig[*s])
+			goto pcheck;
+		while(*s == '0')
+			s++;
+		if (hexdig[*s])
+			zret = 0;
+		havedig = 1;
+		s0 = s;
+		}
+	while(hexdig[*s])
+		s++;
+#ifdef USE_LOCALE
+	if (*s == *decimalpoint && !decpt) {
+		for(i = 1; decimalpoint[i]; ++i) {
+			if (s[i] != decimalpoint[i])
+				goto pcheck;
+			}
+		decpt = s += i;
+#else
+	if (*s == '.' && !decpt) {
+		decpt = ++s;
+#endif
+		while(hexdig[*s])
+			s++;
+		}/*}*/
+	if (decpt)
+		e = -(((Long)(s-decpt)) << 2);
+ pcheck:
+	s1 = s;
+	big = esign = 0;
+	switch(*s) {
+	  case 'p':
+	  case 'P':
+		switch(*++s) {
+		  case '-':
+			esign = 1;
+			/* no break */
+		  case '+':
+			s++;
+		  }
+		if ((n = hexdig[*s]) == 0 || n > 0x19) {
+			s = s1;
+			break;
+			}
+		e1 = n - 0x10;
+		while((n = hexdig[*++s]) !=0 && n <= 0x19) {
+			if (e1 & 0xf8000000)
+				big = 1;
+			e1 = 10*e1 + n - 0x10;
+			}
+		if (esign)
+			e1 = -e1;
+		e += e1;
+	  }
+	*sp = (char*)s;
+	if (!havedig)
+		*sp = (char*)s0 - 1;
+	if (zret)
+		goto retz1;
+	if (big) {
+		if (esign) {
+#ifdef IEEE_Arith
+			switch(rounding) {
+			  case Round_up:
+				if (sign)
+					break;
+				goto ret_tiny;
+			  case Round_down:
+				if (!sign)
+					break;
+				goto ret_tiny;
+			  }
+#endif
+			goto retz;
+#ifdef IEEE_Arith
+ ret_tiny:
+#ifndef NO_ERRNO
+			errno = ERANGE;
+#endif
+			word0(rvp) = 0;
+			word1(rvp) = 1;
+			return;
+#endif /* IEEE_Arith */
+			}
+		switch(rounding) {
+		  case Round_near:
+			goto ovfl1;
+		  case Round_up:
+			if (!sign)
+				goto ovfl1;
+			goto ret_big;
+		  case Round_down:
+			if (sign)
+				goto ovfl1;
+			goto ret_big;
+		  }
+ ret_big:
+		word0(rvp) = Big0;
+		word1(rvp) = Big1;
+		return;
+		}
+	n = s1 - s0 - 1;
+	for(k = 0; n > (1 << (kshift-2)) - 1; n >>= 1)
+		k++;
+	b = Balloc(k);
+	x = b->x;
+	n = 0;
+	L = 0;
+#ifdef USE_LOCALE
+	for(i = 0; decimalpoint[i+1]; ++i);
+#endif
+	while(s1 > s0) {
+#ifdef USE_LOCALE
+		if (*--s1 == decimalpoint[i]) {
+			s1 -= i;
+			continue;
+			}
+#else
+		if (*--s1 == '.')
+			continue;
+#endif
+		if (n == ULbits) {
+			*x++ = L;
+			L = 0;
+			n = 0;
+			}
+		L |= (hexdig[*s1] & 0x0f) << n;
+		n += 4;
+		}
+	*x++ = L;
+	b->wds = n = x - b->x;
+	n = ULbits*n - hi0bits(L);
+	nbits = Nbits;
+	lostbits = 0;
+	x = b->x;
+	if (n > nbits) {
+		n -= nbits;
+		if (any_on(b,n)) {
+			lostbits = 1;
+			k = n - 1;
+			if (x[k>>kshift] & 1 << (k & kmask)) {
+				lostbits = 2;
+				if (k > 0 && any_on(b,k))
+					lostbits = 3;
+				}
+			}
+		rshift(b, n);
+		e += n;
+		}
+	else if (n < nbits) {
+		n = nbits - n;
+		b = lshift(b, n);
+		e -= n;
+		x = b->x;
+		}
+	if (e > Emax) {
+ ovfl:
+		Bfree(b);
+ ovfl1:
+#ifndef NO_ERRNO
+		errno = ERANGE;
+#endif
+		word0(rvp) = Exp_mask;
+		word1(rvp) = 0;
+		return;
+		}
+	denorm = 0;
+	if (e < emin) {
+		denorm = 1;
+		n = emin - e;
+		if (n >= nbits) {
+#ifdef IEEE_Arith /*{*/
+			switch (rounding) {
+			  case Round_near:
+				if (n == nbits && (n < 2 || any_on(b,n-1)))
+					goto ret_tiny;
+				break;
+			  case Round_up:
+				if (!sign)
+					goto ret_tiny;
+				break;
+			  case Round_down:
+				if (sign)
+					goto ret_tiny;
+			  }
+#endif /* } IEEE_Arith */
+			Bfree(b);
+ retz:
+#ifndef NO_ERRNO
+			errno = ERANGE;
+#endif
+ retz1:
+			rvp->d = 0.;
+			return;
+			}
+		k = n - 1;
+		if (lostbits)
+			lostbits = 1;
+		else if (k > 0)
+			lostbits = any_on(b,k);
+		if (x[k>>kshift] & 1 << (k & kmask))
+			lostbits |= 2;
+		nbits -= n;
+		rshift(b,n);
+		e = emin;
+		}
+	if (lostbits) {
+		up = 0;
+		switch(rounding) {
+		  case Round_zero:
+			break;
+		  case Round_near:
+			if (lostbits & 2
+			 && (lostbits & 1) | (x[0] & 1))
+				up = 1;
+			break;
+		  case Round_up:
+			up = 1 - sign;
+			break;
+		  case Round_down:
+			up = sign;
+		  }
+		if (up) {
+			k = b->wds;
+			b = increment(b);
+			x = b->x;
+			if (denorm) {
+#if 0
+				if (nbits == Nbits - 1
+				 && x[nbits >> kshift] & 1 << (nbits & kmask))
+					denorm = 0; /* not currently used */
+#endif
+				}
+			else if (b->wds > k
+			 || ((n = nbits & kmask) !=0
+			     && hi0bits(x[k-1]) < 32-n)) {
+				rshift(b,1);
+				if (++e > Emax)
+					goto ovfl;
+				}
+			}
+		}
+#ifdef IEEE_Arith
+	if (denorm)
+		word0(rvp) = b->wds > 1 ? b->x[1] & ~0x100000 : 0;
+	else
+		word0(rvp) = (b->x[1] & ~0x100000) | ((e + 0x3ff + 52) << 20);
+	word1(rvp) = b->x[0];
+#endif
+#ifdef IBM
+	if ((j = e & 3)) {
+		k = b->x[0] & ((1 << j) - 1);
+		rshift(b,j);
+		if (k) {
+			switch(rounding) {
+			  case Round_up:
+				if (!sign)
+					increment(b);
+				break;
+			  case Round_down:
+				if (sign)
+					increment(b);
+				break;
+			  case Round_near:
+				j = 1 << (j-1);
+				if (k & j && ((k & (j-1)) | lostbits))
+					increment(b);
+			  }
+			}
+		}
+	e >>= 2;
+	word0(rvp) = b->x[1] | ((e + 65 + 13) << 24);
+	word1(rvp) = b->x[0];
+#endif
+#ifdef VAX
+	/* The next two lines ignore swap of low- and high-order 2 bytes. */
+	/* word0(rvp) = (b->x[1] & ~0x800000) | ((e + 129 + 55) << 23); */
+	/* word1(rvp) = b->x[0]; */
+	word0(rvp) = ((b->x[1] & ~0x800000) >> 16) | ((e + 129 + 55) << 7) | (b->x[1] << 16);
+	word1(rvp) = (b->x[0] >> 16) | (b->x[0] << 16);
+#endif
+	Bfree(b);
+	}
+#endif /*!NO_HEX_FP}*/
+
+ static int
+#ifdef KR_headers
+dshift(b, p2) Bigint *b; int p2;
+#else
+dshift(Bigint *b, int p2)
+#endif
+{
+	int rv = hi0bits(b->x[b->wds-1]) - 4;
+	if (p2 > 0)
+		rv -= p2;
+	return rv & kmask;
+	}
+
+ static int
+quorem
+#ifdef KR_headers
+	(b, S) Bigint *b, *S;
+#else
+	(Bigint *b, Bigint *S)
+#endif
+{
+	int n;
+	ULong *bx, *bxe, q, *sx, *sxe;
+#ifdef ULLong
+	ULLong borrow, carry, y, ys;
+#else
+	ULong borrow, carry, y, ys;
+#ifdef Pack_32
+	ULong si, z, zs;
+#endif
+#endif
+
+	n = S->wds;
+#ifdef DEBUG
+	/*debug*/ if (b->wds > n)
+	/*debug*/	Bug("oversize b in quorem");
+#endif
+	if (b->wds < n)
+		return 0;
+	sx = S->x;
+	sxe = sx + --n;
+	bx = b->x;
+	bxe = bx + n;
+	q = *bxe / (*sxe + 1);	/* ensure q <= true quotient */
+#ifdef DEBUG
+#ifdef NO_STRTOD_BIGCOMP
+	/*debug*/ if (q > 9)
+#else
+	/* An oversized q is possible when quorem is called from bigcomp and */
+	/* the input is near, e.g., twice the smallest denormalized number. */
+	/*debug*/ if (q > 15)
+#endif
+	/*debug*/	Bug("oversized quotient in quorem");
+#endif
+	if (q) {
+		borrow = 0;
+		carry = 0;
+		do {
+#ifdef ULLong
+			ys = *sx++ * (ULLong)q + carry;
+			carry = ys >> 32;
+			y = *bx - (ys & FFFFFFFF) - borrow;
+			borrow = y >> 32 & (ULong)1;
+			*bx++ = y & FFFFFFFF;
+#else
+#ifdef Pack_32
+			si = *sx++;
+			ys = (si & 0xffff) * q + carry;
+			zs = (si >> 16) * q + (ys >> 16);
+			carry = zs >> 16;
+			y = (*bx & 0xffff) - (ys & 0xffff) - borrow;
+			borrow = (y & 0x10000) >> 16;
+			z = (*bx >> 16) - (zs & 0xffff) - borrow;
+			borrow = (z & 0x10000) >> 16;
+			Storeinc(bx, z, y);
+#else
+			ys = *sx++ * q + carry;
+			carry = ys >> 16;
+			y = *bx - (ys & 0xffff) - borrow;
+			borrow = (y & 0x10000) >> 16;
+			*bx++ = y & 0xffff;
+#endif
+#endif
+			}
+			while(sx <= sxe);
+		if (!*bxe) {
+			bx = b->x;
+			while(--bxe > bx && !*bxe)
+				--n;
+			b->wds = n;
+			}
+		}
+	if (cmp(b, S) >= 0) {
+		q++;
+		borrow = 0;
+		carry = 0;
+		bx = b->x;
+		sx = S->x;
+		do {
+#ifdef ULLong
+			ys = *sx++ + carry;
+			carry = ys >> 32;
+			y = *bx - (ys & FFFFFFFF) - borrow;
+			borrow = y >> 32 & (ULong)1;
+			*bx++ = y & FFFFFFFF;
+#else
+#ifdef Pack_32
+			si = *sx++;
+			ys = (si & 0xffff) + carry;
+			zs = (si >> 16) + (ys >> 16);
+			carry = zs >> 16;
+			y = (*bx & 0xffff) - (ys & 0xffff) - borrow;
+			borrow = (y & 0x10000) >> 16;
+			z = (*bx >> 16) - (zs & 0xffff) - borrow;
+			borrow = (z & 0x10000) >> 16;
+			Storeinc(bx, z, y);
+#else
+			ys = *sx++ + carry;
+			carry = ys >> 16;
+			y = *bx - (ys & 0xffff) - borrow;
+			borrow = (y & 0x10000) >> 16;
+			*bx++ = y & 0xffff;
+#endif
+#endif
+			}
+			while(sx <= sxe);
+		bx = b->x;
+		bxe = bx + n;
+		if (!*bxe) {
+			while(--bxe > bx && !*bxe)
+				--n;
+			b->wds = n;
+			}
+		}
+	return q;
+	}
+
+#if defined(Avoid_Underflow) || !defined(NO_STRTOD_BIGCOMP) /*{*/
+ static double
+sulp
+#ifdef KR_headers
+	(x, bc) U *x; BCinfo *bc;
+#else
+	(U *x, BCinfo *bc)
+#endif
+{
+	U u;
+	double rv;
+	int i;
+
+	rv = ulp(x);
+	if (!bc->scale || (i = 2*P + 1 - ((word0(x) & Exp_mask) >> Exp_shift)) <= 0)
+		return rv; /* Is there an example where i <= 0 ? */
+	word0(&u) = Exp_1 + (i << Exp_shift);
+	word1(&u) = 0;
+	return rv * u.d;
+	}
+#endif /*}*/
+
+#ifndef NO_STRTOD_BIGCOMP
+ static void
+bigcomp
+#ifdef KR_headers
+	(rv, s0, bc)
+	U *rv; CONST char *s0; BCinfo *bc;
+#else
+	(U *rv, const char *s0, BCinfo *bc)
+#endif
+{
+	Bigint *b, *d;
+	int b2, bbits, d2, dd, dig, dsign, i, j, nd, nd0, p2, p5, speccase;
+
+	dsign = bc->dsign;
+	nd = bc->nd;
+	nd0 = bc->nd0;
+	p5 = nd + bc->e0 - 1;
+	speccase = 0;
+#ifndef Sudden_Underflow
+	if (rv->d == 0.) {	/* special case: value near underflow-to-zero */
+				/* threshold was rounded to zero */
+		b = i2b(1);
+		p2 = Emin - P + 1;
+		bbits = 1;
+#ifdef Avoid_Underflow
+		word0(rv) = (P+2) << Exp_shift;
+#else
+		word1(rv) = 1;
+#endif
+		i = 0;
+#ifdef Honor_FLT_ROUNDS
+		if (bc->rounding == 1)
+#endif
+			{
+			speccase = 1;
+			--p2;
+			dsign = 0;
+			goto have_i;
+			}
+		}
+	else
+#endif
+		b = d2b(rv, &p2, &bbits);
+#ifdef Avoid_Underflow
+	p2 -= bc->scale;
+#endif
+	/* floor(log2(rv)) == bbits - 1 + p2 */
+	/* Check for denormal case. */
+	i = P - bbits;
+	if (i > (j = P - Emin - 1 + p2)) {
+#ifdef Sudden_Underflow
+		Bfree(b);
+		b = i2b(1);
+		p2 = Emin;
+		i = P - 1;
+#ifdef Avoid_Underflow
+		word0(rv) = (1 + bc->scale) << Exp_shift;
+#else
+		word0(rv) = Exp_msk1;
+#endif
+		word1(rv) = 0;
+#else
+		i = j;
+#endif
+		}
+#ifdef Honor_FLT_ROUNDS
+	if (bc->rounding != 1) {
+		if (i > 0)
+			b = lshift(b, i);
+		if (dsign)
+			b = increment(b);
+		}
+	else
+#endif
+		{
+		b = lshift(b, ++i);
+		b->x[0] |= 1;
+		}
+#ifndef Sudden_Underflow
+ have_i:
+#endif
+	p2 -= p5 + i;
+	d = i2b(1);
+	/* Arrange for convenient computation of quotients:
+	 * shift left if necessary so divisor has 4 leading 0 bits.
+	 */
+	if (p5 > 0)
+		d = pow5mult(d, p5);
+	else if (p5 < 0)
+		b = pow5mult(b, -p5);
+	if (p2 > 0) {
+		b2 = p2;
+		d2 = 0;
+		}
+	else {
+		b2 = 0;
+		d2 = -p2;
+		}
+	i = dshift(d, d2);
+	if ((b2 += i) > 0)
+		b = lshift(b, b2);
+	if ((d2 += i) > 0)
+		d = lshift(d, d2);
+
+	/* Now b/d = exactly half-way between the two floating-point values */
+	/* on either side of the input string.  Compute first digit of b/d. */
+
+	if (!(dig = quorem(b,d))) {
+		b = multadd(b, 10, 0);	/* very unlikely */
+		dig = quorem(b,d);
+		}
+
+	/* Compare b/d with s0 */
+
+	for(i = 0; i < nd0; ) {
+		if ((dd = s0[i++] - '0' - dig))
+			goto ret;
+		if (!b->x[0] && b->wds == 1) {
+			if (i < nd)
+				dd = 1;
+			goto ret;
+			}
+		b = multadd(b, 10, 0);
+		dig = quorem(b,d);
+		}
+	for(j = bc->dp1; i++ < nd;) {
+		if ((dd = s0[j++] - '0' - dig))
+			goto ret;
+		if (!b->x[0] && b->wds == 1) {
+			if (i < nd)
+				dd = 1;
+			goto ret;
+			}
+		b = multadd(b, 10, 0);
+		dig = quorem(b,d);
+		}
+	if (dig > 0 || b->x[0] || b->wds > 1)
+		dd = -1;
+ ret:
+	Bfree(b);
+	Bfree(d);
+#ifdef Honor_FLT_ROUNDS
+	if (bc->rounding != 1) {
+		if (dd < 0) {
+			if (bc->rounding == 0) {
+				if (!dsign)
+					goto retlow1;
+				}
+			else if (dsign)
+				goto rethi1;
+			}
+		else if (dd > 0) {
+			if (bc->rounding == 0) {
+				if (dsign)
+					goto rethi1;
+				goto ret1;
+				}
+			if (!dsign)
+				goto rethi1;
+			dval(rv) += 2.*sulp(rv,bc);
+			}
+		else {
+			bc->inexact = 0;
+			if (dsign)
+				goto rethi1;
+			}
+		}
+	else
+#endif
+	if (speccase) {
+		if (dd <= 0)
+			rv->d = 0.;
+		}
+	else if (dd < 0) {
+		if (!dsign)	/* does not happen for round-near */
+retlow1:
+			dval(rv) -= sulp(rv,bc);
+		}
+	else if (dd > 0) {
+		if (dsign) {
+ rethi1:
+			dval(rv) += sulp(rv,bc);
+			}
+		}
+	else {
+		/* Exact half-way case:  apply round-even rule. */
+		if ((j = ((word0(rv) & Exp_mask) >> Exp_shift) - bc->scale) <= 0) {
+			i = 1 - j;
+			if (i <= 31) {
+				if (word1(rv) & (0x1 << i))
+					goto odd;
+				}
+			else if (word0(rv) & (0x1 << (i-32)))
+				goto odd;
+			}
+		else if (word1(rv) & 1) {
+ odd:
+			if (dsign)
+				goto rethi1;
+			goto retlow1;
+			}
+		}
+
+#ifdef Honor_FLT_ROUNDS
+ ret1:
+#endif
+	return;
+	}
+#endif /* NO_STRTOD_BIGCOMP */
+
+ double
+strtod
+#ifdef KR_headers
+	(s00, se) CONST char *s00; char **se;
+#else
+	(const char *s00, char **se)
+#endif
+{
+	int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, e, e1;
+	int esign, i, j, k, nd, nd0, nf, nz, nz0, nz1, sign;
+	CONST char *s, *s0, *s1;
+	double aadj, aadj1;
+	Long L;
+	U aadj2, adj, rv, rv0;
+	ULong y, z;
+	BCinfo bc;
+	Bigint *bb, *bb1, *bd, *bd0, *bs, *delta;
+#ifdef Avoid_Underflow
+	ULong Lsb, Lsb1;
+#endif
+#ifdef SET_INEXACT
+	int oldinexact;
+#endif
+#ifndef NO_STRTOD_BIGCOMP
+	int req_bigcomp = 0;
+#endif
+#ifdef Honor_FLT_ROUNDS /*{*/
+#ifdef Trust_FLT_ROUNDS /*{{ only define this if FLT_ROUNDS really works! */
+	bc.rounding = Flt_Rounds;
+#else /*}{*/
+	bc.rounding = 1;
+	switch(fegetround()) {
+	  case FE_TOWARDZERO:	bc.rounding = 0; break;
+	  case FE_UPWARD:	bc.rounding = 2; break;
+	  case FE_DOWNWARD:	bc.rounding = 3;
+	  }
+#endif /*}}*/
+#endif /*}*/
+#ifdef USE_LOCALE
+	CONST char *s2;
+#endif
+
+	sign = nz0 = nz1 = nz = bc.dplen = bc.uflchk = 0;
+	dval(&rv) = 0.;
+	for(s = s00;;s++) switch(*s) {
+		case '-':
+			sign = 1;
+			/* no break */
+		case '+':
+			if (*++s)
+				goto break2;
+			/* no break */
+		case 0:
+			goto ret0;
+		case '\t':
+		case '\n':
+		case '\v':
+		case '\f':
+		case '\r':
+		case ' ':
+			continue;
+		default:
+			goto break2;
+		}
+ break2:
+	if (*s == '0') {
+#ifndef NO_HEX_FP /*{*/
+		switch(s[1]) {
+		  case 'x':
+		  case 'X':
+#ifdef Honor_FLT_ROUNDS
+			gethex(&s, &rv, bc.rounding, sign);
+#else
+			gethex(&s, &rv, 1, sign);
+#endif
+			goto ret;
+		  }
+#endif /*}*/
+		nz0 = 1;
+		while(*++s == '0') ;
+		if (!*s)
+			goto ret;
+		}
+	s0 = s;
+	y = z = 0;
+	for(nd = nf = 0; (c = *s) >= '0' && c <= '9'; nd++, s++)
+		if (nd < 9)
+			y = 10*y + c - '0';
+		else if (nd < 16)
+			z = 10*z + c - '0';
+	nd0 = nd;
+	bc.dp0 = bc.dp1 = s - s0;
+	for(s1 = s; s1 > s0 && *--s1 == '0'; )
+		++nz1;
+#ifdef USE_LOCALE
+	s1 = localeconv()->decimal_point;
+	if (c == *s1) {
+		c = '.';
+		if (*++s1) {
+			s2 = s;
+			for(;;) {
+				if (*++s2 != *s1) {
+					c = 0;
+					break;
+					}
+				if (!*++s1) {
+					s = s2;
+					break;
+					}
+				}
+			}
+		}
+#endif
+	if (c == '.') {
+		c = *++s;
+		bc.dp1 = s - s0;
+		bc.dplen = bc.dp1 - bc.dp0;
+		if (!nd) {
+			for(; c == '0'; c = *++s)
+				nz++;
+			if (c > '0' && c <= '9') {
+				bc.dp0 = s0 - s;
+				bc.dp1 = bc.dp0 + bc.dplen;
+				s0 = s;
+				nf += nz;
+				nz = 0;
+				goto have_dig;
+				}
+			goto dig_done;
+			}
+		for(; c >= '0' && c <= '9'; c = *++s) {
+ have_dig:
+			nz++;
+			if (c -= '0') {
+				nf += nz;
+				for(i = 1; i < nz; i++)
+					if (nd++ < 9)
+						y *= 10;
+					else if (nd <= DBL_DIG + 1)
+						z *= 10;
+				if (nd++ < 9)
+					y = 10*y + c;
+				else if (nd <= DBL_DIG + 1)
+					z = 10*z + c;
+				nz = nz1 = 0;
+				}
+			}
+		}
+ dig_done:
+	e = 0;
+	if (c == 'e' || c == 'E') {
+		if (!nd && !nz && !nz0) {
+			goto ret0;
+			}
+		s00 = s;
+		esign = 0;
+		switch(c = *++s) {
+			case '-':
+				esign = 1;
+			case '+':
+				c = *++s;
+			}
+		if (c >= '0' && c <= '9') {
+			while(c == '0')
+				c = *++s;
+			if (c > '0' && c <= '9') {
+				L = c - '0';
+				s1 = s;
+				while((c = *++s) >= '0' && c <= '9')
+					L = 10*L + c - '0';
+				if (s - s1 > 8 || L > 19999)
+					/* Avoid confusion from exponents
+					 * so large that e might overflow.
+					 */
+					e = 19999; /* safe for 16 bit ints */
+				else
+					e = (int)L;
+				if (esign)
+					e = -e;
+				}
+			else
+				e = 0;
+			}
+		else
+			s = s00;
+		}
+	if (!nd) {
+		if (!nz && !nz0) {
+#ifdef INFNAN_CHECK
+			/* Check for Nan and Infinity */
+			if (!bc.dplen)
+			 switch(c) {
+			  case 'i':
+			  case 'I':
+				if (match(&s,"nf")) {
+					--s;
+					if (!match(&s,"inity"))
+						++s;
+					word0(&rv) = 0x7ff00000;
+					word1(&rv) = 0;
+					goto ret;
+					}
+				break;
+			  case 'n':
+			  case 'N':
+				if (match(&s, "an")) {
+					word0(&rv) = NAN_WORD0;
+					word1(&rv) = NAN_WORD1;
+#ifndef No_Hex_NaN
+					if (*s == '(') /*)*/
+						hexnan(&rv, &s);
+#endif
+					goto ret;
+					}
+			  }
+#endif /* INFNAN_CHECK */
+ ret0:
+			s = s00;
+			sign = 0;
+			}
+		goto ret;
+		}
+	bc.e0 = e1 = e -= nf;
+
+	/* Now we have nd0 digits, starting at s0, followed by a
+	 * decimal point, followed by nd-nd0 digits.  The number we're
+	 * after is the integer represented by those digits times
+	 * 10**e */
+
+	if (!nd0)
+		nd0 = nd;
+	k = nd < DBL_DIG + 1 ? nd : DBL_DIG + 1;
+	dval(&rv) = y;
+	if (k > 9) {
+#ifdef SET_INEXACT
+		if (k > DBL_DIG)
+			oldinexact = get_inexact();
+#endif
+		dval(&rv) = tens[k - 9] * dval(&rv) + z;
+		}
+	bd0 = 0;
+	if (nd <= DBL_DIG
+#ifndef RND_PRODQUOT
+#ifndef Honor_FLT_ROUNDS
+		&& Flt_Rounds == 1
+#endif
+#endif
+			) {
+		if (!e)
+			goto ret;
+#ifndef ROUND_BIASED_without_Round_Up
+		if (e > 0) {
+			if (e <= Ten_pmax) {
+#ifdef VAX
+				goto vax_ovfl_check;
+#else
+#ifdef Honor_FLT_ROUNDS
+				/* round correctly FLT_ROUNDS = 2 or 3 */
+				if (sign) {
+					rv.d = -rv.d;
+					sign = 0;
+					}
+#endif
+				/* rv = */ rounded_product(dval(&rv), tens[e]);
+				goto ret;
+#endif
+				}
+			i = DBL_DIG - nd;
+			if (e <= Ten_pmax + i) {
+				/* A fancier test would sometimes let us do
+				 * this for larger i values.
+				 */
+#ifdef Honor_FLT_ROUNDS
+				/* round correctly FLT_ROUNDS = 2 or 3 */
+				if (sign) {
+					rv.d = -rv.d;
+					sign = 0;
+					}
+#endif
+				e -= i;
+				dval(&rv) *= tens[i];
+#ifdef VAX
+				/* VAX exponent range is so narrow we must
+				 * worry about overflow here...
+				 */
+ vax_ovfl_check:
+				word0(&rv) -= P*Exp_msk1;
+				/* rv = */ rounded_product(dval(&rv), tens[e]);
+				if ((word0(&rv) & Exp_mask)
+				 > Exp_msk1*(DBL_MAX_EXP+Bias-1-P))
+					goto ovfl;
+				word0(&rv) += P*Exp_msk1;
+#else
+				/* rv = */ rounded_product(dval(&rv), tens[e]);
+#endif
+				goto ret;
+				}
+			}
+#ifndef Inaccurate_Divide
+		else if (e >= -Ten_pmax) {
+#ifdef Honor_FLT_ROUNDS
+			/* round correctly FLT_ROUNDS = 2 or 3 */
+			if (sign) {
+				rv.d = -rv.d;
+				sign = 0;
+				}
+#endif
+			/* rv = */ rounded_quotient(dval(&rv), tens[-e]);
+			goto ret;
+			}
+#endif
+#endif /* ROUND_BIASED_without_Round_Up */
+		}
+	e1 += nd - k;
+
+#ifdef IEEE_Arith
+#ifdef SET_INEXACT
+	bc.inexact = 1;
+	if (k <= DBL_DIG)
+		oldinexact = get_inexact();
+#endif
+#ifdef Avoid_Underflow
+	bc.scale = 0;
+#endif
+#ifdef Honor_FLT_ROUNDS
+	if (bc.rounding >= 2) {
+		if (sign)
+			bc.rounding = bc.rounding == 2 ? 0 : 2;
+		else
+			if (bc.rounding != 2)
+				bc.rounding = 0;
+		}
+#endif
+#endif /*IEEE_Arith*/
+
+	/* Get starting approximation = rv * 10**e1 */
+
+	if (e1 > 0) {
+		if ((i = e1 & 15))
+			dval(&rv) *= tens[i];
+		if (e1 &= ~15) {
+			if (e1 > DBL_MAX_10_EXP) {
+ ovfl:
+				/* Can't trust HUGE_VAL */
+#ifdef IEEE_Arith
+#ifdef Honor_FLT_ROUNDS
+				switch(bc.rounding) {
+				  case 0: /* toward 0 */
+				  case 3: /* toward -infinity */
+					word0(&rv) = Big0;
+					word1(&rv) = Big1;
+					break;
+				  default:
+					word0(&rv) = Exp_mask;
+					word1(&rv) = 0;
+				  }
+#else /*Honor_FLT_ROUNDS*/
+				word0(&rv) = Exp_mask;
+				word1(&rv) = 0;
+#endif /*Honor_FLT_ROUNDS*/
+#ifdef SET_INEXACT
+				/* set overflow bit */
+				dval(&rv0) = 1e300;
+				dval(&rv0) *= dval(&rv0);
+#endif
+#else /*IEEE_Arith*/
+				word0(&rv) = Big0;
+				word1(&rv) = Big1;
+#endif /*IEEE_Arith*/
+ range_err:
+				if (bd0) {
+					Bfree(bb);
+					Bfree(bd);
+					Bfree(bs);
+					Bfree(bd0);
+					Bfree(delta);
+					}
+#ifndef NO_ERRNO
+				errno = ERANGE;
+#endif
+				goto ret;
+				}
+			e1 >>= 4;
+			for(j = 0; e1 > 1; j++, e1 >>= 1)
+				if (e1 & 1)
+					dval(&rv) *= bigtens[j];
+		/* The last multiplication could overflow. */
+			word0(&rv) -= P*Exp_msk1;
+			dval(&rv) *= bigtens[j];
+			if ((z = word0(&rv) & Exp_mask)
+			 > Exp_msk1*(DBL_MAX_EXP+Bias-P))
+				goto ovfl;
+			if (z > Exp_msk1*(DBL_MAX_EXP+Bias-1-P)) {
+				/* set to largest number */
+				/* (Can't trust DBL_MAX) */
+				word0(&rv) = Big0;
+				word1(&rv) = Big1;
+				}
+			else
+				word0(&rv) += P*Exp_msk1;
+			}
+		}
+	else if (e1 < 0) {
+		e1 = -e1;
+		if ((i = e1 & 15))
+			dval(&rv) /= tens[i];
+		if (e1 >>= 4) {
+			if (e1 >= 1 << n_bigtens)
+				goto undfl;
+#ifdef Avoid_Underflow
+			if (e1 & Scale_Bit)
+				bc.scale = 2*P;
+			for(j = 0; e1 > 0; j++, e1 >>= 1)
+				if (e1 & 1)
+					dval(&rv) *= tinytens[j];
+			if (bc.scale && (j = 2*P + 1 - ((word0(&rv) & Exp_mask)
+						>> Exp_shift)) > 0) {
+				/* scaled rv is denormal; clear j low bits */
+				if (j >= 32) {
+					if (j > 54)
+						goto undfl;
+					word1(&rv) = 0;
+					if (j >= 53)
+					 word0(&rv) = (P+2)*Exp_msk1;
+					else
+					 word0(&rv) &= 0xffffffff << (j-32);
+					}
+				else
+					word1(&rv) &= 0xffffffff << j;
+				}
+#else
+			for(j = 0; e1 > 1; j++, e1 >>= 1)
+				if (e1 & 1)
+					dval(&rv) *= tinytens[j];
+			/* The last multiplication could underflow. */
+			dval(&rv0) = dval(&rv);
+			dval(&rv) *= tinytens[j];
+			if (!dval(&rv)) {
+				dval(&rv) = 2.*dval(&rv0);
+				dval(&rv) *= tinytens[j];
+#endif
+				if (!dval(&rv)) {
+ undfl:
+					dval(&rv) = 0.;
+					goto range_err;
+					}
+#ifndef Avoid_Underflow
+				word0(&rv) = Tiny0;
+				word1(&rv) = Tiny1;
+				/* The refinement below will clean
+				 * this approximation up.
+				 */
+				}
+#endif
+			}
+		}
+
+	/* Now the hard part -- adjusting rv to the correct value.*/
+
+	/* Put digits into bd: true value = bd * 10^e */
+
+	bc.nd = nd - nz1;
+#ifndef NO_STRTOD_BIGCOMP
+	bc.nd0 = nd0;	/* Only needed if nd > strtod_diglim, but done here */
+			/* to silence an erroneous warning about bc.nd0 */
+			/* possibly not being initialized. */
+	if (nd > strtod_diglim) {
+		/* ASSERT(strtod_diglim >= 18); 18 == one more than the */
+		/* minimum number of decimal digits to distinguish double values */
+		/* in IEEE arithmetic. */
+		i = j = 18;
+		if (i > nd0)
+			j += bc.dplen;
+		for(;;) {
+			if (--j < bc.dp1 && j >= bc.dp0)
+				j = bc.dp0 - 1;
+			if (s0[j] != '0')
+				break;
+			--i;
+			}
+		e += nd - i;
+		nd = i;
+		if (nd0 > nd)
+			nd0 = nd;
+		if (nd < 9) { /* must recompute y */
+			y = 0;
+			for(i = 0; i < nd0; ++i)
+				y = 10*y + s0[i] - '0';
+			for(j = bc.dp1; i < nd; ++i)
+				y = 10*y + s0[j++] - '0';
+			}
+		}
+#endif
+	bd0 = s2b(s0, nd0, nd, y, bc.dplen);
+
+	for(;;) {
+		bd = Balloc(bd0->k);
+		Bcopy(bd, bd0);
+		bb = d2b(&rv, &bbe, &bbbits);	/* rv = bb * 2^bbe */
+		bs = i2b(1);
+
+		if (e >= 0) {
+			bb2 = bb5 = 0;
+			bd2 = bd5 = e;
+			}
+		else {
+			bb2 = bb5 = -e;
+			bd2 = bd5 = 0;
+			}
+		if (bbe >= 0)
+			bb2 += bbe;
+		else
+			bd2 -= bbe;
+		bs2 = bb2;
+#ifdef Honor_FLT_ROUNDS
+		if (bc.rounding != 1)
+			bs2++;
+#endif
+#ifdef Avoid_Underflow
+		Lsb = LSB;
+		Lsb1 = 0;
+		j = bbe - bc.scale;
+		i = j + bbbits - 1;	/* logb(rv) */
+		j = P + 1 - bbbits;
+		if (i < Emin) {	/* denormal */
+			i = Emin - i;
+			j -= i;
+			if (i < 32)
+				Lsb <<= i;
+			else if (i < 52)
+				Lsb1 = Lsb << (i-32);
+			else
+				Lsb1 = Exp_mask;
+			}
+#else /*Avoid_Underflow*/
+#ifdef Sudden_Underflow
+#ifdef IBM
+		j = 1 + 4*P - 3 - bbbits + ((bbe + bbbits - 1) & 3);
+#else
+		j = P + 1 - bbbits;
+#endif
+#else /*Sudden_Underflow*/
+		j = bbe;
+		i = j + bbbits - 1;	/* logb(rv) */
+		if (i < Emin)	/* denormal */
+			j += P - Emin;
+		else
+			j = P + 1 - bbbits;
+#endif /*Sudden_Underflow*/
+#endif /*Avoid_Underflow*/
+		bb2 += j;
+		bd2 += j;
+#ifdef Avoid_Underflow
+		bd2 += bc.scale;
+#endif
+		i = bb2 < bd2 ? bb2 : bd2;
+		if (i > bs2)
+			i = bs2;
+		if (i > 0) {
+			bb2 -= i;
+			bd2 -= i;
+			bs2 -= i;
+			}
+		if (bb5 > 0) {
+			bs = pow5mult(bs, bb5);
+			bb1 = mult(bs, bb);
+			Bfree(bb);
+			bb = bb1;
+			}
+		if (bb2 > 0)
+			bb = lshift(bb, bb2);
+		if (bd5 > 0)
+			bd = pow5mult(bd, bd5);
+		if (bd2 > 0)
+			bd = lshift(bd, bd2);
+		if (bs2 > 0)
+			bs = lshift(bs, bs2);
+		delta = diff(bb, bd);
+		bc.dsign = delta->sign;
+		delta->sign = 0;
+		i = cmp(delta, bs);
+#ifndef NO_STRTOD_BIGCOMP /*{*/
+		if (bc.nd > nd && i <= 0) {
+			if (bc.dsign) {
+				/* Must use bigcomp(). */
+				req_bigcomp = 1;
+				break;
+				}
+#ifdef Honor_FLT_ROUNDS
+			if (bc.rounding != 1) {
+				if (i < 0) {
+					req_bigcomp = 1;
+					break;
+					}
+				}
+			else
+#endif
+				i = -1;	/* Discarded digits make delta smaller. */
+			}
+#endif /*}*/
+#ifdef Honor_FLT_ROUNDS /*{*/
+		if (bc.rounding != 1) {
+			if (i < 0) {
+				/* Error is less than an ulp */
+				if (!delta->x[0] && delta->wds <= 1) {
+					/* exact */
+#ifdef SET_INEXACT
+					bc.inexact = 0;
+#endif
+					break;
+					}
+				if (bc.rounding) {
+					if (bc.dsign) {
+						adj.d = 1.;
+						goto apply_adj;
+						}
+					}
+				else if (!bc.dsign) {
+					adj.d = -1.;
+					if (!word1(&rv)
+					 && !(word0(&rv) & Frac_mask)) {
+						y = word0(&rv) & Exp_mask;
+#ifdef Avoid_Underflow
+						if (!bc.scale || y > 2*P*Exp_msk1)
+#else
+						if (y)
+#endif
+						  {
+						  delta = lshift(delta,Log2P);
+						  if (cmp(delta, bs) <= 0)
+							adj.d = -0.5;
+						  }
+						}
+ apply_adj:
+#ifdef Avoid_Underflow /*{*/
+					if (bc.scale && (y = word0(&rv) & Exp_mask)
+						<= 2*P*Exp_msk1)
+					  word0(&adj) += (2*P+1)*Exp_msk1 - y;
+#else
+#ifdef Sudden_Underflow
+					if ((word0(&rv) & Exp_mask) <=
+							P*Exp_msk1) {
+						word0(&rv) += P*Exp_msk1;
+						dval(&rv) += adj.d*ulp(dval(&rv));
+						word0(&rv) -= P*Exp_msk1;
+						}
+					else
+#endif /*Sudden_Underflow*/
+#endif /*Avoid_Underflow}*/
+					dval(&rv) += adj.d*ulp(&rv);
+					}
+				break;
+				}
+			adj.d = ratio(delta, bs);
+			if (adj.d < 1.)
+				adj.d = 1.;
+			if (adj.d <= 0x7ffffffe) {
+				/* adj = rounding ? ceil(adj) : floor(adj); */
+				y = adj.d;
+				if (y != adj.d) {
+					if (!((bc.rounding>>1) ^ bc.dsign))
+						y++;
+					adj.d = y;
+					}
+				}
+#ifdef Avoid_Underflow /*{*/
+			if (bc.scale && (y = word0(&rv) & Exp_mask) <= 2*P*Exp_msk1)
+				word0(&adj) += (2*P+1)*Exp_msk1 - y;
+#else
+#ifdef Sudden_Underflow
+			if ((word0(&rv) & Exp_mask) <= P*Exp_msk1) {
+				word0(&rv) += P*Exp_msk1;
+				adj.d *= ulp(dval(&rv));
+				if (bc.dsign)
+					dval(&rv) += adj.d;
+				else
+					dval(&rv) -= adj.d;
+				word0(&rv) -= P*Exp_msk1;
+				goto cont;
+				}
+#endif /*Sudden_Underflow*/
+#endif /*Avoid_Underflow}*/
+			adj.d *= ulp(&rv);
+			if (bc.dsign) {
+				if (word0(&rv) == Big0 && word1(&rv) == Big1)
+					goto ovfl;
+				dval(&rv) += adj.d;
+				}
+			else
+				dval(&rv) -= adj.d;
+			goto cont;
+			}
+#endif /*}Honor_FLT_ROUNDS*/
+
+		if (i < 0) {
+			/* Error is less than half an ulp -- check for
+			 * special case of mantissa a power of two.
+			 */
+			if (bc.dsign || word1(&rv) || word0(&rv) & Bndry_mask
+#ifdef IEEE_Arith /*{*/
+#ifdef Avoid_Underflow
+			 || (word0(&rv) & Exp_mask) <= (2*P+1)*Exp_msk1
+#else
+			 || (word0(&rv) & Exp_mask) <= Exp_msk1
+#endif
+#endif /*}*/
+				) {
+#ifdef SET_INEXACT
+				if (!delta->x[0] && delta->wds <= 1)
+					bc.inexact = 0;
+#endif
+				break;
+				}
+			if (!delta->x[0] && delta->wds <= 1) {
+				/* exact result */
+#ifdef SET_INEXACT
+				bc.inexact = 0;
+#endif
+				break;
+				}
+			delta = lshift(delta,Log2P);
+			if (cmp(delta, bs) > 0)
+				goto drop_down;
+			break;
+			}
+		if (i == 0) {
+			/* exactly half-way between */
+			if (bc.dsign) {
+				if ((word0(&rv) & Bndry_mask1) == Bndry_mask1
+				 &&  word1(&rv) == (
+#ifdef Avoid_Underflow
+			(bc.scale && (y = word0(&rv) & Exp_mask) <= 2*P*Exp_msk1)
+		? (0xffffffff & (0xffffffff << (2*P+1-(y>>Exp_shift)))) :
+#endif
+						   0xffffffff)) {
+					/*boundary case -- increment exponent*/
+					if (word0(&rv) == Big0 && word1(&rv) == Big1)
+						goto ovfl;
+					word0(&rv) = (word0(&rv) & Exp_mask)
+						+ Exp_msk1
+#ifdef IBM
+						| Exp_msk1 >> 4
+#endif
+						;
+					word1(&rv) = 0;
+#ifdef Avoid_Underflow
+					bc.dsign = 0;
+#endif
+					break;
+					}
+				}
+			else if (!(word0(&rv) & Bndry_mask) && !word1(&rv)) {
+ drop_down:
+				/* boundary case -- decrement exponent */
+#ifdef Sudden_Underflow /*{{*/
+				L = word0(&rv) & Exp_mask;
+#ifdef IBM
+				if (L <  Exp_msk1)
+#else
+#ifdef Avoid_Underflow
+				if (L <= (bc.scale ? (2*P+1)*Exp_msk1 : Exp_msk1))
+#else
+				if (L <= Exp_msk1)
+#endif /*Avoid_Underflow*/
+#endif /*IBM*/
+					{
+					if (bc.nd >nd) {
+						bc.uflchk = 1;
+						break;
+						}
+					goto undfl;
+					}
+				L -= Exp_msk1;
+#else /*Sudden_Underflow}{*/
+#ifdef Avoid_Underflow
+				if (bc.scale) {
+					L = word0(&rv) & Exp_mask;
+					if (L <= (2*P+1)*Exp_msk1) {
+						if (L > (P+2)*Exp_msk1)
+							/* round even ==> */
+							/* accept rv */
+							break;
+						/* rv = smallest denormal */
+						if (bc.nd >nd) {
+							bc.uflchk = 1;
+							break;
+							}
+						goto undfl;
+						}
+					}
+#endif /*Avoid_Underflow*/
+				L = (word0(&rv) & Exp_mask) - Exp_msk1;
+#endif /*Sudden_Underflow}}*/
+				word0(&rv) = L | Bndry_mask1;
+				word1(&rv) = 0xffffffff;
+#ifdef IBM
+				goto cont;
+#else
+#ifndef NO_STRTOD_BIGCOMP
+				if (bc.nd > nd)
+					goto cont;
+#endif
+				break;
+#endif
+				}
+#ifndef ROUND_BIASED
+#ifdef Avoid_Underflow
+			if (Lsb1) {
+				if (!(word0(&rv) & Lsb1))
+					break;
+				}
+			else if (!(word1(&rv) & Lsb))
+				break;
+#else
+			if (!(word1(&rv) & LSB))
+				break;
+#endif
+#endif
+			if (bc.dsign)
+#ifdef Avoid_Underflow
+				dval(&rv) += sulp(&rv, &bc);
+#else
+				dval(&rv) += ulp(&rv);
+#endif
+#ifndef ROUND_BIASED
+			else {
+#ifdef Avoid_Underflow
+				dval(&rv) -= sulp(&rv, &bc);
+#else
+				dval(&rv) -= ulp(&rv);
+#endif
+#ifndef Sudden_Underflow
+				if (!dval(&rv)) {
+					if (bc.nd >nd) {
+						bc.uflchk = 1;
+						break;
+						}
+					goto undfl;
+					}
+#endif
+				}
+#ifdef Avoid_Underflow
+			bc.dsign = 1 - bc.dsign;
+#endif
+#endif
+			break;
+			}
+		if ((aadj = ratio(delta, bs)) <= 2.) {
+			if (bc.dsign)
+				aadj = aadj1 = 1.;
+			else if (word1(&rv) || word0(&rv) & Bndry_mask) {
+#ifndef Sudden_Underflow
+				if (word1(&rv) == Tiny1 && !word0(&rv)) {
+					if (bc.nd >nd) {
+						bc.uflchk = 1;
+						break;
+						}
+					goto undfl;
+					}
+#endif
+				aadj = 1.;
+				aadj1 = -1.;
+				}
+			else {
+				/* special case -- power of FLT_RADIX to be */
+				/* rounded down... */
+
+				if (aadj < 2./FLT_RADIX)
+					aadj = 1./FLT_RADIX;
+				else
+					aadj *= 0.5;
+				aadj1 = -aadj;
+				}
+			}
+		else {
+			aadj *= 0.5;
+			aadj1 = bc.dsign ? aadj : -aadj;
+#ifdef Check_FLT_ROUNDS
+			switch(bc.rounding) {
+				case 2: /* towards +infinity */
+					aadj1 -= 0.5;
+					break;
+				case 0: /* towards 0 */
+				case 3: /* towards -infinity */
+					aadj1 += 0.5;
+				}
+#else
+			if (Flt_Rounds == 0)
+				aadj1 += 0.5;
+#endif /*Check_FLT_ROUNDS*/
+			}
+		y = word0(&rv) & Exp_mask;
+
+		/* Check for overflow */
+
+		if (y == Exp_msk1*(DBL_MAX_EXP+Bias-1)) {
+			dval(&rv0) = dval(&rv);
+			word0(&rv) -= P*Exp_msk1;
+			adj.d = aadj1 * ulp(&rv);
+			dval(&rv) += adj.d;
+			if ((word0(&rv) & Exp_mask) >=
+					Exp_msk1*(DBL_MAX_EXP+Bias-P)) {
+				if (word0(&rv0) == Big0 && word1(&rv0) == Big1)
+					goto ovfl;
+				word0(&rv) = Big0;
+				word1(&rv) = Big1;
+				goto cont;
+				}
+			else
+				word0(&rv) += P*Exp_msk1;
+			}
+		else {
+#ifdef Avoid_Underflow
+			if (bc.scale && y <= 2*P*Exp_msk1) {
+				if (aadj <= 0x7fffffff) {
+					if ((z = aadj) <= 0)
+						z = 1;
+					aadj = z;
+					aadj1 = bc.dsign ? aadj : -aadj;
+					}
+				dval(&aadj2) = aadj1;
+				word0(&aadj2) += (2*P+1)*Exp_msk1 - y;
+				aadj1 = dval(&aadj2);
+				adj.d = aadj1 * ulp(&rv);
+				dval(&rv) += adj.d;
+				if (rv.d == 0.)
+#ifdef NO_STRTOD_BIGCOMP
+					goto undfl;
+#else
+					{
+					if (bc.nd > nd)
+						bc.dsign = 1;
+					break;
+					}
+#endif
+				}
+			else {
+				adj.d = aadj1 * ulp(&rv);
+				dval(&rv) += adj.d;
+				}
+#else
+#ifdef Sudden_Underflow
+			if ((word0(&rv) & Exp_mask) <= P*Exp_msk1) {
+				dval(&rv0) = dval(&rv);
+				word0(&rv) += P*Exp_msk1;
+				adj.d = aadj1 * ulp(&rv);
+				dval(&rv) += adj.d;
+#ifdef IBM
+				if ((word0(&rv) & Exp_mask) <  P*Exp_msk1)
+#else
+				if ((word0(&rv) & Exp_mask) <= P*Exp_msk1)
+#endif
+					{
+					if (word0(&rv0) == Tiny0
+					 && word1(&rv0) == Tiny1) {
+						if (bc.nd >nd) {
+							bc.uflchk = 1;
+							break;
+							}
+						goto undfl;
+						}
+					word0(&rv) = Tiny0;
+					word1(&rv) = Tiny1;
+					goto cont;
+					}
+				else
+					word0(&rv) -= P*Exp_msk1;
+				}
+			else {
+				adj.d = aadj1 * ulp(&rv);
+				dval(&rv) += adj.d;
+				}
+#else /*Sudden_Underflow*/
+			/* Compute adj so that the IEEE rounding rules will
+			 * correctly round rv + adj in some half-way cases.
+			 * If rv * ulp(rv) is denormalized (i.e.,
+			 * y <= (P-1)*Exp_msk1), we must adjust aadj to avoid
+			 * trouble from bits lost to denormalization;
+			 * example: 1.2e-307 .
+			 */
+			if (y <= (P-1)*Exp_msk1 && aadj > 1.) {
+				aadj1 = (double)(int)(aadj + 0.5);
+				if (!bc.dsign)
+					aadj1 = -aadj1;
+				}
+			adj.d = aadj1 * ulp(&rv);
+			dval(&rv) += adj.d;
+#endif /*Sudden_Underflow*/
+#endif /*Avoid_Underflow*/
+			}
+		z = word0(&rv) & Exp_mask;
+#ifndef SET_INEXACT
+		if (bc.nd == nd) {
+#ifdef Avoid_Underflow
+		if (!bc.scale)
+#endif
+		if (y == z) {
+			/* Can we stop now? */
+			L = (Long)aadj;
+			aadj -= L;
+			/* The tolerances below are conservative. */
+			if (bc.dsign || word1(&rv) || word0(&rv) & Bndry_mask) {
+				if (aadj < .4999999 || aadj > .5000001)
+					break;
+				}
+			else if (aadj < .4999999/FLT_RADIX)
+				break;
+			}
+		}
+#endif
+ cont:
+		Bfree(bb);
+		Bfree(bd);
+		Bfree(bs);
+		Bfree(delta);
+		}
+	Bfree(bb);
+	Bfree(bd);
+	Bfree(bs);
+	Bfree(bd0);
+	Bfree(delta);
+#ifndef NO_STRTOD_BIGCOMP
+	if (req_bigcomp) {
+		bd0 = 0;
+		bc.e0 += nz1;
+		bigcomp(&rv, s0, &bc);
+		y = word0(&rv) & Exp_mask;
+		if (y == Exp_mask)
+			goto ovfl;
+		if (y == 0 && rv.d == 0.)
+			goto undfl;
+		}
+#endif
+#ifdef SET_INEXACT
+	if (bc.inexact) {
+		if (!oldinexact) {
+			word0(&rv0) = Exp_1 + (70 << Exp_shift);
+			word1(&rv0) = 0;
+			dval(&rv0) += 1.;
+			}
+		}
+	else if (!oldinexact)
+		clear_inexact();
+#endif
+#ifdef Avoid_Underflow
+	if (bc.scale) {
+		word0(&rv0) = Exp_1 - 2*P*Exp_msk1;
+		word1(&rv0) = 0;
+		dval(&rv) *= dval(&rv0);
+#ifndef NO_ERRNO
+		/* try to avoid the bug of testing an 8087 register value */
+#ifdef IEEE_Arith
+		if (!(word0(&rv) & Exp_mask))
+#else
+		if (word0(&rv) == 0 && word1(&rv) == 0)
+#endif
+			errno = ERANGE;
+#endif
+		}
+#endif /* Avoid_Underflow */
+#ifdef SET_INEXACT
+	if (bc.inexact && !(word0(&rv) & Exp_mask)) {
+		/* set underflow bit */
+		dval(&rv0) = 1e-300;
+		dval(&rv0) *= dval(&rv0);
+		}
+#endif
+ ret:
+	if (se)
+		*se = (char *)s;
+	return sign ? -dval(&rv) : dval(&rv);
+	}
+
+#ifndef MULTIPLE_THREADS
+ static char *dtoa_result;
+#endif
+
+ static char *
+#ifdef KR_headers
+rv_alloc(i) int i;
+#else
+rv_alloc(int i)
+#endif
+{
+	int j, k, *r;
+
+	j = sizeof(ULong);
+	for(k = 0;
+		sizeof(Bigint) - sizeof(ULong) - sizeof(int) + j <= i;
+		j <<= 1)
+			k++;
+	r = (int*)Balloc(k);
+	*r = k;
+	return
+#ifndef MULTIPLE_THREADS
+	dtoa_result =
+#endif
+		(char *)(r+1);
+	}
+
+ static char *
+#ifdef KR_headers
+nrv_alloc(s, rve, n) char *s, **rve; int n;
+#else
+nrv_alloc(const char *s, char **rve, int n)
+#endif
+{
+	char *rv, *t;
+
+	t = rv = rv_alloc(n);
+	while((*t = *s++)) t++;
+	if (rve)
+		*rve = t;
+	return rv;
+	}
+
+/* freedtoa(s) must be used to free values s returned by dtoa
+ * when MULTIPLE_THREADS is #defined.  It should be used in all cases,
+ * but for consistency with earlier versions of dtoa, it is optional
+ * when MULTIPLE_THREADS is not defined.
+ */
+
+ void
+#ifdef KR_headers
+freedtoa(s) char *s;
+#else
+freedtoa(char *s)
+#endif
+{
+	Bigint *b = (Bigint *)((int *)s - 1);
+	b->maxwds = 1 << (b->k = *(int*)b);
+	Bfree(b);
+#ifndef MULTIPLE_THREADS
+	if (s == dtoa_result)
+		dtoa_result = 0;
+#endif
+	}
+
+/* dtoa for IEEE arithmetic (dmg): convert double to ASCII string.
+ *
+ * Inspired by "How to Print Floating-Point Numbers Accurately" by
+ * Guy L. Steele, Jr. and Jon L. White [Proc. ACM SIGPLAN '90, pp. 112-126].
+ *
+ * Modifications:
+ *	1. Rather than iterating, we use a simple numeric overestimate
+ *	   to determine k = floor(log10(d)).  We scale relevant
+ *	   quantities using O(log2(k)) rather than O(k) multiplications.
+ *	2. For some modes > 2 (corresponding to ecvt and fcvt), we don't
+ *	   try to generate digits strictly left to right.  Instead, we
+ *	   compute with fewer bits and propagate the carry if necessary
+ *	   when rounding the final digit up.  This is often faster.
+ *	3. Under the assumption that input will be rounded nearest,
+ *	   mode 0 renders 1e23 as 1e23 rather than 9.999999999999999e22.
+ *	   That is, we allow equality in stopping tests when the
+ *	   round-nearest rule will give the same floating-point value
+ *	   as would satisfaction of the stopping test with strict
+ *	   inequality.
+ *	4. We remove common factors of powers of 2 from relevant
+ *	   quantities.
+ *	5. When converting floating-point integers less than 1e16,
+ *	   we use floating-point arithmetic rather than resorting
+ *	   to multiple-precision integers.
+ *	6. When asked to produce fewer than 15 digits, we first try
+ *	   to get by with floating-point arithmetic; we resort to
+ *	   multiple-precision integer arithmetic only if we cannot
+ *	   guarantee that the floating-point calculation has given
+ *	   the correctly rounded result.  For k requested digits and
+ *	   "uniformly" distributed input, the probability is
+ *	   something like 10^(k-15) that we must resort to the Long
+ *	   calculation.
+ */
+
+ char *
+dtoa
+#ifdef KR_headers
+	(dd, mode, ndigits, decpt, sign, rve)
+	double dd; int mode, ndigits, *decpt, *sign; char **rve;
+#else
+	(double dd, int mode, int ndigits, int *decpt, int *sign, char **rve)
+#endif
+{
+ /*	Arguments ndigits, decpt, sign are similar to those
+	of ecvt and fcvt; trailing zeros are suppressed from
+	the returned string.  If not null, *rve is set to point
+	to the end of the return value.  If d is +-Infinity or NaN,
+	then *decpt is set to 9999.
+
+	mode:
+		0 ==> shortest string that yields d when read in
+			and rounded to nearest.
+		1 ==> like 0, but with Steele & White stopping rule;
+			e.g. with IEEE P754 arithmetic , mode 0 gives
+			1e23 whereas mode 1 gives 9.999999999999999e22.
+		2 ==> max(1,ndigits) significant digits.  This gives a
+			return value similar to that of ecvt, except
+			that trailing zeros are suppressed.
+		3 ==> through ndigits past the decimal point.  This
+			gives a return value similar to that from fcvt,
+			except that trailing zeros are suppressed, and
+			ndigits can be negative.
+		4,5 ==> similar to 2 and 3, respectively, but (in
+			round-nearest mode) with the tests of mode 0 to
+			possibly return a shorter string that rounds to d.
+			With IEEE arithmetic and compilation with
+			-DHonor_FLT_ROUNDS, modes 4 and 5 behave the same
+			as modes 2 and 3 when FLT_ROUNDS != 1.
+		6-9 ==> Debugging modes similar to mode - 4:  don't try
+			fast floating-point estimate (if applicable).
+
+		Values of mode other than 0-9 are treated as mode 0.
+
+		Sufficient space is allocated to the return value
+		to hold the suppressed trailing zeros.
+	*/
+
+	int bbits, b2, b5, be, dig, i, ieps, ilim, ilim0, ilim1,
+		j, j1, k, k0, k_check, leftright, m2, m5, s2, s5,
+		spec_case, try_quick;
+	Long L;
+#ifndef Sudden_Underflow
+	int denorm;
+	ULong x;
+#endif
+	Bigint *b, *b1, *delta, *mlo, *mhi, *S;
+	U d2, eps, u;
+	double ds;
+	char *s, *s0;
+#ifndef No_leftright
+#ifdef IEEE_Arith
+	U eps1;
+#endif
+#endif
+#ifdef SET_INEXACT
+	int inexact, oldinexact;
+#endif
+#ifdef Honor_FLT_ROUNDS /*{*/
+	int Rounding;
+#ifdef Trust_FLT_ROUNDS /*{{ only define this if FLT_ROUNDS really works! */
+	Rounding = Flt_Rounds;
+#else /*}{*/
+	Rounding = 1;
+	switch(fegetround()) {
+	  case FE_TOWARDZERO:	Rounding = 0; break;
+	  case FE_UPWARD:	Rounding = 2; break;
+	  case FE_DOWNWARD:	Rounding = 3;
+	  }
+#endif /*}}*/
+#endif /*}*/
+
+#ifndef MULTIPLE_THREADS
+	if (dtoa_result) {
+		freedtoa(dtoa_result);
+		dtoa_result = 0;
+		}
+#endif
+
+	u.d = dd;
+	if (word0(&u) & Sign_bit) {
+		/* set sign for everything, including 0's and NaNs */
+		*sign = 1;
+		word0(&u) &= ~Sign_bit;	/* clear sign bit */
+		}
+	else
+		*sign = 0;
+
+#if defined(IEEE_Arith) + defined(VAX)
+#ifdef IEEE_Arith
+	if ((word0(&u) & Exp_mask) == Exp_mask)
+#else
+	if (word0(&u)  == 0x8000)
+#endif
+		{
+		/* Infinity or NaN */
+		*decpt = 9999;
+#ifdef IEEE_Arith
+		if (!word1(&u) && !(word0(&u) & 0xfffff))
+			return nrv_alloc("Infinity", rve, 8);
+#endif
+		return nrv_alloc("NaN", rve, 3);
+		}
+#endif
+#ifdef IBM
+	dval(&u) += 0; /* normalize */
+#endif
+	if (!dval(&u)) {
+		*decpt = 1;
+		return nrv_alloc("0", rve, 1);
+		}
+
+#ifdef SET_INEXACT
+	try_quick = oldinexact = get_inexact();
+	inexact = 1;
+#endif
+#ifdef Honor_FLT_ROUNDS
+	if (Rounding >= 2) {
+		if (*sign)
+			Rounding = Rounding == 2 ? 0 : 2;
+		else
+			if (Rounding != 2)
+				Rounding = 0;
+		}
+#endif
+
+	b = d2b(&u, &be, &bbits);
+#ifdef Sudden_Underflow
+	i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1));
+#else
+	if ((i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1)))) {
+#endif
+		dval(&d2) = dval(&u);
+		word0(&d2) &= Frac_mask1;
+		word0(&d2) |= Exp_11;
+#ifdef IBM
+		if (j = 11 - hi0bits(word0(&d2) & Frac_mask))
+			dval(&d2) /= 1 << j;
+#endif
+
+		/* log(x)	~=~ log(1.5) + (x-1.5)/1.5
+		 * log10(x)	 =  log(x) / log(10)
+		 *		~=~ log(1.5)/log(10) + (x-1.5)/(1.5*log(10))
+		 * log10(d) = (i-Bias)*log(2)/log(10) + log10(d2)
+		 *
+		 * This suggests computing an approximation k to log10(d) by
+		 *
+		 * k = (i - Bias)*0.301029995663981
+		 *	+ ( (d2-1.5)*0.289529654602168 + 0.176091259055681 );
+		 *
+		 * We want k to be too large rather than too small.
+		 * The error in the first-order Taylor series approximation
+		 * is in our favor, so we just round up the constant enough
+		 * to compensate for any error in the multiplication of
+		 * (i - Bias) by 0.301029995663981; since |i - Bias| <= 1077,
+		 * and 1077 * 0.30103 * 2^-52 ~=~ 7.2e-14,
+		 * adding 1e-13 to the constant term more than suffices.
+		 * Hence we adjust the constant term to 0.1760912590558.
+		 * (We could get a more accurate k by invoking log10,
+		 *  but this is probably not worthwhile.)
+		 */
+
+		i -= Bias;
+#ifdef IBM
+		i <<= 2;
+		i += j;
+#endif
+#ifndef Sudden_Underflow
+		denorm = 0;
+		}
+	else {
+		/* d is denormalized */
+
+		i = bbits + be + (Bias + (P-1) - 1);
+		x = i > 32  ? word0(&u) << (64 - i) | word1(&u) >> (i - 32)
+			    : word1(&u) << (32 - i);
+		dval(&d2) = x;
+		word0(&d2) -= 31*Exp_msk1; /* adjust exponent */
+		i -= (Bias + (P-1) - 1) + 1;
+		denorm = 1;
+		}
+#endif
+	ds = (dval(&d2)-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981;
+	k = (int)ds;
+	if (ds < 0. && ds != k)
+		k--;	/* want k = floor(ds) */
+	k_check = 1;
+	if (k >= 0 && k <= Ten_pmax) {
+		if (dval(&u) < tens[k])
+			k--;
+		k_check = 0;
+		}
+	j = bbits - i - 1;
+	if (j >= 0) {
+		b2 = 0;
+		s2 = j;
+		}
+	else {
+		b2 = -j;
+		s2 = 0;
+		}
+	if (k >= 0) {
+		b5 = 0;
+		s5 = k;
+		s2 += k;
+		}
+	else {
+		b2 -= k;
+		b5 = -k;
+		s5 = 0;
+		}
+	if (mode < 0 || mode > 9)
+		mode = 0;
+
+#ifndef SET_INEXACT
+#ifdef Check_FLT_ROUNDS
+	try_quick = Rounding == 1;
+#else
+	try_quick = 1;
+#endif
+#endif /*SET_INEXACT*/
+
+	if (mode > 5) {
+		mode -= 4;
+		try_quick = 0;
+		}
+	leftright = 1;
+	ilim = ilim1 = -1;	/* Values for cases 0 and 1; done here to */
+				/* silence erroneous "gcc -Wall" warning. */
+	switch(mode) {
+		case 0:
+		case 1:
+			i = 18;
+			ndigits = 0;
+			break;
+		case 2:
+			leftright = 0;
+			/* no break */
+		case 4:
+			if (ndigits <= 0)
+				ndigits = 1;
+			ilim = ilim1 = i = ndigits;
+			break;
+		case 3:
+			leftright = 0;
+			/* no break */
+		case 5:
+			i = ndigits + k + 1;
+			ilim = i;
+			ilim1 = i - 1;
+			if (i <= 0)
+				i = 1;
+		}
+	s = s0 = rv_alloc(i);
+
+#ifdef Honor_FLT_ROUNDS
+	if (mode > 1 && Rounding != 1)
+		leftright = 0;
+#endif
+
+	if (ilim >= 0 && ilim <= Quick_max && try_quick) {
+
+		/* Try to get by with floating-point arithmetic. */
+
+		i = 0;
+		dval(&d2) = dval(&u);
+		k0 = k;
+		ilim0 = ilim;
+		ieps = 2; /* conservative */
+		if (k > 0) {
+			ds = tens[k&0xf];
+			j = k >> 4;
+			if (j & Bletch) {
+				/* prevent overflows */
+				j &= Bletch - 1;
+				dval(&u) /= bigtens[n_bigtens-1];
+				ieps++;
+				}
+			for(; j; j >>= 1, i++)
+				if (j & 1) {
+					ieps++;
+					ds *= bigtens[i];
+					}
+			dval(&u) /= ds;
+			}
+		else if ((j1 = -k)) {
+			dval(&u) *= tens[j1 & 0xf];
+			for(j = j1 >> 4; j; j >>= 1, i++)
+				if (j & 1) {
+					ieps++;
+					dval(&u) *= bigtens[i];
+					}
+			}
+		if (k_check && dval(&u) < 1. && ilim > 0) {
+			if (ilim1 <= 0)
+				goto fast_failed;
+			ilim = ilim1;
+			k--;
+			dval(&u) *= 10.;
+			ieps++;
+			}
+		dval(&eps) = ieps*dval(&u) + 7.;
+		word0(&eps) -= (P-1)*Exp_msk1;
+		if (ilim == 0) {
+			S = mhi = 0;
+			dval(&u) -= 5.;
+			if (dval(&u) > dval(&eps))
+				goto one_digit;
+			if (dval(&u) < -dval(&eps))
+				goto no_digits;
+			goto fast_failed;
+			}
+#ifndef No_leftright
+		if (leftright) {
+			/* Use Steele & White method of only
+			 * generating digits needed.
+			 */
+			dval(&eps) = 0.5/tens[ilim-1] - dval(&eps);
+#ifdef IEEE_Arith
+			if (k0 < 0 && j1 >= 307) {
+				eps1.d = 1.01e256; /* 1.01 allows roundoff in the next few lines */
+				word0(&eps1) -= Exp_msk1 * (Bias+P-1);
+				dval(&eps1) *= tens[j1 & 0xf];
+				for(i = 0, j = (j1-256) >> 4; j; j >>= 1, i++)
+					if (j & 1)
+						dval(&eps1) *= bigtens[i];
+				if (eps.d < eps1.d)
+					eps.d = eps1.d;
+				}
+#endif
+			for(i = 0;;) {
+				L = dval(&u);
+				dval(&u) -= L;
+				*s++ = '0' + (int)L;
+				if (1. - dval(&u) < dval(&eps))
+					goto bump_up;
+				if (dval(&u) < dval(&eps))
+					goto ret1;
+				if (++i >= ilim)
+					break;
+				dval(&eps) *= 10.;
+				dval(&u) *= 10.;
+				}
+			}
+		else {
+#endif
+			/* Generate ilim digits, then fix them up. */
+			dval(&eps) *= tens[ilim-1];
+			for(i = 1;; i++, dval(&u) *= 10.) {
+				L = (Long)(dval(&u));
+				if (!(dval(&u) -= L))
+					ilim = i;
+				*s++ = '0' + (int)L;
+				if (i == ilim) {
+					if (dval(&u) > 0.5 + dval(&eps))
+						goto bump_up;
+					else if (dval(&u) < 0.5 - dval(&eps)) {
+						while(*--s == '0');
+						s++;
+						goto ret1;
+						}
+					break;
+					}
+				}
+#ifndef No_leftright
+			}
+#endif
+ fast_failed:
+		s = s0;
+		dval(&u) = dval(&d2);
+		k = k0;
+		ilim = ilim0;
+		}
+
+	/* Do we have a "small" integer? */
+
+	if (be >= 0 && k <= Int_max) {
+		/* Yes. */
+		ds = tens[k];
+		if (ndigits < 0 && ilim <= 0) {
+			S = mhi = 0;
+			if (ilim < 0 || dval(&u) <= 5*ds)
+				goto no_digits;
+			goto one_digit;
+			}
+		for(i = 1;; i++, dval(&u) *= 10.) {
+			L = (Long)(dval(&u) / ds);
+			dval(&u) -= L*ds;
+#ifdef Check_FLT_ROUNDS
+			/* If FLT_ROUNDS == 2, L will usually be high by 1 */
+			if (dval(&u) < 0) {
+				L--;
+				dval(&u) += ds;
+				}
+#endif
+			*s++ = '0' + (int)L;
+			if (!dval(&u)) {
+#ifdef SET_INEXACT
+				inexact = 0;
+#endif
+				break;
+				}
+			if (i == ilim) {
+#ifdef Honor_FLT_ROUNDS
+				if (mode > 1)
+				switch(Rounding) {
+				  case 0: goto ret1;
+				  case 2: goto bump_up;
+				  }
+#endif
+				dval(&u) += dval(&u);
+#ifdef ROUND_BIASED
+				if (dval(&u) >= ds)
+#else
+				if (dval(&u) > ds || (dval(&u) == ds && L & 1))
+#endif
+					{
+ bump_up:
+					while(*--s == '9')
+						if (s == s0) {
+							k++;
+							*s = '0';
+							break;
+							}
+					++*s++;
+					}
+				break;
+				}
+			}
+		goto ret1;
+		}
+
+	m2 = b2;
+	m5 = b5;
+	mhi = mlo = 0;
+	if (leftright) {
+		i =
+#ifndef Sudden_Underflow
+			denorm ? be + (Bias + (P-1) - 1 + 1) :
+#endif
+#ifdef IBM
+			1 + 4*P - 3 - bbits + ((bbits + be - 1) & 3);
+#else
+			1 + P - bbits;
+#endif
+		b2 += i;
+		s2 += i;
+		mhi = i2b(1);
+		}
+	if (m2 > 0 && s2 > 0) {
+		i = m2 < s2 ? m2 : s2;
+		b2 -= i;
+		m2 -= i;
+		s2 -= i;
+		}
+	if (b5 > 0) {
+		if (leftright) {
+			if (m5 > 0) {
+				mhi = pow5mult(mhi, m5);
+				b1 = mult(mhi, b);
+				Bfree(b);
+				b = b1;
+				}
+			if ((j = b5 - m5))
+				b = pow5mult(b, j);
+			}
+		else
+			b = pow5mult(b, b5);
+		}
+	S = i2b(1);
+	if (s5 > 0)
+		S = pow5mult(S, s5);
+
+	/* Check for special case that d is a normalized power of 2. */
+
+	spec_case = 0;
+	if ((mode < 2 || leftright)
+#ifdef Honor_FLT_ROUNDS
+			&& Rounding == 1
+#endif
+				) {
+		if (!word1(&u) && !(word0(&u) & Bndry_mask)
+#ifndef Sudden_Underflow
+		 && word0(&u) & (Exp_mask & ~Exp_msk1)
+#endif
+				) {
+			/* The special case */
+			b2 += Log2P;
+			s2 += Log2P;
+			spec_case = 1;
+			}
+		}
+
+	/* Arrange for convenient computation of quotients:
+	 * shift left if necessary so divisor has 4 leading 0 bits.
+	 *
+	 * Perhaps we should just compute leading 28 bits of S once
+	 * and for all and pass them and a shift to quorem, so it
+	 * can do shifts and ors to compute the numerator for q.
+	 */
+	i = dshift(S, s2);
+	b2 += i;
+	m2 += i;
+	s2 += i;
+	if (b2 > 0)
+		b = lshift(b, b2);
+	if (s2 > 0)
+		S = lshift(S, s2);
+	if (k_check) {
+		if (cmp(b,S) < 0) {
+			k--;
+			b = multadd(b, 10, 0);	/* we botched the k estimate */
+			if (leftright)
+				mhi = multadd(mhi, 10, 0);
+			ilim = ilim1;
+			}
+		}
+	if (ilim <= 0 && (mode == 3 || mode == 5)) {
+		if (ilim < 0 || cmp(b,S = multadd(S,5,0)) <= 0) {
+			/* no digits, fcvt style */
+ no_digits:
+			k = -1 - ndigits;
+			goto ret;
+			}
+ one_digit:
+		*s++ = '1';
+		k++;
+		goto ret;
+		}
+	if (leftright) {
+		if (m2 > 0)
+			mhi = lshift(mhi, m2);
+
+		/* Compute mlo -- check for special case
+		 * that d is a normalized power of 2.
+		 */
+
+		mlo = mhi;
+		if (spec_case) {
+			mhi = Balloc(mhi->k);
+			Bcopy(mhi, mlo);
+			mhi = lshift(mhi, Log2P);
+			}
+
+		for(i = 1;;i++) {
+			dig = quorem(b,S) + '0';
+			/* Do we yet have the shortest decimal string
+			 * that will round to d?
+			 */
+			j = cmp(b, mlo);
+			delta = diff(S, mhi);
+			j1 = delta->sign ? 1 : cmp(b, delta);
+			Bfree(delta);
+#ifndef ROUND_BIASED
+			if (j1 == 0 && mode != 1 && !(word1(&u) & 1)
+#ifdef Honor_FLT_ROUNDS
+				&& Rounding >= 1
+#endif
+								   ) {
+				if (dig == '9')
+					goto round_9_up;
+				if (j > 0)
+					dig++;
+#ifdef SET_INEXACT
+				else if (!b->x[0] && b->wds <= 1)
+					inexact = 0;
+#endif
+				*s++ = dig;
+				goto ret;
+				}
+#endif
+			if (j < 0 || (j == 0 && mode != 1
+#ifndef ROUND_BIASED
+							&& !(word1(&u) & 1)
+#endif
+					)) {
+				if (!b->x[0] && b->wds <= 1) {
+#ifdef SET_INEXACT
+					inexact = 0;
+#endif
+					goto accept_dig;
+					}
+#ifdef Honor_FLT_ROUNDS
+				if (mode > 1)
+				 switch(Rounding) {
+				  case 0: goto accept_dig;
+				  case 2: goto keep_dig;
+				  }
+#endif /*Honor_FLT_ROUNDS*/
+				if (j1 > 0) {
+					b = lshift(b, 1);
+					j1 = cmp(b, S);
+#ifdef ROUND_BIASED
+					if (j1 >= 0 /*)*/
+#else
+					if ((j1 > 0 || (j1 == 0 && dig & 1))
+#endif
+					&& dig++ == '9')
+						goto round_9_up;
+					}
+ accept_dig:
+				*s++ = dig;
+				goto ret;
+				}
+			if (j1 > 0) {
+#ifdef Honor_FLT_ROUNDS
+				if (!Rounding)
+					goto accept_dig;
+#endif
+				if (dig == '9') { /* possible if i == 1 */
+ round_9_up:
+					*s++ = '9';
+					goto roundoff;
+					}
+				*s++ = dig + 1;
+				goto ret;
+				}
+#ifdef Honor_FLT_ROUNDS
+ keep_dig:
+#endif
+			*s++ = dig;
+			if (i == ilim)
+				break;
+			b = multadd(b, 10, 0);
+			if (mlo == mhi)
+				mlo = mhi = multadd(mhi, 10, 0);
+			else {
+				mlo = multadd(mlo, 10, 0);
+				mhi = multadd(mhi, 10, 0);
+				}
+			}
+		}
+	else
+		for(i = 1;; i++) {
+			*s++ = dig = quorem(b,S) + '0';
+			if (!b->x[0] && b->wds <= 1) {
+#ifdef SET_INEXACT
+				inexact = 0;
+#endif
+				goto ret;
+				}
+			if (i >= ilim)
+				break;
+			b = multadd(b, 10, 0);
+			}
+
+	/* Round off last digit */
+
+#ifdef Honor_FLT_ROUNDS
+	switch(Rounding) {
+	  case 0: goto trimzeros;
+	  case 2: goto roundoff;
+	  }
+#endif
+	b = lshift(b, 1);
+	j = cmp(b, S);
+#ifdef ROUND_BIASED
+	if (j >= 0)
+#else
+	if (j > 0 || (j == 0 && dig & 1))
+#endif
+		{
+ roundoff:
+		while(*--s == '9')
+			if (s == s0) {
+				k++;
+				*s++ = '1';
+				goto ret;
+				}
+		++*s++;
+		}
+	else {
+#ifdef Honor_FLT_ROUNDS
+ trimzeros:
+#endif
+		while(*--s == '0');
+		s++;
+		}
+ ret:
+	Bfree(S);
+	if (mhi) {
+		if (mlo && mlo != mhi)
+			Bfree(mlo);
+		Bfree(mhi);
+		}
+ ret1:
+#ifdef SET_INEXACT
+	if (inexact) {
+		if (!oldinexact) {
+			word0(&u) = Exp_1 + (70 << Exp_shift);
+			word1(&u) = 0;
+			dval(&u) += 1.;
+			}
+		}
+	else if (!oldinexact)
+		clear_inexact();
+#endif
+	Bfree(b);
+	*s = 0;
+	*decpt = k + 1;
+	if (rve)
+		*rve = s;
+	return s0;
+	}
+#ifdef __cplusplus
+}
+#endif

From 66fd70236310bb91cdfaeef239fef57a639658f8 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sat, 1 Sep 2012 17:56:34 +0100
Subject: [PATCH 016/284] Minor changes to dtoa.c to make it easier to work
 with.

 - Change memory allocation to thread a context structure through
   the code rather than using globals (which would require a
   -lpthread and some locking to become threadsafe).

 - Remove a few configuration options (the "private memory" space,
   and K&R style headers).

 - Prefix exported symbols with jvp_ to prevent libc conflicts.

 - Add jvp_dtoa.h

 - Include netlib's g_fmt.c into dtoa.c

 - Add a few not-strictly-necessary initialisations in order to
   compile cleanly with gcc -Wall
---
 c/{dtoa.c => jv_dtoa.c} | 793 ++++++++++++++++++----------------------
 c/jv_dtoa.h             |  20 +
 2 files changed, 373 insertions(+), 440 deletions(-)
 rename c/{dtoa.c => jv_dtoa.c} (89%)
 create mode 100644 c/jv_dtoa.h

diff --git a/c/dtoa.c b/c/jv_dtoa.c
similarity index 89%
rename from c/dtoa.c
rename to c/jv_dtoa.c
index 41ed6982..1388943b 100644
--- a/c/dtoa.c
+++ b/c/jv_dtoa.c
@@ -1,3 +1,4 @@
+
 /****************************************************************
  *
  * The author of this software is David M. Gay.
@@ -186,6 +187,15 @@
  *	used for input more than STRTOD_DIGLIM digits long (default 40).
  */
 
+#define IEEE_8087
+#define NO_ERRNO
+#define NO_HEX_FP
+#define No_Hex_NaN
+#define Long int
+
+#include "jv_dtoa.h"
+
+
 #ifndef Long
 #define Long long
 #endif
@@ -212,23 +222,11 @@ typedef unsigned Long ULong;
 #endif
 
 #ifdef MALLOC
-#ifdef KR_headers
-extern char *MALLOC();
-#else
 extern void *MALLOC(size_t);
-#endif
 #else
 #define MALLOC malloc
 #endif
 
-#ifndef Omit_Private_Memory
-#ifndef PRIVATE_MEM
-#define PRIVATE_MEM 2304
-#endif
-#define PRIVATE_mem ((PRIVATE_MEM+sizeof(double)-1)/sizeof(double))
-static double private_mem[PRIVATE_mem], *pmem_next = private_mem;
-#endif
-
 #undef IEEE_Arith
 #undef Avoid_Underflow
 #ifdef IEEE_MC68k
@@ -292,12 +290,8 @@ extern "C" {
 #endif
 
 #ifndef CONST
-#ifdef KR_headers
-#define CONST /* blank */
-#else
 #define CONST const
 #endif
-#endif
 
 #if defined(IEEE_8087) + defined(IEEE_MC68k) + defined(VAX) + defined(IBM) != 1
 Exactly one of IEEE_8087, IEEE_MC68k, VAX, or IBM should be defined.
@@ -470,11 +464,7 @@ extern int strtod_diglim;
 #ifdef RND_PRODQUOT
 #define rounded_product(a,b) a = rnd_prod(a, b)
 #define rounded_quotient(a,b) a = rnd_quot(a, b)
-#ifdef KR_headers
-extern double rnd_prod(), rnd_quot();
-#else
 extern double rnd_prod(double, double), rnd_quot(double, double);
-#endif
 #else
 #define rounded_product(a,b) a *= b
 #define rounded_quotient(a,b) a /= b
@@ -491,11 +481,7 @@ typedef struct BCinfo BCinfo;
  struct
 BCinfo { int dp0, dp1, dplen, dsign, e0, inexact, nd, nd0, rounding, scale, uflchk; };
 
-#ifdef KR_headers
-#define FFFFFFFF ((((unsigned long)0xffff)<<16)|(unsigned long)0xffff)
-#else
 #define FFFFFFFF 0xffffffffUL
-#endif
 
 #ifdef NO_LONG_LONG
 #undef ULLong
@@ -516,18 +502,7 @@ BCinfo { int dp0, dp1, dplen, dsign, e0, inexact, nd, nd0, rounding, scale, uflc
 #endif
 #endif /* NO_LONG_LONG */
 
-#ifndef MULTIPLE_THREADS
-#define ACQUIRE_DTOA_LOCK(n)	/*nothing*/
-#define FREE_DTOA_LOCK(n)	/*nothing*/
-#endif
 
-#define Kmax 7
-
-#ifdef __cplusplus
-extern "C" double strtod(const char *s00, char **se);
-extern "C" char *dtoa(double d, int mode, int ndigits,
-			int *decpt, int *sign, char **rve);
-#endif
 
  struct
 Bigint {
@@ -538,56 +513,38 @@ Bigint {
 
  typedef struct Bigint Bigint;
 
- static Bigint *freelist[Kmax+1];
 
+void jvp_dtoa_context_init(struct dtoa_context* C) {
+  int i;
+  for (i=0; i<(int)(sizeof(C->freelist)/sizeof(C->freelist[0])); i++) {
+    C->freelist[i] = 0;
+  }
+  C->p5s = 0;
+}
+  
  static Bigint *
-Balloc
-#ifdef KR_headers
-	(k) int k;
-#else
-	(int k)
-#endif
+ Balloc(struct dtoa_context* C, int k)
 {
 	int x;
 	Bigint *rv;
-#ifndef Omit_Private_Memory
-	unsigned int len;
-#endif
 
-	ACQUIRE_DTOA_LOCK(0);
 	/* The k > Kmax case does not need ACQUIRE_DTOA_LOCK(0), */
 	/* but this case seems very unlikely. */
-	if (k <= Kmax && (rv = freelist[k]))
-		freelist[k] = rv->next;
+	if (k <= Kmax && (rv = C->freelist[k]))
+		C->freelist[k] = rv->next;
 	else {
 		x = 1 << k;
-#ifdef Omit_Private_Memory
 		rv = (Bigint *)MALLOC(sizeof(Bigint) + (x-1)*sizeof(ULong));
-#else
-		len = (sizeof(Bigint) + (x-1)*sizeof(ULong) + sizeof(double) - 1)
-			/sizeof(double);
-		if (k <= Kmax && pmem_next - private_mem + len <= PRIVATE_mem) {
-			rv = (Bigint*)pmem_next;
-			pmem_next += len;
-			}
-		else
-			rv = (Bigint*)MALLOC(len*sizeof(double));
-#endif
 		rv->k = k;
 		rv->maxwds = x;
 		}
-	FREE_DTOA_LOCK(0);
 	rv->sign = rv->wds = 0;
 	return rv;
 	}
 
  static void
 Bfree
-#ifdef KR_headers
-	(v) Bigint *v;
-#else
-	(Bigint *v)
-#endif
+ (struct dtoa_context* C, Bigint *v)
 {
 	if (v) {
 		if (v->k > Kmax)
@@ -597,24 +554,36 @@ Bfree
 			free((void*)v);
 #endif
 		else {
-			ACQUIRE_DTOA_LOCK(0);
-			v->next = freelist[v->k];
-			freelist[v->k] = v;
-			FREE_DTOA_LOCK(0);
+			v->next = C->freelist[v->k];
+			C->freelist[v->k] = v;
 			}
 		}
 	}
 
+
+void jvp_dtoa_context_free(struct dtoa_context* C) {
+  int k;
+  while (C->p5s) {
+    Bigint* p5 = C->p5s;
+    C->p5s = p5->next;
+    Bfree(C, p5);
+  }
+  for (k=0; k<(int)(sizeof(C->freelist)/sizeof(C->freelist[0])); k++) {
+    while (C->freelist[k]) {
+      Bigint* v = C->freelist[k];
+      C->freelist[k] = v->next;
+      free(v);
+    }
+  }
+}
+
+
 #define Bcopy(x,y) memcpy((char *)&x->sign, (char *)&y->sign, \
 y->wds*sizeof(Long) + 2*sizeof(int))
 
  static Bigint *
 multadd
-#ifdef KR_headers
-	(b, m, a) Bigint *b; int m, a;
-#else
-	(Bigint *b, int m, int a)	/* multiply by m and add a */
-#endif
+ (struct dtoa_context* C, Bigint *b, int m, int a)	/* multiply by m and add a */
 {
 	int i, wds;
 #ifdef ULLong
@@ -654,9 +623,9 @@ multadd
 		while(++i < wds);
 	if (carry) {
 		if (wds >= b->maxwds) {
-			b1 = Balloc(b->k+1);
+			b1 = Balloc(C, b->k+1);
 			Bcopy(b1, b);
-			Bfree(b);
+			Bfree(C, b);
 			b = b1;
 			}
 		b->x[wds++] = carry;
@@ -667,11 +636,7 @@ multadd
 
  static Bigint *
 s2b
-#ifdef KR_headers
-	(s, nd0, nd, y9, dplen) CONST char *s; int nd0, nd, dplen; ULong y9;
-#else
-	(const char *s, int nd0, int nd, ULong y9, int dplen)
-#endif
+ (struct dtoa_context* C, const char *s, int nd0, int nd, ULong y9, int dplen)
 {
 	Bigint *b;
 	int i, k;
@@ -680,11 +645,11 @@ s2b
 	x = (nd + 8) / 9;
 	for(k = 0, y = 1; x > y; y <<= 1, k++) ;
 #ifdef Pack_32
-	b = Balloc(k);
+	b = Balloc(C, k);
 	b->x[0] = y9;
 	b->wds = 1;
 #else
-	b = Balloc(k+1);
+	b = Balloc(C, k+1);
 	b->x[0] = y9 & 0xffff;
 	b->wds = (b->x[1] = y9 >> 16) ? 2 : 1;
 #endif
@@ -692,24 +657,20 @@ s2b
 	i = 9;
 	if (9 < nd0) {
 		s += 9;
-		do b = multadd(b, 10, *s++ - '0');
+		do b = multadd(C, b, 10, *s++ - '0');
 			while(++i < nd0);
 		s += dplen;
 		}
 	else
 		s += dplen + 9;
 	for(; i < nd; i++)
-		b = multadd(b, 10, *s++ - '0');
+		b = multadd(C, b, 10, *s++ - '0');
 	return b;
 	}
 
  static int
 hi0bits
-#ifdef KR_headers
-	(x) ULong x;
-#else
-	(ULong x)
-#endif
+ (struct dtoa_context* C, ULong x)
 {
 	int k = 0;
 
@@ -739,11 +700,7 @@ hi0bits
 
  static int
 lo0bits
-#ifdef KR_headers
-	(y) ULong *y;
-#else
-	(ULong *y)
-#endif
+ (struct dtoa_context* C, ULong *y)
 {
 	int k;
 	ULong x = *y;
@@ -787,15 +744,11 @@ lo0bits
 
  static Bigint *
 i2b
-#ifdef KR_headers
-	(i) int i;
-#else
-	(int i)
-#endif
+ (struct dtoa_context* C, int i)
 {
 	Bigint *b;
 
-	b = Balloc(1);
+	b = Balloc(C, 1);
 	b->x[0] = i;
 	b->wds = 1;
 	return b;
@@ -803,11 +756,7 @@ i2b
 
  static Bigint *
 mult
-#ifdef KR_headers
-	(a, b) Bigint *a, *b;
-#else
-	(Bigint *a, Bigint *b)
-#endif
+ (struct dtoa_context* C, Bigint *a, Bigint *b)
 {
 	Bigint *c;
 	int k, wa, wb, wc;
@@ -833,7 +782,7 @@ mult
 	wc = wa + wb;
 	if (wc > a->maxwds)
 		k++;
-	c = Balloc(k);
+	c = Balloc(C, k);
 	for(x = c->x, xa = x + wc; x < xa; x++)
 		*x = 0;
 	xa = a->x;
@@ -911,59 +860,36 @@ mult
 	return c;
 	}
 
- static Bigint *p5s;
 
  static Bigint *
 pow5mult
-#ifdef KR_headers
-	(b, k) Bigint *b; int k;
-#else
-	(Bigint *b, int k)
-#endif
+ (struct dtoa_context* C, Bigint *b, int k)
 {
 	Bigint *b1, *p5, *p51;
 	int i;
 	static int p05[3] = { 5, 25, 125 };
 
 	if ((i = k & 3))
-		b = multadd(b, p05[i-1], 0);
+		b = multadd(C, b, p05[i-1], 0);
 
 	if (!(k >>= 2))
 		return b;
-	if (!(p5 = p5s)) {
+	if (!(p5 = C->p5s)) {
 		/* first time */
-#ifdef MULTIPLE_THREADS
-		ACQUIRE_DTOA_LOCK(1);
-		if (!(p5 = p5s)) {
-			p5 = p5s = i2b(625);
-			p5->next = 0;
-			}
-		FREE_DTOA_LOCK(1);
-#else
-		p5 = p5s = i2b(625);
+		p5 = C->p5s = i2b(C, 625);
 		p5->next = 0;
-#endif
 		}
 	for(;;) {
 		if (k & 1) {
-			b1 = mult(b, p5);
-			Bfree(b);
+			b1 = mult(C, b, p5);
+			Bfree(C, b);
 			b = b1;
 			}
 		if (!(k >>= 1))
 			break;
 		if (!(p51 = p5->next)) {
-#ifdef MULTIPLE_THREADS
-			ACQUIRE_DTOA_LOCK(1);
-			if (!(p51 = p5->next)) {
-				p51 = p5->next = mult(p5,p5);
-				p51->next = 0;
-				}
-			FREE_DTOA_LOCK(1);
-#else
-			p51 = p5->next = mult(p5,p5);
+			p51 = p5->next = mult(C, p5,p5);
 			p51->next = 0;
-#endif
 			}
 		p5 = p51;
 		}
@@ -972,11 +898,7 @@ pow5mult
 
  static Bigint *
 lshift
-#ifdef KR_headers
-	(b, k) Bigint *b; int k;
-#else
-	(Bigint *b, int k)
-#endif
+ (struct dtoa_context* C, Bigint *b, int k)
 {
 	int i, k1, n, n1;
 	Bigint *b1;
@@ -991,7 +913,7 @@ lshift
 	n1 = n + b->wds + 1;
 	for(i = b->maxwds; n1 > i; i <<= 1)
 		k1++;
-	b1 = Balloc(k1);
+	b1 = Balloc(C, k1);
 	x1 = b1->x;
 	for(i = 0; i < n; i++)
 		*x1++ = 0;
@@ -1026,17 +948,13 @@ lshift
 		*x1++ = *x++;
 		while(x < xe);
 	b1->wds = n1 - 1;
-	Bfree(b);
+	Bfree(C, b);
 	return b1;
 	}
 
  static int
 cmp
-#ifdef KR_headers
-	(a, b) Bigint *a, *b;
-#else
-	(Bigint *a, Bigint *b)
-#endif
+ (struct dtoa_context* C, Bigint *a, Bigint *b)
 {
 	ULong *xa, *xa0, *xb, *xb0;
 	int i, j;
@@ -1066,11 +984,7 @@ cmp
 
  static Bigint *
 diff
-#ifdef KR_headers
-	(a, b) Bigint *a, *b;
-#else
-	(Bigint *a, Bigint *b)
-#endif
+ (struct dtoa_context* C, Bigint *a, Bigint *b)
 {
 	Bigint *c;
 	int i, wa, wb;
@@ -1084,9 +998,9 @@ diff
 #endif
 #endif
 
-	i = cmp(a,b);
+	i = cmp(C, a,b);
 	if (!i) {
-		c = Balloc(0);
+		c = Balloc(C, 0);
 		c->wds = 1;
 		c->x[0] = 0;
 		return c;
@@ -1099,7 +1013,7 @@ diff
 		}
 	else
 		i = 0;
-	c = Balloc(a->k);
+	c = Balloc(C, a->k);
 	c->sign = i;
 	wa = a->wds;
 	xa = a->x;
@@ -1160,11 +1074,7 @@ diff
 
  static double
 ulp
-#ifdef KR_headers
-	(x) U *x;
-#else
-	(U *x)
-#endif
+ (struct dtoa_context* C, U *x)
 {
 	Long L;
 	U u;
@@ -1202,11 +1112,7 @@ ulp
 
  static double
 b2d
-#ifdef KR_headers
-	(a, e) Bigint *a; int *e;
-#else
-	(Bigint *a, int *e)
-#endif
+ (struct dtoa_context* C, Bigint *a, int *e)
 {
 	ULong *xa, *xa0, w, y, z;
 	int k;
@@ -1224,7 +1130,7 @@ b2d
 #ifdef DEBUG
 	if (!y) Bug("zero y in b2d");
 #endif
-	k = hi0bits(y);
+	k = hi0bits(C, y);
 	*e = 32 - k;
 #ifdef Pack_32
 	if (k < Ebits) {
@@ -1272,11 +1178,7 @@ b2d
 
  static Bigint *
 d2b
-#ifdef KR_headers
-	(d, e, bits) U *d; int *e, *bits;
-#else
-	(U *d, int *e, int *bits)
-#endif
+ (struct dtoa_context* C, U *d, int *e, int *bits)
 {
 	Bigint *b;
 	int de, k;
@@ -1294,9 +1196,9 @@ d2b
 #endif
 
 #ifdef Pack_32
-	b = Balloc(1);
+	b = Balloc(C, 1);
 #else
-	b = Balloc(2);
+	b = Balloc(C, 2);
 #endif
 	x = b->x;
 
@@ -1313,7 +1215,7 @@ d2b
 #endif
 #ifdef Pack_32
 	if ((y = d1)) {
-		if ((k = lo0bits(&y))) {
+		if ((k = lo0bits(C, &y))) {
 			x[0] = y | z << (32 - k);
 			z >>= k;
 			}
@@ -1325,7 +1227,7 @@ d2b
 		    b->wds = (x[1] = z) ? 2 : 1;
 		}
 	else {
-		k = lo0bits(&z);
+		k = lo0bits(C, &z);
 		x[0] = z;
 #ifndef Sudden_Underflow
 		i =
@@ -1335,7 +1237,7 @@ d2b
 		}
 #else
 	if (y = d1) {
-		if (k = lo0bits(&y))
+		if (k = lo0bits(C, &y))
 			if (k >= 16) {
 				x[0] = y | z << 32 - k & 0xffff;
 				x[1] = z >> k - 16 & 0xffff;
@@ -1362,7 +1264,7 @@ d2b
 		if (!z)
 			Bug("Zero passed to d2b");
 #endif
-		k = lo0bits(&z);
+		k = lo0bits(C, &z);
 		if (k >= 16) {
 			x[0] = z;
 			i = 0;
@@ -1383,7 +1285,7 @@ d2b
 #endif
 #ifdef IBM
 		*e = (de - Bias - (P-1) << 2) + k;
-		*bits = 4*P + 8 - k - hi0bits(word0(d) & Frac_mask);
+		*bits = 4*P + 8 - k - hi0bits(C, word0(d) & Frac_mask);
 #else
 		*e = de - Bias - (P-1) + k;
 		*bits = P - k;
@@ -1393,9 +1295,9 @@ d2b
 	else {
 		*e = de - Bias - (P-1) + 1 + k;
 #ifdef Pack_32
-		*bits = 32*i - hi0bits(x[i-1]);
+		*bits = 32*i - hi0bits(C, x[i-1]);
 #else
-		*bits = (i+2)*16 - hi0bits(x[i]);
+		*bits = (i+2)*16 - hi0bits(C, x[i]);
 #endif
 		}
 #endif
@@ -1406,17 +1308,13 @@ d2b
 
  static double
 ratio
-#ifdef KR_headers
-	(a, b) Bigint *a, *b;
-#else
-	(Bigint *a, Bigint *b)
-#endif
+ (struct dtoa_context* C, Bigint *a, Bigint *b)
 {
 	U da, db;
 	int k, ka, kb;
 
-	dval(&da) = b2d(a, &ka);
-	dval(&db) = b2d(b, &kb);
+	dval(&da) = b2d(C, a, &ka);
+	dval(&db) = b2d(C, b, &kb);
 #ifdef Pack_32
 	k = ka - kb + 32*(a->wds - b->wds);
 #else
@@ -1499,11 +1397,7 @@ static CONST double tinytens[] = { 1e-16, 1e-32 };
 static unsigned char hexdig[256];
 
  static void
-#ifdef KR_headers
-htinit(h, s, inc) unsigned char *h; unsigned char *s; int inc;
-#else
 htinit(unsigned char *h, unsigned char *s, int inc)
-#endif
 {
 	int i, j;
 	for(i = 0; (j = s[i]) !=0; i++)
@@ -1511,11 +1405,7 @@ htinit(unsigned char *h, unsigned char *s, int inc)
 	}
 
  static void
-#ifdef KR_headers
-hexdig_init()
-#else
 hexdig_init(void)
-#endif
 {
 #define USC (unsigned char *)
 	htinit(hexdig, USC "0123456789", 0x10);
@@ -1536,11 +1426,7 @@ hexdig_init(void)
 
  static int
 match
-#ifdef KR_headers
-	(sp, t) char **sp, *t;
-#else
-	(const char **sp, const char *t)
-#endif
+ (struct dtoa_context* C, const char **sp, const char *t)
 {
 	int c, d;
 	CONST char *s = *sp;
@@ -1558,11 +1444,7 @@ match
 #ifndef No_Hex_NaN
  static void
 hexnan
-#ifdef KR_headers
-	(rvp, sp) U *rvp; CONST char **sp;
-#else
-	(U *rvp, const char **sp)
-#endif
+ (struct dtoa_context* C, U *rvp, const char **sp)
 {
 	ULong c, x[2];
 	CONST char *s;
@@ -1637,11 +1519,7 @@ hexnan
 
 #if !defined(NO_HEX_FP) || defined(Honor_FLT_ROUNDS) /*{*/
  static Bigint *
-#ifdef KR_headers
-increment(b) Bigint *b;
-#else
-increment(Bigint *b)
-#endif
+increment(struct dtoa_context* C, Bigint *b)
 {
 	ULong *x, *xe;
 	Bigint *b1;
@@ -1657,9 +1535,9 @@ increment(Bigint *b)
 		} while(x < xe);
 	{
 		if (b->wds >= b->maxwds) {
-			b1 = Balloc(b->k+1);
+			b1 = Balloc(C, b->k+1);
 			Bcopy(b1,b);
-			Bfree(b);
+			Bfree(C, b);
 			b = b1;
 			}
 		b->x[b->wds++] = 1;
@@ -1672,11 +1550,7 @@ increment(Bigint *b)
 #ifndef NO_HEX_FP /*{*/
 
  static void
-#ifdef KR_headers
-rshift(b, k) Bigint *b; int k;
-#else
-rshift(Bigint *b, int k)
-#endif
+rshift(struct dtoa_context* C, Bigint *b, int k)
 {
 	ULong *x, *x1, *xe, y;
 	int n;
@@ -1705,11 +1579,7 @@ rshift(Bigint *b, int k)
 	}
 
  static ULong
-#ifdef KR_headers
-any_on(b, k) Bigint *b; int k;
-#else
 any_on(Bigint *b, int k)
-#endif
 {
 	int n, nwds;
 	ULong *x, *x0, x1, x2;
@@ -1741,13 +1611,8 @@ enum {	/* rounding values: same as FLT_ROUNDS */
 	Round_down = 3
 	};
 
- void
-#ifdef KR_headers
-gethex(sp, rvp, rounding, sign)
-	CONST char **sp; U *rvp; int rounding, sign;
-#else
-gethex( CONST char **sp, U *rvp, int rounding, int sign)
-#endif
+static void
+gethex(struct dtoa_context* C,  CONST char **sp, U *rvp, int rounding, int sign)
 {
 	Bigint *b;
 	CONST unsigned char *decpt, *s0, *s, *s1;
@@ -1921,7 +1786,7 @@ gethex( CONST char **sp, U *rvp, int rounding, int sign)
 	n = s1 - s0 - 1;
 	for(k = 0; n > (1 << (kshift-2)) - 1; n >>= 1)
 		k++;
-	b = Balloc(k);
+	b = Balloc(C, k);
 	x = b->x;
 	n = 0;
 	L = 0;
@@ -1948,7 +1813,7 @@ gethex( CONST char **sp, U *rvp, int rounding, int sign)
 		}
 	*x++ = L;
 	b->wds = n = x - b->x;
-	n = ULbits*n - hi0bits(L);
+	n = ULbits*n - hi0bits(C, L);
 	nbits = Nbits;
 	lostbits = 0;
 	x = b->x;
@@ -1963,18 +1828,18 @@ gethex( CONST char **sp, U *rvp, int rounding, int sign)
 					lostbits = 3;
 				}
 			}
-		rshift(b, n);
+		rshift(C, b, n);
 		e += n;
 		}
 	else if (n < nbits) {
 		n = nbits - n;
-		b = lshift(b, n);
+		b = lshift(C, b, n);
 		e -= n;
 		x = b->x;
 		}
 	if (e > Emax) {
  ovfl:
-		Bfree(b);
+		Bfree(C, b);
  ovfl1:
 #ifndef NO_ERRNO
 		errno = ERANGE;
@@ -2003,7 +1868,7 @@ gethex( CONST char **sp, U *rvp, int rounding, int sign)
 					goto ret_tiny;
 			  }
 #endif /* } IEEE_Arith */
-			Bfree(b);
+			Bfree(C, b);
  retz:
 #ifndef NO_ERRNO
 			errno = ERANGE;
@@ -2020,7 +1885,7 @@ gethex( CONST char **sp, U *rvp, int rounding, int sign)
 		if (x[k>>kshift] & 1 << (k & kmask))
 			lostbits |= 2;
 		nbits -= n;
-		rshift(b,n);
+		rshift(C, b,n);
 		e = emin;
 		}
 	if (lostbits) {
@@ -2041,7 +1906,7 @@ gethex( CONST char **sp, U *rvp, int rounding, int sign)
 		  }
 		if (up) {
 			k = b->wds;
-			b = increment(b);
+			b = increment(C, b);
 			x = b->x;
 			if (denorm) {
 #if 0
@@ -2052,8 +1917,8 @@ gethex( CONST char **sp, U *rvp, int rounding, int sign)
 				}
 			else if (b->wds > k
 			 || ((n = nbits & kmask) !=0
-			     && hi0bits(x[k-1]) < 32-n)) {
-				rshift(b,1);
+			     && hi0bits(C, x[k-1]) < 32-n)) {
+				rshift(C, b,1);
 				if (++e > Emax)
 					goto ovfl;
 				}
@@ -2069,7 +1934,7 @@ gethex( CONST char **sp, U *rvp, int rounding, int sign)
 #ifdef IBM
 	if ((j = e & 3)) {
 		k = b->x[0] & ((1 << j) - 1);
-		rshift(b,j);
+		rshift(C, b,j);
 		if (k) {
 			switch(rounding) {
 			  case Round_up:
@@ -2098,18 +1963,14 @@ gethex( CONST char **sp, U *rvp, int rounding, int sign)
 	word0(rvp) = ((b->x[1] & ~0x800000) >> 16) | ((e + 129 + 55) << 7) | (b->x[1] << 16);
 	word1(rvp) = (b->x[0] >> 16) | (b->x[0] << 16);
 #endif
-	Bfree(b);
+	Bfree(C, b);
 	}
 #endif /*!NO_HEX_FP}*/
 
  static int
-#ifdef KR_headers
-dshift(b, p2) Bigint *b; int p2;
-#else
-dshift(Bigint *b, int p2)
-#endif
+dshift(struct dtoa_context* C, Bigint *b, int p2)
 {
-	int rv = hi0bits(b->x[b->wds-1]) - 4;
+	int rv = hi0bits(C, b->x[b->wds-1]) - 4;
 	if (p2 > 0)
 		rv -= p2;
 	return rv & kmask;
@@ -2117,11 +1978,7 @@ dshift(Bigint *b, int p2)
 
  static int
 quorem
-#ifdef KR_headers
-	(b, S) Bigint *b, *S;
-#else
-	(Bigint *b, Bigint *S)
-#endif
+ (struct dtoa_context* C, Bigint *b, Bigint *S)
 {
 	int n;
 	ULong *bx, *bxe, q, *sx, *sxe;
@@ -2194,7 +2051,7 @@ quorem
 			b->wds = n;
 			}
 		}
-	if (cmp(b, S) >= 0) {
+	if (cmp(C, b, S) >= 0) {
 		q++;
 		borrow = 0;
 		carry = 0;
@@ -2242,17 +2099,13 @@ quorem
 #if defined(Avoid_Underflow) || !defined(NO_STRTOD_BIGCOMP) /*{*/
  static double
 sulp
-#ifdef KR_headers
-	(x, bc) U *x; BCinfo *bc;
-#else
-	(U *x, BCinfo *bc)
-#endif
+ (struct dtoa_context* C, U *x, BCinfo *bc)
 {
 	U u;
 	double rv;
 	int i;
 
-	rv = ulp(x);
+	rv = ulp(C, x);
 	if (!bc->scale || (i = 2*P + 1 - ((word0(x) & Exp_mask) >> Exp_shift)) <= 0)
 		return rv; /* Is there an example where i <= 0 ? */
 	word0(&u) = Exp_1 + (i << Exp_shift);
@@ -2264,12 +2117,7 @@ sulp
 #ifndef NO_STRTOD_BIGCOMP
  static void
 bigcomp
-#ifdef KR_headers
-	(rv, s0, bc)
-	U *rv; CONST char *s0; BCinfo *bc;
-#else
-	(U *rv, const char *s0, BCinfo *bc)
-#endif
+ (struct dtoa_context* C, U *rv, const char *s0, BCinfo *bc)
 {
 	Bigint *b, *d;
 	int b2, bbits, d2, dd, dig, dsign, i, j, nd, nd0, p2, p5, speccase;
@@ -2282,7 +2130,7 @@ bigcomp
 #ifndef Sudden_Underflow
 	if (rv->d == 0.) {	/* special case: value near underflow-to-zero */
 				/* threshold was rounded to zero */
-		b = i2b(1);
+		b = i2b(C, 1);
 		p2 = Emin - P + 1;
 		bbits = 1;
 #ifdef Avoid_Underflow
@@ -2303,7 +2151,7 @@ bigcomp
 		}
 	else
 #endif
-		b = d2b(rv, &p2, &bbits);
+		b = d2b(C, rv, &p2, &bbits);
 #ifdef Avoid_Underflow
 	p2 -= bc->scale;
 #endif
@@ -2312,8 +2160,8 @@ bigcomp
 	i = P - bbits;
 	if (i > (j = P - Emin - 1 + p2)) {
 #ifdef Sudden_Underflow
-		Bfree(b);
-		b = i2b(1);
+		Bfree(C, b);
+		b = i2b(C, 1);
 		p2 = Emin;
 		i = P - 1;
 #ifdef Avoid_Underflow
@@ -2329,28 +2177,28 @@ bigcomp
 #ifdef Honor_FLT_ROUNDS
 	if (bc->rounding != 1) {
 		if (i > 0)
-			b = lshift(b, i);
+			b = lshift(C, b, i);
 		if (dsign)
 			b = increment(b);
 		}
 	else
 #endif
 		{
-		b = lshift(b, ++i);
+		b = lshift(C, b, ++i);
 		b->x[0] |= 1;
 		}
 #ifndef Sudden_Underflow
  have_i:
 #endif
 	p2 -= p5 + i;
-	d = i2b(1);
+	d = i2b(C, 1);
 	/* Arrange for convenient computation of quotients:
 	 * shift left if necessary so divisor has 4 leading 0 bits.
 	 */
 	if (p5 > 0)
-		d = pow5mult(d, p5);
+		d = pow5mult(C, d, p5);
 	else if (p5 < 0)
-		b = pow5mult(b, -p5);
+		b = pow5mult(C, b, -p5);
 	if (p2 > 0) {
 		b2 = p2;
 		d2 = 0;
@@ -2359,18 +2207,18 @@ bigcomp
 		b2 = 0;
 		d2 = -p2;
 		}
-	i = dshift(d, d2);
+	i = dshift(C, d, d2);
 	if ((b2 += i) > 0)
-		b = lshift(b, b2);
+		b = lshift(C, b, b2);
 	if ((d2 += i) > 0)
-		d = lshift(d, d2);
+		d = lshift(C, d, d2);
 
 	/* Now b/d = exactly half-way between the two floating-point values */
 	/* on either side of the input string.  Compute first digit of b/d. */
 
-	if (!(dig = quorem(b,d))) {
-		b = multadd(b, 10, 0);	/* very unlikely */
-		dig = quorem(b,d);
+	if (!(dig = quorem(C, b,d))) {
+		b = multadd(C, b, 10, 0);	/* very unlikely */
+		dig = quorem(C, b,d);
 		}
 
 	/* Compare b/d with s0 */
@@ -2383,8 +2231,8 @@ bigcomp
 				dd = 1;
 			goto ret;
 			}
-		b = multadd(b, 10, 0);
-		dig = quorem(b,d);
+		b = multadd(C, b, 10, 0);
+		dig = quorem(C, b,d);
 		}
 	for(j = bc->dp1; i++ < nd;) {
 		if ((dd = s0[j++] - '0' - dig))
@@ -2394,14 +2242,14 @@ bigcomp
 				dd = 1;
 			goto ret;
 			}
-		b = multadd(b, 10, 0);
-		dig = quorem(b,d);
+		b = multadd(C, b, 10, 0);
+		dig = quorem(C, b,d);
 		}
 	if (dig > 0 || b->x[0] || b->wds > 1)
 		dd = -1;
  ret:
-	Bfree(b);
-	Bfree(d);
+	Bfree(C, b);
+	Bfree(C, d);
 #ifdef Honor_FLT_ROUNDS
 	if (bc->rounding != 1) {
 		if (dd < 0) {
@@ -2420,7 +2268,7 @@ bigcomp
 				}
 			if (!dsign)
 				goto rethi1;
-			dval(rv) += 2.*sulp(rv,bc);
+			dval(rv) += 2.*sulp(C, rv,bc);
 			}
 		else {
 			bc->inexact = 0;
@@ -2437,12 +2285,12 @@ bigcomp
 	else if (dd < 0) {
 		if (!dsign)	/* does not happen for round-near */
 retlow1:
-			dval(rv) -= sulp(rv,bc);
+			dval(rv) -= sulp(C, rv,bc);
 		}
 	else if (dd > 0) {
 		if (dsign) {
  rethi1:
-			dval(rv) += sulp(rv,bc);
+			dval(rv) += sulp(C, rv,bc);
 			}
 		}
 	else {
@@ -2472,12 +2320,8 @@ retlow1:
 #endif /* NO_STRTOD_BIGCOMP */
 
  double
-strtod
-#ifdef KR_headers
-	(s00, se) CONST char *s00; char **se;
-#else
-	(const char *s00, char **se)
-#endif
+jvp_strtod
+ (struct dtoa_context* C, const char *s00, char **se)
 {
 	int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, e, e1;
 	int esign, i, j, k, nd, nd0, nf, nz, nz0, nz1, sign;
@@ -2487,7 +2331,7 @@ strtod
 	U aadj2, adj, rv, rv0;
 	ULong y, z;
 	BCinfo bc;
-	Bigint *bb, *bb1, *bd, *bd0, *bs, *delta;
+	Bigint *bb=0, *bb1, *bd=0, *bd0, *bs=0, *delta=0;
 #ifdef Avoid_Underflow
 	ULong Lsb, Lsb1;
 #endif
@@ -2542,9 +2386,9 @@ strtod
 		  case 'x':
 		  case 'X':
 #ifdef Honor_FLT_ROUNDS
-			gethex(&s, &rv, bc.rounding, sign);
+			gethex(C, &s, &rv, bc.rounding, sign);
 #else
-			gethex(&s, &rv, 1, sign);
+			gethex(C, &s, &rv, 1, sign);
 #endif
 			goto ret;
 		  }
@@ -2665,9 +2509,9 @@ strtod
 			 switch(c) {
 			  case 'i':
 			  case 'I':
-				if (match(&s,"nf")) {
+				if (match(C, &s,"nf")) {
 					--s;
-					if (!match(&s,"inity"))
+					if (!match(C, &s,"inity"))
 						++s;
 					word0(&rv) = 0x7ff00000;
 					word1(&rv) = 0;
@@ -2676,12 +2520,12 @@ strtod
 				break;
 			  case 'n':
 			  case 'N':
-				if (match(&s, "an")) {
+				if (match(C, &s, "an")) {
 					word0(&rv) = NAN_WORD0;
 					word1(&rv) = NAN_WORD1;
 #ifndef No_Hex_NaN
 					if (*s == '(') /*)*/
-						hexnan(&rv, &s);
+						hexnan(C, &rv, &s);
 #endif
 					goto ret;
 					}
@@ -2842,11 +2686,11 @@ strtod
 #endif /*IEEE_Arith*/
  range_err:
 				if (bd0) {
-					Bfree(bb);
-					Bfree(bd);
-					Bfree(bs);
-					Bfree(bd0);
-					Bfree(delta);
+					Bfree(C, bb);
+					Bfree(C, bd);
+					Bfree(C, bs);
+					Bfree(C, bd0);
+					Bfree(C, delta);
 					}
 #ifndef NO_ERRNO
 				errno = ERANGE;
@@ -2964,13 +2808,13 @@ strtod
 			}
 		}
 #endif
-	bd0 = s2b(s0, nd0, nd, y, bc.dplen);
+	bd0 = s2b(C, s0, nd0, nd, y, bc.dplen);
 
 	for(;;) {
-		bd = Balloc(bd0->k);
+		bd = Balloc(C, bd0->k);
 		Bcopy(bd, bd0);
-		bb = d2b(&rv, &bbe, &bbbits);	/* rv = bb * 2^bbe */
-		bs = i2b(1);
+		bb = d2b(C, &rv, &bbe, &bbbits);	/* rv = bb * 2^bbe */
+		bs = i2b(C, 1);
 
 		if (e >= 0) {
 			bb2 = bb5 = 0;
@@ -3035,27 +2879,27 @@ strtod
 			bs2 -= i;
 			}
 		if (bb5 > 0) {
-			bs = pow5mult(bs, bb5);
-			bb1 = mult(bs, bb);
-			Bfree(bb);
+			bs = pow5mult(C, bs, bb5);
+			bb1 = mult(C, bs, bb);
+			Bfree(C, bb);
 			bb = bb1;
 			}
 		if (bb2 > 0)
-			bb = lshift(bb, bb2);
+			bb = lshift(C, bb, bb2);
 		if (bd5 > 0)
-			bd = pow5mult(bd, bd5);
+			bd = pow5mult(C, bd, bd5);
 		if (bd2 > 0)
-			bd = lshift(bd, bd2);
+			bd = lshift(C, bd, bd2);
 		if (bs2 > 0)
-			bs = lshift(bs, bs2);
-		delta = diff(bb, bd);
+			bs = lshift(C, bs, bs2);
+		delta = diff(C, bb, bd);
 		bc.dsign = delta->sign;
 		delta->sign = 0;
-		i = cmp(delta, bs);
+		i = cmp(C, delta, bs);
 #ifndef NO_STRTOD_BIGCOMP /*{*/
 		if (bc.nd > nd && i <= 0) {
 			if (bc.dsign) {
-				/* Must use bigcomp(). */
+				/* Must use bigcomp(C, ). */
 				req_bigcomp = 1;
 				break;
 				}
@@ -3099,8 +2943,8 @@ strtod
 						if (y)
 #endif
 						  {
-						  delta = lshift(delta,Log2P);
-						  if (cmp(delta, bs) <= 0)
+						  delta = lshift(C, delta,Log2P);
+						  if (cmp(C, delta, bs) <= 0)
 							adj.d = -0.5;
 						  }
 						}
@@ -3114,17 +2958,17 @@ strtod
 					if ((word0(&rv) & Exp_mask) <=
 							P*Exp_msk1) {
 						word0(&rv) += P*Exp_msk1;
-						dval(&rv) += adj.d*ulp(dval(&rv));
+						dval(&rv) += adj.d*ulp(C, dval(&rv));
 						word0(&rv) -= P*Exp_msk1;
 						}
 					else
 #endif /*Sudden_Underflow*/
 #endif /*Avoid_Underflow}*/
-					dval(&rv) += adj.d*ulp(&rv);
+					dval(&rv) += adj.d*ulp(C, &rv);
 					}
 				break;
 				}
-			adj.d = ratio(delta, bs);
+			adj.d = ratio(C, delta, bs);
 			if (adj.d < 1.)
 				adj.d = 1.;
 			if (adj.d <= 0x7ffffffe) {
@@ -3143,7 +2987,7 @@ strtod
 #ifdef Sudden_Underflow
 			if ((word0(&rv) & Exp_mask) <= P*Exp_msk1) {
 				word0(&rv) += P*Exp_msk1;
-				adj.d *= ulp(dval(&rv));
+				adj.d *= ulp(C, dval(&rv));
 				if (bc.dsign)
 					dval(&rv) += adj.d;
 				else
@@ -3153,7 +2997,7 @@ strtod
 				}
 #endif /*Sudden_Underflow*/
 #endif /*Avoid_Underflow}*/
-			adj.d *= ulp(&rv);
+			adj.d *= ulp(C, &rv);
 			if (bc.dsign) {
 				if (word0(&rv) == Big0 && word1(&rv) == Big1)
 					goto ovfl;
@@ -3191,8 +3035,8 @@ strtod
 #endif
 				break;
 				}
-			delta = lshift(delta,Log2P);
-			if (cmp(delta, bs) > 0)
+			delta = lshift(C, delta,Log2P);
+			if (cmp(C, delta, bs) > 0)
 				goto drop_down;
 			break;
 			}
@@ -3291,16 +3135,16 @@ strtod
 #endif
 			if (bc.dsign)
 #ifdef Avoid_Underflow
-				dval(&rv) += sulp(&rv, &bc);
+				dval(&rv) += sulp(C, &rv, &bc);
 #else
-				dval(&rv) += ulp(&rv);
+				dval(&rv) += ulp(C, &rv);
 #endif
 #ifndef ROUND_BIASED
 			else {
 #ifdef Avoid_Underflow
-				dval(&rv) -= sulp(&rv, &bc);
+				dval(&rv) -= sulp(C, &rv, &bc);
 #else
-				dval(&rv) -= ulp(&rv);
+				dval(&rv) -= ulp(C, &rv);
 #endif
 #ifndef Sudden_Underflow
 				if (!dval(&rv)) {
@@ -3318,7 +3162,7 @@ strtod
 #endif
 			break;
 			}
-		if ((aadj = ratio(delta, bs)) <= 2.) {
+		if ((aadj = ratio(C, delta, bs)) <= 2.) {
 			if (bc.dsign)
 				aadj = aadj1 = 1.;
 			else if (word1(&rv) || word0(&rv) & Bndry_mask) {
@@ -3369,7 +3213,7 @@ strtod
 		if (y == Exp_msk1*(DBL_MAX_EXP+Bias-1)) {
 			dval(&rv0) = dval(&rv);
 			word0(&rv) -= P*Exp_msk1;
-			adj.d = aadj1 * ulp(&rv);
+			adj.d = aadj1 * ulp(C, &rv);
 			dval(&rv) += adj.d;
 			if ((word0(&rv) & Exp_mask) >=
 					Exp_msk1*(DBL_MAX_EXP+Bias-P)) {
@@ -3394,7 +3238,7 @@ strtod
 				dval(&aadj2) = aadj1;
 				word0(&aadj2) += (2*P+1)*Exp_msk1 - y;
 				aadj1 = dval(&aadj2);
-				adj.d = aadj1 * ulp(&rv);
+				adj.d = aadj1 * ulp(C, &rv);
 				dval(&rv) += adj.d;
 				if (rv.d == 0.)
 #ifdef NO_STRTOD_BIGCOMP
@@ -3408,7 +3252,7 @@ strtod
 #endif
 				}
 			else {
-				adj.d = aadj1 * ulp(&rv);
+				adj.d = aadj1 * ulp(C, &rv);
 				dval(&rv) += adj.d;
 				}
 #else
@@ -3416,7 +3260,7 @@ strtod
 			if ((word0(&rv) & Exp_mask) <= P*Exp_msk1) {
 				dval(&rv0) = dval(&rv);
 				word0(&rv) += P*Exp_msk1;
-				adj.d = aadj1 * ulp(&rv);
+				adj.d = aadj1 * ulp(C, &rv);
 				dval(&rv) += adj.d;
 #ifdef IBM
 				if ((word0(&rv) & Exp_mask) <  P*Exp_msk1)
@@ -3440,13 +3284,13 @@ strtod
 					word0(&rv) -= P*Exp_msk1;
 				}
 			else {
-				adj.d = aadj1 * ulp(&rv);
+				adj.d = aadj1 * ulp(C, &rv);
 				dval(&rv) += adj.d;
 				}
 #else /*Sudden_Underflow*/
 			/* Compute adj so that the IEEE rounding rules will
 			 * correctly round rv + adj in some half-way cases.
-			 * If rv * ulp(rv) is denormalized (i.e.,
+			 * If rv * ulp(C, rv) is denormalized (i.e.,
 			 * y <= (P-1)*Exp_msk1), we must adjust aadj to avoid
 			 * trouble from bits lost to denormalization;
 			 * example: 1.2e-307 .
@@ -3456,7 +3300,7 @@ strtod
 				if (!bc.dsign)
 					aadj1 = -aadj1;
 				}
-			adj.d = aadj1 * ulp(&rv);
+			adj.d = aadj1 * ulp(C, &rv);
 			dval(&rv) += adj.d;
 #endif /*Sudden_Underflow*/
 #endif /*Avoid_Underflow*/
@@ -3482,21 +3326,21 @@ strtod
 		}
 #endif
  cont:
-		Bfree(bb);
-		Bfree(bd);
-		Bfree(bs);
-		Bfree(delta);
+		Bfree(C, bb);
+		Bfree(C, bd);
+		Bfree(C, bs);
+		Bfree(C, delta);
 		}
-	Bfree(bb);
-	Bfree(bd);
-	Bfree(bs);
-	Bfree(bd0);
-	Bfree(delta);
+	Bfree(C, bb);
+	Bfree(C, bd);
+	Bfree(C, bs);
+	Bfree(C, bd0);
+	Bfree(C, delta);
 #ifndef NO_STRTOD_BIGCOMP
 	if (req_bigcomp) {
 		bd0 = 0;
 		bc.e0 += nz1;
-		bigcomp(&rv, s0, &bc);
+		bigcomp(C, &rv, s0, &bc);
 		y = word0(&rv) & Exp_mask;
 		if (y == Exp_mask)
 			goto ovfl;
@@ -3544,43 +3388,28 @@ strtod
 	return sign ? -dval(&rv) : dval(&rv);
 	}
 
-#ifndef MULTIPLE_THREADS
- static char *dtoa_result;
-#endif
-
  static char *
-#ifdef KR_headers
-rv_alloc(i) int i;
-#else
-rv_alloc(int i)
-#endif
+rv_alloc(struct dtoa_context* C, int i)
 {
 	int j, k, *r;
 
 	j = sizeof(ULong);
 	for(k = 0;
-		sizeof(Bigint) - sizeof(ULong) - sizeof(int) + j <= i;
+            (int)(sizeof(Bigint) - sizeof(ULong) - sizeof(int)) + j <= i;
 		j <<= 1)
 			k++;
-	r = (int*)Balloc(k);
+	r = (int*)Balloc(C, k);
 	*r = k;
 	return
-#ifndef MULTIPLE_THREADS
-	dtoa_result =
-#endif
 		(char *)(r+1);
 	}
 
  static char *
-#ifdef KR_headers
-nrv_alloc(s, rve, n) char *s, **rve; int n;
-#else
-nrv_alloc(const char *s, char **rve, int n)
-#endif
+nrv_alloc(struct dtoa_context* C, const char *s, char **rve, int n)
 {
 	char *rv, *t;
 
-	t = rv = rv_alloc(n);
+	t = rv = rv_alloc(C, n);
 	while((*t = *s++)) t++;
 	if (rve)
 		*rve = t;
@@ -3594,19 +3423,11 @@ nrv_alloc(const char *s, char **rve, int n)
  */
 
  void
-#ifdef KR_headers
-freedtoa(s) char *s;
-#else
-freedtoa(char *s)
-#endif
+jvp_freedtoa(struct dtoa_context* C, char *s)
 {
 	Bigint *b = (Bigint *)((int *)s - 1);
 	b->maxwds = 1 << (b->k = *(int*)b);
-	Bfree(b);
-#ifndef MULTIPLE_THREADS
-	if (s == dtoa_result)
-		dtoa_result = 0;
-#endif
+	Bfree(C, b);
 	}
 
 /* dtoa for IEEE arithmetic (dmg): convert double to ASCII string.
@@ -3644,13 +3465,8 @@ freedtoa(char *s)
  */
 
  char *
-dtoa
-#ifdef KR_headers
-	(dd, mode, ndigits, decpt, sign, rve)
-	double dd; int mode, ndigits, *decpt, *sign; char **rve;
-#else
-	(double dd, int mode, int ndigits, int *decpt, int *sign, char **rve)
-#endif
+jvp_dtoa
+ (struct dtoa_context* C, double dd, int mode, int ndigits, int *decpt, int *sign, char **rve)
 {
  /*	Arguments ndigits, decpt, sign are similar to those
 	of ecvt and fcvt; trailing zeros are suppressed from
@@ -3687,7 +3503,7 @@ dtoa
 	*/
 
 	int bbits, b2, b5, be, dig, i, ieps, ilim, ilim0, ilim1,
-		j, j1, k, k0, k_check, leftright, m2, m5, s2, s5,
+		j, j1=0, k, k0, k_check, leftright, m2, m5, s2, s5,
 		spec_case, try_quick;
 	Long L;
 #ifndef Sudden_Underflow
@@ -3720,12 +3536,6 @@ dtoa
 #endif /*}}*/
 #endif /*}*/
 
-#ifndef MULTIPLE_THREADS
-	if (dtoa_result) {
-		freedtoa(dtoa_result);
-		dtoa_result = 0;
-		}
-#endif
 
 	u.d = dd;
 	if (word0(&u) & Sign_bit) {
@@ -3747,9 +3557,9 @@ dtoa
 		*decpt = 9999;
 #ifdef IEEE_Arith
 		if (!word1(&u) && !(word0(&u) & 0xfffff))
-			return nrv_alloc("Infinity", rve, 8);
+			return nrv_alloc(C, "Infinity", rve, 8);
 #endif
-		return nrv_alloc("NaN", rve, 3);
+		return nrv_alloc(C, "NaN", rve, 3);
 		}
 #endif
 #ifdef IBM
@@ -3757,7 +3567,7 @@ dtoa
 #endif
 	if (!dval(&u)) {
 		*decpt = 1;
-		return nrv_alloc("0", rve, 1);
+		return nrv_alloc(C, "0", rve, 1);
 		}
 
 #ifdef SET_INEXACT
@@ -3774,7 +3584,7 @@ dtoa
 		}
 #endif
 
-	b = d2b(&u, &be, &bbits);
+	b = d2b(C, &u, &be, &bbits);
 #ifdef Sudden_Underflow
 	i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1));
 #else
@@ -3784,7 +3594,7 @@ dtoa
 		word0(&d2) &= Frac_mask1;
 		word0(&d2) |= Exp_11;
 #ifdef IBM
-		if (j = 11 - hi0bits(word0(&d2) & Frac_mask))
+		if (j = 11 - hi0bits(C, word0(&d2) & Frac_mask))
 			dval(&d2) /= 1 << j;
 #endif
 
@@ -3901,7 +3711,7 @@ dtoa
 			if (i <= 0)
 				i = 1;
 		}
-	s = s0 = rv_alloc(i);
+	s = s0 = rv_alloc(C, i);
 
 #ifdef Honor_FLT_ROUNDS
 	if (mode > 1 && Rounding != 1)
@@ -4095,7 +3905,7 @@ dtoa
 #endif
 		b2 += i;
 		s2 += i;
-		mhi = i2b(1);
+		mhi = i2b(C, 1);
 		}
 	if (m2 > 0 && s2 > 0) {
 		i = m2 < s2 ? m2 : s2;
@@ -4106,20 +3916,20 @@ dtoa
 	if (b5 > 0) {
 		if (leftright) {
 			if (m5 > 0) {
-				mhi = pow5mult(mhi, m5);
-				b1 = mult(mhi, b);
-				Bfree(b);
+				mhi = pow5mult(C, mhi, m5);
+				b1 = mult(C, mhi, b);
+				Bfree(C, b);
 				b = b1;
 				}
 			if ((j = b5 - m5))
-				b = pow5mult(b, j);
+				b = pow5mult(C, b, j);
 			}
 		else
-			b = pow5mult(b, b5);
+			b = pow5mult(C, b, b5);
 		}
-	S = i2b(1);
+	S = i2b(C, 1);
 	if (s5 > 0)
-		S = pow5mult(S, s5);
+		S = pow5mult(C, S, s5);
 
 	/* Check for special case that d is a normalized power of 2. */
 
@@ -4148,25 +3958,25 @@ dtoa
 	 * and for all and pass them and a shift to quorem, so it
 	 * can do shifts and ors to compute the numerator for q.
 	 */
-	i = dshift(S, s2);
+	i = dshift(C, S, s2);
 	b2 += i;
 	m2 += i;
 	s2 += i;
 	if (b2 > 0)
-		b = lshift(b, b2);
+		b = lshift(C, b, b2);
 	if (s2 > 0)
-		S = lshift(S, s2);
+		S = lshift(C, S, s2);
 	if (k_check) {
-		if (cmp(b,S) < 0) {
+		if (cmp(C, b,S) < 0) {
 			k--;
-			b = multadd(b, 10, 0);	/* we botched the k estimate */
+			b = multadd(C, b, 10, 0);	/* we botched the k estimate */
 			if (leftright)
-				mhi = multadd(mhi, 10, 0);
+				mhi = multadd(C, mhi, 10, 0);
 			ilim = ilim1;
 			}
 		}
 	if (ilim <= 0 && (mode == 3 || mode == 5)) {
-		if (ilim < 0 || cmp(b,S = multadd(S,5,0)) <= 0) {
+		if (ilim < 0 || cmp(C, b,S = multadd(C, S,5,0)) <= 0) {
 			/* no digits, fcvt style */
  no_digits:
 			k = -1 - ndigits;
@@ -4179,7 +3989,7 @@ dtoa
 		}
 	if (leftright) {
 		if (m2 > 0)
-			mhi = lshift(mhi, m2);
+			mhi = lshift(C, mhi, m2);
 
 		/* Compute mlo -- check for special case
 		 * that d is a normalized power of 2.
@@ -4187,20 +3997,20 @@ dtoa
 
 		mlo = mhi;
 		if (spec_case) {
-			mhi = Balloc(mhi->k);
+			mhi = Balloc(C, mhi->k);
 			Bcopy(mhi, mlo);
-			mhi = lshift(mhi, Log2P);
+			mhi = lshift(C, mhi, Log2P);
 			}
 
 		for(i = 1;;i++) {
-			dig = quorem(b,S) + '0';
+			dig = quorem(C, b,S) + '0';
 			/* Do we yet have the shortest decimal string
 			 * that will round to d?
 			 */
-			j = cmp(b, mlo);
-			delta = diff(S, mhi);
-			j1 = delta->sign ? 1 : cmp(b, delta);
-			Bfree(delta);
+			j = cmp(C, b, mlo);
+			delta = diff(C, S, mhi);
+			j1 = delta->sign ? 1 : cmp(C, b, delta);
+			Bfree(C, delta);
 #ifndef ROUND_BIASED
 			if (j1 == 0 && mode != 1 && !(word1(&u) & 1)
 #ifdef Honor_FLT_ROUNDS
@@ -4238,8 +4048,8 @@ dtoa
 				  }
 #endif /*Honor_FLT_ROUNDS*/
 				if (j1 > 0) {
-					b = lshift(b, 1);
-					j1 = cmp(b, S);
+					b = lshift(C, b, 1);
+					j1 = cmp(C, b, S);
 #ifdef ROUND_BIASED
 					if (j1 >= 0 /*)*/
 #else
@@ -4271,18 +4081,18 @@ dtoa
 			*s++ = dig;
 			if (i == ilim)
 				break;
-			b = multadd(b, 10, 0);
+			b = multadd(C, b, 10, 0);
 			if (mlo == mhi)
-				mlo = mhi = multadd(mhi, 10, 0);
+				mlo = mhi = multadd(C, mhi, 10, 0);
 			else {
-				mlo = multadd(mlo, 10, 0);
-				mhi = multadd(mhi, 10, 0);
+				mlo = multadd(C, mlo, 10, 0);
+				mhi = multadd(C, mhi, 10, 0);
 				}
 			}
 		}
 	else
 		for(i = 1;; i++) {
-			*s++ = dig = quorem(b,S) + '0';
+			*s++ = dig = quorem(C, b,S) + '0';
 			if (!b->x[0] && b->wds <= 1) {
 #ifdef SET_INEXACT
 				inexact = 0;
@@ -4291,7 +4101,7 @@ dtoa
 				}
 			if (i >= ilim)
 				break;
-			b = multadd(b, 10, 0);
+			b = multadd(C, b, 10, 0);
 			}
 
 	/* Round off last digit */
@@ -4302,8 +4112,8 @@ dtoa
 	  case 2: goto roundoff;
 	  }
 #endif
-	b = lshift(b, 1);
-	j = cmp(b, S);
+	b = lshift(C, b, 1);
+	j = cmp(C, b, S);
 #ifdef ROUND_BIASED
 	if (j >= 0)
 #else
@@ -4327,11 +4137,11 @@ dtoa
 		s++;
 		}
  ret:
-	Bfree(S);
+	Bfree(C, S);
 	if (mhi) {
 		if (mlo && mlo != mhi)
-			Bfree(mlo);
-		Bfree(mhi);
+			Bfree(C, mlo);
+		Bfree(C, mhi);
 		}
  ret1:
 #ifdef SET_INEXACT
@@ -4345,7 +4155,7 @@ dtoa
 	else if (!oldinexact)
 		clear_inexact();
 #endif
-	Bfree(b);
+	Bfree(C, b);
 	*s = 0;
 	*decpt = k + 1;
 	if (rve)
@@ -4355,3 +4165,106 @@ dtoa
 #ifdef __cplusplus
 }
 #endif
+
+
+
+
+
+
+
+
+/****************************************************************
+ *
+ * The author of this software is David M. Gay.
+ *
+ * Copyright (c) 1991, 1996 by Lucent Technologies.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ *
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHOR NOR LUCENT MAKES ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ *
+ ***************************************************************/
+
+/* g_fmt(buf,x) stores the closest decimal approximation to x in buf;
+ * it suffices to declare buf
+ *	char buf[32];
+ */
+
+ char *
+ jvp_dtoa_fmt(struct dtoa_context* C, register char *b, double x)
+{
+	register int i, k;
+	register char *s;
+	int decpt, j, sign;
+	char *b0, *s0, *se;
+
+	b0 = b;
+#ifdef IGNORE_ZERO_SIGN
+	if (!x) {
+		*b++ = '0';
+		*b = 0;
+		goto done;
+		}
+#endif
+	s = s0 = jvp_dtoa(C, x, 0, 0, &decpt, &sign, &se);
+	if (sign)
+		*b++ = '-';
+	if (decpt == 9999) /* Infinity or Nan */ {
+		while((*b++ = *s++));
+		goto done0;
+		}
+	if (decpt <= -4 || decpt > se - s + 5) {
+		*b++ = *s++;
+		if (*s) {
+			*b++ = '.';
+			while((*b = *s++))
+				b++;
+			}
+		*b++ = 'e';
+		/* sprintf(b, "%+.2d", decpt - 1); */
+		if (--decpt < 0) {
+			*b++ = '-';
+			decpt = -decpt;
+			}
+		else
+			*b++ = '+';
+		for(j = 2, k = 10; 10*k <= decpt; j++, k *= 10);
+		for(;;) {
+			i = decpt / k;
+			*b++ = i + '0';
+			if (--j <= 0)
+				break;
+			decpt -= i*k;
+			decpt *= 10;
+			}
+		*b = 0;
+		}
+	else if (decpt <= 0) {
+		*b++ = '.';
+		for(; decpt < 0; decpt++)
+			*b++ = '0';
+		while((*b++ = *s++));
+		}
+	else {
+		while((*b = *s++)) {
+			b++;
+			if (--decpt == 0 && *s)
+				*b++ = '.';
+			}
+		for(; decpt > 0; decpt--)
+			*b++ = '0';
+		*b = 0;
+		}
+ done0:
+	jvp_freedtoa(C, s0);
+        goto done;
+ done:
+	return b0;
+	}
diff --git a/c/jv_dtoa.h b/c/jv_dtoa.h
new file mode 100644
index 00000000..e9346c0e
--- /dev/null
+++ b/c/jv_dtoa.h
@@ -0,0 +1,20 @@
+
+#define Kmax 7
+
+struct Bigint;
+struct dtoa_context {
+  struct Bigint *freelist[Kmax+1];
+  struct Bigint *p5s;
+};
+
+void jvp_dtoa_context_init(struct dtoa_context* ctx);
+void jvp_dtoa_context_free(struct dtoa_context* ctx);
+
+double jvp_strtod(struct dtoa_context* C, const char* s, char** se);
+
+
+char* jvp_dtoa(struct dtoa_context* C, double dd, int mode, int ndigits, int *decpt, int *sign, char **rve);
+void jvp_freedtoa(struct dtoa_context* C, char *s);
+
+#define JVP_DTOA_FMT_MAX_LEN 32
+char* jvp_dtoa_fmt(struct dtoa_context* C, register char *b, double x);

From 92654f8204cebd88a350ea2a12c2cfb324003e1c Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sat, 1 Sep 2012 18:24:17 +0100
Subject: [PATCH 017/284] Fix a memory leak when inserting into an object with
 an already-present key

---
 c/jv.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/c/jv.c b/c/jv.c
index 09b600d8..6f72c9d4 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -602,6 +602,7 @@ static jv* jvp_object_write(jv_complex* object, jvp_string* key) {
     jvp_string_free_p(key);
   } else {
     slot = jvp_object_add_slot(object, key, bucket);
+    slot->value = jv_null();
   }
   if (slot == 0) {
     jvp_object_rehash(object);
@@ -609,6 +610,7 @@ static jv* jvp_object_write(jv_complex* object, jvp_string* key) {
     assert(!jvp_object_find_slot(object, key, bucket));
     slot = jvp_object_add_slot(object, key, bucket);
     assert(slot);
+    slot->value = jv_null();
   }
   return &slot->value;
 }
@@ -654,7 +656,9 @@ jv jv_object_set(jv object, jv key, jv value) {
   assert(jv_get_kind(object) == JV_KIND_OBJECT);
   assert(jv_get_kind(key) == JV_KIND_STRING);
   // copy/free of object, key, value coalesced
-  *jvp_object_write(&object.val.complex, jvp_string_ptr(&key.val.complex)) = value;
+  jv* slot = jvp_object_write(&object.val.complex, jvp_string_ptr(&key.val.complex));
+  jv_free(*slot);
+  *slot = value;
   return object;
 }
 

From e98624e5a9aaee0cf359d11c1fc4769ec848ea4d Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sat, 1 Sep 2012 19:16:43 +0100
Subject: [PATCH 018/284] First pass at a JSON parser

---
 c/Makefile   |   9 +-
 c/jv.h       |  11 +-
 c/jv_parse.c | 351 +++++++++++++++++++++++++++++++++++++++++++++++++++
 c/jv_print.c |  59 ++++++++-
 c/jvtest.c   |   2 -
 5 files changed, 421 insertions(+), 11 deletions(-)
 create mode 100644 c/jv_parse.c

diff --git a/c/Makefile b/c/Makefile
index b77971da..08e72705 100644
--- a/c/Makefile
+++ b/c/Makefile
@@ -21,11 +21,12 @@ parsertest: parser.tab.c lexer.yy.c main.c opcode.c bytecode.c compile.c execute
 	$(CC) -o $@ $^ -ljansson
 
 jvtest: jvtest.c jv.c jv_print.c
-	$(CC) -o $@ $^ -ljansson
+	$(CC) -DNO_JANSSON -o $@ $^
+
+jv_parse: jv_parse.c jv.c jv_print.c jv_dtoa.c
+	$(CC) -DNO_JANSSON -o $@ $^
+
 
 test: jvtest
 	valgrind --error-exitcode=1 -q --leak-check=full ./jvtest
 
-jsparse: jsparse.l jv.c
-	flex -o jsparse.c jsparse.l
-	gcc -o jsparse jsparse.c -ljansson
\ No newline at end of file
diff --git a/c/jv.h b/c/jv.h
index 52158b72..d815827a 100644
--- a/c/jv.h
+++ b/c/jv.h
@@ -1,10 +1,11 @@
 #ifndef JV_H
 #define JV_H
 
-#include <jansson.h>
 #include <stdint.h>
 #include <assert.h>
-
+#include <stddef.h>
+#ifndef NO_JANSSON
+#include <jansson.h>
 static json_t* jv_lookup(json_t* t, json_t* k) {
   json_t* v;
   if (json_is_object(t) && json_is_string(k)) {
@@ -38,7 +39,7 @@ static json_t* jv_insert(json_t* root, json_t* value, json_t** path, int pathlen
   }
   return jv_modify(root, *path, jv_insert(jv_lookup(root, *path), value, path+1, pathlen-1));
 }
-
+#endif
 
 
 
@@ -116,6 +117,10 @@ jv jv_object_iter_key(jv, int);
 jv jv_object_iter_value(jv, int);
 
 
+void jv_dump(jv);
+
+
+
 #endif
 
 
diff --git a/c/jv_parse.c b/c/jv_parse.c
new file mode 100644
index 00000000..4f7ef019
--- /dev/null
+++ b/c/jv_parse.c
@@ -0,0 +1,351 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "jv.h"
+#include "jv_dtoa.h"
+jv stack[1000];
+int stackpos = 0;
+jv next;
+int hasnext;
+
+typedef const char* presult;
+
+#define TRY(x) do {presult msg__ = (x); if (msg__) return msg__; } while(0)
+#ifdef __GNUC__
+#define pfunc __attribute__((warn_unused_result)) presult
+#else
+#define pfunc presult
+#endif
+
+
+
+pfunc value(jv val) {
+  if (hasnext) return "Expected separator between values";
+  hasnext = 1;
+  next = val;
+  return 0;
+}
+
+void push(jv v) {
+  stack[stackpos++] = v;
+}
+
+pfunc token(char ch) {
+  switch (ch) {
+  case '[':
+    if (hasnext) return "Expected separator between values";
+    push(jv_array());
+    break;
+
+  case '{':
+    if (hasnext) return "Expected separator between values";
+    push(jv_object());
+    break;
+
+  case ':':
+    if (!hasnext) 
+      return "Expected string key before ':'";
+    if (stackpos == 0 || jv_get_kind(stack[stackpos-1]) != JV_KIND_OBJECT)
+      return "':' not as part of an object";
+    if (jv_get_kind(next) != JV_KIND_STRING)
+      return "Object keys must be strings";
+    push(next);
+    hasnext = 0;
+    break;
+
+  case ',':
+    if (!hasnext)
+      return "Expected value before ','";
+    if (stackpos == 0)
+      return "',' not as part of an object or array";
+    if (jv_get_kind(stack[stackpos-1]) == JV_KIND_ARRAY) {
+      stack[stackpos-1] = jv_array_append(stack[stackpos-1], next);
+      hasnext = 0;
+    } else if (jv_get_kind(stack[stackpos-1]) == JV_KIND_STRING) {
+      assert(stackpos > 1 && jv_get_kind(stack[stackpos-2]) == JV_KIND_OBJECT);
+      stack[stackpos-2] = jv_object_set(stack[stackpos-2], stack[stackpos-1], next);
+      stackpos--;
+      hasnext = 0;
+    } else {
+      // this case hits on input like {"a", "b"}
+      return "Objects must consist of key:value pairs";
+    }
+    break;
+
+  case ']':
+    if (stackpos == 0 || jv_get_kind(stack[stackpos-1]) != JV_KIND_ARRAY)
+      return "Unmatched ']'";
+    if (hasnext) {
+      stack[stackpos-1] = jv_array_append(stack[stackpos-1], next);
+      hasnext = 0;
+    } else {
+      if (jv_array_length(jv_copy(stack[stackpos-1])) != 0) {
+        // this case hits on input like [1,2,3,]
+        return "Expected another array element";
+      }
+    }
+    hasnext = 1;
+    next = stack[--stackpos];
+    break;
+
+  case '}':
+    if (stackpos == 0)
+      return "Unmatched '}'";
+    if (hasnext) {
+      if (jv_get_kind(stack[stackpos-1]) != JV_KIND_STRING)
+        return "Objects must consist of key:value pairs";
+      assert(stackpos > 1 && jv_get_kind(stack[stackpos-2]) == JV_KIND_OBJECT);
+      stack[stackpos-2] = jv_object_set(stack[stackpos-2], stack[stackpos-1], next);
+      stackpos--;
+      hasnext = 0;
+    } else {
+      if (jv_get_kind(stack[stackpos-1]) != JV_KIND_OBJECT)
+        return "Unmatched '}'";
+      // FIXME: assert object empty
+    }
+    hasnext = 1;
+    next = stack[--stackpos];
+    break;
+  }
+  return 0;
+}
+
+
+char tokenbuf[1000];
+int tokenpos;
+struct dtoa_context dtoa;
+
+void tokenadd(char c) {
+  tokenbuf[tokenpos++] = c;
+}
+
+int unhex4(char* hex) {
+  int r = 0;
+  for (int i=0; i<4; i++) {
+    char c = *hex++;
+    int n;
+    if ('0' <= c && c <= '9') n = c - '0';
+    else if ('a' <= c && c <= 'f') n = c - 'a' + 10;
+    else if ('A' <= c && c <= 'F') n = c - 'A' + 10;
+    r <<= 4;
+    r |= n;
+  }
+  return r;
+}
+
+int utf8_encode(int codepoint, char* out) {
+  assert(codepoint >= 0 && codepoint <= 0x10FFFF);
+  char* start = out;
+  if (codepoint <= 0x7F) {
+    *out++ = codepoint;
+  } else if (codepoint <= 0x7FF) {
+    *out++ = 0xC0 + ((codepoint & 0x7C0) >> 6);
+    *out++ = 0x80 + ((codepoint & 0x03F));
+  } else if(codepoint <= 0xFFFF) {
+    *out++ = 0xE0 + ((codepoint & 0xF000) >> 12);
+    *out++ = 0x80 + ((codepoint & 0x0FC0) >> 6);
+    *out++ = 0x80 + ((codepoint & 0x003F));
+  } else {
+    *out++ = 0xF0 + ((codepoint & 0x1C0000) >> 18);
+    *out++ = 0x80 + ((codepoint & 0x03F000) >> 12);
+    *out++ = 0x80 + ((codepoint & 0x000FC0) >> 6);
+    *out++ = 0x80 + ((codepoint & 0x00003F));
+  }
+  return out - start;
+}
+
+pfunc found_string() {
+  char* in = tokenbuf;
+  char* out = tokenbuf;
+  char* end = tokenbuf + tokenpos;
+  
+  while (in < end) {
+    char c = *in++;
+    if (c == '\\') {
+      if (in >= end)
+        return "Expected escape character at end of string";
+      c = *in++;
+      switch (c) {
+      case '\\':
+      case '"':
+      case '/': *out++ = c;    break;
+      case 'b': *out++ = '\b'; break;
+      case 'f': *out++ = '\f'; break;
+      case 't': *out++ = '\t'; break;
+      case 'n': *out++ = '\n'; break;
+      case 'r': *out++ = '\r'; break;
+
+      case 'u':
+        /* ahh, the complicated case */
+        if (in + 4 > end)
+          return "Invalid \\uXXXX escape";
+        unsigned long codepoint = unhex4(in);
+        in += 4;
+        if (0xD800 <= codepoint && codepoint <= 0xDBFF) {
+          /* who thought UTF-16 surrogate pairs were a good idea? */
+          if (in + 6 > end || in[0] != '\\' || in[1] != 'u')
+            return "Invalid \\uXXXX\\uXXXX surrogate pair escape";
+          unsigned long surrogate = unhex4(in+2);
+          if (!(0xDC00 <= surrogate && surrogate <= 0xDFFF))
+            return "Invalid \\uXXXX\\uXXXX surrogate pair escape";
+          in += 6;
+          codepoint = 0x10000 + (((codepoint - 0xD800) << 10)
+                                 |(surrogate - 0xDC00));
+        }
+        // FIXME assert valid codepoint
+        out += utf8_encode(codepoint, out);
+        break;
+
+      default:
+        return "Invalid escape";
+      }
+    } else {
+      *out++ = c;
+    }
+  }
+  TRY(value(jv_string_sized(tokenbuf, out - tokenbuf)));
+  tokenpos=0;
+  return 0;
+}
+
+pfunc check_literal() {
+  if (tokenpos == 0) return 0;
+
+  const char* pattern = 0;
+  int plen;
+  jv v;
+  switch (tokenbuf[0]) {
+  case 't': pattern = "true"; plen = 4; v = jv_true(); break;
+  case 'f': pattern = "false"; plen = 5; v = jv_false(); break;
+  case 'n': pattern = "null"; plen = 4; v = jv_null(); break;
+  }
+  if (pattern) {
+    if (tokenpos != plen) return "Invalid literal";
+    for (int i=0; i<plen; i++) 
+      if (tokenbuf[i] != pattern[i])
+        return "Invalid literal";
+    TRY(value(v));
+  } else {
+    // FIXME: better parser
+    tokenbuf[tokenpos] = 0; // FIXME: invalid
+    char* end = 0;
+    double d = jvp_strtod(&dtoa, tokenbuf, &end);
+    if (end == 0 || *end != 0)
+      return "Invalid numeric literal";
+    TRY(value(jv_number(d)));
+  }
+  tokenpos=0;
+  return 0;
+}
+
+typedef enum {
+  LITERAL,
+  WHITESPACE,
+  STRUCTURE,
+  QUOTE,
+  INVALID
+} chclass;
+
+chclass classify(char c) {
+  switch (c) {
+  case ' ':
+  case '\t':
+  case '\r':
+  case '\n':
+    return WHITESPACE;
+  case '"':
+    return QUOTE;
+  case '[':
+  case ',':
+  case ']':
+  case '{':
+  case ':':
+  case '}':
+    return STRUCTURE;
+  default:
+    return LITERAL;
+  }
+}
+
+
+enum state {
+  NORMAL,
+  STRING,
+  STRING_ESCAPE
+};
+
+enum state st = NORMAL;
+
+pfunc scan(char ch) {
+  if (st == NORMAL) {
+    chclass cls = classify(ch);
+    if (cls != LITERAL) {
+      TRY(check_literal());
+    }
+    switch (cls) {
+    case LITERAL:
+      tokenadd(ch);
+      break;
+    case WHITESPACE:
+      break;
+    case QUOTE:
+      st = STRING;
+      break;
+    case STRUCTURE:
+      TRY(token(ch));
+      break;
+    case INVALID:
+      return "Invalid character";
+    }
+  } else {
+    if (ch == '"' && st == STRING) {
+      TRY(found_string());
+      st = NORMAL;
+    } else {
+      tokenadd(ch);
+      if (ch == '\\' && st == STRING) {
+        st = STRING_ESCAPE;
+      } else {
+        st = STRING;
+      }
+    }
+  }
+  return 0;
+}
+
+pfunc finish() {
+  assert(st == NORMAL);
+  TRY(check_literal());
+
+  if (stackpos != 0)
+    return "Unfinished JSON term";
+  
+  // this will happen on the empty string
+  if (!hasnext)
+    return "Expected JSON value";
+  
+  return 0;
+}
+
+
+int main(int argc, char* argv[]) {
+  assert(argc == 2);
+  jvp_dtoa_context_init(&dtoa);
+  char* p = argv[1];
+  char ch;
+  while ((ch = *p++)) {
+    presult msg = scan(ch);
+    if (msg){
+      printf("ERROR: %s\n", msg);
+      return 1;
+    }
+  }
+  presult msg = finish();
+  if (msg) {
+    printf("ERROR: %s\n", msg);
+    return 1;
+  }
+  jvp_dtoa_context_free(&dtoa);
+  jv_dump(next);
+  printf("\n");
+  return 0;
+}
diff --git a/c/jv_print.c b/c/jv_print.c
index b26d0b36..c082e935 100644
--- a/c/jv_print.c
+++ b/c/jv_print.c
@@ -1,7 +1,55 @@
 #include "jv.h"
 #include <stdio.h>
 
-void jv_dump(jv x) {
+#include "jv_dtoa.h"
+
+static void jv_dump_string(jv str, int ascii_only) {
+  assert(jv_get_kind(str) == JV_KIND_STRING);
+  const char* i = jv_string_value(str);
+  const char* end = i + jv_string_length(str);
+  while (i < end) {
+    int unicode_escape;
+    int c = (unsigned char)*i++;
+    if (0x20 <= c && c <= 0x7E) {
+      // printable ASCII
+      if (c == '"' || c == '\\') {
+        putchar('\\');
+      }
+      putchar(c);
+      unicode_escape = 0;
+    } else if (c < 0x20 || c == 0x7F) {
+      // ASCII control character
+      switch (c) {
+      case '\b':
+        putchar('\\');
+        putchar('b');
+        break;
+      case '\t':
+        putchar('\\');
+        putchar('t');
+        break;
+      case '\r':
+        putchar('\\');
+        putchar('r');
+        break;
+      case '\n':
+        putchar('\\');
+        putchar('n');
+        break;
+      case '\f':
+        putchar('\\');
+        putchar('f');
+        break;
+      default:
+        unicode_escape = 1;
+        break;
+      }
+    }
+  }
+}
+
+static void jv_dump_term(struct dtoa_context* C, jv x) {
+  char buf[JVP_DTOA_FMT_MAX_LEN];
   switch (jv_get_kind(x)) {
   case JV_KIND_NULL:
     printf("null");
@@ -13,7 +61,7 @@ void jv_dump(jv x) {
     printf("true");
     break;
   case JV_KIND_NUMBER:
-    printf("%f", jv_number_value(x));
+    printf("%s", jvp_dtoa_fmt(C, buf, jv_number_value(x)));
     break;
   case JV_KIND_STRING:
     // FIXME: all sorts of broken
@@ -43,3 +91,10 @@ void jv_dump(jv x) {
   }
   jv_free(x);
 }
+
+void jv_dump(jv x) {
+  struct dtoa_context C;
+  jvp_dtoa_context_init(&C);
+  jv_dump_term(&C, x);
+  jvp_dtoa_context_free(&C);
+}
diff --git a/c/jvtest.c b/c/jvtest.c
index 667d706b..2b5a6276 100644
--- a/c/jvtest.c
+++ b/c/jvtest.c
@@ -3,8 +3,6 @@
 #include <string.h>
 #include "jv.h"
 
-void jv_dump(jv);
-
 int main(){
   /// Arrays and numbers
   {

From 22f8aed31e54dc801e9682c93cdbf51d8a83a303 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 2 Sep 2012 00:24:23 +0100
Subject: [PATCH 019/284] Validation for empty objects

Now (correctly) fails to parse {,}
---
 c/jv.c       | 16 ++++++++++++++++
 c/jv.h       |  1 +
 c/jv_parse.c |  3 ++-
 3 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/c/jv.c b/c/jv.c
index 6f72c9d4..3029904b 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -632,6 +632,15 @@ static int jvp_object_delete(jv_complex* object, jvp_string* key) {
   return 0;
 }
 
+static int jvp_object_length(jv_complex* object) {
+  int n = 0;
+  for (int i=0; i<jvp_object_size(object); i++) {
+    struct object_slot* slot = jvp_object_get_slot(object, i);
+    if (slot->string) n++;
+  }
+  return n;
+}
+
 /*
  * Objects (public interface)
  */
@@ -670,6 +679,13 @@ jv jv_object_delete(jv object, jv key) {
   return object;
 }
 
+int jv_object_length(jv object) {
+  assert(jv_get_kind(object) == JV_KIND_OBJECT);
+  int n = jvp_object_length(&object.val.complex);
+  jv_free(object);
+  return n;
+}
+
 /*
  * Object iteration (internal helpers)
  */
diff --git a/c/jv.h b/c/jv.h
index d815827a..44fe4798 100644
--- a/c/jv.h
+++ b/c/jv.h
@@ -109,6 +109,7 @@ jv jv_object();
 jv jv_object_get(jv object, jv key);
 jv jv_object_set(jv object, jv key, jv value);
 jv jv_object_delete(jv object, jv key);
+int jv_object_length(jv object);
 
 int jv_object_iter(jv);
 int jv_object_iter_next(jv, int);
diff --git a/c/jv_parse.c b/c/jv_parse.c
index 4f7ef019..31e8d68d 100644
--- a/c/jv_parse.c
+++ b/c/jv_parse.c
@@ -100,7 +100,8 @@ pfunc token(char ch) {
     } else {
       if (jv_get_kind(stack[stackpos-1]) != JV_KIND_OBJECT)
         return "Unmatched '}'";
-      // FIXME: assert object empty
+      if (jv_object_length(jv_copy(stack[stackpos-1])) != 0)
+        return "Expected another key-value pair";
     }
     hasnext = 1;
     next = stack[--stackpos];

From 2cb9a6e61dd9605cfd24d44695be5f0a1a00aaba Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 2 Sep 2012 16:31:59 +0100
Subject: [PATCH 020/284] Move from Jansson to JV - everything but the
 interpreter loop

Passes valgrind --leak-check=full.
---
 c/Makefile   |  2 +-
 c/builtin.c  | 30 ++++++++---------
 c/bytecode.c | 22 +++++++++++--
 c/bytecode.h |  9 ++++--
 c/compile.c  | 16 +++++----
 c/compile.h  |  2 +-
 c/jv.c       |  6 ++--
 c/jv.h       | 91 ++++++++++++++++++++++++++++++----------------------
 c/jv_parse.c | 24 ++++++++------
 c/lexer.l    |  4 +--
 c/main.c     | 36 ++++++++++++---------
 c/parser.y   | 51 +++++++++++++++--------------
 12 files changed, 170 insertions(+), 123 deletions(-)

diff --git a/c/Makefile b/c/Makefile
index 08e72705..bf33acf3 100644
--- a/c/Makefile
+++ b/c/Makefile
@@ -24,7 +24,7 @@ jvtest: jvtest.c jv.c jv_print.c
 	$(CC) -DNO_JANSSON -o $@ $^
 
 jv_parse: jv_parse.c jv.c jv_print.c jv_dtoa.c
-	$(CC) -DNO_JANSSON -o $@ $^
+	$(CC) -DNO_JANSSON -o $@ $^ -DJV_PARSE_MAIN
 
 
 test: jvtest
diff --git a/c/builtin.c b/c/builtin.c
index ef37c28c..0252566a 100644
--- a/c/builtin.c
+++ b/c/builtin.c
@@ -1,28 +1,24 @@
 #include "builtin.h"
 
-#include <jansson.h>
-
-
-static void f_false(json_t* input[], json_t* output[]) {
-  output[0] = json_false();
+static void f_false(jv input[], jv output[]) {
+  output[0] = jv_false();
 }
 
-static void f_true(json_t* input[], json_t* output[]) {
-  output[0] = json_true();
+static void f_true(jv input[], jv output[]) {
+  output[0] = jv_true();
 }
 
 
-static void f_plus(json_t* input[], json_t* output[]) {
-  json_t* a = input[2];
-  json_t* b = input[1];
-  if (json_is_number(a) && json_is_number(b)) {
-    output[0] = json_real(json_number_value(a) + 
-                          json_number_value(b));
-  } else if (json_is_array(a) && json_is_array(b)) {
-    output[0] = json_copy(a);
-    json_array_extend(output[0], b);
+static void f_plus(jv input[], jv output[]) {
+  jv a = input[2];
+  jv b = input[1];
+  if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
+    output[0] = jv_number(jv_number_value(a) + 
+                          jv_number_value(b));
+  } else if (jv_get_kind(a) == JV_KIND_ARRAY && jv_get_kind(b) == JV_KIND_ARRAY) {
+    output[0] = jv_array_concat(a, b);
   } else {
-    output[0] = json_string("wtf gaize");
+    output[0] = jv_string("wtf gaize");
   }
 }
 
diff --git a/c/bytecode.c b/c/bytecode.c
index ef585bd7..208e82f0 100644
--- a/c/bytecode.c
+++ b/c/bytecode.c
@@ -1,6 +1,7 @@
 #include <stdio.h>
 #include <stdint.h>
-#include <jansson.h>
+#include <stdlib.h>
+
 #include "bytecode.h"
 #include "opcode.h"
 
@@ -57,8 +58,7 @@ void dump_operation(struct bytecode* bc, uint16_t* codeptr) {
       printf(" %04d", pc + imm);
     } else if (op->flags & OP_HAS_CONSTANT) {
       printf(" ");
-      json_dumpf(json_array_get(bc->constants, imm),
-                 stdout, JSON_ENCODE_ANY);
+      jv_dump(jv_array_get(jv_copy(bc->constants), imm));
     } else if (op->flags & OP_HAS_VARIABLE) {
       uint16_t v = bc->code[pc++];
       printf(" v%d", v);
@@ -70,3 +70,19 @@ void dump_operation(struct bytecode* bc, uint16_t* codeptr) {
     }
   }  
 }
+
+void symbol_table_free(struct symbol_table* syms) {
+  free(syms->cfunctions);
+  free(syms);
+}
+
+void bytecode_free(struct bytecode* bc) {
+  free(bc->code);
+  jv_free(bc->constants);
+  for (int i=0; i<bc->nsubfunctions; i++)
+    bytecode_free(bc->subfunctions[i]);
+  if (!bc->parent)
+    symbol_table_free(bc->globals);
+  free(bc->subfunctions);
+  free(bc);
+}
diff --git a/c/bytecode.h b/c/bytecode.h
index b1146ad7..5ffe80a6 100644
--- a/c/bytecode.h
+++ b/c/bytecode.h
@@ -1,11 +1,11 @@
 #ifndef BYTECODE_H
 #define BYTECODE_H
-#include <jansson.h>
 #include <stdint.h>
 
+#include "jv.h"
 #include "opcode.h"
 
-typedef void (*cfunction_ptr)(json_t* input[], json_t* output[]);
+typedef void (*cfunction_ptr)(jv input[], jv output[]);
 
 struct cfunction {
   cfunction_ptr fptr;
@@ -33,7 +33,7 @@ struct bytecode {
   int nlocals;
   int nclosures;
 
-  json_t* constants;
+  jv constants; // JSON array of constants
   struct symbol_table* globals;
 
   struct bytecode** subfunctions;
@@ -46,4 +46,7 @@ void dump_disassembly(int, struct bytecode* code);
 void dump_code(int, struct bytecode* code);
 void dump_operation(struct bytecode* bc, uint16_t* op);
 
+void symbol_table_free(struct symbol_table* syms);
+void bytecode_free(struct bytecode* bc);
+
 #endif
diff --git a/c/compile.c b/c/compile.c
index dc90aed3..b7fcc4f2 100644
--- a/c/compile.c
+++ b/c/compile.c
@@ -1,5 +1,6 @@
 #include <assert.h>
 #include <string.h>
+#include <stdlib.h>
 #include "opcode.h"
 #include "compile.h"
 
@@ -13,7 +14,7 @@ struct inst {
   union {
     uint16_t intval;
     struct inst* target;
-    json_t* constant;
+    jv constant;
     struct cfunction* cfunc;
   } imm;
 
@@ -52,6 +53,9 @@ static void inst_free(struct inst* i) {
   if (opcode_describe(i->op)->flags & OP_HAS_BLOCK) {
     block_free(i->subfn);
   }
+  if (opcode_describe(i->op)->flags & OP_HAS_CONSTANT) {
+    jv_free(i->imm.constant);
+  }
   free(i);
 }
 
@@ -89,7 +93,7 @@ block gen_op_simple(opcode op) {
 }
 
 
-block gen_op_const(opcode op, json_t* constant) {
+block gen_op_const(opcode op, jv constant) {
   assert(opcode_describe(op)->flags & OP_HAS_CONSTANT);
   inst* i = inst_new(op);
   i->imm.constant = constant;
@@ -267,7 +271,7 @@ block gen_both(block a, block b) {
 block gen_collect(block expr) {
   block c = gen_noop();
   block_append(&c, gen_op_simple(DUP));
-  block_append(&c, gen_op_const(LOADK, json_array()));
+  block_append(&c, gen_op_const(LOADK, jv_array()));
   block array_var = block_bind(gen_op_var_unbound(STOREV, "collect"),
                                gen_noop(), OP_HAS_VARIABLE);
   block_append(&c, array_var);
@@ -395,7 +399,7 @@ static void compile(struct bytecode* bc, block b) {
   uint16_t* code = malloc(sizeof(uint16_t) * bc->codelen);
   bc->code = code;
   pos = 0;
-  json_t* constant_pool = json_array();
+  jv constant_pool = jv_array();
   int maxvar = -1;
   for (inst* curr = b.first; curr; curr = curr->next) {
     const struct opcode_description* op = opcode_describe(curr->op);
@@ -436,8 +440,8 @@ static void compile(struct bytecode* bc, block b) {
       }
       assert(nargs - 1 == desired_params);
     } else if (opflags & OP_HAS_CONSTANT) {
-      code[pos++] = json_array_size(constant_pool);
-      json_array_append(constant_pool, curr->imm.constant);
+      code[pos++] = jv_array_length(jv_copy(constant_pool));
+      constant_pool = jv_array_append(constant_pool, jv_copy(curr->imm.constant));
     } else if (opflags & OP_HAS_VARIABLE) {
       code[pos++] = nesting_level(bc, curr->bound_by);
       uint16_t var = (uint16_t)curr->bound_by->imm.intval;
diff --git a/c/compile.h b/c/compile.h
index 4c0a3a17..5f0be89b 100644
--- a/c/compile.h
+++ b/c/compile.h
@@ -13,7 +13,7 @@ typedef struct block {
 
 block gen_noop();
 block gen_op_simple(opcode op);
-block gen_op_const(opcode op, json_t* constant);
+block gen_op_const(opcode op, jv constant);
 block gen_op_target(opcode op, block target);
 block gen_op_var_unbound(opcode op, const char* name);
 block gen_op_var_bound(opcode op, block binder);
diff --git a/c/jv.c b/c/jv.c
index 3029904b..7944d642 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -278,7 +278,7 @@ static jvp_string* jvp_string_alloc(uint32_t size) {
   return s;
 }
 
-static jv_complex jvp_string_new(char* data, uint32_t length) {
+static jv_complex jvp_string_new(const char* data, uint32_t length) {
   jvp_string* s = jvp_string_alloc(length);
   memcpy(s->data, data, length);
   s->data[length] = 0;
@@ -389,14 +389,14 @@ static int jvp_string_equal(jv_complex* a, jv_complex* b) {
  * Strings (public API)
  */
 
-jv jv_string_sized(char* str, int len) {
+jv jv_string_sized(const char* str, int len) {
   jv j;
   j.kind = JV_KIND_STRING;
   j.val.complex = jvp_string_new(str, len);
   return j;
 }
 
-jv jv_string(char* str) {
+jv jv_string(const char* str) {
   return jv_string_sized(str, strlen(str));
 }
 
diff --git a/c/jv.h b/c/jv.h
index 44fe4798..7696b03b 100644
--- a/c/jv.h
+++ b/c/jv.h
@@ -4,42 +4,6 @@
 #include <stdint.h>
 #include <assert.h>
 #include <stddef.h>
-#ifndef NO_JANSSON
-#include <jansson.h>
-static json_t* jv_lookup(json_t* t, json_t* k) {
-  json_t* v;
-  if (json_is_object(t) && json_is_string(k)) {
-    v = json_object_get(t, json_string_value(k));
-  } else if (json_is_array(t) && json_is_number(k)) {
-    v = json_array_get(t, json_integer_value(k));
-  } else {
-    assert(0&&"bad lookup");
-  }
-  if (v) 
-    return v;
-  else
-    return json_null();
-}
-
-static json_t* jv_modify(json_t* t, json_t* k, json_t* v) {
-  t = json_copy(t);
-  if (json_is_object(t) && json_is_string(k)) {
-    json_object_set(t, json_string_value(k), v);
-  } else if (json_is_array(t) && json_is_number(k)) {
-    json_array_set(t, json_integer_value(k), v);
-  } else {
-    assert(0 && "bad mod");
-  }
-  return t;
-}
-
-static json_t* jv_insert(json_t* root, json_t* value, json_t** path, int pathlen) {
-  if (pathlen == 0) {
-    return value;
-  }
-  return jv_modify(root, *path, jv_insert(jv_lookup(root, *path), value, path+1, pathlen-1));
-}
-#endif
 
 
 
@@ -99,8 +63,8 @@ jv jv_array_concat(jv, jv);
 jv jv_array_slice(jv, int, int);
 
 
-jv jv_string(char*);
-jv jv_string_sized(char*, int);
+jv jv_string(const char*);
+jv jv_string_sized(const char*, int);
 int jv_string_length(jv);
 uint32_t jv_string_hash(jv);
 const char* jv_string_value(jv);
@@ -119,6 +83,57 @@ jv jv_object_iter_value(jv, int);
 
 
 void jv_dump(jv);
+jv jv_parse(const char* string);
+
+
+
+
+
+static jv jv_lookup(jv t, jv k) {
+  jv v;
+  if (jv_get_kind(t) == JV_KIND_OBJECT && jv_get_kind(k) == JV_KIND_STRING) {
+    v = jv_object_get(t, k);
+  } else if (jv_get_kind(t) == JV_KIND_ARRAY && jv_get_kind(k) == JV_KIND_NUMBER) {
+    // FIXME: don't do lookup for noninteger index
+    v = jv_array_get(t, (int)jv_number_value(k));
+  } else {
+    assert(0&&"bad lookup");
+  }
+  return v;
+  // FIXME: invalid indexes, JV_KIND_INVALID
+  /*
+  if (v) 
+    return v;
+  else
+    return jv_null();
+  */
+}
+
+static jv jv_modify(jv t, jv k, jv v) {
+  if (jv_get_kind(t) == JV_KIND_OBJECT && jv_get_kind(k) == JV_KIND_STRING) {
+    t = jv_object_set(t, k, v);
+  } else if (jv_get_kind(t) == JV_KIND_ARRAY && jv_get_kind(k) == JV_KIND_NUMBER) {
+    t = jv_array_set(t, (int)jv_number_value(k), v);
+  } else {
+    assert(0 && "bad mod");
+  }
+  return t;
+}
+
+static jv jv_insert(jv root, jv value, jv* path, int pathlen) {
+  if (pathlen == 0) {
+    jv_free(root);
+    return value;
+  }
+  return jv_modify(root, *path, 
+                   jv_insert(jv_lookup(jv_copy(root), jv_copy(*path)), value, path+1, pathlen-1));
+}
+
+
+
+
+
+
 
 
 
diff --git a/c/jv_parse.c b/c/jv_parse.c
index 31e8d68d..26c2cc38 100644
--- a/c/jv_parse.c
+++ b/c/jv_parse.c
@@ -327,26 +327,32 @@ pfunc finish() {
   return 0;
 }
 
-
-int main(int argc, char* argv[]) {
-  assert(argc == 2);
+jv jv_parse(const char* string) {
   jvp_dtoa_context_init(&dtoa);
-  char* p = argv[1];
+
+  const char* p = string;
   char ch;
   while ((ch = *p++)) {
     presult msg = scan(ch);
     if (msg){
-      printf("ERROR: %s\n", msg);
-      return 1;
+      printf("ERROR: %s (parsing [%s])\n", msg, string);
+      return jv_null();
     }
   }
   presult msg = finish();
   if (msg) {
-    printf("ERROR: %s\n", msg);
-    return 1;
+    printf("ERROR: %s (parsing [%s])\n", msg, string);
+    return jv_null();
   }
   jvp_dtoa_context_free(&dtoa);
-  jv_dump(next);
+  hasnext = 0;
+  return next;
+}
+#if JV_PARSE_MAIN
+int main(int argc, char* argv[]) {
+  assert(argc == 2);
+  jv_dump(jv_parse(argv[1]));
   printf("\n");
   return 0;
 }
+#endif
diff --git a/c/lexer.l b/c/lexer.l
index e4ffafce..34253b01 100644
--- a/c/lexer.l
+++ b/c/lexer.l
@@ -15,8 +15,8 @@
 "|=" { return SETPIPE; }
 "."|"="|";"|"["|"]"|","|":"|"("|")"|"{"|"}"|"|"|"+"|"\$" { return yytext[0];}
 
-[[:digit:]]+  { yylval->num = atoi(yytext);   return NUMBER;}
-[[:alnum:]]+  { yylval->str = strdup(yytext); return IDENT;}
+[[:digit:]]+  { yylval->literal = jv_number((double)atoi(yytext));   return LITERAL;}
+[[:alnum:]]+  { yylval->literal = jv_string(yytext); return IDENT;}
 [ \n\t]+  {}
 %%
 /* perhaps these should be calls... */
diff --git a/c/main.c b/c/main.c
index c03b5a99..56d8d1d2 100644
--- a/c/main.c
+++ b/c/main.c
@@ -2,13 +2,14 @@
 #include "compile.h"
 #include "parser.tab.h"
 #include "builtin.h"
+#include "jv.h"
 
 block compile(const char* str);
 
-void jq_init(struct bytecode* bc, json_t* value);
-json_t* jq_next();
+//void jq_init(struct bytecode* bc, jv value);
+//jv jq_next();
 
-void run_program(struct bytecode* bc);
+//void run_program(struct bytecode* bc);
 
 int skipline(const char* buf) {
   int p = 0;
@@ -30,41 +31,44 @@ void run_tests() {
     block program = compile(buf);
     block_append(&program, gen_op_simple(YIELD));
     block_append(&program, gen_op_simple(BACKTRACK));
-    struct bytecode* bc = block_compile(gen_cbinding(&builtins, program));
+    program = gen_cbinding(&builtins, program);
+    struct bytecode* bc = block_compile(program);
     block_free(program);
     printf("Disassembly:\n");
     dump_disassembly(2, bc);
     printf("\n");
     fgets(buf, sizeof(buf), testdata);
-    json_t* input = json_loads(buf, JSON_DECODE_ANY, 0);
-    jq_init(bc, input);
+    jv input = jv_parse(buf);
+    jv_free(input); //jq_init(bc, input);
 
     while (fgets(buf, sizeof(buf), testdata)) {
       if (skipline(buf)) break;
-      json_t* expected = json_loads(buf, JSON_DECODE_ANY, 0);
-      json_t* actual = jq_next();
-      if (!actual) {
+      jv expected = jv_parse(buf);
+      //jv actual = jq_next(); FIXME
+      jv actual = jv_copy(expected);
+      if (!1) {
         printf("Insufficient results\n");
         pass = 0;
         break;
-      } else if (!json_equal(expected, actual)) {
+      } else if (!jv_equal(expected, actual)) {
         printf("Expected ");
-        json_dumpf(expected, stdout, JSON_ENCODE_ANY);
+        jv_dump(expected);
         printf(", but got ");
-        json_dumpf(actual, stdout, JSON_ENCODE_ANY);
+        jv_dump(actual);
         printf("\n");
         pass = 0;
       }
     }
-    if (pass) {
-      json_t* extra = jq_next();
+    if (pass && 0) { /*
+      jv extra = jq_next();
       if (extra) {
         printf("Superfluous result: ");
         json_dumpf(extra, stdout, JSON_ENCODE_ANY);
         printf("\n");
         pass = 0;
-      }
+        }*/
     }
+    bytecode_free(bc);
     tests++;
     passed+=pass;
   }
@@ -80,5 +84,5 @@ int main(int argc, char* argv[]) {
   block_free(blk);
   dump_disassembly(0, bc);
   printf("\n");
-  run_program(bc);
+  //run_program(bc);
 }
diff --git a/c/parser.y b/c/parser.y
index 5ec03892..14a338a7 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -7,8 +7,7 @@
 %locations
 %define api.pure
 %union {
-  int num;
-  char* str;
+  jv literal;
   block blk;
 }
 
@@ -17,8 +16,8 @@
 %lex-param {yyscan_t lexer}
 
 
-%token <str> IDENT
-%token <num> NUMBER
+%token <literal> IDENT
+%token <literal> LITERAL
 
  /* revolting hack */
 %left ';'
@@ -48,10 +47,6 @@ static block gen_dictpair(block k, block v) {
   return b;
 }
 
-static block gen_string(const char* str) {
-  return gen_op_const(LOADK, json_string(str));
-}
-
 static block gen_index(block obj, block key) {
   return block_join(obj, block_join(gen_subexp(key), gen_op_simple(INDEX)));
 }
@@ -64,18 +59,23 @@ program: Exp { *answer = $1; }
 Exp:
 "def" IDENT ':' Exp ';' Exp {
   block body = block_join($4, gen_op_simple(RET));
-  $$ = block_bind(gen_op_block_defn(CLOSURE_CREATE, $2, body), $6, OP_IS_CALL_PSEUDO);
+  $$ = block_bind(gen_op_block_defn(CLOSURE_CREATE, jv_string_value($2), body), 
+                  $6, OP_IS_CALL_PSEUDO);
+  jv_free($2);
 } |
 
 "def" IDENT '(' IDENT ')' ':' Exp ';' Exp {
-  block body = block_bind(gen_op_block_unbound(CLOSURE_PARAM, $4), block_join($7, gen_op_simple(RET)), OP_IS_CALL_PSEUDO);
-  $$ = block_bind(gen_op_block_defn(CLOSURE_CREATE, $2, body), $9, OP_IS_CALL_PSEUDO);
+  block body = block_bind(gen_op_block_unbound(CLOSURE_PARAM, jv_string_value($4)), block_join($7, gen_op_simple(RET)), OP_IS_CALL_PSEUDO);
+  $$ = block_bind(gen_op_block_defn(CLOSURE_CREATE, jv_string_value($2), body), $9, OP_IS_CALL_PSEUDO);
+  jv_free($2);
+  jv_free($4);
 } |
 
 Term "as" '$' IDENT '|' Exp {
   $$ = gen_op_simple(DUP);
   block_append(&$$, $1);
-  block_append(&$$, block_bind(gen_op_var_unbound(STOREV, $4), $6, OP_HAS_VARIABLE));
+  block_append(&$$, block_bind(gen_op_var_unbound(STOREV, jv_string_value($4)), $6, OP_HAS_VARIABLE));
+  jv_free($4);
 } |
 
 Exp '=' Exp {
@@ -129,10 +129,10 @@ Term:
   $$ = gen_noop(); 
 } |
 Term '.' IDENT {
-  $$ = gen_index($1, gen_string($3)); 
+  $$ = gen_index($1, gen_op_const(LOADK, $3)); 
 } |
 '.' IDENT { 
-  $$ = gen_index(gen_noop(), gen_string($2)); 
+  $$ = gen_index(gen_noop(), gen_op_const(LOADK, $2)); 
 } |
 /* FIXME: string literals */
 Term '[' Exp ']' {
@@ -141,8 +141,8 @@ Term '[' Exp ']' {
 Term '[' ']' {
   $$ = block_join($1, gen_op_simple(EACH)); 
 } |
-NUMBER {
-  $$ = gen_op_const(LOADK, json_integer($1)); 
+LITERAL {
+  $$ = gen_op_const(LOADK, $1); 
 } |
 '(' Exp ')' { 
   $$ = $2; 
@@ -151,26 +151,29 @@ NUMBER {
   $$ = gen_collect($2); 
 } |
 '[' ']' { 
-  $$ = gen_op_const(LOADK, json_array()); 
+  $$ = gen_op_const(LOADK, jv_array()); 
 } |
 '{' MkDict '}' { 
-  $$ = gen_subexp(gen_op_const(LOADK, json_object()));
+  $$ = gen_subexp(gen_op_const(LOADK, jv_object()));
   block_append(&$$, $2);
   block_append(&$$, gen_op_simple(POP));
 } |
 '$' IDENT {
-  $$ = gen_op_var_unbound(LOADV, $2); 
+  $$ = gen_op_var_unbound(LOADV, jv_string_value($2)); 
+  jv_free($2);
 } | 
 IDENT {
-  $$ = gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, $1));
+  $$ = gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, jv_string_value($1)));
+  jv_free($1);
 } |
 IDENT '(' Exp ')' {
   $$ = gen_op_call(CALL_1_1, 
-                   block_join(gen_op_block_unbound(CLOSURE_REF, $1),
+                   block_join(gen_op_block_unbound(CLOSURE_REF, jv_string_value($1)),
                               block_bind(gen_op_block_defn(CLOSURE_CREATE,
                                                 "lambda",
                                                            block_join($3, gen_op_simple(RET))),
                                          gen_noop(), OP_IS_CALL_PSEUDO)));
+  jv_free($1);
 }
 
 MkDict:
@@ -184,11 +187,11 @@ MkDictPair
 
 MkDictPair
 : IDENT ':' ExpD { 
-  $$ = gen_dictpair(gen_string($1), $3);
+  $$ = gen_dictpair(gen_op_const(LOADK, $1), $3);
  }
 | IDENT {
-  $$ = gen_dictpair(gen_string($1),
-                    gen_index(gen_noop(), gen_string($1)));
+  $$ = gen_dictpair(gen_op_const(LOADK, jv_copy($1)),
+                    gen_index(gen_noop(), gen_op_const(LOADK, $1)));
   }
 | '(' Exp ')' ':' ExpD {
   $$ = gen_dictpair($2, $5);

From f72c5ffac0dd03bafd01b73011e8409371429326 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 2 Sep 2012 17:20:13 +0100
Subject: [PATCH 021/284] Move from Jansson to JV - interpreter loop

Passes tests, but leaks some memory.
---
 c/Makefile         |   4 +-
 c/execute.c        | 146 ++++++++++++++++++++++-----------------------
 c/execute.h        |  14 -----
 c/forkable_stack.h |   6 +-
 c/frame_layout.h   |   8 ++-
 c/jv.c             |   2 +-
 c/main.c           |  13 ++--
 7 files changed, 90 insertions(+), 103 deletions(-)
 delete mode 100644 c/execute.h

diff --git a/c/Makefile b/c/Makefile
index bf33acf3..2e598204 100644
--- a/c/Makefile
+++ b/c/Makefile
@@ -17,8 +17,8 @@ parser.tab.c: parser.y lexer.yy.h
 	bison -W -d parser.y -v --report-file=parser.info
 parser.tab.h: parser.tab.c
 
-parsertest: parser.tab.c lexer.yy.c main.c opcode.c bytecode.c compile.c execute.c builtin.c
-	$(CC) -o $@ $^ -ljansson
+parsertest: parser.tab.c lexer.yy.c main.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c
+	$(CC) -o $@ $^
 
 jvtest: jvtest.c jv.c jv_print.c
 	$(CC) -DNO_JANSSON -o $@ $^
diff --git a/c/execute.c b/c/execute.c
index 9aa85b29..46779363 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -1,10 +1,8 @@
-#include <jansson.h>
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
 
-
 #include "opcode.h"
 #include "bytecode.h"
 #include "compile.h"
@@ -16,16 +14,16 @@
 
 
 typedef struct {
-  json_t* value;
+  jv value;
   int pathidx;
 } stackval;
 
 
-json_t** pathbuf;
+jv* pathbuf;
 int pathsize; // number of allocated elements
 
-
-int path_push(stackval sv, json_t* val) {
+// FIXME mem
+int path_push(stackval sv, jv val) {
   int pos = sv.pathidx;
   assert(pos <= pathsize);
   assert(pos >= 0);
@@ -37,14 +35,15 @@ int path_push(stackval sv, json_t* val) {
   return pos + 1;
 }
 
-stackval stackval_replace(stackval value, json_t* newjs) {
+stackval stackval_replace(stackval value, jv newjs) {
+  jv_free(value.value);
   stackval s = {newjs, value.pathidx};
   return s;
 }
 
 
 // Probably all uses of this function are bugs
-stackval stackval_root(json_t* v) {
+stackval stackval_root(jv v) {
   stackval s = {v, 0};
   return s;
 }
@@ -63,7 +62,9 @@ void stk_push(stackval val) {
 stackval stk_pop() {
   data_stk_elem* s = forkable_stack_peek(&data_stk);
   stackval sv = s->sv;
-  forkable_stack_pop(&data_stk);
+  if (!forkable_stack_pop(&data_stk)) {
+    sv.value = jv_copy(sv.value);
+  }
   return sv;
 }
 
@@ -118,9 +119,9 @@ static struct closure make_closure(struct forkable_stack* stk, frame_ptr fr, uin
 
 #define ON_BACKTRACK(op) ((op)+NUM_OPCODES)
 
-json_t* jq_next() {
-  json_t* cfunc_input[MAX_CFUNCTION_ARGS] = {0};
-  json_t* cfunc_output[MAX_CFUNCTION_ARGS] = {0};
+jv jq_next() {
+  jv cfunc_input[MAX_CFUNCTION_ARGS];
+  jv cfunc_output[MAX_CFUNCTION_ARGS];
 
   assert(!forkable_stack_empty(&frame_stk));
   uint16_t* pc = *frame_current_retaddr(&frame_stk);
@@ -143,7 +144,7 @@ json_t* jq_next() {
       } else {
         param = forkable_stack_peek_next(&data_stk, param);
       }
-      json_dumpf(param->sv.value, stdout, JSON_ENCODE_ANY);
+      jv_dump(jv_copy(param->sv.value));
       if (i < opdesc->stack_in-1) printf(" | ");
     }
 
@@ -159,16 +160,18 @@ json_t* jq_next() {
     default: assert(0 && "invalid instruction");
 
     case LOADK: {
-      json_t* v = json_array_get(frame_current_bytecode(&frame_stk)->constants, *pc++);
-      assert(v);
+      jv v = jv_array_get(jv_copy(frame_current_bytecode(&frame_stk)->constants), *pc++);
+      //FIXME assert(v);
       stack_push(stackval_replace(stack_pop(), v));
       break;
     }
 
     case DUP: {
       stackval v = stack_pop();
+      stackval v2 = v;
+      v2.value = jv_copy(v.value);
       stack_push(v);
-      stack_push(v);
+      stack_push(v2);
       break;
     }
 
@@ -181,44 +184,42 @@ json_t* jq_next() {
     }
       
     case POP: {
-      stack_pop();
+      jv_free(stack_pop().value);
       break;
     }
 
     case APPEND: {
       // FIXME paths
-      json_t* v = stack_pop().value;
-      json_t* array = stack_pop().value;
-      array = json_copy(array);
-      json_array_append(array, v);
+      jv v = stack_pop().value;
+      jv array = stack_pop().value;
+      array = jv_array_append(array, v);
       stack_push(stackval_root(array));
       break;
     }
 
     case INSERT: {
       stackval stktop = stack_pop();
-      json_t* v = stack_pop().value;
-      json_t* k = stack_pop().value;
+      jv v = stack_pop().value;
+      jv k = stack_pop().value;
       stackval objv = stack_pop();
-      assert(json_is_string(k));
-      assert(json_is_object(objv.value));
-      json_t* obj = json_copy(objv.value);
-      json_object_set(obj, json_string_value(k), v);
-      assert(json_is_object(obj));
-      stack_push(stackval_replace(objv, obj));
+      assert(jv_get_kind(k) == JV_KIND_STRING);
+      assert(jv_get_kind(objv.value) == JV_KIND_OBJECT);
+      objv.value = jv_object_set(objv.value, k, v);
+      stack_push(objv);
       stack_push(stktop);
       break;
     }
 
+      // FIXME: loadv/storev may do too much copying/freeing
     case LOADV: {
       uint16_t level = *pc++;
       uint16_t v = *pc++;
       frame_ptr fp = frame_get_level(&frame_stk, frame_current(&frame_stk), level);
-      json_t** var = frame_local_var(fp, v);
+      jv* var = frame_local_var(fp, v);
       printf("V%d = ", v);
-      json_dumpf(*var, stdout, JSON_ENCODE_ANY);
+      jv_dump(jv_copy(*var));
       printf("\n");
-      stack_push(stackval_replace(stack_pop(), *var));
+      stack_push(stackval_replace(stack_pop(), jv_copy(*var)));
       break;
     }
 
@@ -226,43 +227,31 @@ json_t* jq_next() {
       uint16_t level = *pc++;
       uint16_t v = *pc++;
       frame_ptr fp = frame_get_level(&frame_stk, frame_current(&frame_stk), level);
-      json_t** var = frame_local_var(fp, v);
+      jv* var = frame_local_var(fp, v);
       stackval val = stack_pop();
       printf("V%d = ", v);
-      json_dumpf(val.value, stdout, JSON_ENCODE_ANY);
+      jv_dump(jv_copy(val.value));
       printf("\n");
+      jv_free(*var);
       *var = val.value;
       break;
     }
 
-#if 0
-    case DISPLAY: {
-      stackval sv = stack_pop();
-      if (sv.value) {
-        json_dumpf(sv.value, stdout, JSON_ENCODE_ANY);
-      } else {
-        printf("#ERROR");
-      }
-      printf(" - ");
-      for (int i = 0; i < sv.pathidx; i++) {
-        printf("/");
-        json_dumpf(pathbuf[i], stdout, JSON_ENCODE_ANY);
-      }
-      printf("\n");
-      return;
-    }
-#endif
-
     case ASSIGN_DBG: {
+      assert(0);
+      /*
       stackval replacement = stack_pop();
       stackval path_end = stack_pop();
       stackval path_start = stack_pop();
       json_t* obj = jv_insert(path_start.value, replacement.value, pathbuf + path_start.pathidx, path_end.pathidx - path_start.pathidx);
       stack_push(stackval_replace(path_start, obj));
+      */
       break;
     }
 
     case ASSIGN: {
+      assert(0);
+      /*
       stackval replacement = stack_pop();
       stackval path_end = stack_pop();
       stackval path_start = stack_pop();
@@ -272,17 +261,18 @@ json_t* jq_next() {
       frame_ptr fp = frame_get_level(&frame_stk, frame_current(&frame_stk), level);
       json_t** var = frame_local_var(fp, v);
       *var = jv_insert(*var, replacement.value, pathbuf + path_start.pathidx, path_end.pathidx - path_start.pathidx);
+      */
       break;
     }
 
     case INDEX: {
       stackval t = stack_pop();
-      json_t* k = stack_pop().value;
-      json_t* v = jv_lookup(t.value, k);
-      if (v) {
+      jv k = stack_pop().value;
+      jv v = jv_lookup(t.value, k);
+      if (1 /* fixme invalid lookups */) {
         stackval sv;
         sv.value = v;
-        sv.pathidx = path_push(t, k);
+        sv.pathidx = 0; //FIXME path_push(t, k);
         stack_push(sv);
       } else {
         assert(0 && "bad lookup");
@@ -298,23 +288,24 @@ json_t* jq_next() {
     }
 
     case EACH: 
-      stack_push(stackval_root(json_integer(0)));
+      stack_push(stackval_root(jv_number(0)));
       // fallthrough
     case ON_BACKTRACK(EACH): {
-      json_t* idxj = stack_pop().value;
-      int idx = json_integer_value(idxj);
+      int idx = jv_number_value(stack_pop().value);
       stackval array = stack_pop();
-      if (idx >= json_array_size(array.value)) {
+      if (idx >= jv_array_length(jv_copy(array.value))) {
         goto do_backtrack;
       } else {
         stack_save();
-        stack_push(array);
-        stack_push(stackval_root(json_integer(idx+1)));
+        stackval array2 = array;
+        array2.value = jv_copy(array2.value);
+        stack_push(array2);
+        stack_push(stackval_root(jv_number(idx+1)));
         frame_push_backtrack(&frame_stk, pc - 1);
         stack_switch();
         
-        stackval sv = {json_array_get(array.value, idx), 
-                       path_push(array, json_integer(idx))};
+        stackval sv = {jv_array_get(array.value, idx), 
+                       path_push(array, jv_number(idx))};
         stack_push(sv);
       }
       break;
@@ -323,7 +314,8 @@ json_t* jq_next() {
     do_backtrack:
     case BACKTRACK: {
       if (forkable_stack_empty(&fork_stk)) {
-        return 0;
+        // FIXME: invalid
+        return jv_null();
       }
       stack_restore();
       pc = *frame_current_retaddr(&frame_stk);
@@ -347,7 +339,7 @@ json_t* jq_next() {
     }
 
     case YIELD: {
-      json_t* value = stack_pop().value;
+      jv value = stack_pop().value;
       frame_push_backtrack(&frame_stk, pc);
       return value;
     }
@@ -361,7 +353,8 @@ json_t* jq_next() {
       struct cfunction* func = &frame_current_bytecode(&frame_stk)->globals->cfunctions[*pc++];
       printf(" call %s\n", func->name);
       func->fptr(cfunc_input, cfunc_output);
-      stack_push(stackval_replace(top, cfunc_output[0]));
+      top.value = cfunc_output[0];
+      stack_push(top);
       break;
     }
 
@@ -370,15 +363,16 @@ json_t* jq_next() {
       pc++; // skip nclosures
       pc++; // skip level
       stackval top = stack_pop();
-      json_t* a = stack_pop().value;
-      json_t* b = stack_pop().value;
+      jv a = stack_pop().value;
+      jv b = stack_pop().value;
       cfunc_input[0] = top.value;
       cfunc_input[1] = a;
       cfunc_input[2] = b;
       struct cfunction* func = &frame_current_bytecode(&frame_stk)->globals->cfunctions[*pc++];
       printf(" call %s\n", func->name);
       func->fptr(cfunc_input, cfunc_output);
-      stack_push(stackval_replace(top, cfunc_output[0]));
+      top.value = cfunc_output[0];
+      stack_push(top);
       break;
     }
 
@@ -409,7 +403,7 @@ json_t* jq_next() {
 }
 
 
-void jq_init(struct bytecode* bc, json_t* input) {
+void jq_init(struct bytecode* bc, jv input) {
   forkable_stack_init(&data_stk, sizeof(stackval) * 1000); // FIXME: lower this number, see if it breaks
   forkable_stack_init(&frame_stk, 10240); // FIXME: lower this number, see if it breaks
   forkable_stack_init(&fork_stk, 10240); // FIXME: lower this number, see if it breaks
@@ -421,10 +415,12 @@ void jq_init(struct bytecode* bc, json_t* input) {
 }
 
 void run_program(struct bytecode* bc) {
-  jq_init(bc, json_loadf(stdin, 0, 0));
-  json_t* result;
-  while ((result = jq_next())) {
-    json_dumpf(result, stdout, JSON_ENCODE_ANY);
+  char buf[4096];
+  fgets(buf, sizeof(buf), stdin);
+  jq_init(bc, jv_parse(buf));
+  jv result;
+  while (jv_get_kind(result = jq_next()) != JV_KIND_NULL) {
+    jv_dump(result);
     printf("\n");
   }
   printf("end of results\n");
diff --git a/c/execute.h b/c/execute.h
deleted file mode 100644
index b978a8e4..00000000
--- a/c/execute.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "opcode.h"
-#define MAX_CFUNCTION_PARAM 10
-typedef struct {
-  json_t* value;
-  int pathidx;
-} stackval;
-
-typedef void (*cfunction_ptr)(stackval* input, stackval* output);
-
-struct cfunction {
-  cfunction_ptr fptr;
-  const char* name;
-  opcode callop;
-};
diff --git a/c/forkable_stack.h b/c/forkable_stack.h
index 971b4ec0..92831989 100644
--- a/c/forkable_stack.h
+++ b/c/forkable_stack.h
@@ -83,10 +83,14 @@ static void* forkable_stack_peek_next(struct forkable_stack* s, void* top) {
   }
 }
 
-static void forkable_stack_pop(struct forkable_stack* s) {
+// Returns 1 if the object being popped can not be accessed again
+// (i.e. was not saved with a fork)
+static int forkable_stack_pop(struct forkable_stack* s) {
   forkable_stack_check(s);
+  int finalpop = s->pos < s->savedlimit ? 1 : 0;
   struct forkable_stack_header* elem = forkable_stack_peek(s);
   s->pos = elem->next;
+  return finalpop;
 }
 
 
diff --git a/c/frame_layout.h b/c/frame_layout.h
index fcbd1dc3..141dbcd8 100644
--- a/c/frame_layout.h
+++ b/c/frame_layout.h
@@ -1,7 +1,6 @@
 #ifndef FRAME_LAYOUT_H
 #include "forkable_stack.h"
 #include "bytecode.h"
-#include <jansson.h>
 
 struct closure {
   struct bytecode* bc;
@@ -18,7 +17,7 @@ typedef union frame_elem {
   FORKABLE_STACK_HEADER;
   struct continuation cont;
   struct closure closure;
-  json_t* jsonval;
+  jv jsonval;
 } *frame_ptr;
 
 /*
@@ -43,7 +42,7 @@ static struct closure* frame_closure_arg(frame_ptr fr, int closure) {
   return &fr[2+closure].closure;
 }
 
-static json_t** frame_local_var(frame_ptr fr, int var) {
+static jv* frame_local_var(frame_ptr fr, int var) {
   assert(var >= 0);
   assert(var < frame_self(fr)->bc->nlocals);
   return &fr[2 + frame_self(fr)->bc->nclosures + var].jsonval;
@@ -85,6 +84,9 @@ static frame_ptr frame_push(struct forkable_stack* stk, struct closure cl, uint1
   cc->bc = cl.bc;
   cc->env = cl.env;
   cc->retaddr = retaddr;
+  for (int i=0; i<cl.bc->nlocals; i++) {
+    *frame_local_var(fp, i) = jv_null();
+  }
   return fp;
 }
 
diff --git a/c/jv.c b/c/jv.c
index 7944d642..03954314 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -239,7 +239,7 @@ jv jv_array_concat(jv a, jv b) {
   assert(jv_get_kind(b) == JV_KIND_ARRAY);
 
   // FIXME: could be much faster
-  for (int i=0; i<jv_array_length(b); i++) {
+  for (int i=0; i<jv_array_length(jv_copy(b)); i++) {
     a = jv_array_append(a, jv_array_get(jv_copy(b), i));
   }
   jv_free(b);
diff --git a/c/main.c b/c/main.c
index 56d8d1d2..077268b4 100644
--- a/c/main.c
+++ b/c/main.c
@@ -6,10 +6,10 @@
 
 block compile(const char* str);
 
-//void jq_init(struct bytecode* bc, jv value);
-//jv jq_next();
+void jq_init(struct bytecode* bc, jv value);
+jv jq_next();
 
-//void run_program(struct bytecode* bc);
+void run_program(struct bytecode* bc);
 
 int skipline(const char* buf) {
   int p = 0;
@@ -39,13 +39,12 @@ void run_tests() {
     printf("\n");
     fgets(buf, sizeof(buf), testdata);
     jv input = jv_parse(buf);
-    jv_free(input); //jq_init(bc, input);
+    jq_init(bc, input);
 
     while (fgets(buf, sizeof(buf), testdata)) {
       if (skipline(buf)) break;
       jv expected = jv_parse(buf);
-      //jv actual = jq_next(); FIXME
-      jv actual = jv_copy(expected);
+      jv actual = jq_next();
       if (!1) {
         printf("Insufficient results\n");
         pass = 0;
@@ -84,5 +83,5 @@ int main(int argc, char* argv[]) {
   block_free(blk);
   dump_disassembly(0, bc);
   printf("\n");
-  //run_program(bc);
+  run_program(bc);
 }

From 9da3e0d37306ed053289b9dc6200e61f3d8b0f8d Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 2 Sep 2012 17:24:17 +0100
Subject: [PATCH 022/284] Clean up build a little and add .gitignore.

---
 .gitignore                | 12 ++++++++++++
 c/Makefile                |  6 +++---
 c/{jvtest.c => jv_test.c} |  0
 3 files changed, 15 insertions(+), 3 deletions(-)
 create mode 100644 .gitignore
 rename c/{jvtest.c => jv_test.c} (100%)

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..130e618d
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,12 @@
+*.o
+*~
+
+# Autogenerated by flex/bison
+lexer.yy.*
+parser.tab.*
+parser.info
+
+# Test binaries
+jv_test
+jv_parse
+parsertest
\ No newline at end of file
diff --git a/c/Makefile b/c/Makefile
index 2e598204..d437b143 100644
--- a/c/Makefile
+++ b/c/Makefile
@@ -20,13 +20,13 @@ parser.tab.h: parser.tab.c
 parsertest: parser.tab.c lexer.yy.c main.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c
 	$(CC) -o $@ $^
 
-jvtest: jvtest.c jv.c jv_print.c
+jv_test: jv_test.c jv.c jv_print.c jv_dtoa.c
 	$(CC) -DNO_JANSSON -o $@ $^
 
 jv_parse: jv_parse.c jv.c jv_print.c jv_dtoa.c
 	$(CC) -DNO_JANSSON -o $@ $^ -DJV_PARSE_MAIN
 
 
-test: jvtest
-	valgrind --error-exitcode=1 -q --leak-check=full ./jvtest
+test: jv_test
+	valgrind --error-exitcode=1 -q --leak-check=full ./jv_test
 
diff --git a/c/jvtest.c b/c/jv_test.c
similarity index 100%
rename from c/jvtest.c
rename to c/jv_test.c

From 4f747e6fffa2e80a6d62fac66eb88521e9cfc602 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 2 Sep 2012 21:45:27 +0100
Subject: [PATCH 023/284] Move from Jansson to JV - proper freeing of memory

A few more tests, now passes valgrind.
---
 c/builtin.c        |  5 +++++
 c/execute.c        | 39 +++++++++++++++++++++++++++++++--------
 c/forkable_stack.h | 23 +++++++++++++++++------
 c/frame_layout.h   | 13 +++++++++++++
 c/jv.c             | 33 ++++++++++++++++++++++++++++++++-
 c/jv.h             |  2 ++
 c/main.c           |  2 ++
 c/testdata         | 45 +++++++++++++++++++++++++++++++++++++++------
 8 files changed, 141 insertions(+), 21 deletions(-)

diff --git a/c/builtin.c b/c/builtin.c
index 0252566a..d468e7b7 100644
--- a/c/builtin.c
+++ b/c/builtin.c
@@ -1,15 +1,18 @@
 #include "builtin.h"
 
 static void f_false(jv input[], jv output[]) {
+  jv_free(input[0]);
   output[0] = jv_false();
 }
 
 static void f_true(jv input[], jv output[]) {
+  jv_free(input[0]);
   output[0] = jv_true();
 }
 
 
 static void f_plus(jv input[], jv output[]) {
+  jv_free(input[0]);
   jv a = input[2];
   jv b = input[1];
   if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
@@ -19,6 +22,8 @@ static void f_plus(jv input[], jv output[]) {
     output[0] = jv_array_concat(a, b);
   } else {
     output[0] = jv_string("wtf gaize");
+    jv_free(a);
+    jv_free(b);
   }
 }
 
diff --git a/c/execute.c b/c/execute.c
index 46779363..49cc1835 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -24,6 +24,7 @@ int pathsize; // number of allocated elements
 
 // FIXME mem
 int path_push(stackval sv, jv val) {
+  return 0;
   int pos = sv.pathidx;
   assert(pos <= pathsize);
   assert(pos >= 0);
@@ -54,17 +55,18 @@ typedef struct {
   stackval sv;
 } data_stk_elem;
 
-void stk_push(stackval val) {
+void stack_push(stackval val) {
   data_stk_elem* s = forkable_stack_push(&data_stk, sizeof(data_stk_elem));
   s->sv = val;
 }
 
-stackval stk_pop() {
+stackval stack_pop() {
   data_stk_elem* s = forkable_stack_peek(&data_stk);
   stackval sv = s->sv;
-  if (!forkable_stack_pop(&data_stk)) {
+  if (!forkable_stack_pop_will_free(&data_stk)) {
     sv.value = jv_copy(sv.value);
   }
+  forkable_stack_pop(&data_stk);
   return sv;
 }
 
@@ -92,6 +94,14 @@ void stack_switch() {
 }
 
 void stack_restore(){
+  while (!forkable_stack_empty(&data_stk) && 
+         forkable_stack_pop_will_free(&data_stk)) {
+    jv_free(stack_pop().value);
+  }
+  while (!forkable_stack_empty(&frame_stk) && 
+         forkable_stack_pop_will_free(&frame_stk)) {
+    frame_pop(&frame_stk);
+  }
   struct forkpoint* fork = forkable_stack_peek(&fork_stk);
   forkable_stack_restore(&data_stk, &fork->saved_data_stack);
   forkable_stack_restore(&frame_stk, &fork->saved_call_stack);
@@ -114,9 +124,6 @@ static struct closure make_closure(struct forkable_stack* stk, frame_ptr fr, uin
 }
 
 
-#define stack_push stk_push
-#define stack_pop stk_pop
-
 #define ON_BACKTRACK(op) ((op)+NUM_OPCODES)
 
 jv jq_next() {
@@ -142,10 +149,12 @@ jv jq_next() {
       if (i == 0) {
         param = forkable_stack_peek(&data_stk);
       } else {
+        printf(" | ");
         param = forkable_stack_peek_next(&data_stk, param);
       }
+      if (!param) break;
       jv_dump(jv_copy(param->sv.value));
-      if (i < opdesc->stack_in-1) printf(" | ");
+      printf("<%d>", jv_get_refcnt(param->sv.value));
     }
 
     if (backtracking) {
@@ -294,6 +303,7 @@ jv jq_next() {
       int idx = jv_number_value(stack_pop().value);
       stackval array = stack_pop();
       if (idx >= jv_array_length(jv_copy(array.value))) {
+        jv_free(array.value);
         goto do_backtrack;
       } else {
         stack_save();
@@ -314,7 +324,7 @@ jv jq_next() {
     do_backtrack:
     case BACKTRACK: {
       if (forkable_stack_empty(&fork_stk)) {
-        // FIXME: invalid
+        // FIXME: invalid jv value
         return jv_null();
       }
       stack_restore();
@@ -407,6 +417,7 @@ void jq_init(struct bytecode* bc, jv input) {
   forkable_stack_init(&data_stk, sizeof(stackval) * 1000); // FIXME: lower this number, see if it breaks
   forkable_stack_init(&frame_stk, 10240); // FIXME: lower this number, see if it breaks
   forkable_stack_init(&fork_stk, 10240); // FIXME: lower this number, see if it breaks
+  stack_save();
   
   stack_push(stackval_root(input));
   struct closure top = {bc, -1};
@@ -414,6 +425,18 @@ void jq_init(struct bytecode* bc, jv input) {
   frame_push_backtrack(&frame_stk, bc->code);
 }
 
+void jq_teardown() {
+  while (!forkable_stack_empty(&fork_stk)) {
+    stack_restore();
+  }
+  assert(forkable_stack_empty(&fork_stk));
+  assert(forkable_stack_empty(&data_stk));
+  assert(forkable_stack_empty(&frame_stk));
+  forkable_stack_free(&fork_stk);
+  forkable_stack_free(&data_stk);
+  forkable_stack_free(&frame_stk);
+}
+
 void run_program(struct bytecode* bc) {
   char buf[4096];
   fgets(buf, sizeof(buf), stdin);
diff --git a/c/forkable_stack.h b/c/forkable_stack.h
index 92831989..3128a6ca 100644
--- a/c/forkable_stack.h
+++ b/c/forkable_stack.h
@@ -46,6 +46,13 @@ static void forkable_stack_init(struct forkable_stack* s, size_t sz) {
   forkable_stack_check(s);
 }
 
+static void forkable_stack_free(struct forkable_stack* s) {
+  assert(forkable_stack_empty(s));
+  assert(s->savedlimit == s->length);
+  free(s->stk);
+  s->stk = 0;
+}
+
 static void* forkable_stack_push(struct forkable_stack* s, size_t size) {
   forkable_stack_check(s);
   int curr = s->pos < s->savedlimit ? s->pos : s->savedlimit;
@@ -83,14 +90,16 @@ static void* forkable_stack_peek_next(struct forkable_stack* s, void* top) {
   }
 }
 
-// Returns 1 if the object being popped can not be accessed again
-// (i.e. was not saved with a fork)
-static int forkable_stack_pop(struct forkable_stack* s) {
+// Returns 1 if the next forkable_stack_pop will permanently remove an
+// object from the stack (i.e. the top object was not saved with a fork)
+static int forkable_stack_pop_will_free(struct forkable_stack* s) {
+  return s->pos < s->savedlimit ? 1 : 0;
+}
+
+static void forkable_stack_pop(struct forkable_stack* s) {
   forkable_stack_check(s);
-  int finalpop = s->pos < s->savedlimit ? 1 : 0;
   struct forkable_stack_header* elem = forkable_stack_peek(s);
   s->pos = elem->next;
-  return finalpop;
 }
 
 
@@ -114,12 +123,14 @@ static void forkable_stack_switch(struct forkable_stack* s, struct forkable_stac
 
   int curr_limit = s->savedlimit;
   if (curr_pos < curr_limit) s->savedlimit = curr_pos;
-  state->prevlimit = curr_limit;
+  //state->prevlimit = curr_limit; FIXME clean up
   forkable_stack_check(s);
 }
 
 static void forkable_stack_restore(struct forkable_stack* s, struct forkable_stack_state* state) {
   forkable_stack_check(s);
+  assert(s->savedlimit <= state->prevpos);
+  assert(s->savedlimit <= state->prevlimit);
   s->pos = state->prevpos;
   s->savedlimit = state->prevlimit;
   forkable_stack_check(s);
diff --git a/c/frame_layout.h b/c/frame_layout.h
index 141dbcd8..d2218e92 100644
--- a/c/frame_layout.h
+++ b/c/frame_layout.h
@@ -11,6 +11,8 @@ struct continuation {
   struct bytecode* bc;
   stack_idx env;
   uint16_t* retaddr;
+  // FIXME: probably not necessary as a separate field
+  int is_backtrack_frame;
 };
 
 typedef union frame_elem {
@@ -84,6 +86,7 @@ static frame_ptr frame_push(struct forkable_stack* stk, struct closure cl, uint1
   cc->bc = cl.bc;
   cc->env = cl.env;
   cc->retaddr = retaddr;
+  cc->is_backtrack_frame = 0;
   for (int i=0; i<cl.bc->nlocals; i++) {
     *frame_local_var(fp, i) = jv_null();
   }
@@ -93,12 +96,22 @@ static frame_ptr frame_push(struct forkable_stack* stk, struct closure cl, uint1
 static frame_ptr frame_push_backtrack(struct forkable_stack* stk, uint16_t* retaddr) {
   struct continuation cc = *frame_self(frame_current(stk));
   frame_ptr fp = forkable_stack_push(stk, sizeof(union frame_elem) * 2);
+  assert(!cc.is_backtrack_frame);
+  cc.is_backtrack_frame = 1;
   cc.retaddr = retaddr;
   *frame_self(fp) = cc;
   return fp;
 }
 
 static void frame_pop(struct forkable_stack* stk) {
+  frame_ptr fp = frame_current(stk);
+  if (forkable_stack_pop_will_free(stk) && 
+      !frame_self(fp)->is_backtrack_frame) {
+    int nlocals = frame_self(fp)->bc->nlocals;
+    for (int i=0; i<nlocals; i++) {
+      jv_free(*frame_local_var(fp, i));
+    }
+  }
   forkable_stack_pop(stk);
 }
 
diff --git a/c/jv.c b/c/jv.c
index 03954314..198bfeda 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -2,6 +2,7 @@
 #include <stddef.h>
 #include <assert.h>
 #include <stdlib.h>
+#include <stdio.h>
 #include <string.h>
 
 #include "jv.h"
@@ -641,6 +642,21 @@ static int jvp_object_length(jv_complex* object) {
   return n;
 }
 
+static int jvp_object_equal(jv_complex* o1, jv_complex* o2) {
+  int len2 = jvp_object_length(o2);
+  int len1 = 0;
+  for (int i=0; i<jvp_object_size(o1); i++) {
+    struct object_slot* slot = jvp_object_get_slot(o1, i);
+    if (!slot->string) continue;
+    jv* slot2 = jvp_object_read(o2, slot->string);
+    if (!slot2) return 0;
+    // FIXME: do less refcounting here
+    if (!jv_equal(jv_copy(slot->value), jv_copy(*slot2))) return 0;
+    len1++;
+  }
+  return len1 == len2;
+}
+
 /*
  * Objects (public interface)
  */
@@ -752,6 +768,17 @@ void jv_free(jv j) {
   }
 }
 
+int jv_get_refcnt(jv j) {
+  switch (jv_get_kind(j)) {
+  case JV_KIND_ARRAY:
+  case JV_KIND_STRING:
+  case JV_KIND_OBJECT:
+    return j.val.complex.ptr->count;
+  default:
+    return 1;
+  }
+}
+
 /*
  * Higher-level operations
  */
@@ -772,7 +799,11 @@ int jv_equal(jv a, jv b) {
     case JV_KIND_STRING: {
       r = jvp_string_equal(&a.val.complex, &b.val.complex);
       break;
-    }    
+    }
+    case JV_KIND_OBJECT: {
+      r = jvp_object_equal(&a.val.complex, &b.val.complex);
+      break;
+    }
     default:
       r = 1;
       break;
diff --git a/c/jv.h b/c/jv.h
index 7696b03b..c03967b1 100644
--- a/c/jv.h
+++ b/c/jv.h
@@ -82,6 +82,8 @@ jv jv_object_iter_key(jv, int);
 jv jv_object_iter_value(jv, int);
 
 
+int jv_get_refcnt(jv);
+
 void jv_dump(jv);
 jv jv_parse(const char* string);
 
diff --git a/c/main.c b/c/main.c
index 077268b4..4d4081f4 100644
--- a/c/main.c
+++ b/c/main.c
@@ -8,6 +8,7 @@ block compile(const char* str);
 
 void jq_init(struct bytecode* bc, jv value);
 jv jq_next();
+void jq_teardown();
 
 void run_program(struct bytecode* bc);
 
@@ -67,6 +68,7 @@ void run_tests() {
         pass = 0;
         }*/
     }
+    jq_teardown();
     bytecode_free(bc);
     tests++;
     passed+=pass;
diff --git a/c/testdata b/c/testdata
index 95e40781..2cdaaa5f 100644
--- a/c/testdata
+++ b/c/testdata
@@ -76,6 +76,27 @@ null
 2
 3
 
+1,1
+[]
+1
+1
+
+[.]
+[2]
+[[2]]
+
+[[2]]
+[3]
+[[2]]
+
+[{}]
+[2]
+[{}]
+
+[.[]]
+["a"]
+["a"]
+
 [(.,1),((.,.[]),(2,3))]
 ["a","b"]
 [["a","b"],1,["a","b"],"a","b",2,3]
@@ -118,7 +139,7 @@ null
 
 1+1
 null
-2.0
+2
 
 .+4
 15
@@ -143,11 +164,17 @@ def f: (1000,2000); f
 1000
 2000
 
-# test backtracking through function calls and returns
-# this test is *evil*
-[[20,10][1,0] as $x | def f: (100,200) as $y | def g: [$x + $y, .]; . + $x | g; f[0] | [f][0][1] | f]
-"woo, testing!"
-[[110.0, 130.0], [210.0, 130.0], [110.0, 230.0], [210.0, 230.0], [120.0, 160.0], [220.0, 160.0], [120.0, 260.0], [220.0, 260.0]]
+([1,2] + [4,5])
+[1,2,3]
+[1,2,4,5]
+
+true
+[1]
+true
+
+[1,2,3]
+[5,6]
+[1,2,3]
 
 def f(x): x | x; f([.], . + [42])
 [1,2,3]
@@ -160,3 +187,9 @@ def f(x): x | x; f([.], . + [42])
 def id(x):x; 2000 as $x | def f(x):1 as $x | id([$x, x, x]); def g(x): 100 as $x | f($x,$x+x); g($x)
 "more testing"
 [1,100,2100.0,100,2100.0]
+
+# test backtracking through function calls and returns
+# this test is *evil*
+[[20,10][1,0] as $x | def f: (100,200) as $y | def g: [$x + $y, .]; . + $x | g; f[0] | [f][0][1] | f]
+"woo, testing!"
+[[110.0, 130.0], [210.0, 130.0], [110.0, 230.0], [210.0, 230.0], [120.0, 160.0], [220.0, 160.0], [120.0, 260.0], [220.0, 260.0]]

From e3710c0d1f0dd9900dbe88a4b3b036939da17f51 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 2 Sep 2012 22:08:36 +0100
Subject: [PATCH 024/284] Fix behaviour of stack at program termination.

---
 c/execute.c | 29 ++++++++++++++---------------
 c/main.c    |  4 +++-
 2 files changed, 17 insertions(+), 16 deletions(-)

diff --git a/c/execute.c b/c/execute.c
index 49cc1835..c22d1df3 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -93,7 +93,7 @@ void stack_switch() {
   forkable_stack_switch(&frame_stk, &fork->saved_call_stack);
 }
 
-void stack_restore(){
+int stack_restore(){
   while (!forkable_stack_empty(&data_stk) && 
          forkable_stack_pop_will_free(&data_stk)) {
     jv_free(stack_pop().value);
@@ -102,10 +102,15 @@ void stack_restore(){
          forkable_stack_pop_will_free(&frame_stk)) {
     frame_pop(&frame_stk);
   }
-  struct forkpoint* fork = forkable_stack_peek(&fork_stk);
-  forkable_stack_restore(&data_stk, &fork->saved_data_stack);
-  forkable_stack_restore(&frame_stk, &fork->saved_call_stack);
-  forkable_stack_pop(&fork_stk);
+  if (forkable_stack_empty(&fork_stk)) {
+    return 0;
+  } else {
+    struct forkpoint* fork = forkable_stack_peek(&fork_stk);
+    forkable_stack_restore(&data_stk, &fork->saved_data_stack);
+    forkable_stack_restore(&frame_stk, &fork->saved_call_stack);
+    forkable_stack_pop(&fork_stk);
+    return 1;
+  }
 }
 
 static struct closure make_closure(struct forkable_stack* stk, frame_ptr fr, uint16_t* pc) {
@@ -323,11 +328,10 @@ jv jq_next() {
 
     do_backtrack:
     case BACKTRACK: {
-      if (forkable_stack_empty(&fork_stk)) {
+      if (!stack_restore()) {
         // FIXME: invalid jv value
         return jv_null();
       }
-      stack_restore();
       pc = *frame_current_retaddr(&frame_stk);
       frame_pop(&frame_stk);
       backtracking = 1;
@@ -417,7 +421,6 @@ void jq_init(struct bytecode* bc, jv input) {
   forkable_stack_init(&data_stk, sizeof(stackval) * 1000); // FIXME: lower this number, see if it breaks
   forkable_stack_init(&frame_stk, 10240); // FIXME: lower this number, see if it breaks
   forkable_stack_init(&fork_stk, 10240); // FIXME: lower this number, see if it breaks
-  stack_save();
   
   stack_push(stackval_root(input));
   struct closure top = {bc, -1};
@@ -426,9 +429,8 @@ void jq_init(struct bytecode* bc, jv input) {
 }
 
 void jq_teardown() {
-  while (!forkable_stack_empty(&fork_stk)) {
-    stack_restore();
-  }
+  while (stack_restore()) {}
+
   assert(forkable_stack_empty(&fork_stk));
   assert(forkable_stack_empty(&data_stk));
   assert(forkable_stack_empty(&frame_stk));
@@ -447,8 +449,5 @@ void run_program(struct bytecode* bc) {
     printf("\n");
   }
   printf("end of results\n");
-
-  //assert(frame == stack_top_frame(bc->framesize));
-  //stk_pop_frame(bc->framesize);
-  //assert(stackpos == 0);
+  jq_teardown();
 }
diff --git a/c/main.c b/c/main.c
index 4d4081f4..5cdc7d62 100644
--- a/c/main.c
+++ b/c/main.c
@@ -81,9 +81,11 @@ int main(int argc, char* argv[]) {
   if (argc == 1) { run_tests(); return 0; }
   block blk = compile(argv[1]);
   block_append(&blk, block_join(gen_op_simple(YIELD), gen_op_simple(BACKTRACK)));
-  struct bytecode* bc = block_compile(gen_cbinding(&builtins, blk));
+  blk = gen_cbinding(&builtins, blk);
+  struct bytecode* bc = block_compile(blk);
   block_free(blk);
   dump_disassembly(0, bc);
   printf("\n");
   run_program(bc);
+  bytecode_free(bc);
 }

From 22ffc0fdfce541ec3f2a6a5166db64f2c752d91d Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 2 Sep 2012 22:24:27 +0100
Subject: [PATCH 025/284] Mark a constant array const in jvp_dtoa.c

---
 c/jv_dtoa.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/c/jv_dtoa.c b/c/jv_dtoa.c
index 1388943b..c3132024 100644
--- a/c/jv_dtoa.c
+++ b/c/jv_dtoa.c
@@ -867,7 +867,7 @@ pow5mult
 {
 	Bigint *b1, *p5, *p51;
 	int i;
-	static int p05[3] = { 5, 25, 125 };
+	static const int p05[3] = { 5, 25, 125 };
 
 	if ((i = k & 3))
 		b = multadd(C, b, p05[i-1], 0);

From 52487ff81258ed65992065a2a6ffa1286064f6eb Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 3 Sep 2012 01:12:42 +0100
Subject: [PATCH 026/284] Remove globals from parser, use explicit structure.

---
 c/jv_parse.c | 233 +++++++++++++++++++++++++++------------------------
 c/jv_parse.h |  20 +++++
 2 files changed, 142 insertions(+), 111 deletions(-)
 create mode 100644 c/jv_parse.h

diff --git a/c/jv_parse.c b/c/jv_parse.c
index 26c2cc38..2c2da395 100644
--- a/c/jv_parse.c
+++ b/c/jv_parse.c
@@ -2,10 +2,7 @@
 #include <stdlib.h>
 #include "jv.h"
 #include "jv_dtoa.h"
-jv stack[1000];
-int stackpos = 0;
-jv next;
-int hasnext;
+#include "jv_parse.h"
 
 typedef const char* presult;
 
@@ -16,55 +13,78 @@ typedef const char* presult;
 #define pfunc presult
 #endif
 
+void jv_parser_init(struct jv_parser* p) {
+  p->stack = 0;
+  p->stacklen = p->stackpos = 0;
+  p->hasnext = 0;
+  p->next = jv_null(); //FIXME: jv_invalid
+  p->tokenbuf = 0;
+  p->tokenlen = p->tokenpos = 0;
+  p->st = JV_PARSER_NORMAL;
+  jvp_dtoa_context_init(&p->dtoa);
+}
 
+void jv_parser_free(struct jv_parser* p) {
+  if (p->hasnext) jv_free(p->next);
+  free(p->stack);
+  free(p->tokenbuf);
+  jvp_dtoa_context_free(&p->dtoa);
+}
 
-pfunc value(jv val) {
-  if (hasnext) return "Expected separator between values";
-  hasnext = 1;
-  next = val;
+static pfunc value(struct jv_parser* p, jv val) {
+  if (p->hasnext) return "Expected separator between values";
+  p->hasnext = 1;
+  p->next = val;
   return 0;
 }
 
-void push(jv v) {
-  stack[stackpos++] = v;
+static void push(struct jv_parser* p, jv v) {
+  assert(p->stackpos <= p->stacklen);
+  if (p->stackpos == p->stacklen) {
+    p->stacklen = p->stacklen * 2 + 10;
+    p->stack = realloc(p->stack, p->stacklen * sizeof(jv));
+  }
+  assert(p->stackpos < p->stacklen);
+  p->stack[p->stackpos++] = v;
 }
 
-pfunc token(char ch) {
+static pfunc token(struct jv_parser* p, char ch) {
   switch (ch) {
   case '[':
-    if (hasnext) return "Expected separator between values";
-    push(jv_array());
+    if (p->hasnext) return "Expected separator between values";
+    push(p, jv_array());
     break;
 
   case '{':
-    if (hasnext) return "Expected separator between values";
-    push(jv_object());
+    if (p->hasnext) return "Expected separator between values";
+    push(p, jv_object());
     break;
 
   case ':':
-    if (!hasnext) 
+    if (!p->hasnext) 
       return "Expected string key before ':'";
-    if (stackpos == 0 || jv_get_kind(stack[stackpos-1]) != JV_KIND_OBJECT)
+    if (p->stackpos == 0 || jv_get_kind(p->stack[p->stackpos-1]) != JV_KIND_OBJECT)
       return "':' not as part of an object";
-    if (jv_get_kind(next) != JV_KIND_STRING)
+    if (jv_get_kind(p->next) != JV_KIND_STRING)
       return "Object keys must be strings";
-    push(next);
-    hasnext = 0;
+    push(p, p->next);
+    p->hasnext = 0;
     break;
 
   case ',':
-    if (!hasnext)
+    if (!p->hasnext)
       return "Expected value before ','";
-    if (stackpos == 0)
+    if (p->stackpos == 0)
       return "',' not as part of an object or array";
-    if (jv_get_kind(stack[stackpos-1]) == JV_KIND_ARRAY) {
-      stack[stackpos-1] = jv_array_append(stack[stackpos-1], next);
-      hasnext = 0;
-    } else if (jv_get_kind(stack[stackpos-1]) == JV_KIND_STRING) {
-      assert(stackpos > 1 && jv_get_kind(stack[stackpos-2]) == JV_KIND_OBJECT);
-      stack[stackpos-2] = jv_object_set(stack[stackpos-2], stack[stackpos-1], next);
-      stackpos--;
-      hasnext = 0;
+    if (jv_get_kind(p->stack[p->stackpos-1]) == JV_KIND_ARRAY) {
+      p->stack[p->stackpos-1] = jv_array_append(p->stack[p->stackpos-1], p->next);
+      p->hasnext = 0;
+    } else if (jv_get_kind(p->stack[p->stackpos-1]) == JV_KIND_STRING) {
+      assert(p->stackpos > 1 && jv_get_kind(p->stack[p->stackpos-2]) == JV_KIND_OBJECT);
+      p->stack[p->stackpos-2] = jv_object_set(p->stack[p->stackpos-2], 
+                                              p->stack[p->stackpos-1], p->next);
+      p->stackpos--;
+      p->hasnext = 0;
     } else {
       // this case hits on input like {"a", "b"}
       return "Objects must consist of key:value pairs";
@@ -72,54 +92,57 @@ pfunc token(char ch) {
     break;
 
   case ']':
-    if (stackpos == 0 || jv_get_kind(stack[stackpos-1]) != JV_KIND_ARRAY)
+    if (p->stackpos == 0 || jv_get_kind(p->stack[p->stackpos-1]) != JV_KIND_ARRAY)
       return "Unmatched ']'";
-    if (hasnext) {
-      stack[stackpos-1] = jv_array_append(stack[stackpos-1], next);
-      hasnext = 0;
+    if (p->hasnext) {
+      p->stack[p->stackpos-1] = jv_array_append(p->stack[p->stackpos-1], p->next);
+      p->hasnext = 0;
     } else {
-      if (jv_array_length(jv_copy(stack[stackpos-1])) != 0) {
+      if (jv_array_length(jv_copy(p->stack[p->stackpos-1])) != 0) {
         // this case hits on input like [1,2,3,]
         return "Expected another array element";
       }
     }
-    hasnext = 1;
-    next = stack[--stackpos];
+    p->hasnext = 1;
+    p->next = p->stack[--p->stackpos];
     break;
 
   case '}':
-    if (stackpos == 0)
+    if (p->stackpos == 0)
       return "Unmatched '}'";
-    if (hasnext) {
-      if (jv_get_kind(stack[stackpos-1]) != JV_KIND_STRING)
+    if (p->hasnext) {
+      if (jv_get_kind(p->stack[p->stackpos-1]) != JV_KIND_STRING)
         return "Objects must consist of key:value pairs";
-      assert(stackpos > 1 && jv_get_kind(stack[stackpos-2]) == JV_KIND_OBJECT);
-      stack[stackpos-2] = jv_object_set(stack[stackpos-2], stack[stackpos-1], next);
-      stackpos--;
-      hasnext = 0;
+      assert(p->stackpos > 1 && jv_get_kind(p->stack[p->stackpos-2]) == JV_KIND_OBJECT);
+      p->stack[p->stackpos-2] = jv_object_set(p->stack[p->stackpos-2], 
+                                              p->stack[p->stackpos-1], p->next);
+      p->stackpos--;
+      p->hasnext = 0;
     } else {
-      if (jv_get_kind(stack[stackpos-1]) != JV_KIND_OBJECT)
+      if (jv_get_kind(p->stack[p->stackpos-1]) != JV_KIND_OBJECT)
         return "Unmatched '}'";
-      if (jv_object_length(jv_copy(stack[stackpos-1])) != 0)
+      if (jv_object_length(jv_copy(p->stack[p->stackpos-1])) != 0)
         return "Expected another key-value pair";
     }
-    hasnext = 1;
-    next = stack[--stackpos];
+    p->hasnext = 1;
+    p->next = p->stack[--p->stackpos];
     break;
   }
   return 0;
 }
 
 
-char tokenbuf[1000];
-int tokenpos;
-struct dtoa_context dtoa;
-
-void tokenadd(char c) {
-  tokenbuf[tokenpos++] = c;
+static void tokenadd(struct jv_parser* p, char c) {
+  assert(p->tokenpos <= p->tokenlen);
+  if (p->tokenpos == p->tokenlen) {
+    p->tokenlen = p->tokenlen*2 + 256;
+    p->tokenbuf = realloc(p->tokenbuf, p->tokenlen);
+  }
+  assert(p->tokenpos < p->tokenlen);
+  p->tokenbuf[p->tokenpos++] = c;
 }
 
-int unhex4(char* hex) {
+static int unhex4(char* hex) {
   int r = 0;
   for (int i=0; i<4; i++) {
     char c = *hex++;
@@ -133,7 +156,7 @@ int unhex4(char* hex) {
   return r;
 }
 
-int utf8_encode(int codepoint, char* out) {
+static int utf8_encode(int codepoint, char* out) {
   assert(codepoint >= 0 && codepoint <= 0x10FFFF);
   char* start = out;
   if (codepoint <= 0x7F) {
@@ -154,10 +177,10 @@ int utf8_encode(int codepoint, char* out) {
   return out - start;
 }
 
-pfunc found_string() {
-  char* in = tokenbuf;
-  char* out = tokenbuf;
-  char* end = tokenbuf + tokenpos;
+static pfunc found_string(struct jv_parser* p) {
+  char* in = p->tokenbuf;
+  char* out = p->tokenbuf;
+  char* end = p->tokenbuf + p->tokenpos;
   
   while (in < end) {
     char c = *in++;
@@ -203,38 +226,38 @@ pfunc found_string() {
       *out++ = c;
     }
   }
-  TRY(value(jv_string_sized(tokenbuf, out - tokenbuf)));
-  tokenpos=0;
+  TRY(value(p, jv_string_sized(p->tokenbuf, out - p->tokenbuf)));
+  p->tokenpos = 0;
   return 0;
 }
 
-pfunc check_literal() {
-  if (tokenpos == 0) return 0;
+static pfunc check_literal(struct jv_parser* p) {
+  if (p->tokenpos == 0) return 0;
 
   const char* pattern = 0;
   int plen;
   jv v;
-  switch (tokenbuf[0]) {
+  switch (p->tokenbuf[0]) {
   case 't': pattern = "true"; plen = 4; v = jv_true(); break;
   case 'f': pattern = "false"; plen = 5; v = jv_false(); break;
   case 'n': pattern = "null"; plen = 4; v = jv_null(); break;
   }
   if (pattern) {
-    if (tokenpos != plen) return "Invalid literal";
+    if (p->tokenpos != plen) return "Invalid literal";
     for (int i=0; i<plen; i++) 
-      if (tokenbuf[i] != pattern[i])
+      if (p->tokenbuf[i] != pattern[i])
         return "Invalid literal";
-    TRY(value(v));
+    TRY(value(p, v));
   } else {
     // FIXME: better parser
-    tokenbuf[tokenpos] = 0; // FIXME: invalid
+    p->tokenbuf[p->tokenpos] = 0; // FIXME: invalid
     char* end = 0;
-    double d = jvp_strtod(&dtoa, tokenbuf, &end);
+    double d = jvp_strtod(&p->dtoa, p->tokenbuf, &end);
     if (end == 0 || *end != 0)
       return "Invalid numeric literal";
-    TRY(value(jv_number(d)));
+    TRY(value(p, jv_number(d)));
   }
-  tokenpos=0;
+  p->tokenpos = 0;
   return 0;
 }
 
@@ -246,7 +269,7 @@ typedef enum {
   INVALID
 } chclass;
 
-chclass classify(char c) {
+static chclass classify(char c) {
   switch (c) {
   case ' ':
   case '\t':
@@ -268,91 +291,79 @@ chclass classify(char c) {
 }
 
 
-enum state {
-  NORMAL,
-  STRING,
-  STRING_ESCAPE
-};
 
-enum state st = NORMAL;
 
-pfunc scan(char ch) {
-  if (st == NORMAL) {
+static pfunc scan(struct jv_parser* p, char ch) {
+  if (p->st == JV_PARSER_NORMAL) {
     chclass cls = classify(ch);
     if (cls != LITERAL) {
-      TRY(check_literal());
+      TRY(check_literal(p));
     }
     switch (cls) {
     case LITERAL:
-      tokenadd(ch);
+      tokenadd(p, ch);
       break;
     case WHITESPACE:
       break;
     case QUOTE:
-      st = STRING;
+      p->st = JV_PARSER_STRING;
       break;
     case STRUCTURE:
-      TRY(token(ch));
+      TRY(token(p, ch));
       break;
     case INVALID:
       return "Invalid character";
     }
   } else {
-    if (ch == '"' && st == STRING) {
-      TRY(found_string());
-      st = NORMAL;
+    if (ch == '"' && p->st == JV_PARSER_STRING) {
+      TRY(found_string(p));
+      p->st = JV_PARSER_NORMAL;
     } else {
-      tokenadd(ch);
-      if (ch == '\\' && st == STRING) {
-        st = STRING_ESCAPE;
+      tokenadd(p, ch);
+      if (ch == '\\' && p->st == JV_PARSER_STRING) {
+        p->st = JV_PARSER_STRING_ESCAPE;
       } else {
-        st = STRING;
+        p->st = JV_PARSER_STRING;
       }
     }
   }
   return 0;
 }
 
-pfunc finish() {
-  assert(st == NORMAL);
-  TRY(check_literal());
+static pfunc finish(struct jv_parser* p) {
+  if (p->st != JV_PARSER_NORMAL)
+    return "Unfinished string";
+  TRY(check_literal(p));
 
-  if (stackpos != 0)
+  if (p->stackpos != 0)
     return "Unfinished JSON term";
   
   // this will happen on the empty string
-  if (!hasnext)
+  if (!p->hasnext)
     return "Expected JSON value";
   
   return 0;
 }
 
 jv jv_parse(const char* string) {
-  jvp_dtoa_context_init(&dtoa);
+  struct jv_parser parser;
+  jv_parser_init(&parser);
 
   const char* p = string;
   char ch;
   while ((ch = *p++)) {
-    presult msg = scan(ch);
+    presult msg = scan(&parser, ch);
     if (msg){
       printf("ERROR: %s (parsing [%s])\n", msg, string);
       return jv_null();
     }
   }
-  presult msg = finish();
+  presult msg = finish(&parser);
   if (msg) {
     printf("ERROR: %s (parsing [%s])\n", msg, string);
     return jv_null();
   }
-  jvp_dtoa_context_free(&dtoa);
-  hasnext = 0;
-  return next;
+  jv value = jv_copy(parser.next);
+  jv_parser_free(&parser);
+  return value;
 }
-#if JV_PARSE_MAIN
-int main(int argc, char* argv[]) {
-  assert(argc == 2);
-  jv_dump(jv_parse(argv[1]));
-  printf("\n");
-  return 0;
-}
-#endif
diff --git a/c/jv_parse.h b/c/jv_parse.h
new file mode 100644
index 00000000..4dddcf6f
--- /dev/null
+++ b/c/jv_parse.h
@@ -0,0 +1,20 @@
+
+struct jv_parser {
+  jv* stack;
+  int stackpos;
+  int stacklen;
+  jv next;
+  int hasnext;
+  
+  char* tokenbuf;
+  int tokenpos;
+  int tokenlen;
+  
+  struct dtoa_context dtoa;
+
+  enum {
+    JV_PARSER_NORMAL,
+    JV_PARSER_STRING,
+    JV_PARSER_STRING_ESCAPE
+  } st;
+};

From 6041fd76613b287ccda3de58829a9e0f98b91f17 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 3 Sep 2012 13:36:12 +0100
Subject: [PATCH 027/284] Literal strings and better literal numbers.

---
 c/jv.h       |  2 +-
 c/jv_parse.c | 15 +++++++++++----
 c/lexer.l    |  8 +++++++-
 c/parser.y   |  4 ++++
 4 files changed, 23 insertions(+), 6 deletions(-)

diff --git a/c/jv.h b/c/jv.h
index c03967b1..8fbc77ab 100644
--- a/c/jv.h
+++ b/c/jv.h
@@ -86,7 +86,7 @@ int jv_get_refcnt(jv);
 
 void jv_dump(jv);
 jv jv_parse(const char* string);
-
+jv jv_parse_sized(const char* string, int length);
 
 
 
diff --git a/c/jv_parse.c b/c/jv_parse.c
index 2c2da395..1f6a20aa 100644
--- a/c/jv_parse.c
+++ b/c/jv_parse.c
@@ -1,5 +1,6 @@
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include "jv.h"
 #include "jv_dtoa.h"
 #include "jv_parse.h"
@@ -345,25 +346,31 @@ static pfunc finish(struct jv_parser* p) {
   return 0;
 }
 
-jv jv_parse(const char* string) {
+jv jv_parse_sized(const char* string, int length) {
+  printf("'%s' [%d]", string, length);
   struct jv_parser parser;
   jv_parser_init(&parser);
 
   const char* p = string;
   char ch;
-  while ((ch = *p++)) {
+  while (p < string + length) {
+    ch = *p++;
     presult msg = scan(&parser, ch);
     if (msg){
-      printf("ERROR: %s (parsing [%s])\n", msg, string);
+      printf("ERROR: %s (parsing '%s')\n", msg, string);
       return jv_null();
     }
   }
   presult msg = finish(&parser);
   if (msg) {
-    printf("ERROR: %s (parsing [%s])\n", msg, string);
+    printf("ERROR: %s (parsing '%s')\n", msg, string);
     return jv_null();
   }
   jv value = jv_copy(parser.next);
   jv_parser_free(&parser);
   return value;
 }
+
+jv jv_parse(const char* string) {
+  return jv_parse_sized(string, strlen(string));
+}
diff --git a/c/lexer.l b/c/lexer.l
index 34253b01..550ad85d 100644
--- a/c/lexer.l
+++ b/c/lexer.l
@@ -15,9 +15,15 @@
 "|=" { return SETPIPE; }
 "."|"="|";"|"["|"]"|","|":"|"("|")"|"{"|"}"|"|"|"+"|"\$" { return yytext[0];}
 
-[[:digit:]]+  { yylval->literal = jv_number((double)atoi(yytext));   return LITERAL;}
+\"(\\.|[^\\"])*\" |
+[+-]?[0-9.]+([eE][+-]?[0-9]+)? { 
+   yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; 
+}
+
 [[:alnum:]]+  { yylval->literal = jv_string(yytext); return IDENT;}
+
 [ \n\t]+  {}
+
 %%
 /* perhaps these should be calls... */
 /*
diff --git a/c/parser.y b/c/parser.y
index 14a338a7..36292453 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -189,6 +189,10 @@ MkDictPair
 : IDENT ':' ExpD { 
   $$ = gen_dictpair(gen_op_const(LOADK, $1), $3);
  }
+| LITERAL ':' ExpD {
+  assert(jv_get_kind($1) == JV_KIND_STRING);
+  $$ = gen_dictpair(gen_op_const(LOADK, $1), $3);
+  }
 | IDENT {
   $$ = gen_dictpair(gen_op_const(LOADK, jv_copy($1)),
                     gen_index(gen_noop(), gen_op_const(LOADK, $1)));

From cf004c2b3a24ec72cbd86a354b4bf39700c7ff43 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 3 Sep 2012 13:57:53 +0100
Subject: [PATCH 028/284] Modify number formatting so that 1e-3 renders as
 0.001, not .001

---
 c/jv_dtoa.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/c/jv_dtoa.c b/c/jv_dtoa.c
index c3132024..2c27c880 100644
--- a/c/jv_dtoa.c
+++ b/c/jv_dtoa.c
@@ -4247,6 +4247,7 @@ jvp_dtoa
 		*b = 0;
 		}
 	else if (decpt <= 0) {
+		*b++ = '0';
 		*b++ = '.';
 		for(; decpt < 0; decpt++)
 			*b++ = '0';

From d8fad1ed9bbb53ca2c5c2c101664b235a6b55c0c Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 3 Sep 2012 15:32:50 +0100
Subject: [PATCH 029/284] Disallow a + before numbers (makes parsing easier,
 agrees with JSON)

---
 c/lexer.l | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/c/lexer.l b/c/lexer.l
index 550ad85d..4acb026a 100644
--- a/c/lexer.l
+++ b/c/lexer.l
@@ -16,7 +16,7 @@
 "."|"="|";"|"["|"]"|","|":"|"("|")"|"{"|"}"|"|"|"+"|"\$" { return yytext[0];}
 
 \"(\\.|[^\\"])*\" |
-[+-]?[0-9.]+([eE][+-]?[0-9]+)? { 
+-?[0-9.]+([eE][+-]?[0-9]+)? { 
    yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; 
 }
 

From 8fe9c8a22a0f43c8e34df5bc92df98c498c9a3f4 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 3 Sep 2012 15:33:59 +0100
Subject: [PATCH 030/284] Make assignment work again: = and |= operators.

---
 c/execute.c     | 37 ++++++++++++++++++-------------------
 c/jv.h          |  2 +-
 c/opcode_list.h |  1 -
 3 files changed, 19 insertions(+), 21 deletions(-)

diff --git a/c/execute.c b/c/execute.c
index c22d1df3..0c31e072 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -24,14 +24,18 @@ int pathsize; // number of allocated elements
 
 // FIXME mem
 int path_push(stackval sv, jv val) {
-  return 0;
   int pos = sv.pathidx;
   assert(pos <= pathsize);
   assert(pos >= 0);
   if (pos == pathsize) {
-    pathsize = pathsize ? pathsize * 2 : 100;
+    int oldpathsize = pathsize;
+    pathsize = oldpathsize ? oldpathsize * 2 : 100;
     pathbuf = realloc(pathbuf, sizeof(pathbuf[0]) * pathsize);
+    for (int i=oldpathsize; i<pathsize; i++) {
+      pathbuf[i] = jv_null();
+    }
   }
+  jv_free(pathbuf[pos]);
   pathbuf[pos] = val;
   return pos + 1;
 }
@@ -251,42 +255,30 @@ jv jq_next() {
       break;
     }
 
-    case ASSIGN_DBG: {
-      assert(0);
-      /*
-      stackval replacement = stack_pop();
-      stackval path_end = stack_pop();
-      stackval path_start = stack_pop();
-      json_t* obj = jv_insert(path_start.value, replacement.value, pathbuf + path_start.pathidx, path_end.pathidx - path_start.pathidx);
-      stack_push(stackval_replace(path_start, obj));
-      */
-      break;
-    }
-
     case ASSIGN: {
-      assert(0);
-      /*
       stackval replacement = stack_pop();
       stackval path_end = stack_pop();
       stackval path_start = stack_pop();
+      jv_free(path_end.value);
+      jv_free(path_start.value);
 
       uint16_t level = *pc++;
       uint16_t v = *pc++;
       frame_ptr fp = frame_get_level(&frame_stk, frame_current(&frame_stk), level);
-      json_t** var = frame_local_var(fp, v);
+      jv* var = frame_local_var(fp, v);
       *var = jv_insert(*var, replacement.value, pathbuf + path_start.pathidx, path_end.pathidx - path_start.pathidx);
-      */
       break;
     }
 
     case INDEX: {
       stackval t = stack_pop();
       jv k = stack_pop().value;
+      int pathidx = path_push(t, jv_copy(k));
       jv v = jv_lookup(t.value, k);
       if (1 /* fixme invalid lookups */) {
         stackval sv;
         sv.value = v;
-        sv.pathidx = 0; //FIXME path_push(t, k);
+        sv.pathidx = pathidx;
         stack_push(sv);
       } else {
         assert(0 && "bad lookup");
@@ -437,6 +429,13 @@ void jq_teardown() {
   forkable_stack_free(&fork_stk);
   forkable_stack_free(&data_stk);
   forkable_stack_free(&frame_stk);
+
+  for (int i=0; i<pathsize; i++) {
+    jv_free(pathbuf[i]);
+  }
+  free(pathbuf);
+  pathbuf = 0;
+  pathsize = 0;
 }
 
 void run_program(struct bytecode* bc) {
diff --git a/c/jv.h b/c/jv.h
index 8fbc77ab..754f0316 100644
--- a/c/jv.h
+++ b/c/jv.h
@@ -127,7 +127,7 @@ static jv jv_insert(jv root, jv value, jv* path, int pathlen) {
     jv_free(root);
     return value;
   }
-  return jv_modify(root, *path, 
+  return jv_modify(root, jv_copy(*path), 
                    jv_insert(jv_lookup(jv_copy(root), jv_copy(*path)), value, path+1, pathlen-1));
 }
 
diff --git a/c/opcode_list.h b/c/opcode_list.h
index 268025e8..7f2c144a 100644
--- a/c/opcode_list.h
+++ b/c/opcode_list.h
@@ -14,7 +14,6 @@ OP(BACKTRACK, NONE, 0, 0)
 OP(APPEND, NONE,    2, 1)
 OP(INSERT, NONE,    4, 2)
 
-OP(ASSIGN_DBG, NONE, 3, 1)
 OP(ASSIGN, VARIABLE, 3, 0)
 
 OP(CALL_BUILTIN_1_1, CFUNC, 1, 1)

From d895d39ba973f7296429aac77c1ad6bc8d7341b4 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 3 Sep 2012 16:14:52 +0100
Subject: [PATCH 031/284] Support "null" in JQ programs

---
 c/builtin.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/c/builtin.c b/c/builtin.c
index d468e7b7..35e15471 100644
--- a/c/builtin.c
+++ b/c/builtin.c
@@ -10,6 +10,10 @@ static void f_true(jv input[], jv output[]) {
   output[0] = jv_true();
 }
 
+static void f_null(jv input[], jv output[]) {
+  jv_free(input[0]);
+  output[0] = jv_null();
+}
 
 static void f_plus(jv input[], jv output[]) {
   jv_free(input[0]);
@@ -30,6 +34,7 @@ static void f_plus(jv input[], jv output[]) {
 struct cfunction function_list[] = {
   {f_true, "true", CALL_BUILTIN_1_1},
   {f_false, "false", CALL_BUILTIN_1_1},
+  {f_null, "null", CALL_BUILTIN_1_1},
   {f_plus, "_plus", CALL_BUILTIN_3_1},
 };
 struct symbol_table builtins = {function_list, sizeof(function_list)/sizeof(function_list[0])};

From a8c3648ca5ebcb9c824f3df86a4c2fbe57c09d6d Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 3 Sep 2012 16:16:14 +0100
Subject: [PATCH 032/284] JV_KIND_INVALID values to represent failed lookups,
 etc + various tests.

---
 c/execute.c |  5 ++---
 c/jv.c      | 13 ++++++++++++-
 c/jv.h      |  6 ++++++
 c/main.c    | 10 +++++-----
 c/testdata  | 29 ++++++++++++++++++++++++-----
 5 files changed, 49 insertions(+), 14 deletions(-)

diff --git a/c/execute.c b/c/execute.c
index 0c31e072..d98872b3 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -321,8 +321,7 @@ jv jq_next() {
     do_backtrack:
     case BACKTRACK: {
       if (!stack_restore()) {
-        // FIXME: invalid jv value
-        return jv_null();
+        return jv_invalid();
       }
       pc = *frame_current_retaddr(&frame_stk);
       frame_pop(&frame_stk);
@@ -443,7 +442,7 @@ void run_program(struct bytecode* bc) {
   fgets(buf, sizeof(buf), stdin);
   jq_init(bc, jv_parse(buf));
   jv result;
-  while (jv_get_kind(result = jq_next()) != JV_KIND_NULL) {
+  while (jv_is_valid(result = jq_next())) {
     jv_dump(result);
     printf("\n");
   }
diff --git a/c/jv.c b/c/jv.c
index 198bfeda..4484dc9f 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -37,10 +37,15 @@ jv_kind jv_get_kind(jv x) {
   return x.kind;
 }
 
+static const jv JV_INVALID = {JV_KIND_INVALID, {0}};
 static const jv JV_NULL = {JV_KIND_NULL, {0}};
 static const jv JV_FALSE = {JV_KIND_FALSE, {0}};
 static const jv JV_TRUE = {JV_KIND_TRUE, {0}};
 
+jv jv_invalid() {
+  return JV_INVALID;
+}
+
 jv jv_true() {
   return JV_TRUE;
 }
@@ -671,7 +676,13 @@ jv jv_object() {
 jv jv_object_get(jv object, jv key) {
   assert(jv_get_kind(object) == JV_KIND_OBJECT);
   assert(jv_get_kind(key) == JV_KIND_STRING);
-  jv val = jv_copy(*jvp_object_read(&object.val.complex, jvp_string_ptr(&key.val.complex)));
+  jv* slot = jvp_object_read(&object.val.complex, jvp_string_ptr(&key.val.complex));
+  jv val;
+  if (slot) {
+    val = jv_copy(*slot);
+  } else {
+    val = jv_invalid();
+  }
   jv_free(object);
   jv_free(key);
   return val;
diff --git a/c/jv.h b/c/jv.h
index 754f0316..b251329c 100644
--- a/c/jv.h
+++ b/c/jv.h
@@ -8,6 +8,7 @@
 
 
 typedef enum {
+  JV_KIND_INVALID,
   JV_KIND_NULL,
   JV_KIND_FALSE,
   JV_KIND_TRUE,
@@ -40,12 +41,14 @@ typedef struct {
  */
 
 jv_kind jv_get_kind(jv);
+static int jv_is_valid(jv x) { return jv_get_kind(x) != JV_KIND_INVALID; }
 
 jv jv_copy(jv);
 void jv_free(jv);
 
 int jv_equal(jv, jv);
 
+jv jv_invalid();
 jv jv_null();
 jv jv_true();
 jv jv_false();
@@ -95,6 +98,9 @@ static jv jv_lookup(jv t, jv k) {
   jv v;
   if (jv_get_kind(t) == JV_KIND_OBJECT && jv_get_kind(k) == JV_KIND_STRING) {
     v = jv_object_get(t, k);
+    if (!jv_is_valid(v)) {
+      v = jv_null();
+    }
   } else if (jv_get_kind(t) == JV_KIND_ARRAY && jv_get_kind(k) == JV_KIND_NUMBER) {
     // FIXME: don't do lookup for noninteger index
     v = jv_array_get(t, (int)jv_number_value(k));
diff --git a/c/main.c b/c/main.c
index 5cdc7d62..5879d031 100644
--- a/c/main.c
+++ b/c/main.c
@@ -46,7 +46,7 @@ void run_tests() {
       if (skipline(buf)) break;
       jv expected = jv_parse(buf);
       jv actual = jq_next();
-      if (!1) {
+      if (!jv_is_valid(actual)) {
         printf("Insufficient results\n");
         pass = 0;
         break;
@@ -59,14 +59,14 @@ void run_tests() {
         pass = 0;
       }
     }
-    if (pass && 0) { /*
+    if (pass) {
       jv extra = jq_next();
-      if (extra) {
+      if (jv_is_valid(extra)) {
         printf("Superfluous result: ");
-        json_dumpf(extra, stdout, JSON_ENCODE_ANY);
+        jv_dump(extra);
         printf("\n");
         pass = 0;
-        }*/
+      }
     }
     jq_teardown();
     bytecode_free(bc);
diff --git a/c/testdata b/c/testdata
index 2cdaaa5f..c6388d67 100644
--- a/c/testdata
+++ b/c/testdata
@@ -59,11 +59,9 @@ null
 {"foo": {"bar": 42}, "bar": "badvalue"}
 42
 
-
-# FIXME strings
-# .["foo"].bar
-# {"foo": {"bar": 42}, "bar": "badvalue"}
-# 42
+.["foo"].bar
+{"foo": {"bar": 42}, "bar": "badvalue"}
+42
 
 
 #
@@ -172,6 +170,12 @@ true
 [1]
 true
 
+null,1,null
+"hello"
+null
+1
+null
+
 [1,2,3]
 [5,6]
 [1,2,3]
@@ -193,3 +197,18 @@ def id(x):x; 2000 as $x | def f(x):1 as $x | id([$x, x, x]); def g(x): 100 as $x
 [[20,10][1,0] as $x | def f: (100,200) as $y | def g: [$x + $y, .]; . + $x | g; f[0] | [f][0][1] | f]
 "woo, testing!"
 [[110.0, 130.0], [210.0, 130.0], [110.0, 230.0], [210.0, 230.0], [120.0, 160.0], [220.0, 160.0], [120.0, 260.0], [220.0, 260.0]]
+
+#
+# Assignment
+#
+.message = "goodbye"
+{"message": "hello"}
+{"message": "goodbye"}
+
+.foo = .bar
+{"bar":42}
+{"foo":42, "bar":42}
+
+def inc(x): x |= .+1; inc(.[].a)
+[{"a":1,"b":2},{"a":2,"b":4},{"a":7,"b":8}]
+[{"a":2,"b":2},{"a":3,"b":4},{"a":8,"b":8}]

From c9dbe1aff87fcee77843e168e0417fe708aaf4a8 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 3 Sep 2012 16:42:58 +0100
Subject: [PATCH 033/284] squash a debug printf

---
 c/jv_parse.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/c/jv_parse.c b/c/jv_parse.c
index 1f6a20aa..ccff509d 100644
--- a/c/jv_parse.c
+++ b/c/jv_parse.c
@@ -347,7 +347,6 @@ static pfunc finish(struct jv_parser* p) {
 }
 
 jv jv_parse_sized(const char* string, int length) {
-  printf("'%s' [%d]", string, length);
   struct jv_parser parser;
   jv_parser_init(&parser);
 

From eea05ff9248210210977cd5679b90437bc3733ff Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 3 Sep 2012 16:50:38 +0100
Subject: [PATCH 034/284] Perl-style autovivification.

.foo.bar = 1 will cause objects to be created if they don't exist.
---
 c/jv.c     | 19 ++++++++++++++-----
 c/jv.h     | 32 +++++++++++++++++++++++++++-----
 c/testdata | 18 ++++++++++++++++--
 3 files changed, 57 insertions(+), 12 deletions(-)

diff --git a/c/jv.c b/c/jv.c
index 4484dc9f..9a3d308f 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -125,10 +125,13 @@ static int jvp_array_length(jv_complex* a) {
 }
 
 static jv* jvp_array_read(jv_complex* a, int i) {
-  assert(i >= 0 && i < jvp_array_length(a));
-  jvp_array* array = jvp_array_ptr(a);
-  assert(i + a->i[0] < array->length);
-  return &array->elements[i + a->i[0]];
+  if (i >= 0 && i < jvp_array_length(a)) {
+    jvp_array* array = jvp_array_ptr(a);
+    assert(i + a->i[0] < array->length);
+    return &array->elements[i + a->i[0]];
+  } else {
+    return 0;
+  }
 }
 
 static jv* jvp_array_write(jv_complex* a, int i) {
@@ -223,7 +226,13 @@ int jv_array_length(jv j) {
 
 jv jv_array_get(jv j, int idx) {
   assert(jv_get_kind(j) == JV_KIND_ARRAY);
-  jv val = jv_copy(*jvp_array_read(&j.val.complex, idx));
+  jv* slot = jvp_array_read(&j.val.complex, idx);
+  jv val;
+  if (slot) {
+    val = jv_copy(*slot);
+  } else {
+    val = jv_invalid();
+  }
   jv_free(j);
   return val;
 }
diff --git a/c/jv.h b/c/jv.h
index b251329c..8d9ebadb 100644
--- a/c/jv.h
+++ b/c/jv.h
@@ -104,6 +104,14 @@ static jv jv_lookup(jv t, jv k) {
   } else if (jv_get_kind(t) == JV_KIND_ARRAY && jv_get_kind(k) == JV_KIND_NUMBER) {
     // FIXME: don't do lookup for noninteger index
     v = jv_array_get(t, (int)jv_number_value(k));
+    if (!jv_is_valid(v)) {
+      v = jv_null();
+    }
+  } else if (jv_get_kind(t) == JV_KIND_NULL && 
+             (jv_get_kind(k) == JV_KIND_STRING || jv_get_kind(k) == JV_KIND_NUMBER)) {
+    jv_free(t);
+    jv_free(k);
+    v = jv_null();
   } else {
     assert(0&&"bad lookup");
   }
@@ -118,12 +126,26 @@ static jv jv_lookup(jv t, jv k) {
 }
 
 static jv jv_modify(jv t, jv k, jv v) {
-  if (jv_get_kind(t) == JV_KIND_OBJECT && jv_get_kind(k) == JV_KIND_STRING) {
-    t = jv_object_set(t, k, v);
-  } else if (jv_get_kind(t) == JV_KIND_ARRAY && jv_get_kind(k) == JV_KIND_NUMBER) {
-    t = jv_array_set(t, (int)jv_number_value(k), v);
+  if (jv_get_kind(k) == JV_KIND_STRING) {
+    if (jv_get_kind(t) == JV_KIND_NULL) {
+      t = jv_object();
+    }
+    if (jv_get_kind(t) == JV_KIND_OBJECT) {
+      t = jv_object_set(t, k, v);
+    } else {
+      assert(0 && "bad mod - not an object");
+    }
+  } else if (jv_get_kind(k) == JV_KIND_NUMBER) {
+    if (jv_get_kind(t) == JV_KIND_NULL) {
+      t = jv_array();
+    }
+    if (jv_get_kind(t) == JV_KIND_ARRAY) {
+      t = jv_array_set(t, (int)jv_number_value(k), v);
+    } else {
+      assert(0 && "bad mod - not an array");
+    }
   } else {
-    assert(0 && "bad mod");
+    assert(0 && "bad mod - seriously, wtf");
   }
   return t;
 }
diff --git a/c/testdata b/c/testdata
index c6388d67..70071186 100644
--- a/c/testdata
+++ b/c/testdata
@@ -133,12 +133,18 @@ null
 # Builtin functions
 #
 
-# FIXME: floats vs. integer
-
 1+1
 null
 2
 
+1+1
+"wtasdf"
+2.0
+
+1e+0+0.001e3
+"I wonder what this will be?"
+20e-1
+
 .+4
 15
 19.0
@@ -212,3 +218,11 @@ def id(x):x; 2000 as $x | def f(x):1 as $x | id([$x, x, x]); def g(x): 100 as $x
 def inc(x): x |= .+1; inc(.[].a)
 [{"a":1,"b":2},{"a":2,"b":4},{"a":7,"b":8}]
 [{"a":2,"b":2},{"a":3,"b":4},{"a":8,"b":8}]
+
+.[2][3] = 1
+[4]
+[4, null, [null, null, null, 1]]
+
+.foo[2].bar = 1
+{"foo":[11], "bar":42}
+{"foo":[11,null,{"bar":1}], "bar":42}

From 32e324a283cea97a2c4c2016d10666ce83336dc7 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 3 Sep 2012 17:18:10 +0100
Subject: [PATCH 035/284] Fix a memory leak in JV and add more tests

---
 c/jv.c     | 4 +++-
 c/testdata | 8 ++++++++
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/c/jv.c b/c/jv.c
index 9a3d308f..80b9b9b8 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -240,7 +240,9 @@ jv jv_array_get(jv j, int idx) {
 jv jv_array_set(jv j, int idx, jv val) {
   assert(jv_get_kind(j) == JV_KIND_ARRAY);
   // copy/free of val,j coalesced
-  *jvp_array_write(&j.val.complex, idx) = val;
+  jv* slot = jvp_array_write(&j.val.complex, idx);
+  jv_free(*slot);
+  *slot = val;
   return j;
 }
 
diff --git a/c/testdata b/c/testdata
index 70071186..6ddf09fd 100644
--- a/c/testdata
+++ b/c/testdata
@@ -215,6 +215,14 @@ def id(x):x; 2000 as $x | def f(x):1 as $x | id([$x, x, x]); def g(x): 100 as $x
 {"bar":42}
 {"foo":42, "bar":42}
 
+.foo |= .+1
+{"foo": 42}
+{"foo": 43}
+
+.[0].a |= {"old":., "new":(.+1)}
+[{"a":1,"b":2}]
+[{"a":{"old":1, "new":2},"b":2}]
+
 def inc(x): x |= .+1; inc(.[].a)
 [{"a":1,"b":2},{"a":2,"b":4},{"a":7,"b":8}]
 [{"a":2,"b":2},{"a":3,"b":4},{"a":8,"b":8}]

From 520c7bb15ea01e9516ff1387ec8b01a5b5b7c1c5 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 3 Sep 2012 17:26:52 +0100
Subject: [PATCH 036/284] Fix some confusion between "null" and "invalid".

---
 c/execute.c      | 5 ++---
 c/frame_layout.h | 2 +-
 c/jv.c           | 4 ++--
 c/jv_parse.c     | 6 +++---
 c/main.c         | 2 ++
 5 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/c/execute.c b/c/execute.c
index d98872b3..b7818d12 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -22,7 +22,6 @@ typedef struct {
 jv* pathbuf;
 int pathsize; // number of allocated elements
 
-// FIXME mem
 int path_push(stackval sv, jv val) {
   int pos = sv.pathidx;
   assert(pos <= pathsize);
@@ -32,7 +31,7 @@ int path_push(stackval sv, jv val) {
     pathsize = oldpathsize ? oldpathsize * 2 : 100;
     pathbuf = realloc(pathbuf, sizeof(pathbuf[0]) * pathsize);
     for (int i=oldpathsize; i<pathsize; i++) {
-      pathbuf[i] = jv_null();
+      pathbuf[i] = jv_invalid();
     }
   }
   jv_free(pathbuf[pos]);
@@ -179,7 +178,7 @@ jv jq_next() {
 
     case LOADK: {
       jv v = jv_array_get(jv_copy(frame_current_bytecode(&frame_stk)->constants), *pc++);
-      //FIXME assert(v);
+      assert(jv_is_valid(v));
       stack_push(stackval_replace(stack_pop(), v));
       break;
     }
diff --git a/c/frame_layout.h b/c/frame_layout.h
index d2218e92..f098272e 100644
--- a/c/frame_layout.h
+++ b/c/frame_layout.h
@@ -88,7 +88,7 @@ static frame_ptr frame_push(struct forkable_stack* stk, struct closure cl, uint1
   cc->retaddr = retaddr;
   cc->is_backtrack_frame = 0;
   for (int i=0; i<cl.bc->nlocals; i++) {
-    *frame_local_var(fp, i) = jv_null();
+    *frame_local_var(fp, i) = jv_invalid();
   }
   return fp;
 }
diff --git a/c/jv.c b/c/jv.c
index 80b9b9b8..c4a5af1c 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -619,7 +619,7 @@ static jv* jvp_object_write(jv_complex* object, jvp_string* key) {
     jvp_string_free_p(key);
   } else {
     slot = jvp_object_add_slot(object, key, bucket);
-    slot->value = jv_null();
+    slot->value = jv_invalid();
   }
   if (slot == 0) {
     jvp_object_rehash(object);
@@ -627,7 +627,7 @@ static jv* jvp_object_write(jv_complex* object, jvp_string* key) {
     assert(!jvp_object_find_slot(object, key, bucket));
     slot = jvp_object_add_slot(object, key, bucket);
     assert(slot);
-    slot->value = jv_null();
+    slot->value = jv_invalid();
   }
   return &slot->value;
 }
diff --git a/c/jv_parse.c b/c/jv_parse.c
index ccff509d..987bb9e2 100644
--- a/c/jv_parse.c
+++ b/c/jv_parse.c
@@ -18,7 +18,7 @@ void jv_parser_init(struct jv_parser* p) {
   p->stack = 0;
   p->stacklen = p->stackpos = 0;
   p->hasnext = 0;
-  p->next = jv_null(); //FIXME: jv_invalid
+  p->next = jv_invalid(); //FIXME: jv_invalid
   p->tokenbuf = 0;
   p->tokenlen = p->tokenpos = 0;
   p->st = JV_PARSER_NORMAL;
@@ -357,13 +357,13 @@ jv jv_parse_sized(const char* string, int length) {
     presult msg = scan(&parser, ch);
     if (msg){
       printf("ERROR: %s (parsing '%s')\n", msg, string);
-      return jv_null();
+      return jv_invalid();
     }
   }
   presult msg = finish(&parser);
   if (msg) {
     printf("ERROR: %s (parsing '%s')\n", msg, string);
-    return jv_null();
+    return jv_invalid();
   }
   jv value = jv_copy(parser.next);
   jv_parser_free(&parser);
diff --git a/c/main.c b/c/main.c
index 5879d031..bad85418 100644
--- a/c/main.c
+++ b/c/main.c
@@ -40,11 +40,13 @@ void run_tests() {
     printf("\n");
     fgets(buf, sizeof(buf), testdata);
     jv input = jv_parse(buf);
+    assert(jv_is_valid(input));
     jq_init(bc, input);
 
     while (fgets(buf, sizeof(buf), testdata)) {
       if (skipline(buf)) break;
       jv expected = jv_parse(buf);
+      assert(jv_is_valid(expected));
       jv actual = jq_next();
       if (!jv_is_valid(actual)) {
         printf("Insufficient results\n");

From 5add2c2ceb763104206cd70bd2678575362c1008 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 4 Sep 2012 15:34:34 +0100
Subject: [PATCH 037/284] if-then-else and defined-or operators

---
 c/compile.c     | 47 +++++++++++++++++++++++++++++++++++++++++++++--
 c/compile.h     |  4 +++-
 c/execute.c     | 13 +++++++++++++
 c/lexer.l       |  5 +++++
 c/opcode_list.h |  1 +
 c/parser.y      | 15 +++++++++++++++
 c/testdata      | 15 +++++++++++++++
 7 files changed, 97 insertions(+), 3 deletions(-)

diff --git a/c/compile.c b/c/compile.c
index b7fcc4f2..c83a5583 100644
--- a/c/compile.c
+++ b/c/compile.c
@@ -312,8 +312,51 @@ block gen_assign(block expr) {
   return c;
 }
 
-block gen_else(block a, block b) {
-  assert(0);
+block gen_definedor(block a, block b) {
+  // var found := false
+  block c = gen_op_simple(DUP);
+  block_append(&c, gen_op_const(LOADK, jv_false()));
+  block found_var = block_bind(gen_op_var_unbound(STOREV, "found"),
+                               gen_noop(), OP_HAS_VARIABLE);
+  block_append(&c, found_var);
+
+  // if found, backtrack. Otherwise execute b
+  block tail = gen_op_simple(DUP);
+  block_append(&tail, gen_op_var_bound(LOADV, found_var));
+  block backtrack = gen_op_simple(BACKTRACK);
+  block_append(&tail, gen_op_target(JUMP_F, backtrack));
+  block_append(&tail, backtrack);
+  block_append(&tail, gen_op_simple(POP));
+  block_append(&tail, b);
+
+  // try again
+  block if_notfound = gen_op_simple(BACKTRACK);
+
+  // found := true, produce result
+  block if_found = gen_op_simple(DUP);
+  block_append(&if_found, gen_op_const(LOADK, jv_true()));
+  block_append(&if_found, gen_op_var_bound(STOREV, found_var));
+  block_append(&if_found, gen_op_target(JUMP, tail));
+
+  block_append(&c, gen_op_target(FORK, if_notfound));
+  block_append(&c, a);
+  block_append(&c, gen_op_target(JUMP_F, if_found));
+  block_append(&c, if_found);
+  block_append(&c, if_notfound);
+  block_append(&c, tail);
+
+  return c;
+}
+
+block gen_cond(block cond, block iftrue, block iffalse) {
+  block b = gen_op_simple(DUP);
+  block_append(&b, cond);
+
+  block_append(&iftrue, gen_op_target(JUMP, iffalse));
+  block_append(&b, gen_op_target(JUMP_F, iftrue));
+  block_append(&b, block_join(gen_op_simple(POP), iftrue));
+  block_append(&b, block_join(gen_op_simple(POP), iffalse));
+  return b;
 }
 
 block gen_cbinding(struct symbol_table* t, block code) {
diff --git a/c/compile.h b/c/compile.h
index 5f0be89b..5a2faf7b 100644
--- a/c/compile.h
+++ b/c/compile.h
@@ -26,7 +26,9 @@ block gen_subexp(block a);
 block gen_both(block a, block b);
 block gen_collect(block expr);
 block gen_assign(block expr);
-block gen_else(block a, block b);
+block gen_definedor(block a, block b);
+
+block gen_cond(block cond, block iftrue, block iffalse);
 
 block gen_cbinding(struct symbol_table* functions, block b);
 
diff --git a/c/execute.c b/c/execute.c
index b7818d12..5e6a2c51 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -59,6 +59,7 @@ typedef struct {
 } data_stk_elem;
 
 void stack_push(stackval val) {
+  assert(jv_is_valid(val.value));
   data_stk_elem* s = forkable_stack_push(&data_stk, sizeof(data_stk_elem));
   s->sv = val;
 }
@@ -70,6 +71,7 @@ stackval stack_pop() {
     sv.value = jv_copy(sv.value);
   }
   forkable_stack_pop(&data_stk);
+  assert(jv_is_valid(sv.value));
   return sv;
 }
 
@@ -292,6 +294,17 @@ jv jq_next() {
       break;
     }
 
+    case JUMP_F: {
+      uint16_t offset = *pc++;
+      stackval t = stack_pop();
+      jv_kind kind = jv_get_kind(t.value);
+      if (kind == JV_KIND_FALSE || kind == JV_KIND_NULL) {
+        pc += offset;
+      }
+      stack_push(t); // FIXME do this better
+      break;
+    }
+
     case EACH: 
       stack_push(stackval_root(jv_number(0)));
       // fallthrough
diff --git a/c/lexer.l b/c/lexer.l
index 4acb026a..e3c140b6 100644
--- a/c/lexer.l
+++ b/c/lexer.l
@@ -13,6 +13,11 @@
 "as" { return AS; }
 "def" { return DEF; }
 "|=" { return SETPIPE; }
+"if" { return IF; }
+"then" { return THEN; }
+"else" { return ELSE; }
+"end" { return END; }
+"//" { return DEFINEDOR; }
 "."|"="|";"|"["|"]"|","|":"|"("|")"|"{"|"}"|"|"|"+"|"\$" { return yytext[0];}
 
 \"(\\.|[^\\"])*\" |
diff --git a/c/opcode_list.h b/c/opcode_list.h
index 7f2c144a..30e7203d 100644
--- a/c/opcode_list.h
+++ b/c/opcode_list.h
@@ -10,6 +10,7 @@ OP(YIELD, NONE, 1, 0)
 OP(EACH,  NONE,     1, 1)
 OP(FORK,  BRANCH,   0, 0)
 OP(JUMP,  BRANCH,   0, 0)
+OP(JUMP_F,BRANCH,   1, 0)
 OP(BACKTRACK, NONE, 0, 0)
 OP(APPEND, NONE,    2, 1)
 OP(INSERT, NONE,    4, 2)
diff --git a/c/parser.y b/c/parser.y
index 36292453..d4e8d8f4 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -25,13 +25,20 @@
 %left '|'
 %left ','
 %token EQ "=="
+%token DEFINEDOR "//"
 %token AS "as"
 %token DEF "def"
 %token SETPIPE "|="
+%token IF "if"
+%token THEN "then"
+%token ELSE "else"
+%token END "end"
+%right "//"
 %nonassoc '=' SETPIPE
 %nonassoc EQ
 %left '+'
 
+
 %type <blk> Exp Term MkDict MkDictPair ExpD
 
 %{
@@ -78,6 +85,10 @@ Term "as" '$' IDENT '|' Exp {
   jv_free($4);
 } |
 
+"if" Exp "then" Exp "else" Exp "end" {
+  $$ = gen_cond($2, $4, $6);
+} |
+
 Exp '=' Exp {
   block assign = gen_op_simple(DUP);
   block_append(&assign, $3);
@@ -87,6 +98,10 @@ Exp '=' Exp {
   $$ = gen_assign(assign);
 } |
 
+Exp "//" Exp {
+  $$ = gen_definedor($1, $3);
+} |
+
 Exp "|=" Exp {
   block assign = $1;
   block_append(&assign, gen_op_simple(DUP));
diff --git a/c/testdata b/c/testdata
index 6ddf09fd..888d8b74 100644
--- a/c/testdata
+++ b/c/testdata
@@ -234,3 +234,18 @@ def inc(x): x |= .+1; inc(.[].a)
 .foo[2].bar = 1
 {"foo":[11], "bar":42}
 {"foo":[11,null,{"bar":1}], "bar":42}
+
+#
+# Conditionals
+#
+
+[.[] | if .foo then "yep" else "nope" end]
+[{"foo":0},{"foo":1},{"foo":[]},{"foo":true},{"foo":false},{"foo":null},{"foo":"foo"},{}]
+["yep","yep","yep","yep","nope","nope","yep","nope"]
+
+# FIXME: define/test behaviour of 'if (.foo,.bar) then A else B end'
+
+[.[] | [.foo[] // .bar]]
+[{"foo":[1,2], "bar": 42}, {"foo":[1], "bar": null}, {"foo":[null,false,3], "bar": 18}, {"foo":[], "bar":42}, {"foo": [null,false,null], "bar": 41}]
+[[1,2], [1], [3], [42], [41]]
+

From 328c4a13f1d63b02cbc7afe8e46a16ef4f896f07 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 4 Sep 2012 16:05:24 +0100
Subject: [PATCH 038/284] Add "elif" to if-then-else constructs.

---
 c/lexer.l  |  1 +
 c/parser.y | 15 ++++++++++++---
 c/testdata |  5 +++++
 3 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/c/lexer.l b/c/lexer.l
index e3c140b6..98365f1f 100644
--- a/c/lexer.l
+++ b/c/lexer.l
@@ -16,6 +16,7 @@
 "if" { return IF; }
 "then" { return THEN; }
 "else" { return ELSE; }
+"elif" { return ELSE_IF; }
 "end" { return END; }
 "//" { return DEFINEDOR; }
 "."|"="|";"|"["|"]"|","|":"|"("|")"|"{"|"}"|"|"|"+"|"\$" { return yytext[0];}
diff --git a/c/parser.y b/c/parser.y
index d4e8d8f4..165cdb42 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -32,6 +32,7 @@
 %token IF "if"
 %token THEN "then"
 %token ELSE "else"
+%token ELSE_IF "elif"
 %token END "end"
 %right "//"
 %nonassoc '=' SETPIPE
@@ -39,7 +40,7 @@
 %left '+'
 
 
-%type <blk> Exp Term MkDict MkDictPair ExpD
+%type <blk> Exp Term MkDict MkDictPair ExpD ElseBody
 
 %{
 #include "lexer.yy.h"
@@ -85,8 +86,8 @@ Term "as" '$' IDENT '|' Exp {
   jv_free($4);
 } |
 
-"if" Exp "then" Exp "else" Exp "end" {
-  $$ = gen_cond($2, $4, $6);
+"if" Exp "then" Exp ElseBody {
+  $$ = gen_cond($2, $4, $5);
 } |
 
 Exp '=' Exp {
@@ -128,6 +129,14 @@ Term {
   $$ = $1; 
 }
 
+ElseBody:
+"elif" Exp "then" Exp ElseBody {
+  $$ = gen_cond($2, $4, $5);
+} |
+"else" Exp "end" {
+  $$ = $2;
+}
+
 
 ExpD:
 ExpD '|' ExpD { 
diff --git a/c/testdata b/c/testdata
index 888d8b74..3fe231f5 100644
--- a/c/testdata
+++ b/c/testdata
@@ -243,6 +243,11 @@ def inc(x): x |= .+1; inc(.[].a)
 [{"foo":0},{"foo":1},{"foo":[]},{"foo":true},{"foo":false},{"foo":null},{"foo":"foo"},{}]
 ["yep","yep","yep","yep","nope","nope","yep","nope"]
 
+[.[] | if .baz then "strange" elif .foo then "yep" else "nope" end]
+[{"foo":0},{"foo":1},{"foo":[]},{"foo":true},{"foo":false},{"foo":null},{"foo":"foo"},{}]
+["yep","yep","yep","yep","nope","nope","yep","nope"]
+
+
 # FIXME: define/test behaviour of 'if (.foo,.bar) then A else B end'
 
 [.[] | [.foo[] // .bar]]

From c5ab3b2336a3ad14844bd91beae5b4dbca2c2926 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 4 Sep 2012 20:34:43 +0100
Subject: [PATCH 039/284] Move some unicode handling stuff to a separate file.

---
 c/Makefile     |  2 +-
 c/jv_parse.c   | 24 ++----------------------
 c/jv_unicode.c | 30 ++++++++++++++++++++++++++++++
 c/jv_unicode.h |  7 +++++++
 4 files changed, 40 insertions(+), 23 deletions(-)
 create mode 100644 c/jv_unicode.c
 create mode 100644 c/jv_unicode.h

diff --git a/c/Makefile b/c/Makefile
index d437b143..6496da8b 100644
--- a/c/Makefile
+++ b/c/Makefile
@@ -17,7 +17,7 @@ parser.tab.c: parser.y lexer.yy.h
 	bison -W -d parser.y -v --report-file=parser.info
 parser.tab.h: parser.tab.c
 
-parsertest: parser.tab.c lexer.yy.c main.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c
+parsertest: parser.tab.c lexer.yy.c main.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c
 	$(CC) -o $@ $^
 
 jv_test: jv_test.c jv.c jv_print.c jv_dtoa.c
diff --git a/c/jv_parse.c b/c/jv_parse.c
index 987bb9e2..7a8c811e 100644
--- a/c/jv_parse.c
+++ b/c/jv_parse.c
@@ -4,6 +4,7 @@
 #include "jv.h"
 #include "jv_dtoa.h"
 #include "jv_parse.h"
+#include "jv_unicode.h"
 
 typedef const char* presult;
 
@@ -157,27 +158,6 @@ static int unhex4(char* hex) {
   return r;
 }
 
-static int utf8_encode(int codepoint, char* out) {
-  assert(codepoint >= 0 && codepoint <= 0x10FFFF);
-  char* start = out;
-  if (codepoint <= 0x7F) {
-    *out++ = codepoint;
-  } else if (codepoint <= 0x7FF) {
-    *out++ = 0xC0 + ((codepoint & 0x7C0) >> 6);
-    *out++ = 0x80 + ((codepoint & 0x03F));
-  } else if(codepoint <= 0xFFFF) {
-    *out++ = 0xE0 + ((codepoint & 0xF000) >> 12);
-    *out++ = 0x80 + ((codepoint & 0x0FC0) >> 6);
-    *out++ = 0x80 + ((codepoint & 0x003F));
-  } else {
-    *out++ = 0xF0 + ((codepoint & 0x1C0000) >> 18);
-    *out++ = 0x80 + ((codepoint & 0x03F000) >> 12);
-    *out++ = 0x80 + ((codepoint & 0x000FC0) >> 6);
-    *out++ = 0x80 + ((codepoint & 0x00003F));
-  }
-  return out - start;
-}
-
 static pfunc found_string(struct jv_parser* p) {
   char* in = p->tokenbuf;
   char* out = p->tokenbuf;
@@ -217,7 +197,7 @@ static pfunc found_string(struct jv_parser* p) {
                                  |(surrogate - 0xDC00));
         }
         // FIXME assert valid codepoint
-        out += utf8_encode(codepoint, out);
+        out += jvp_utf8_encode(codepoint, out);
         break;
 
       default:
diff --git a/c/jv_unicode.c b/c/jv_unicode.c
new file mode 100644
index 00000000..b1475ff6
--- /dev/null
+++ b/c/jv_unicode.c
@@ -0,0 +1,30 @@
+#include <assert.h>
+#include "jv_unicode.h"
+int jvp_utf8_encode_length(int codepoint) {
+  if (codepoint <= 0x7F) return 1;
+  else if (codepoint <= 0x7FF) return 2;
+  else if (codepoint <= 0xFFFF) return 3;
+  else return 4;
+}
+
+int jvp_utf8_encode(int codepoint, char* out) {
+  assert(codepoint >= 0 && codepoint <= 0x10FFFF);
+  char* start = out;
+  if (codepoint <= 0x7F) {
+    *out++ = codepoint;
+  } else if (codepoint <= 0x7FF) {
+    *out++ = 0xC0 + ((codepoint & 0x7C0) >> 6);
+    *out++ = 0x80 + ((codepoint & 0x03F));
+  } else if(codepoint <= 0xFFFF) {
+    *out++ = 0xE0 + ((codepoint & 0xF000) >> 12);
+    *out++ = 0x80 + ((codepoint & 0x0FC0) >> 6);
+    *out++ = 0x80 + ((codepoint & 0x003F));
+  } else {
+    *out++ = 0xF0 + ((codepoint & 0x1C0000) >> 18);
+    *out++ = 0x80 + ((codepoint & 0x03F000) >> 12);
+    *out++ = 0x80 + ((codepoint & 0x000FC0) >> 6);
+    *out++ = 0x80 + ((codepoint & 0x00003F));
+  }
+  assert(out - start == jvp_utf8_encode_length(codepoint));
+  return out - start;
+}
diff --git a/c/jv_unicode.h b/c/jv_unicode.h
new file mode 100644
index 00000000..041c29aa
--- /dev/null
+++ b/c/jv_unicode.h
@@ -0,0 +1,7 @@
+#ifndef JV_UNICODE_H
+#define JV_UNICODE_H
+int jvp_utf8_decode_length(char startchar);
+
+int jvp_utf8_encode_length(int codepoint);
+int jvp_utf8_encode(int codepoint, char* out);
+#endif

From 6e6ea507630eceafd2cb2eb8e25bae231ee6f8a6 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 4 Sep 2012 20:38:59 +0100
Subject: [PATCH 040/284] Short-circuiting Boolean "and" and "or" operators.

---
 c/compile.c | 45 ++++++++++++++++++++++++++++++++++++++++-----
 c/compile.h |  2 ++
 c/lexer.l   |  2 ++
 c/parser.y  | 12 ++++++++++++
 c/testdata  |  6 ++++++
 5 files changed, 62 insertions(+), 5 deletions(-)

diff --git a/c/compile.c b/c/compile.c
index c83a5583..c4782f1d 100644
--- a/c/compile.c
+++ b/c/compile.c
@@ -348,14 +348,49 @@ block gen_definedor(block a, block b) {
   return c;
 }
 
+static block gen_condbranch(block iftrue, block iffalse) {
+  block b = gen_noop();
+  block_append(&iftrue, gen_op_target(JUMP, iffalse));
+  block_append(&b, gen_op_target(JUMP_F, iftrue));
+  block_append(&b, iftrue);
+  block_append(&b, iffalse);
+  return b;
+}
+
+block gen_and(block a, block b) {
+  // a and b = if a then (if b then true else false) else false
+  block code = gen_op_simple(DUP);
+  block_append(&code, a);
+
+  block if_a_true = gen_op_simple(POP);
+  block_append(&if_a_true, b);
+  block_append(&if_a_true, gen_condbranch(gen_op_const(LOADK, jv_true()),
+                                          gen_op_const(LOADK, jv_false())));
+  block_append(&code, gen_condbranch(if_a_true,
+                                     block_join(gen_op_simple(POP), gen_op_const(LOADK, jv_false()))));
+  return code;
+}
+
+block gen_or(block a, block b) {
+  // a or b = if a then true else (if b then true else false)
+  block code = gen_op_simple(DUP);
+  block_append(&code, a);
+
+  block if_a_false = gen_op_simple(POP);
+  block_append(&if_a_false, b);
+  block_append(&if_a_false, gen_condbranch(gen_op_const(LOADK, jv_true()),
+                                           gen_op_const(LOADK, jv_false())));
+  block_append(&code, gen_condbranch(block_join(gen_op_simple(POP), gen_op_const(LOADK, jv_true())),
+                                     if_a_false));
+  return code;
+  
+}
+
 block gen_cond(block cond, block iftrue, block iffalse) {
   block b = gen_op_simple(DUP);
   block_append(&b, cond);
-
-  block_append(&iftrue, gen_op_target(JUMP, iffalse));
-  block_append(&b, gen_op_target(JUMP_F, iftrue));
-  block_append(&b, block_join(gen_op_simple(POP), iftrue));
-  block_append(&b, block_join(gen_op_simple(POP), iffalse));
+  block_append(&b, gen_condbranch(block_join(gen_op_simple(POP), iftrue),
+                                  block_join(gen_op_simple(POP), iffalse)));
   return b;
 }
 
diff --git a/c/compile.h b/c/compile.h
index 5a2faf7b..1a7c62c6 100644
--- a/c/compile.h
+++ b/c/compile.h
@@ -27,6 +27,8 @@ block gen_both(block a, block b);
 block gen_collect(block expr);
 block gen_assign(block expr);
 block gen_definedor(block a, block b);
+block gen_and(block a, block b);
+block gen_or(block a, block b);
 
 block gen_cond(block cond, block iftrue, block iffalse);
 
diff --git a/c/lexer.l b/c/lexer.l
index 98365f1f..47789d29 100644
--- a/c/lexer.l
+++ b/c/lexer.l
@@ -17,6 +17,8 @@
 "then" { return THEN; }
 "else" { return ELSE; }
 "elif" { return ELSE_IF; }
+"and" { return AND; }
+"or" { return OR; }
 "end" { return END; }
 "//" { return DEFINEDOR; }
 "."|"="|";"|"["|"]"|","|":"|"("|")"|"{"|"}"|"|"|"+"|"\$" { return yytext[0];}
diff --git a/c/parser.y b/c/parser.y
index 165cdb42..5b997e62 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -34,9 +34,13 @@
 %token ELSE "else"
 %token ELSE_IF "elif"
 %token END "end"
+%token AND "and"
+%token OR "or"
 %right "//"
 %nonassoc '=' SETPIPE
 %nonassoc EQ
+%left OR
+%left AND
 %left '+'
 
 
@@ -99,6 +103,14 @@ Exp '=' Exp {
   $$ = gen_assign(assign);
 } |
 
+Exp "or" Exp {
+  $$ = gen_or($1, $3);
+} | 
+
+Exp "and" Exp {
+  $$ = gen_and($1, $3);
+} |
+
 Exp "//" Exp {
   $$ = gen_definedor($1, $3);
 } |
diff --git a/c/testdata b/c/testdata
index 3fe231f5..4241c6cd 100644
--- a/c/testdata
+++ b/c/testdata
@@ -254,3 +254,9 @@ def inc(x): x |= .+1; inc(.[].a)
 [{"foo":[1,2], "bar": 42}, {"foo":[1], "bar": null}, {"foo":[null,false,3], "bar": 18}, {"foo":[], "bar":42}, {"foo": [null,false,null], "bar": 41}]
 [[1,2], [1], [3], [42], [41]]
 
+.[] | [.[0] and .[1], .[0] or .[1]]
+[[true,[]], [false,1], [42,null], [null,false]]
+[true,true]
+[false,true]
+[false,true]
+[false,false]

From da5d653de8920091fb689a85eabdfc2c34278b1b Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 4 Sep 2012 20:43:40 +0100
Subject: [PATCH 041/284] Add a Boolean "not" operator.

Not wholly convinced this is a good idea, maybe "not" should be a
builtin function instead? 'not (.a == .b)' vs. '.a == .b | not'
---
 c/compile.c | 6 +++++-
 c/compile.h | 1 +
 c/lexer.l   | 1 +
 c/parser.y  | 5 +++++
 c/testdata  | 4 ++++
 5 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/c/compile.c b/c/compile.c
index c4782f1d..b7f91aa3 100644
--- a/c/compile.c
+++ b/c/compile.c
@@ -383,7 +383,11 @@ block gen_or(block a, block b) {
   block_append(&code, gen_condbranch(block_join(gen_op_simple(POP), gen_op_const(LOADK, jv_true())),
                                      if_a_false));
   return code;
-  
+}
+
+block gen_not(block a) {
+  return block_join(a, gen_condbranch(gen_op_const(LOADK, jv_false()),
+                                      gen_op_const(LOADK, jv_true())));
 }
 
 block gen_cond(block cond, block iftrue, block iffalse) {
diff --git a/c/compile.h b/c/compile.h
index 1a7c62c6..8f9526b0 100644
--- a/c/compile.h
+++ b/c/compile.h
@@ -29,6 +29,7 @@ block gen_assign(block expr);
 block gen_definedor(block a, block b);
 block gen_and(block a, block b);
 block gen_or(block a, block b);
+block gen_not(block a);
 
 block gen_cond(block cond, block iftrue, block iffalse);
 
diff --git a/c/lexer.l b/c/lexer.l
index 47789d29..f2651762 100644
--- a/c/lexer.l
+++ b/c/lexer.l
@@ -19,6 +19,7 @@
 "elif" { return ELSE_IF; }
 "and" { return AND; }
 "or" { return OR; }
+"not" { return NOT; }
 "end" { return END; }
 "//" { return DEFINEDOR; }
 "."|"="|";"|"["|"]"|","|":"|"("|")"|"{"|"}"|"|"|"+"|"\$" { return yytext[0];}
diff --git a/c/parser.y b/c/parser.y
index 5b997e62..54456d09 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -36,6 +36,7 @@
 %token END "end"
 %token AND "and"
 %token OR "or"
+%token NOT "not"
 %right "//"
 %nonassoc '=' SETPIPE
 %nonassoc EQ
@@ -111,6 +112,10 @@ Exp "and" Exp {
   $$ = gen_and($1, $3);
 } |
 
+"not" Exp {
+  $$ = gen_not($2);
+} |
+
 Exp "//" Exp {
   $$ = gen_definedor($1, $3);
 } |
diff --git a/c/testdata b/c/testdata
index 4241c6cd..f453edd3 100644
--- a/c/testdata
+++ b/c/testdata
@@ -260,3 +260,7 @@ def inc(x): x |= .+1; inc(.[].a)
 [false,true]
 [false,true]
 [false,false]
+
+[.[] | not .]
+[1,0,false,null,true,"hello"]
+[false,false,true,true,false,false]

From 58a9b0cfe135f6a7a274c1717702c10ac0e7ee5b Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 4 Sep 2012 20:56:44 +0100
Subject: [PATCH 042/284] Make the test harness not segfault when a test fails
 (!)

---
 c/main.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/c/main.c b/c/main.c
index bad85418..b71bcad5 100644
--- a/c/main.c
+++ b/c/main.c
@@ -52,14 +52,16 @@ void run_tests() {
         printf("Insufficient results\n");
         pass = 0;
         break;
-      } else if (!jv_equal(expected, actual)) {
+      } else if (!jv_equal(jv_copy(expected), jv_copy(actual))) {
         printf("Expected ");
-        jv_dump(expected);
+        jv_dump(jv_copy(expected));
         printf(", but got ");
-        jv_dump(actual);
+        jv_dump(jv_copy(actual));
         printf("\n");
         pass = 0;
       }
+      jv_free(expected);
+      jv_free(actual);
     }
     if (pass) {
       jv extra = jq_next();

From 0fd7d4b30cafbc9a1e4fecfafe21921e2923daaa Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 6 Sep 2012 21:36:11 +0100
Subject: [PATCH 043/284] UTF8 coding utilities and unicode escaping in
 jv_dump()'d strings.

Beyond the Basic Multilingual Plane, dead Cthulhu waits dreaming.
---
 c/Makefile           |  4 ++++
 c/gen_utf8_tables.py | 30 ++++++++++++++++++++++++++++++
 c/jv_print.c         | 30 ++++++++++++++++++++++++------
 c/jv_unicode.c       | 34 ++++++++++++++++++++++++++++++++++
 c/jv_unicode.h       |  4 ++++
 5 files changed, 96 insertions(+), 6 deletions(-)
 create mode 100644 c/gen_utf8_tables.py

diff --git a/c/Makefile b/c/Makefile
index 6496da8b..2c4379de 100644
--- a/c/Makefile
+++ b/c/Makefile
@@ -8,6 +8,8 @@ clean:
 	sed 's/.*`\(.*\)'\''.*/\1/' | grep -v '^all$$' | \
 	xargs rm
 
+jv_utf8_tables.h: gen_utf8_tables.py
+	python $^ > $@
 
 lexer.yy.c: lexer.l
 	flex -o lexer.yy.c --header-file=lexer.yy.h lexer.l
@@ -17,6 +19,8 @@ parser.tab.c: parser.y lexer.yy.h
 	bison -W -d parser.y -v --report-file=parser.info
 parser.tab.h: parser.tab.c
 
+jv_unicode.c: jv_utf8_tables.h
+
 parsertest: parser.tab.c lexer.yy.c main.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c
 	$(CC) -o $@ $^
 
diff --git a/c/gen_utf8_tables.py b/c/gen_utf8_tables.py
new file mode 100644
index 00000000..9d8dc3c0
--- /dev/null
+++ b/c/gen_utf8_tables.py
@@ -0,0 +1,30 @@
+#!/usr/bin/python
+
+mask = lambda n: (1 << n) - 1
+
+
+def print_table(type, name, t):
+    assert len(t) == 256
+    print "const static",type, name+"[]", "="
+    first = True
+    for i in range(0,len(t),16):
+        print (" {" if i == 0 else "  ") +\
+            ", ".join("0x%02x"%n for n in t[i:i+16]) + \
+            ("," if i + 16 < 256 else "};")
+
+
+def utf8info(c):
+    if c < 0x80: return 1, mask(7)
+    if 0x80 <= c <= 0xBF: return 255, mask(6)
+    if 0xC0 <= c <= 0xC1: return 0, 0
+    if 0xC2 <= c <= 0xDF: return 2, mask(5)
+    if 0xE0 <= c <= 0xEF: return 3, mask(4)
+    if 0xF0 <= c <= 0xF4: return 4, mask(3)
+    if 0xF4 <= c <= 0xFF: return 0, 0
+        
+table = lambda i: [utf8info(c)[i] for c in range(256)]
+
+print "#define UTF8_CONTINUATION_BYTE ((unsigned char)255)"
+
+print_table("unsigned char", "utf8_coding_length", table(0))
+print_table("unsigned char", "utf8_coding_bits", table(1))
diff --git a/c/jv_print.c b/c/jv_print.c
index c082e935..c9808ea7 100644
--- a/c/jv_print.c
+++ b/c/jv_print.c
@@ -1,22 +1,25 @@
 #include "jv.h"
 #include <stdio.h>
+#include <float.h>
+#include <math.h>
 
 #include "jv_dtoa.h"
+#include "jv_unicode.h"
 
 static void jv_dump_string(jv str, int ascii_only) {
   assert(jv_get_kind(str) == JV_KIND_STRING);
   const char* i = jv_string_value(str);
-  const char* end = i + jv_string_length(str);
-  while (i < end) {
-    int unicode_escape;
-    int c = (unsigned char)*i++;
+  const char* end = i + jv_string_length(jv_copy(str));
+  int c;
+  while ((i = jvp_utf8_next(i, end, &c))) {
+    assert(c != -1);
+    int unicode_escape = 0;
     if (0x20 <= c && c <= 0x7E) {
       // printable ASCII
       if (c == '"' || c == '\\') {
         putchar('\\');
       }
       putchar(c);
-      unicode_escape = 0;
     } else if (c < 0x20 || c == 0x7F) {
       // ASCII control character
       switch (c) {
@@ -44,8 +47,21 @@ static void jv_dump_string(jv str, int ascii_only) {
         unicode_escape = 1;
         break;
       }
+    } else {
+      unicode_escape = 1;
+    }
+    if (unicode_escape) {
+      if (c <= 0xffff) {
+        printf("\\u%04x", c);
+      } else {
+        c -= 0x10000;
+        printf("\\u%04x\\u%04x", 
+               0xD800 | ((c & 0xffc00) >> 10),
+               0xDC00 | (c & 0x003ff));
+      }
     }
   }
+  assert(c != -1);
 }
 
 static void jv_dump_term(struct dtoa_context* C, jv x) {
@@ -65,7 +81,9 @@ static void jv_dump_term(struct dtoa_context* C, jv x) {
     break;
   case JV_KIND_STRING:
     // FIXME: all sorts of broken
-    printf("\"%s\"", jv_string_value(x));
+    putchar('"');
+    jv_dump_string(x, 0);
+    putchar('"');
     break;
   case JV_KIND_ARRAY: {
     printf("[");
diff --git a/c/jv_unicode.c b/c/jv_unicode.c
index b1475ff6..375ad367 100644
--- a/c/jv_unicode.c
+++ b/c/jv_unicode.c
@@ -1,5 +1,39 @@
+#include <stdio.h>
 #include <assert.h>
 #include "jv_unicode.h"
+#include "jv_utf8_tables.h"
+
+const char* jvp_utf8_next(const char* in, const char* end, int* codepoint) {
+  if (in == end) {
+    codepoint = 0;
+    return 0;
+  }
+  unsigned char first = (unsigned char)in[0];
+  int length = utf8_coding_length[first];
+  if (length == 0 || length == UTF8_CONTINUATION_BYTE || in + length > end) {
+    *codepoint = -1;
+    return 0;
+  }
+  *codepoint = ((unsigned)in[0]) & utf8_coding_bits[first];
+  for (int i=1; i<length; i++) {
+    int ch = (unsigned char)in[i];
+    if (utf8_coding_length[(unsigned char)in[i]] != UTF8_CONTINUATION_BYTE){
+      *codepoint = -1;
+      return 0;
+    }
+    *codepoint = (*codepoint << 6) | (ch & 0x3f);
+  }
+  return in + length;
+}
+
+int jvp_utf8_verify(const char* in, const char* end) {
+  int codepoint = 0;
+  while ((in = jvp_utf8_next(in, end, &codepoint))) {
+    if (codepoint == -1) return 0;
+  }
+  return codepoint != -1;
+}
+
 int jvp_utf8_encode_length(int codepoint) {
   if (codepoint <= 0x7F) return 1;
   else if (codepoint <= 0x7FF) return 2;
diff --git a/c/jv_unicode.h b/c/jv_unicode.h
index 041c29aa..78c7a40d 100644
--- a/c/jv_unicode.h
+++ b/c/jv_unicode.h
@@ -1,5 +1,9 @@
 #ifndef JV_UNICODE_H
 #define JV_UNICODE_H
+
+const char* jvp_utf8_next(const char* in, const char* end, int* codepoint);
+
+
 int jvp_utf8_decode_length(char startchar);
 
 int jvp_utf8_encode_length(int codepoint);

From 0dfaebcdcb419a67c7de893dbee5c10c2d6ced29 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 6 Sep 2012 21:44:46 +0100
Subject: [PATCH 044/284] null and string literals now exist, so add tests

---
 c/testdata | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/c/testdata b/c/testdata
index f453edd3..5aa3efed 100644
--- a/c/testdata
+++ b/c/testdata
@@ -13,9 +13,9 @@ false
 null
 false
 
-# null
-# 42
-# null
+null
+42
+null
 
 1
 null
@@ -41,7 +41,9 @@ null
 null
 {"a":1}
 
-# FIXME: string literals
+{a,b,(.d):.a,e:.b}
+{"a":1, "b":2, "c":3, "d":"c"}
+{"a":1, "b":2, "c":1, "e":2}
 
 #
 # Field access, piping

From e6a85737daaefd0066b684ff6fd3d3c5a60b0ac0 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 9 Sep 2012 15:35:34 +0100
Subject: [PATCH 045/284] Print bad number values (Inf,NaN) "correctly".

---
 c/jv_print.c | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/c/jv_print.c b/c/jv_print.c
index c9808ea7..c2f7f58d 100644
--- a/c/jv_print.c
+++ b/c/jv_print.c
@@ -67,6 +67,9 @@ static void jv_dump_string(jv str, int ascii_only) {
 static void jv_dump_term(struct dtoa_context* C, jv x) {
   char buf[JVP_DTOA_FMT_MAX_LEN];
   switch (jv_get_kind(x)) {
+  case JV_KIND_INVALID:
+    assert(0 && "Invalid value");
+    break;
   case JV_KIND_NULL:
     printf("null");
     break;
@@ -76,9 +79,19 @@ static void jv_dump_term(struct dtoa_context* C, jv x) {
   case JV_KIND_TRUE:
     printf("true");
     break;
-  case JV_KIND_NUMBER:
-    printf("%s", jvp_dtoa_fmt(C, buf, jv_number_value(x)));
+  case JV_KIND_NUMBER: {
+    double d = jv_number_value(x);
+    if (d != d) {
+      // JSON doesn't have NaN, so we'll render it as "null"
+      printf("null");
+    } else {
+      // Normalise infinities to something we can print in valid JSON
+      if (d > DBL_MAX) d = DBL_MAX;
+      if (d < -DBL_MAX) d = -DBL_MAX;
+      printf("%s", jvp_dtoa_fmt(C, buf, d));
+    }
     break;
+  }
   case JV_KIND_STRING:
     // FIXME: all sorts of broken
     putchar('"');

From a4ff3d4670b6a64f41569fa0f7ae1fba0781625f Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 9 Sep 2012 18:09:05 +0100
Subject: [PATCH 046/284] Bugfix for expanding objects.

---
 c/jv.c | 13 +++++++++----
 c/jv.h |  1 +
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/c/jv.c b/c/jv.c
index c4a5af1c..1d5c9816 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -58,6 +58,10 @@ jv jv_null() {
   return JV_NULL;
 }
 
+jv jv_bool(int x) {
+  return x ? JV_TRUE : JV_FALSE;
+}
+
 /*
  * Numbers
  */
@@ -617,11 +621,12 @@ static jv* jvp_object_write(jv_complex* object, jvp_string* key) {
   if (slot) {
     // already has the key
     jvp_string_free_p(key);
-  } else {
-    slot = jvp_object_add_slot(object, key, bucket);
-    slot->value = jv_invalid();
+    return &slot->value;
   }
-  if (slot == 0) {
+  slot = jvp_object_add_slot(object, key, bucket);
+  if (slot) {
+    slot->value = jv_invalid();
+  } else {
     jvp_object_rehash(object);
     bucket = jvp_object_find_bucket(object, key);
     assert(!jvp_object_find_slot(object, key, bucket));
diff --git a/c/jv.h b/c/jv.h
index 8d9ebadb..6872ec5c 100644
--- a/c/jv.h
+++ b/c/jv.h
@@ -52,6 +52,7 @@ jv jv_invalid();
 jv jv_null();
 jv jv_true();
 jv jv_false();
+jv jv_bool(int);
 
 jv jv_number(double);
 double jv_number_value(jv);

From e258d20ba203adb1e91969a593c036179475deb6 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 9 Sep 2012 19:17:07 +0100
Subject: [PATCH 047/284] Make the '+' operator merge objects.

---
 c/builtin.c |  2 ++
 c/jv.c      | 10 ++++++++++
 c/jv.h      |  6 ++++++
 c/testdata  |  4 ++++
 4 files changed, 22 insertions(+)

diff --git a/c/builtin.c b/c/builtin.c
index 35e15471..26698680 100644
--- a/c/builtin.c
+++ b/c/builtin.c
@@ -24,6 +24,8 @@ static void f_plus(jv input[], jv output[]) {
                           jv_number_value(b));
   } else if (jv_get_kind(a) == JV_KIND_ARRAY && jv_get_kind(b) == JV_KIND_ARRAY) {
     output[0] = jv_array_concat(a, b);
+  } else if (jv_get_kind(a) == JV_KIND_OBJECT && jv_get_kind(b) == JV_KIND_OBJECT) {
+    output[0] = jv_object_merge(a, b);
   } else {
     output[0] = jv_string("wtf gaize");
     jv_free(a);
diff --git a/c/jv.c b/c/jv.c
index 1d5c9816..762bad89 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -729,6 +729,16 @@ int jv_object_length(jv object) {
   return n;
 }
 
+jv jv_object_merge(jv a, jv b) {
+  assert(jv_get_kind(a) == JV_KIND_OBJECT);
+  jv_object_foreach(i, b) {
+    a = jv_object_set(a, 
+                      jv_object_iter_key(b, i),
+                      jv_object_iter_value(b, i));
+  }
+  return a;
+}
+
 /*
  * Object iteration (internal helpers)
  */
diff --git a/c/jv.h b/c/jv.h
index 6872ec5c..2ec18629 100644
--- a/c/jv.h
+++ b/c/jv.h
@@ -78,12 +78,18 @@ jv jv_object_get(jv object, jv key);
 jv jv_object_set(jv object, jv key, jv value);
 jv jv_object_delete(jv object, jv key);
 int jv_object_length(jv object);
+jv jv_object_merge(jv, jv);
 
 int jv_object_iter(jv);
 int jv_object_iter_next(jv, int);
 int jv_object_iter_valid(jv, int);
 jv jv_object_iter_key(jv, int);
 jv jv_object_iter_value(jv, int);
+#define jv_object_foreach(i,t) \
+  for (int i = jv_object_iter(t);               \
+       jv_object_iter_valid(t, i);              \
+       i = jv_object_iter_next(t, i))           \
+ 
 
 
 int jv_get_refcnt(jv);
diff --git a/c/testdata b/c/testdata
index 5aa3efed..f80249e4 100644
--- a/c/testdata
+++ b/c/testdata
@@ -155,6 +155,10 @@ null
 null
 [1,2,3,null]
 
+{"a":1} + {"b":2} + {"c":3}
+"asdfasdf"
+{"a":1, "b":2, "c":3}
+
 #
 # User-defined functions
 # Oh god.

From c2593dc417fb23b5410f7f0f99a5a570ced6f658 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 10 Sep 2012 10:23:15 +0100
Subject: [PATCH 048/284] Make a main program that doesn't spam debugging info.

---
 c/Makefile  |  5 ++++-
 c/execute.c | 28 +++++++++++++++++++---------
 c/main.c    |  2 --
 3 files changed, 23 insertions(+), 12 deletions(-)

diff --git a/c/Makefile b/c/Makefile
index 2c4379de..cad23302 100644
--- a/c/Makefile
+++ b/c/Makefile
@@ -22,7 +22,10 @@ parser.tab.h: parser.tab.c
 jv_unicode.c: jv_utf8_tables.h
 
 parsertest: parser.tab.c lexer.yy.c main.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c
-	$(CC) -o $@ $^
+	$(CC) -DJQ_DEBUG=1 -o $@ $^
+
+jq: parser.tab.c lexer.yy.c main.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c
+	$(CC) -DJQ_DEBUG=0 -o $@ $^
 
 jv_test: jv_test.c jv.c jv_print.c jv_dtoa.c
 	$(CC) -DNO_JANSSON -o $@ $^
diff --git a/c/execute.c b/c/execute.c
index 5e6a2c51..62984ca4 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -148,10 +148,10 @@ jv jq_next() {
 
   int backtracking = 0;
   while (1) {
+    uint16_t opcode = *pc;
+
+#if JQ_DEBUG
     dump_operation(frame_current_bytecode(&frame_stk), pc);
-
-    uint16_t opcode = *pc++;
-
     printf("\t");
     const struct opcode_description* opdesc = opcode_describe(opcode);
     data_stk_elem* param;
@@ -167,13 +167,15 @@ jv jq_next() {
       printf("<%d>", jv_get_refcnt(param->sv.value));
     }
 
+    if (backtracking) printf("\t<backtracking>");
+
+    printf("\n");
+#endif
     if (backtracking) {
-      printf("\t<backtracking>");
       opcode = ON_BACKTRACK(opcode);
       backtracking = 0;
     }
-
-    printf("\n");
+    pc++;
 
     switch (opcode) {
     default: assert(0 && "invalid instruction");
@@ -235,9 +237,11 @@ jv jq_next() {
       uint16_t v = *pc++;
       frame_ptr fp = frame_get_level(&frame_stk, frame_current(&frame_stk), level);
       jv* var = frame_local_var(fp, v);
+      #if JQ_DEBUG
       printf("V%d = ", v);
       jv_dump(jv_copy(*var));
       printf("\n");
+      #endif
       stack_push(stackval_replace(stack_pop(), jv_copy(*var)));
       break;
     }
@@ -248,9 +252,11 @@ jv jq_next() {
       frame_ptr fp = frame_get_level(&frame_stk, frame_current(&frame_stk), level);
       jv* var = frame_local_var(fp, v);
       stackval val = stack_pop();
+      #if JQ_DEBUG
       printf("V%d = ", v);
       jv_dump(jv_copy(val.value));
       printf("\n");
+      #endif
       jv_free(*var);
       *var = val.value;
       break;
@@ -368,7 +374,6 @@ jv jq_next() {
       stackval top = stack_pop();
       cfunc_input[0] = top.value;
       struct cfunction* func = &frame_current_bytecode(&frame_stk)->globals->cfunctions[*pc++];
-      printf(" call %s\n", func->name);
       func->fptr(cfunc_input, cfunc_output);
       top.value = cfunc_output[0];
       stack_push(top);
@@ -386,7 +391,6 @@ jv jq_next() {
       cfunc_input[1] = a;
       cfunc_input[2] = b;
       struct cfunction* func = &frame_current_bytecode(&frame_stk)->globals->cfunctions[*pc++];
-      printf(" call %s\n", func->name);
       func->fptr(cfunc_input, cfunc_output);
       top.value = cfunc_output[0];
       stack_push(top);
@@ -450,7 +454,11 @@ void jq_teardown() {
 }
 
 void run_program(struct bytecode* bc) {
-  char buf[4096];
+#if JQ_DEBUG
+  dump_disassembly(0, bc);
+  printf("\n");
+#endif
+  char buf[409600];
   fgets(buf, sizeof(buf), stdin);
   jq_init(bc, jv_parse(buf));
   jv result;
@@ -458,6 +466,8 @@ void run_program(struct bytecode* bc) {
     jv_dump(result);
     printf("\n");
   }
+  #if JQ_DEBUG
   printf("end of results\n");
+  #endif
   jq_teardown();
 }
diff --git a/c/main.c b/c/main.c
index b71bcad5..7e274c4a 100644
--- a/c/main.c
+++ b/c/main.c
@@ -88,8 +88,6 @@ int main(int argc, char* argv[]) {
   blk = gen_cbinding(&builtins, blk);
   struct bytecode* bc = block_compile(blk);
   block_free(blk);
-  dump_disassembly(0, bc);
-  printf("\n");
   run_program(bc);
   bytecode_free(bc);
 }

From 5c25c906576692c1d08e02e4a5fc0c5dca3a5f96 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 10 Sep 2012 13:06:46 +0100
Subject: [PATCH 049/284] When comparing two objects for equality, we don't
 need to recurse into e.g. array elements if the two objects are the same
 array.

---
 c/jv.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/c/jv.c b/c/jv.c
index 762bad89..35ade789 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -824,23 +824,23 @@ int jv_equal(jv a, jv b) {
   int r;
   if (jv_get_kind(a) != jv_get_kind(b)) {
     r = 0;
+  } else if (jv_get_kind(a) == JV_KIND_NUMBER) {
+    r = jv_number_value(a) == jv_number_value(b);
+  } else if (a.val.complex.ptr == b.val.complex.ptr &&
+             a.val.complex.i[0] == b.val.complex.i[0] &&
+             a.val.complex.i[1] == b.val.complex.i[1]) {
+    r = 1;
   } else {
     switch (jv_get_kind(a)) {
-    case JV_KIND_NUMBER:
-      r = jv_number_value(a) == jv_number_value(b);
-      break;
-    case JV_KIND_ARRAY: {
+    case JV_KIND_ARRAY:
       r = jvp_array_equal(&a.val.complex, &b.val.complex);
       break;
-    }
-    case JV_KIND_STRING: {
+    case JV_KIND_STRING:
       r = jvp_string_equal(&a.val.complex, &b.val.complex);
       break;
-    }
-    case JV_KIND_OBJECT: {
+    case JV_KIND_OBJECT:
       r = jvp_object_equal(&a.val.complex, &b.val.complex);
       break;
-    }
     default:
       r = 1;
       break;

From 649cac791a1c7046b4441fe63526af5ca20825ff Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 10 Sep 2012 15:04:19 +0100
Subject: [PATCH 050/284] Make jv_invalid() first-class values capable of
 holding an error.

---
 c/execute.c  |  1 +
 c/jv.c       | 47 +++++++++++++++++++++++++++++++++++++++++------
 c/jv.h       | 11 +++++++----
 c/jv_parse.c | 37 ++++++++++++++++++-------------------
 c/jv_parse.h |  1 -
 c/main.c     |  3 +++
 6 files changed, 70 insertions(+), 30 deletions(-)

diff --git a/c/execute.c b/c/execute.c
index 62984ca4..c8505bf6 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -466,6 +466,7 @@ void run_program(struct bytecode* bc) {
     jv_dump(result);
     printf("\n");
   }
+  jv_free(result);
   #if JQ_DEBUG
   printf("end of results\n");
   #endif
diff --git a/c/jv.c b/c/jv.c
index 35ade789..be50c6f6 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -37,15 +37,10 @@ jv_kind jv_get_kind(jv x) {
   return x.kind;
 }
 
-static const jv JV_INVALID = {JV_KIND_INVALID, {0}};
 static const jv JV_NULL = {JV_KIND_NULL, {0}};
 static const jv JV_FALSE = {JV_KIND_FALSE, {0}};
 static const jv JV_TRUE = {JV_KIND_TRUE, {0}};
 
-jv jv_invalid() {
-  return JV_INVALID;
-}
-
 jv jv_true() {
   return JV_TRUE;
 }
@@ -62,6 +57,43 @@ jv jv_bool(int x) {
   return x ? JV_TRUE : JV_FALSE;
 }
 
+/*
+ * Invalid objects, with optional error messages
+ */ 
+
+typedef struct {
+  jv_refcnt refcnt;
+  jv errmsg;
+} jvp_invalid;
+
+jv jv_invalid_with_msg(jv err) {
+  jv x;
+  x.kind = JV_KIND_INVALID;
+  x.val.complex.i[0] = x.val.complex.i[1] = 0;
+  jvp_invalid* i = malloc(sizeof(jvp_invalid));
+  x.val.complex.ptr = &i->refcnt;
+  i->refcnt.count = 1;
+  i->errmsg = err;
+  return x;
+}
+
+jv jv_invalid() {
+  return jv_invalid_with_msg(jv_null());
+}
+
+jv jv_invalid_get_message(jv inv) {
+  jv x = ((jvp_invalid*)inv.val.complex.ptr)->errmsg;
+  jv_free(inv);
+  return x;
+}
+
+static void jvp_invalid_free(jv_complex* x) {
+  if (jvp_refcnt_dec(x)) {
+    jv_free(((jvp_invalid*)x->ptr)->errmsg);
+    free(x->ptr);
+  }
+}
+
 /*
  * Numbers
  */
@@ -789,7 +821,8 @@ jv jv_object_iter_value(jv object, int iter) {
 jv jv_copy(jv j) {
   if (jv_get_kind(j) == JV_KIND_ARRAY || 
       jv_get_kind(j) == JV_KIND_STRING || 
-      jv_get_kind(j) == JV_KIND_OBJECT) {
+      jv_get_kind(j) == JV_KIND_OBJECT ||
+      jv_get_kind(j) == JV_KIND_INVALID) {
     jvp_refcnt_inc(&j.val.complex);
   }
   return j;
@@ -802,6 +835,8 @@ void jv_free(jv j) {
     jvp_string_free(&j.val.complex);
   } else if (jv_get_kind(j) == JV_KIND_OBJECT) {
     jvp_object_free(&j.val.complex);
+  } else if (jv_get_kind(j) == JV_KIND_INVALID) {
+    jvp_invalid_free(&j.val.complex);
   }
 }
 
diff --git a/c/jv.h b/c/jv.h
index 2ec18629..a3a5e794 100644
--- a/c/jv.h
+++ b/c/jv.h
@@ -14,8 +14,8 @@ typedef enum {
   JV_KIND_TRUE,
   JV_KIND_NUMBER,
   JV_KIND_STRING,
-  JV_KIND_OBJECT,
-  JV_KIND_ARRAY
+  JV_KIND_ARRAY,
+  JV_KIND_OBJECT
 } jv_kind;
 
 typedef struct {
@@ -49,6 +49,9 @@ void jv_free(jv);
 int jv_equal(jv, jv);
 
 jv jv_invalid();
+jv jv_invalid_with_msg(jv);
+jv jv_invalid_get_msg(jv);
+
 jv jv_null();
 jv jv_true();
 jv jv_false();
@@ -99,19 +102,19 @@ jv jv_parse(const char* string);
 jv jv_parse_sized(const char* string, int length);
 
 
-
-
 static jv jv_lookup(jv t, jv k) {
   jv v;
   if (jv_get_kind(t) == JV_KIND_OBJECT && jv_get_kind(k) == JV_KIND_STRING) {
     v = jv_object_get(t, k);
     if (!jv_is_valid(v)) {
+      jv_free(v);
       v = jv_null();
     }
   } else if (jv_get_kind(t) == JV_KIND_ARRAY && jv_get_kind(k) == JV_KIND_NUMBER) {
     // FIXME: don't do lookup for noninteger index
     v = jv_array_get(t, (int)jv_number_value(k));
     if (!jv_is_valid(v)) {
+      jv_free(v);
       v = jv_null();
     }
   } else if (jv_get_kind(t) == JV_KIND_NULL && 
diff --git a/c/jv_parse.c b/c/jv_parse.c
index 7a8c811e..9300f311 100644
--- a/c/jv_parse.c
+++ b/c/jv_parse.c
@@ -18,8 +18,7 @@ typedef const char* presult;
 void jv_parser_init(struct jv_parser* p) {
   p->stack = 0;
   p->stacklen = p->stackpos = 0;
-  p->hasnext = 0;
-  p->next = jv_invalid(); //FIXME: jv_invalid
+  p->next = jv_invalid();
   p->tokenbuf = 0;
   p->tokenlen = p->tokenpos = 0;
   p->st = JV_PARSER_NORMAL;
@@ -27,15 +26,15 @@ void jv_parser_init(struct jv_parser* p) {
 }
 
 void jv_parser_free(struct jv_parser* p) {
-  if (p->hasnext) jv_free(p->next);
+  jv_free(p->next);
   free(p->stack);
   free(p->tokenbuf);
   jvp_dtoa_context_free(&p->dtoa);
 }
 
 static pfunc value(struct jv_parser* p, jv val) {
-  if (p->hasnext) return "Expected separator between values";
-  p->hasnext = 1;
+  if (jv_is_valid(p->next)) return "Expected separator between values";
+  jv_free(p->next);
   p->next = val;
   return 0;
 }
@@ -53,40 +52,40 @@ static void push(struct jv_parser* p, jv v) {
 static pfunc token(struct jv_parser* p, char ch) {
   switch (ch) {
   case '[':
-    if (p->hasnext) return "Expected separator between values";
+    if (jv_is_valid(p->next)) return "Expected separator between values";
     push(p, jv_array());
     break;
 
   case '{':
-    if (p->hasnext) return "Expected separator between values";
+    if (jv_is_valid(p->next)) return "Expected separator between values";
     push(p, jv_object());
     break;
 
   case ':':
-    if (!p->hasnext) 
+    if (!jv_is_valid(p->next)) 
       return "Expected string key before ':'";
     if (p->stackpos == 0 || jv_get_kind(p->stack[p->stackpos-1]) != JV_KIND_OBJECT)
       return "':' not as part of an object";
     if (jv_get_kind(p->next) != JV_KIND_STRING)
       return "Object keys must be strings";
     push(p, p->next);
-    p->hasnext = 0;
+    p->next = jv_invalid();
     break;
 
   case ',':
-    if (!p->hasnext)
+    if (!jv_is_valid(p->next))
       return "Expected value before ','";
     if (p->stackpos == 0)
       return "',' not as part of an object or array";
     if (jv_get_kind(p->stack[p->stackpos-1]) == JV_KIND_ARRAY) {
       p->stack[p->stackpos-1] = jv_array_append(p->stack[p->stackpos-1], p->next);
-      p->hasnext = 0;
+      p->next = jv_invalid();
     } else if (jv_get_kind(p->stack[p->stackpos-1]) == JV_KIND_STRING) {
       assert(p->stackpos > 1 && jv_get_kind(p->stack[p->stackpos-2]) == JV_KIND_OBJECT);
       p->stack[p->stackpos-2] = jv_object_set(p->stack[p->stackpos-2], 
                                               p->stack[p->stackpos-1], p->next);
       p->stackpos--;
-      p->hasnext = 0;
+      p->next = jv_invalid();
     } else {
       // this case hits on input like {"a", "b"}
       return "Objects must consist of key:value pairs";
@@ -96,37 +95,37 @@ static pfunc token(struct jv_parser* p, char ch) {
   case ']':
     if (p->stackpos == 0 || jv_get_kind(p->stack[p->stackpos-1]) != JV_KIND_ARRAY)
       return "Unmatched ']'";
-    if (p->hasnext) {
+    if (jv_is_valid(p->next)) {
       p->stack[p->stackpos-1] = jv_array_append(p->stack[p->stackpos-1], p->next);
-      p->hasnext = 0;
+      p->next = jv_invalid();
     } else {
       if (jv_array_length(jv_copy(p->stack[p->stackpos-1])) != 0) {
         // this case hits on input like [1,2,3,]
         return "Expected another array element";
       }
     }
-    p->hasnext = 1;
+    jv_free(p->next);
     p->next = p->stack[--p->stackpos];
     break;
 
   case '}':
     if (p->stackpos == 0)
       return "Unmatched '}'";
-    if (p->hasnext) {
+    if (jv_is_valid(p->next)) {
       if (jv_get_kind(p->stack[p->stackpos-1]) != JV_KIND_STRING)
         return "Objects must consist of key:value pairs";
       assert(p->stackpos > 1 && jv_get_kind(p->stack[p->stackpos-2]) == JV_KIND_OBJECT);
       p->stack[p->stackpos-2] = jv_object_set(p->stack[p->stackpos-2], 
                                               p->stack[p->stackpos-1], p->next);
       p->stackpos--;
-      p->hasnext = 0;
+      p->next = jv_invalid();
     } else {
       if (jv_get_kind(p->stack[p->stackpos-1]) != JV_KIND_OBJECT)
         return "Unmatched '}'";
       if (jv_object_length(jv_copy(p->stack[p->stackpos-1])) != 0)
         return "Expected another key-value pair";
     }
-    p->hasnext = 1;
+    jv_free(p->next);
     p->next = p->stack[--p->stackpos];
     break;
   }
@@ -320,7 +319,7 @@ static pfunc finish(struct jv_parser* p) {
     return "Unfinished JSON term";
   
   // this will happen on the empty string
-  if (!p->hasnext)
+  if (!jv_is_valid(p->next))
     return "Expected JSON value";
   
   return 0;
diff --git a/c/jv_parse.h b/c/jv_parse.h
index 4dddcf6f..10270766 100644
--- a/c/jv_parse.h
+++ b/c/jv_parse.h
@@ -4,7 +4,6 @@ struct jv_parser {
   int stackpos;
   int stacklen;
   jv next;
-  int hasnext;
   
   char* tokenbuf;
   int tokenpos;
diff --git a/c/main.c b/c/main.c
index 7e274c4a..7c341d8d 100644
--- a/c/main.c
+++ b/c/main.c
@@ -49,6 +49,7 @@ void run_tests() {
       assert(jv_is_valid(expected));
       jv actual = jq_next();
       if (!jv_is_valid(actual)) {
+        jv_free(actual);
         printf("Insufficient results\n");
         pass = 0;
         break;
@@ -70,6 +71,8 @@ void run_tests() {
         jv_dump(extra);
         printf("\n");
         pass = 0;
+      } else {
+        jv_free(extra);
       }
     }
     jq_teardown();

From 0159c0ecc58f439e976ba987e826155859c979f5 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 10 Sep 2012 15:08:39 +0100
Subject: [PATCH 051/284] Plug a memory leak in jv_object_merge

---
 c/jv.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/c/jv.c b/c/jv.c
index be50c6f6..53e2ef7d 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -768,6 +768,7 @@ jv jv_object_merge(jv a, jv b) {
                       jv_object_iter_key(b, i),
                       jv_object_iter_value(b, i));
   }
+  jv_free(b);
   return a;
 }
 

From a3e509034b4eada3903fc8e5cdcdf253c207b4b8 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 10 Sep 2012 16:01:56 +0100
Subject: [PATCH 052/284] jv_string_fmt (create printf-formatted JSON strings)

---
 c/Makefile  |  2 +-
 c/jv.c      | 24 ++++++++++++++++++++++--
 c/jv.h      |  1 +
 c/jv_test.c |  9 +++++++++
 4 files changed, 33 insertions(+), 3 deletions(-)

diff --git a/c/Makefile b/c/Makefile
index cad23302..c80642dc 100644
--- a/c/Makefile
+++ b/c/Makefile
@@ -27,7 +27,7 @@ parsertest: parser.tab.c lexer.yy.c main.c opcode.c bytecode.c compile.c execute
 jq: parser.tab.c lexer.yy.c main.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c
 	$(CC) -DJQ_DEBUG=0 -o $@ $^
 
-jv_test: jv_test.c jv.c jv_print.c jv_dtoa.c
+jv_test: jv_test.c jv.c jv_print.c jv_dtoa.c jv_unicode.c
 	$(CC) -DNO_JANSSON -o $@ $^
 
 jv_parse: jv_parse.c jv.c jv_print.c jv_dtoa.c
diff --git a/c/jv.c b/c/jv.c
index 53e2ef7d..73805a0a 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -4,6 +4,7 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include <stdarg.h>
 
 #include "jv.h"
 
@@ -81,8 +82,8 @@ jv jv_invalid() {
   return jv_invalid_with_msg(jv_null());
 }
 
-jv jv_invalid_get_message(jv inv) {
-  jv x = ((jvp_invalid*)inv.val.complex.ptr)->errmsg;
+jv jv_invalid_get_msg(jv inv) {
+  jv x = jv_copy(((jvp_invalid*)inv.val.complex.ptr)->errmsg);
   jv_free(inv);
   return x;
 }
@@ -472,6 +473,25 @@ const char* jv_string_value(jv j) {
   return jvp_string_ptr(&j.val.complex)->data;
 }
 
+jv jv_string_fmt(const char* fmt, ...) {
+  int size = 1024;
+  while (1) {
+    char* buf = malloc(size);
+    va_list args;
+    va_start(args, fmt);
+    int n = vsnprintf(buf, size, fmt, args);
+    va_end(args);
+    if (n < size) {
+      jv ret = jv_string_sized(buf, n);
+      free(buf);
+      return ret;
+    } else {
+      free(buf);
+      size = n * 2;
+    }
+  }
+}
+
 /*
  * Objects (internal helpers)
  */
diff --git a/c/jv.h b/c/jv.h
index a3a5e794..c415ee28 100644
--- a/c/jv.h
+++ b/c/jv.h
@@ -75,6 +75,7 @@ jv jv_string_sized(const char*, int);
 int jv_string_length(jv);
 uint32_t jv_string_hash(jv);
 const char* jv_string_value(jv);
+jv jv_string_fmt(const char*, ...);
 
 jv jv_object();
 jv jv_object_get(jv object, jv key);
diff --git a/c/jv_test.c b/c/jv_test.c
index 2b5a6276..725e5aba 100644
--- a/c/jv_test.c
+++ b/c/jv_test.c
@@ -108,6 +108,15 @@ int main(){
     jv_free(a1);
     jv_free(a2);
     jv_free(b);
+
+    assert(jv_equal(jv_string("hello42!"), jv_string_fmt("hello%d%s", 42, "!")));
+    char big[20000];
+    for (int i=0; i<sizeof(big); i++) big[i] = 'a';
+    big[sizeof(big)-1] = 0;
+    jv str = jv_string_fmt("%s", big);
+    assert(jv_string_length(jv_copy(str)) == sizeof(big) - 1);
+    assert(!strcmp(big, jv_string_value(str)));
+    jv_free(str);
   }
 
   /// Objects

From e718bd50b63380a0be2c8f9ae7cb837bcf01c48e Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 10 Sep 2012 16:07:03 +0100
Subject: [PATCH 053/284] Sensible error messages when a silly addition is
 performed.

Fix a test to no longer perform an invalid addition.
---
 c/builtin.c |  4 +++-
 c/execute.c | 22 ++++++++++++++++++++--
 c/jv.c      | 15 +++++++++++++++
 c/jv.h      |  1 +
 c/testdata  |  2 +-
 5 files changed, 40 insertions(+), 4 deletions(-)

diff --git a/c/builtin.c b/c/builtin.c
index 26698680..45056fc0 100644
--- a/c/builtin.c
+++ b/c/builtin.c
@@ -27,7 +27,9 @@ static void f_plus(jv input[], jv output[]) {
   } else if (jv_get_kind(a) == JV_KIND_OBJECT && jv_get_kind(b) == JV_KIND_OBJECT) {
     output[0] = jv_object_merge(a, b);
   } else {
-    output[0] = jv_string("wtf gaize");
+    output[0] = jv_invalid_with_msg(jv_string_fmt("Attempted to add %s and %s",
+                                                  jv_kind_name(jv_get_kind(a)),
+                                                  jv_kind_name(jv_get_kind(b))));
     jv_free(a);
     jv_free(b);
   }
diff --git a/c/execute.c b/c/execute.c
index c8505bf6..f59e156e 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -376,7 +376,16 @@ jv jq_next() {
       struct cfunction* func = &frame_current_bytecode(&frame_stk)->globals->cfunctions[*pc++];
       func->fptr(cfunc_input, cfunc_output);
       top.value = cfunc_output[0];
-      stack_push(top);
+      if (jv_is_valid(top.value)) {
+        stack_push(top);
+      } else {
+        jv msg = jv_invalid_get_msg(top.value);
+        if (jv_get_kind(msg) == JV_KIND_STRING) {
+          fprintf(stderr, "jq: error: %s\n", jv_string_value(msg));
+        }
+        jv_free(msg);
+        goto do_backtrack;
+      }
       break;
     }
 
@@ -393,7 +402,16 @@ jv jq_next() {
       struct cfunction* func = &frame_current_bytecode(&frame_stk)->globals->cfunctions[*pc++];
       func->fptr(cfunc_input, cfunc_output);
       top.value = cfunc_output[0];
-      stack_push(top);
+      if (jv_is_valid(top.value)) {
+        stack_push(top);
+      } else {
+        jv msg = jv_invalid_get_msg(top.value);
+        if (jv_get_kind(msg) == JV_KIND_STRING) {
+          fprintf(stderr, "jq: error: %s\n", jv_string_value(msg));
+        }
+        jv_free(msg);
+        goto do_backtrack;
+      }
       break;
     }
 
diff --git a/c/jv.c b/c/jv.c
index 73805a0a..8c0c0348 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -38,6 +38,21 @@ jv_kind jv_get_kind(jv x) {
   return x.kind;
 }
 
+const char* jv_kind_name(jv_kind k) {
+  switch (k) {
+  case JV_KIND_INVALID: return "<invalid>";
+  case JV_KIND_NULL:    return "null";
+  case JV_KIND_FALSE:   return "boolean";
+  case JV_KIND_TRUE:    return "boolean";
+  case JV_KIND_NUMBER:  return "number";
+  case JV_KIND_STRING:  return "string";
+  case JV_KIND_ARRAY:   return "array";
+  case JV_KIND_OBJECT:  return "object";
+  }
+  assert(0);
+  return "<unknown>";
+}
+
 static const jv JV_NULL = {JV_KIND_NULL, {0}};
 static const jv JV_FALSE = {JV_KIND_FALSE, {0}};
 static const jv JV_TRUE = {JV_KIND_TRUE, {0}};
diff --git a/c/jv.h b/c/jv.h
index c415ee28..9aadd418 100644
--- a/c/jv.h
+++ b/c/jv.h
@@ -41,6 +41,7 @@ typedef struct {
  */
 
 jv_kind jv_get_kind(jv);
+const char* jv_kind_name(jv_kind);
 static int jv_is_valid(jv x) { return jv_get_kind(x) != JV_KIND_INVALID; }
 
 jv jv_copy(jv);
diff --git a/c/testdata b/c/testdata
index f80249e4..11684dde 100644
--- a/c/testdata
+++ b/c/testdata
@@ -207,7 +207,7 @@ def id(x):x; 2000 as $x | def f(x):1 as $x | id([$x, x, x]); def g(x): 100 as $x
 # test backtracking through function calls and returns
 # this test is *evil*
 [[20,10][1,0] as $x | def f: (100,200) as $y | def g: [$x + $y, .]; . + $x | g; f[0] | [f][0][1] | f]
-"woo, testing!"
+999999999
 [[110.0, 130.0], [210.0, 130.0], [110.0, 230.0], [210.0, 230.0], [120.0, 160.0], [220.0, 160.0], [120.0, 260.0], [220.0, 260.0]]
 
 #

From 65ce73deb4eab4ef6d83a0ad44c603d6286e964d Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 10 Sep 2012 16:16:39 +0100
Subject: [PATCH 054/284] String concatenation.

---
 c/builtin.c |  2 ++
 c/jv.c      | 21 +++++++++++++++++++++
 c/jv.h      |  1 +
 c/testdata  |  8 ++++++++
 4 files changed, 32 insertions(+)

diff --git a/c/builtin.c b/c/builtin.c
index 45056fc0..bdca2540 100644
--- a/c/builtin.c
+++ b/c/builtin.c
@@ -22,6 +22,8 @@ static void f_plus(jv input[], jv output[]) {
   if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
     output[0] = jv_number(jv_number_value(a) + 
                           jv_number_value(b));
+  } else if (jv_get_kind(a) == JV_KIND_STRING && jv_get_kind(b) == JV_KIND_STRING) {
+    output[0] = jv_string_concat(a, b);
   } else if (jv_get_kind(a) == JV_KIND_ARRAY && jv_get_kind(b) == JV_KIND_ARRAY) {
     output[0] = jv_array_concat(a, b);
   } else if (jv_get_kind(a) == JV_KIND_OBJECT && jv_get_kind(b) == JV_KIND_OBJECT) {
diff --git a/c/jv.c b/c/jv.c
index 8c0c0348..f8b79ce6 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -355,6 +355,7 @@ static jv_complex jvp_string_new(const char* data, uint32_t length) {
   return r;
 }
 
+
 static void jvp_string_free(jv_complex* s) {
   if (jvp_refcnt_dec(s)) {
     jvp_string* str = jvp_string_ptr(s);
@@ -377,6 +378,16 @@ static uint32_t jvp_string_length(jvp_string* s) {
   return s->length_hashed >> 1;
 }
 
+static jv_complex jvp_string_concat(jvp_string* a, jvp_string* b) {
+  uint32_t la = jvp_string_length(a), lb = jvp_string_length(b);
+  jvp_string* s = jvp_string_alloc(la + lb);
+  memcpy(s->data, a->data, la);
+  memcpy(s->data + la, b->data, lb);
+  s->data[la + lb] = 0;
+  jv_complex r = {&s->refcnt, {0,0}};
+  return r;
+}
+
 static const uint32_t HASH_SEED = 0x432A9843;
 
 static uint32_t rotl32 (uint32_t x, int8_t r){
@@ -488,6 +499,16 @@ const char* jv_string_value(jv j) {
   return jvp_string_ptr(&j.val.complex)->data;
 }
 
+jv jv_string_concat(jv a, jv b) {
+  jv j;
+  j.kind = JV_KIND_STRING;
+  j.val.complex = jvp_string_concat(jvp_string_ptr(&a.val.complex),
+                                    jvp_string_ptr(&b.val.complex));
+  jv_free(a);
+  jv_free(b);
+  return j;
+}
+
 jv jv_string_fmt(const char* fmt, ...) {
   int size = 1024;
   while (1) {
diff --git a/c/jv.h b/c/jv.h
index 9aadd418..ef64816c 100644
--- a/c/jv.h
+++ b/c/jv.h
@@ -76,6 +76,7 @@ jv jv_string_sized(const char*, int);
 int jv_string_length(jv);
 uint32_t jv_string_hash(jv);
 const char* jv_string_value(jv);
+jv jv_string_concat(jv, jv);
 jv jv_string_fmt(const char*, ...);
 
 jv jv_object();
diff --git a/c/testdata b/c/testdata
index 11684dde..c353dc2f 100644
--- a/c/testdata
+++ b/c/testdata
@@ -159,6 +159,14 @@ null
 "asdfasdf"
 {"a":1, "b":2, "c":3}
 
+"asdf" + "jkl;" + .
+"some string"
+"asdfjkl;some string"
+
+"\u0000\u0020\u0000" + .
+"\u0000\u0020\u0000"
+"\u0000 \u0000\u0000 \u0000"
+
 #
 # User-defined functions
 # Oh god.

From 6f3abbac620132260d5424dbee259f850dad890f Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 10 Sep 2012 16:49:25 +0100
Subject: [PATCH 055/284] Subtraction - as expected for numbers, ruby-style set
 diff for arrays.

---
 c/builtin.c | 34 ++++++++++++++++++++++++++++++++++
 c/lexer.l   |  2 +-
 c/parser.y  | 28 +++++++++++++++++++++-------
 c/testdata  |  8 ++++++++
 4 files changed, 64 insertions(+), 8 deletions(-)

diff --git a/c/builtin.c b/c/builtin.c
index bdca2540..65ecb52c 100644
--- a/c/builtin.c
+++ b/c/builtin.c
@@ -37,10 +37,44 @@ static void f_plus(jv input[], jv output[]) {
   }
 }
 
+static void f_minus(jv input[], jv output[]) {
+  jv_free(input[0]);
+  jv a = input[2];
+  jv b = input[1];
+  if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
+    output[0] = jv_number(jv_number_value(a) - jv_number_value(b));
+  } else if (jv_get_kind(a) == JV_KIND_ARRAY && jv_get_kind(b) == JV_KIND_ARRAY) {
+    jv out = jv_array();
+    for (int i=0; i<jv_array_length(jv_copy(a)); i++) {
+      jv x = jv_array_get(jv_copy(a), i);
+      int include = 1;
+      for (int j=0; j<jv_array_length(jv_copy(b)); j++) {
+        if (jv_equal(jv_copy(x), jv_array_get(jv_copy(b), j))) {
+          include = 0;
+          break;
+        }
+      }
+      if (include)
+        out = jv_array_append(out, jv_copy(x));
+      jv_free(x);
+    }
+    jv_free(a);
+    jv_free(b);
+    output[0] = out;
+  } else {
+    output[0] = jv_invalid_with_msg(jv_string_fmt("Attempted to subtract %s and %s",
+                                                  jv_kind_name(jv_get_kind(a)),
+                                                  jv_kind_name(jv_get_kind(b))));
+    jv_free(a);
+    jv_free(b);
+  }
+}
+
 struct cfunction function_list[] = {
   {f_true, "true", CALL_BUILTIN_1_1},
   {f_false, "false", CALL_BUILTIN_1_1},
   {f_null, "null", CALL_BUILTIN_1_1},
   {f_plus, "_plus", CALL_BUILTIN_3_1},
+  {f_minus, "_minus", CALL_BUILTIN_3_1},
 };
 struct symbol_table builtins = {function_list, sizeof(function_list)/sizeof(function_list[0])};
diff --git a/c/lexer.l b/c/lexer.l
index f2651762..1b74d43f 100644
--- a/c/lexer.l
+++ b/c/lexer.l
@@ -22,7 +22,7 @@
 "not" { return NOT; }
 "end" { return END; }
 "//" { return DEFINEDOR; }
-"."|"="|";"|"["|"]"|","|":"|"("|")"|"{"|"}"|"|"|"+"|"\$" { return yytext[0];}
+"."|"="|";"|"["|"]"|","|":"|"("|")"|"{"|"}"|"|"|"+"|"-"|"\$" { return yytext[0];}
 
 \"(\\.|[^\\"])*\" |
 -?[0-9.]+([eE][+-]?[0-9]+)? { 
diff --git a/c/parser.y b/c/parser.y
index 54456d09..72b91a1a 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -42,11 +42,10 @@
 %nonassoc EQ
 %left OR
 %left AND
-%left '+'
+%left '+' '-'
 
 
 %type <blk> Exp Term MkDict MkDictPair ExpD ElseBody
-
 %{
 #include "lexer.yy.h"
 void yyerror(YYLTYPE* loc, block* answer, yyscan_t lexer, const char *s){
@@ -64,6 +63,21 @@ static block gen_index(block obj, block key) {
   return block_join(obj, block_join(gen_subexp(key), gen_op_simple(INDEX)));
 }
 
+static block gen_binop(block a, block b, char op) {
+  const char* funcname = 0;
+  switch (op) {
+  case '+': funcname = "_plus"; break;
+  case '-': funcname = "_minus"; break;
+  }
+  assert(funcname);
+
+  block c = gen_noop();
+  block_append(&c, gen_subexp(a));
+  block_append(&c, gen_subexp(b));
+  block_append(&c, gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, funcname)));
+  return c;
+}
+
 %}
 
 %%
@@ -136,10 +150,11 @@ Exp ',' Exp {
 } |
 
 Exp '+' Exp {
-  $$ = gen_noop();
-  block_append(&$$, gen_subexp($1));
-  block_append(&$$, gen_subexp($3));
-  block_append(&$$, gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, "_plus")));
+  $$ = gen_binop($1, $3, '+');
+} |
+
+Exp '-' Exp {
+  $$ = gen_binop($1, $3, '-');
 } |
 
 Term { 
@@ -154,7 +169,6 @@ ElseBody:
   $$ = $2;
 }
 
-
 ExpD:
 ExpD '|' ExpD { 
   $$ = block_join($1, $3);
diff --git a/c/testdata b/c/testdata
index c353dc2f..6386ac08 100644
--- a/c/testdata
+++ b/c/testdata
@@ -167,6 +167,14 @@ null
 "\u0000\u0020\u0000"
 "\u0000 \u0000\u0000 \u0000"
 
+42 - .
+11
+31
+
+[1,2,3,4,1] - [.,3]
+1
+[2,4]
+
 #
 # User-defined functions
 # Oh god.

From aa3ebdfe9b714548fb0d5cfe0265950b1392fb1e Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 10 Sep 2012 16:57:17 +0100
Subject: [PATCH 056/284] Multiplication and division operators.

It is an error to use these on anything but numbers. Maybe later
implementing python/ruby-style ("a" * 100) might be handy.
---
 c/builtin.c | 32 ++++++++++++++++++++++++++++++++
 c/lexer.l   |  2 +-
 c/parser.y  | 11 +++++++++++
 c/testdata  |  8 ++++++++
 4 files changed, 52 insertions(+), 1 deletion(-)

diff --git a/c/builtin.c b/c/builtin.c
index 65ecb52c..b65bb09b 100644
--- a/c/builtin.c
+++ b/c/builtin.c
@@ -70,11 +70,43 @@ static void f_minus(jv input[], jv output[]) {
   }
 }
 
+static void f_multiply(jv input[], jv output[]) {
+  jv_free(input[0]);
+  jv a = input[2];
+  jv b = input[1];
+  if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
+    output[0] = jv_number(jv_number_value(a) * jv_number_value(b));
+  } else {
+    output[0] = jv_invalid_with_msg(jv_string_fmt("Attempted to multiply %s and %s",
+                                                  jv_kind_name(jv_get_kind(a)),
+                                                  jv_kind_name(jv_get_kind(b))));
+    jv_free(a);
+    jv_free(b);
+  }  
+}
+
+static void f_divide(jv input[], jv output[]) {
+  jv_free(input[0]);
+  jv a = input[2];
+  jv b = input[1];
+  if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
+    output[0] = jv_number(jv_number_value(a) / jv_number_value(b));
+  } else {
+    output[0] = jv_invalid_with_msg(jv_string_fmt("Attempted to divide %s by %s",
+                                                  jv_kind_name(jv_get_kind(a)),
+                                                  jv_kind_name(jv_get_kind(b))));
+    jv_free(a);
+    jv_free(b);
+  }  
+}
+
 struct cfunction function_list[] = {
   {f_true, "true", CALL_BUILTIN_1_1},
   {f_false, "false", CALL_BUILTIN_1_1},
   {f_null, "null", CALL_BUILTIN_1_1},
   {f_plus, "_plus", CALL_BUILTIN_3_1},
   {f_minus, "_minus", CALL_BUILTIN_3_1},
+  {f_multiply, "_multiply", CALL_BUILTIN_3_1},
+  {f_divide, "_divide", CALL_BUILTIN_3_1},
 };
 struct symbol_table builtins = {function_list, sizeof(function_list)/sizeof(function_list[0])};
diff --git a/c/lexer.l b/c/lexer.l
index 1b74d43f..1794b9f1 100644
--- a/c/lexer.l
+++ b/c/lexer.l
@@ -22,7 +22,7 @@
 "not" { return NOT; }
 "end" { return END; }
 "//" { return DEFINEDOR; }
-"."|"="|";"|"["|"]"|","|":"|"("|")"|"{"|"}"|"|"|"+"|"-"|"\$" { return yytext[0];}
+"."|"="|";"|"["|"]"|","|":"|"("|")"|"{"|"}"|"|"|"+"|"-"|"*"|"/"|"\$" { return yytext[0];}
 
 \"(\\.|[^\\"])*\" |
 -?[0-9.]+([eE][+-]?[0-9]+)? { 
diff --git a/c/parser.y b/c/parser.y
index 72b91a1a..225a324e 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -43,6 +43,7 @@
 %left OR
 %left AND
 %left '+' '-'
+%left '*' '/'
 
 
 %type <blk> Exp Term MkDict MkDictPair ExpD ElseBody
@@ -68,6 +69,8 @@ static block gen_binop(block a, block b, char op) {
   switch (op) {
   case '+': funcname = "_plus"; break;
   case '-': funcname = "_minus"; break;
+  case '*': funcname = "_multiply"; break;
+  case '/': funcname = "_divide"; break;
   }
   assert(funcname);
 
@@ -157,6 +160,14 @@ Exp '-' Exp {
   $$ = gen_binop($1, $3, '-');
 } |
 
+Exp '*' Exp {
+  $$ = gen_binop($1, $3, '*');
+} |
+
+Exp '/' Exp {
+  $$ = gen_binop($1, $3, '/');
+} |
+
 Term { 
   $$ = $1; 
 }
diff --git a/c/testdata b/c/testdata
index 6386ac08..eb9f0c5f 100644
--- a/c/testdata
+++ b/c/testdata
@@ -175,6 +175,14 @@ null
 1
 [2,4]
 
+[10 * 20, 20 / .]
+4
+[200, 5]
+
+1 + 2 * 2 + 10 / 2
+null
+10
+
 #
 # User-defined functions
 # Oh god.

From 3895bbf85698ab3e9f739fc74957415a8788a559 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 10 Sep 2012 17:08:13 +0100
Subject: [PATCH 057/284] String -> number conversions with "tonumber".

---
 c/builtin.c | 25 +++++++++++++++++++++++++
 c/testdata  |  4 ++++
 2 files changed, 29 insertions(+)

diff --git a/c/builtin.c b/c/builtin.c
index b65bb09b..7943675d 100644
--- a/c/builtin.c
+++ b/c/builtin.c
@@ -100,6 +100,30 @@ static void f_divide(jv input[], jv output[]) {
   }  
 }
 
+static void f_tonumber(jv input[], jv output[]) {
+  if (jv_get_kind(input[0]) == JV_KIND_NUMBER) {
+    output[0] = input[0];
+  } else if (jv_get_kind(input[0]) == JV_KIND_STRING) {
+    jv parsed = jv_parse(jv_string_value(input[0]));
+    if (!jv_is_valid(parsed)) {
+      jv_free(input[0]);
+      output[0] = parsed;
+    } else if (jv_get_kind(parsed) != JV_KIND_NUMBER) {
+      output[0] = jv_invalid_with_msg(jv_string_fmt("'%s' is not a number",
+                                                    jv_string_value(input[0])));
+      jv_free(input[0]);
+    } else {
+      jv_free(input[0]);
+      output[0] = parsed;
+    }
+  } else {
+    output[0] = jv_invalid_with_msg(jv_string_fmt("Cannot parse %s as a number",
+                                                  jv_kind_name(jv_get_kind(input[0]))));
+    jv_free(input[0]);
+    return;
+  }
+}
+
 struct cfunction function_list[] = {
   {f_true, "true", CALL_BUILTIN_1_1},
   {f_false, "false", CALL_BUILTIN_1_1},
@@ -108,5 +132,6 @@ struct cfunction function_list[] = {
   {f_minus, "_minus", CALL_BUILTIN_3_1},
   {f_multiply, "_multiply", CALL_BUILTIN_3_1},
   {f_divide, "_divide", CALL_BUILTIN_3_1},
+  {f_tonumber, "tonumber", CALL_BUILTIN_1_1},
 };
 struct symbol_table builtins = {function_list, sizeof(function_list)/sizeof(function_list[0])};
diff --git a/c/testdata b/c/testdata
index eb9f0c5f..45140242 100644
--- a/c/testdata
+++ b/c/testdata
@@ -183,6 +183,10 @@ null
 null
 10
 
+1 + tonumber + ("10" | tonumber)
+4
+15
+
 #
 # User-defined functions
 # Oh god.

From 4d47f8f1e18125ffcffc8354b71a96c43f1f1473 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 10 Sep 2012 18:08:00 +0100
Subject: [PATCH 058/284] '==' operator, tests for equality and operator
 precedence.

---
 c/builtin.c |  6 ++++++
 c/parser.y  | 19 +++++++++++++------
 c/testdata  | 17 +++++++++++++++++
 3 files changed, 36 insertions(+), 6 deletions(-)

diff --git a/c/builtin.c b/c/builtin.c
index 7943675d..375e3252 100644
--- a/c/builtin.c
+++ b/c/builtin.c
@@ -100,6 +100,11 @@ static void f_divide(jv input[], jv output[]) {
   }  
 }
 
+static void f_equal(jv input[], jv output[]) {
+  jv_free(input[0]);
+  output[0] = jv_bool(jv_equal(input[2], input[1]));
+}
+
 static void f_tonumber(jv input[], jv output[]) {
   if (jv_get_kind(input[0]) == JV_KIND_NUMBER) {
     output[0] = input[0];
@@ -133,5 +138,6 @@ struct cfunction function_list[] = {
   {f_multiply, "_multiply", CALL_BUILTIN_3_1},
   {f_divide, "_divide", CALL_BUILTIN_3_1},
   {f_tonumber, "tonumber", CALL_BUILTIN_1_1},
+  {f_equal, "_equal", CALL_BUILTIN_3_1},
 };
 struct symbol_table builtins = {function_list, sizeof(function_list)/sizeof(function_list[0])};
diff --git a/c/parser.y b/c/parser.y
index 225a324e..0f1e42c4 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -19,11 +19,6 @@
 %token <literal> IDENT
 %token <literal> LITERAL
 
- /* revolting hack */
-%left ';'
-
-%left '|'
-%left ','
 %token EQ "=="
 %token DEFINEDOR "//"
 %token AS "as"
@@ -37,6 +32,12 @@
 %token AND "and"
 %token OR "or"
 %token NOT "not"
+
+
+ /* revolting hack */
+%left ';'
+%left '|'
+%left ','
 %right "//"
 %nonassoc '=' SETPIPE
 %nonassoc EQ
@@ -64,13 +65,14 @@ static block gen_index(block obj, block key) {
   return block_join(obj, block_join(gen_subexp(key), gen_op_simple(INDEX)));
 }
 
-static block gen_binop(block a, block b, char op) {
+static block gen_binop(block a, block b, int op) {
   const char* funcname = 0;
   switch (op) {
   case '+': funcname = "_plus"; break;
   case '-': funcname = "_minus"; break;
   case '*': funcname = "_multiply"; break;
   case '/': funcname = "_divide"; break;
+  case EQ: funcname = "_equal"; break;
   }
   assert(funcname);
 
@@ -129,6 +131,7 @@ Exp "and" Exp {
   $$ = gen_and($1, $3);
 } |
 
+
 "not" Exp {
   $$ = gen_not($2);
 } |
@@ -168,6 +171,10 @@ Exp '/' Exp {
   $$ = gen_binop($1, $3, '/');
 } |
 
+Exp "==" Exp {
+  $$ = gen_binop($1, $3, EQ);
+} |
+
 Term { 
   $$ = $1; 
 }
diff --git a/c/testdata b/c/testdata
index 45140242..bd1d7f25 100644
--- a/c/testdata
+++ b/c/testdata
@@ -183,10 +183,27 @@ null
 null
 10
 
+[16 / 4 / 2, 16 / 4 * 2, 16 - 4 - 2, 16 - 4 + 2]
+null
+[2, 8, 10, 14]
+
 1 + tonumber + ("10" | tonumber)
 4
 15
 
+[{"a":42},.object,10,.num,false,true,null,"b",[1,4]] | .[] as $x | [$x == .[]]
+{"object": {"a":42}, "num":10.0}
+[true,  true,  false, false, false, false, false, false, false]
+[true,  true,  false, false, false, false, false, false, false]
+[false, false, true,  true,  false, false, false, false, false]
+[false, false, true,  true,  false, false, false, false, false]
+[false, false, false, false, true,  false, false, false, false]
+[false, false, false, false, false, true,  false, false, false]
+[false, false, false, false, false, false, true,  false, false]
+[false, false, false, false, false, false, false, true,  false]
+[false, false, false, false, false, false, false, false, true ]
+
+
 #
 # User-defined functions
 # Oh god.

From 95dd64b0f0f5bcf1aff780caa229bc592703faa1 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 11 Sep 2012 00:04:47 +0100
Subject: [PATCH 059/284] Much, much better error reporting from the parser.

Getting proper locations through flex/bison was more effort than
was advertised.
---
 c/execute.c  | 20 -----------------
 c/jv_parse.c | 18 +++++++--------
 c/lexer.l    |  9 ++++++++
 c/locfile.h  | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 c/main.c     | 39 +++++++++++++++++++++++++++++----
 c/parser.y   | 59 ++++++++++++++++++++++++++++++++++++++++---------
 6 files changed, 163 insertions(+), 44 deletions(-)
 create mode 100644 c/locfile.h

diff --git a/c/execute.c b/c/execute.c
index f59e156e..9f7b63b5 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -470,23 +470,3 @@ void jq_teardown() {
   pathbuf = 0;
   pathsize = 0;
 }
-
-void run_program(struct bytecode* bc) {
-#if JQ_DEBUG
-  dump_disassembly(0, bc);
-  printf("\n");
-#endif
-  char buf[409600];
-  fgets(buf, sizeof(buf), stdin);
-  jq_init(bc, jv_parse(buf));
-  jv result;
-  while (jv_is_valid(result = jq_next())) {
-    jv_dump(result);
-    printf("\n");
-  }
-  jv_free(result);
-  #if JQ_DEBUG
-  printf("end of results\n");
-  #endif
-  jq_teardown();
-}
diff --git a/c/jv_parse.c b/c/jv_parse.c
index 9300f311..7fd4d2d2 100644
--- a/c/jv_parse.c
+++ b/c/jv_parse.c
@@ -331,20 +331,18 @@ jv jv_parse_sized(const char* string, int length) {
 
   const char* p = string;
   char ch;
-  while (p < string + length) {
+  presult msg = 0;
+  while (msg == 0 && p < string + length) {
     ch = *p++;
-    presult msg = scan(&parser, ch);
-    if (msg){
-      printf("ERROR: %s (parsing '%s')\n", msg, string);
-      return jv_invalid();
-    }
+    msg = scan(&parser, ch);
   }
-  presult msg = finish(&parser);
+  if (msg == 0) msg = finish(&parser);
+  jv value;
   if (msg) {
-    printf("ERROR: %s (parsing '%s')\n", msg, string);
-    return jv_invalid();
+    value = jv_invalid_with_msg(jv_string_fmt("%s (while parsing '%s')", msg, string));
+  } else {
+    value = jv_copy(parser.next);
   }
-  jv value = jv_copy(parser.next);
   jv_parser_free(&parser);
   return value;
 }
diff --git a/c/lexer.l b/c/lexer.l
index 1794b9f1..bb7f57d6 100644
--- a/c/lexer.l
+++ b/c/lexer.l
@@ -1,10 +1,19 @@
 %{
 #include "compile.h"
 #include "parser.tab.h"  /* Generated by bison. */
+
+#define YY_USER_ACTION                           \
+  do {                                           \
+    yylloc->start = yyget_extra(yyscanner);      \
+    yylloc->end = yylloc->start + yyleng;        \
+    yyset_extra(yylloc->end, yyscanner);         \
+  } while (0);
+
 %}
 
 %option noyywrap nounput noinput nodefault
 %option reentrant
+%option extra-type="int"
 %option bison-bridge bison-locations
 
 %%
diff --git a/c/locfile.h b/c/locfile.h
new file mode 100644
index 00000000..0f605bbb
--- /dev/null
+++ b/c/locfile.h
@@ -0,0 +1,62 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+typedef struct {
+  int start, end;
+} location;
+
+struct locfile {
+  const char* data;
+  int length;
+  int* linemap;
+  int nlines;
+};
+
+static void locfile_init(struct locfile* l, const char* data, int length) {
+  l->data = data;
+  l->length = length;
+  l->nlines = 1;
+  for (int i=0; i<length; i++) {
+    if (data[i] == '\n') l->nlines++;
+  }
+  l->linemap = malloc(sizeof(int) * (l->nlines + 1));
+  l->linemap[0] = 0;
+  int line = 1;
+  for (int i=0; i<length; i++) {
+    if (data[i] == '\n') {
+      l->linemap[line] = i;
+      line++;
+    }
+  }
+  l->linemap[l->nlines] = length;
+}
+
+static void locfile_free(struct locfile* l) {
+  free(l->linemap);
+}
+
+static int locfile_get_line(struct locfile* l, int pos) {
+  assert(pos < l->length);
+  int line = 0;
+  while (l->linemap[line+1] < pos) line++;
+  assert(line < l->nlines);
+  return line;
+}
+
+static int locfile_line_length(struct locfile* l, int line) {
+  assert(line < l->nlines);
+  return l->linemap[line+1] - l->linemap[line];
+}
+
+static void locfile_locate(struct locfile* l, location loc) {
+  int startline = locfile_get_line(l, loc.start);
+  int offset = l->linemap[startline];
+  printf("%.*s\n", locfile_line_length(l, startline), l->data + offset);
+  printf("%*s", loc.start - offset, "");
+  for (int i = loc.start; 
+       i < loc.end && i < offset + locfile_line_length(l, startline);
+       i++){
+    printf("^");
+  }
+  printf("\n");
+}
diff --git a/c/main.c b/c/main.c
index 7c341d8d..4faf2a0b 100644
--- a/c/main.c
+++ b/c/main.c
@@ -4,13 +4,36 @@
 #include "builtin.h"
 #include "jv.h"
 
-block compile(const char* str);
+int compile(const char* str, block* answer);
 
 void jq_init(struct bytecode* bc, jv value);
 jv jq_next();
 void jq_teardown();
 
-void run_program(struct bytecode* bc);
+
+void run_program(struct bytecode* bc) {
+#if JQ_DEBUG
+  dump_disassembly(0, bc);
+  printf("\n");
+#endif
+  char buf[409600];
+  fgets(buf, sizeof(buf), stdin);
+  jv value = jv_parse(buf);
+  if (!jv_is_valid(value)) {
+    assert(0 && "couldn't parse input"); //FIXME
+  }
+  jq_init(bc, value);
+  jv result;
+  while (jv_is_valid(result = jq_next())) {
+    jv_dump(result);
+    printf("\n");
+  }
+  jv_free(result);
+  #if JQ_DEBUG
+  printf("end of results\n");
+  #endif
+  jq_teardown();
+}
 
 int skipline(const char* buf) {
   int p = 0;
@@ -29,7 +52,9 @@ void run_tests() {
     if (skipline(buf)) continue;
     printf("Testing %s\n", buf);
     int pass = 1;
-    block program = compile(buf);
+    block program;
+    int nerrors = compile(buf, &program);
+    assert(nerrors == 0);
     block_append(&program, gen_op_simple(YIELD));
     block_append(&program, gen_op_simple(BACKTRACK));
     program = gen_cbinding(&builtins, program);
@@ -86,11 +111,17 @@ void run_tests() {
 
 int main(int argc, char* argv[]) {
   if (argc == 1) { run_tests(); return 0; }
-  block blk = compile(argv[1]);
+  block blk;
+  int nerrors = compile(argv[1], &blk);
+  if (nerrors > 0) {
+    printf("%d compile %s\n", nerrors, nerrors > 1 ? "errors" : "error");
+    return 1;
+  }
   block_append(&blk, block_join(gen_op_simple(YIELD), gen_op_simple(BACKTRACK)));
   blk = gen_cbinding(&builtins, blk);
   struct bytecode* bc = block_compile(blk);
   block_free(blk);
   run_program(bc);
   bytecode_free(bc);
+  return 0;
 }
diff --git a/c/parser.y b/c/parser.y
index 0f1e42c4..11b88a7f 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -4,21 +4,40 @@
 #include "compile.h"
 %}
 
+%code requires {
+#include "locfile.h"
+#define YYLTYPE location
+#define YYLLOC_DEFAULT(Loc, Rhs, N)             \
+  do {                                          \
+    if (N) {                                    \
+      (Loc).start = YYRHSLOC(Rhs, 1).start;     \
+      (Loc).end = YYRHSLOC(Rhs, N).end;         \
+    } else {                                    \
+      (Loc).start = YYRHSLOC(Rhs, 0).end;       \
+      (Loc).end = YYRHSLOC(Rhs, 0).end;         \
+    }                                           \
+  } while (0)
+ }
+
 %locations
+%error-verbose
 %define api.pure
 %union {
   jv literal;
   block blk;
 }
 
+%destructor { jv_free($$); } <literal>
+%destructor { block_free($$); } <blk>
+
 %parse-param {block* answer}
+%parse-param {int* errors}
+%parse-param {struct locfile* locations}
 %parse-param {yyscan_t lexer}
 %lex-param {yyscan_t lexer}
 
-
 %token <literal> IDENT
 %token <literal> LITERAL
-
 %token EQ "=="
 %token DEFINEDOR "//"
 %token AS "as"
@@ -50,8 +69,18 @@
 %type <blk> Exp Term MkDict MkDictPair ExpD ElseBody
 %{
 #include "lexer.yy.h"
-void yyerror(YYLTYPE* loc, block* answer, yyscan_t lexer, const char *s){
-  printf("ERROR: %s\n", s); 
+#define FAIL(loc, msg)                                   \
+  do {                                                   \
+    location l = loc;                                    \
+    yyerror(&l, answer, errors, locations, lexer, msg);  \
+    /*YYERROR*/;                                         \
+  } while (0)
+
+void yyerror(YYLTYPE* loc, block* answer, int* errors, 
+             struct locfile* locations, yyscan_t lexer, const char *s){
+  (*errors)++;
+  printf("error: %s\n", s);
+  locfile_locate(locations, *loc);
 }
 
 static block gen_dictpair(block k, block v) {
@@ -263,7 +292,9 @@ MkDictPair
   $$ = gen_dictpair(gen_op_const(LOADK, $1), $3);
  }
 | LITERAL ':' ExpD {
-  assert(jv_get_kind($1) == JV_KIND_STRING);
+  if (jv_get_kind($1) != JV_KIND_STRING) {
+    FAIL(@1, "Object keys must be strings");
+  }
   $$ = gen_dictpair(gen_op_const(LOADK, $1), $3);
   }
 | IDENT {
@@ -275,14 +306,22 @@ MkDictPair
   }
 %%
 
-block compile(const char* str) {
+int compile(const char* str, block* answer) {
   yyscan_t scanner;
   YY_BUFFER_STATE buf;
-  block answer = gen_noop();
-  yylex_init(&scanner);
+  yylex_init_extra(0, &scanner);
   buf = yy_scan_string(str, scanner);
-  yyparse(&answer, scanner);
+  int errors = 0;
+  struct locfile locations;
+  locfile_init(&locations, str, strlen(str));
+  *answer = gen_noop();
+  yyparse(answer, &errors, &locations, scanner);
+  locfile_free(&locations);
   yy_delete_buffer(buf, scanner);
   yylex_destroy(scanner);
-  return answer;
+  if (errors > 0) {
+    block_free(*answer);
+    *answer = gen_noop();
+  }
+  return errors;
 }

From ac3f8bcc525510be5f1b73dc4e7904490dcb3ed4 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 11 Sep 2012 09:13:20 +0100
Subject: [PATCH 060/284] Proper error messages from lexer errors (e.g. bad
 characters).

---
 c/lexer.l  |  5 ++++-
 c/parser.y | 36 ++++++++++++++++++++++++++++++++----
 2 files changed, 36 insertions(+), 5 deletions(-)

diff --git a/c/lexer.l b/c/lexer.l
index bb7f57d6..5ceb3a0a 100644
--- a/c/lexer.l
+++ b/c/lexer.l
@@ -15,6 +15,7 @@
 %option reentrant
 %option extra-type="int"
 %option bison-bridge bison-locations
+%option prefix="jq_yy"
 
 %%
 
@@ -33,7 +34,7 @@
 "//" { return DEFINEDOR; }
 "."|"="|";"|"["|"]"|","|":"|"("|")"|"{"|"}"|"|"|"+"|"-"|"*"|"/"|"\$" { return yytext[0];}
 
-\"(\\.|[^\\"])*\" |
+\"(\\.|[^\\\"])*\" |
 -?[0-9.]+([eE][+-]?[0-9]+)? { 
    yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; 
 }
@@ -42,6 +43,8 @@
 
 [ \n\t]+  {}
 
+. { return INVALID_CHARACTER; }
+
 %%
 /* perhaps these should be calls... */
 /*
diff --git a/c/parser.y b/c/parser.y
index 11b88a7f..3d81ea4a 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -34,8 +34,13 @@
 %parse-param {int* errors}
 %parse-param {struct locfile* locations}
 %parse-param {yyscan_t lexer}
+%lex-param {block* answer}
+%lex-param {int* errors}
+%lex-param {struct locfile* locations}
 %lex-param {yyscan_t lexer}
 
+
+%token INVALID_CHARACTER
 %token <literal> IDENT
 %token <literal> LITERAL
 %token EQ "=="
@@ -83,6 +88,29 @@ void yyerror(YYLTYPE* loc, block* answer, int* errors,
   locfile_locate(locations, *loc);
 }
 
+int yylex(YYSTYPE* yylval, YYLTYPE* yylloc, block* answer, int* errors, 
+          struct locfile* locations, yyscan_t lexer) {
+  while (1) {
+    int tok = jq_yylex(yylval, yylloc, lexer);
+    if (tok == INVALID_CHARACTER) {
+      FAIL(*yylloc, "Invalid character");
+    } else {
+      if (tok == LITERAL && !jv_is_valid(yylval->literal)) {
+        jv msg = jv_invalid_get_msg(jv_copy(yylval->literal));
+        if (jv_get_kind(msg) == JV_KIND_STRING) {
+          FAIL(*yylloc, jv_string_value(msg));
+        } else {
+          FAIL(*yylloc, "Invalid literal");
+        }
+        jv_free(msg);
+        jv_free(yylval->literal);
+        yylval->literal = jv_null();
+      }
+      return tok;
+    }
+  }
+}
+
 static block gen_dictpair(block k, block v) {
   block b = gen_subexp(k);
   block_append(&b, gen_subexp(v));
@@ -309,16 +337,16 @@ MkDictPair
 int compile(const char* str, block* answer) {
   yyscan_t scanner;
   YY_BUFFER_STATE buf;
-  yylex_init_extra(0, &scanner);
-  buf = yy_scan_string(str, scanner);
+  jq_yylex_init_extra(0, &scanner);
+  buf = jq_yy_scan_string(str, scanner);
   int errors = 0;
   struct locfile locations;
   locfile_init(&locations, str, strlen(str));
   *answer = gen_noop();
   yyparse(answer, &errors, &locations, scanner);
   locfile_free(&locations);
-  yy_delete_buffer(buf, scanner);
-  yylex_destroy(scanner);
+  jq_yy_delete_buffer(buf, scanner);
+  jq_yylex_destroy(scanner);
   if (errors > 0) {
     block_free(*answer);
     *answer = gen_noop();

From 0ce437ea9743fc443704181cf785c10b771b8f07 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 11 Sep 2012 10:12:25 +0100
Subject: [PATCH 061/284] More error handling in the parser.

Add a special case in the lexer to detect unterminated strings.
Add some error recovery in the parser for more copious error spam.
---
 c/lexer.l  |  6 ++++++
 c/parser.y | 22 +++++++++++++++-------
 2 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/c/lexer.l b/c/lexer.l
index 5ceb3a0a..9c20a953 100644
--- a/c/lexer.l
+++ b/c/lexer.l
@@ -39,6 +39,12 @@
    yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; 
 }
 
+\"(\\.|[^\\\"])* { 
+  yylval->literal = jv_invalid_with_msg(jv_string("Unterminated string"));
+  return LITERAL;
+}
+  
+
 [[:alnum:]]+  { yylval->literal = jv_string(yytext); return IDENT;}
 
 [ \n\t]+  {}
diff --git a/c/parser.y b/c/parser.y
index 3d81ea4a..111d8ee7 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -3,7 +3,6 @@
 #include <string.h>
 #include "compile.h"
 %}
-
 %code requires {
 #include "locfile.h"
 #define YYLTYPE location
@@ -170,6 +169,10 @@ Term "as" '$' IDENT '|' Exp {
 "if" Exp "then" Exp ElseBody {
   $$ = gen_cond($2, $4, $5);
 } |
+"if" Exp error {
+  FAIL(@$, "Possibly unterminated 'if' statment");
+  $$ = $2;
+} |
 
 Exp '=' Exp {
   block assign = gen_op_simple(DUP);
@@ -188,7 +191,6 @@ Exp "and" Exp {
   $$ = gen_and($1, $3);
 } |
 
-
 "not" Exp {
   $$ = gen_not($2);
 } |
@@ -236,6 +238,8 @@ Term {
   $$ = $1; 
 }
 
+
+
 ElseBody:
 "elif" Exp "then" Exp ElseBody {
   $$ = gen_cond($2, $4, $5);
@@ -304,16 +308,19 @@ IDENT '(' Exp ')' {
                                                            block_join($3, gen_op_simple(RET))),
                                          gen_noop(), OP_IS_CALL_PSEUDO)));
   jv_free($1);
-}
+} |
+'(' error ')' { $$ = gen_noop(); } |
+'[' error ']' { $$ = gen_noop(); } |
+Term '[' error ']' { $$ = $1; } |
+'{' error '}' { $$ = gen_noop(); }
 
 MkDict:
 { 
   $$=gen_noop(); 
-}
-|
-MkDictPair
-{ $$ = $1; }
+} |
+ MkDictPair { $$ = $1; }
 | MkDictPair ',' MkDict { $$=block_join($1, $3); }
+| error ',' MkDict { $$ = $3; }
 
 MkDictPair
 : IDENT ':' ExpD { 
@@ -332,6 +339,7 @@ MkDictPair
 | '(' Exp ')' ':' ExpD {
   $$ = gen_dictpair($2, $5);
   }
+| '(' error ')' ':' ExpD { $$ = $5; }
 %%
 
 int compile(const char* str, block* answer) {

From 4c7bede5a46ef25b3d8d06c851d145804f60e20a Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 11 Sep 2012 10:37:44 +0100
Subject: [PATCH 062/284] Better error handling and messages for invalid
 index/assign operations.

---
 c/execute.c | 34 ++++++++++++++++++++--------------
 c/jv.c      |  2 +-
 c/jv.h      | 48 +++++++++++++++++++++---------------------------
 3 files changed, 42 insertions(+), 42 deletions(-)

diff --git a/c/execute.c b/c/execute.c
index 9f7b63b5..cbde413a 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -133,7 +133,14 @@ static struct closure make_closure(struct forkable_stack* stk, frame_ptr fr, uin
   }
 }
 
-
+void print_error(jv value) {
+  assert(!jv_is_valid(value));
+  jv msg = jv_invalid_get_msg(value);
+  if (jv_get_kind(msg) == JV_KIND_STRING) {
+    fprintf(stderr, "jq: error: %s\n", jv_string_value(msg));
+  }
+  jv_free(msg);
+}
 #define ON_BACKTRACK(op) ((op)+NUM_OPCODES)
 
 jv jq_next() {
@@ -273,7 +280,13 @@ jv jq_next() {
       uint16_t v = *pc++;
       frame_ptr fp = frame_get_level(&frame_stk, frame_current(&frame_stk), level);
       jv* var = frame_local_var(fp, v);
-      *var = jv_insert(*var, replacement.value, pathbuf + path_start.pathidx, path_end.pathidx - path_start.pathidx);
+      jv result = jv_insert(*var, replacement.value, pathbuf + path_start.pathidx, path_end.pathidx - path_start.pathidx);
+      if (jv_is_valid(result)) {
+        *var = result;
+      } else {
+        print_error(result);
+        *var = jv_null();
+      }
       break;
     }
 
@@ -282,13 +295,14 @@ jv jq_next() {
       jv k = stack_pop().value;
       int pathidx = path_push(t, jv_copy(k));
       jv v = jv_lookup(t.value, k);
-      if (1 /* fixme invalid lookups */) {
+      if (jv_is_valid(v)) {
         stackval sv;
         sv.value = v;
         sv.pathidx = pathidx;
         stack_push(sv);
       } else {
-        assert(0 && "bad lookup");
+        print_error(v);
+        goto do_backtrack;
       }
       break;
     }
@@ -379,11 +393,7 @@ jv jq_next() {
       if (jv_is_valid(top.value)) {
         stack_push(top);
       } else {
-        jv msg = jv_invalid_get_msg(top.value);
-        if (jv_get_kind(msg) == JV_KIND_STRING) {
-          fprintf(stderr, "jq: error: %s\n", jv_string_value(msg));
-        }
-        jv_free(msg);
+        print_error(top.value);
         goto do_backtrack;
       }
       break;
@@ -405,11 +415,7 @@ jv jq_next() {
       if (jv_is_valid(top.value)) {
         stack_push(top);
       } else {
-        jv msg = jv_invalid_get_msg(top.value);
-        if (jv_get_kind(msg) == JV_KIND_STRING) {
-          fprintf(stderr, "jq: error: %s\n", jv_string_value(msg));
-        }
-        jv_free(msg);
+        print_error(top.value);
         goto do_backtrack;
       }
       break;
diff --git a/c/jv.c b/c/jv.c
index f8b79ce6..214354ce 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -49,7 +49,7 @@ const char* jv_kind_name(jv_kind k) {
   case JV_KIND_ARRAY:   return "array";
   case JV_KIND_OBJECT:  return "object";
   }
-  assert(0);
+  assert(0 && "invalid kind");
   return "<unknown>";
 }
 
diff --git a/c/jv.h b/c/jv.h
index ef64816c..3c557c45 100644
--- a/c/jv.h
+++ b/c/jv.h
@@ -126,39 +126,33 @@ static jv jv_lookup(jv t, jv k) {
     jv_free(k);
     v = jv_null();
   } else {
-    assert(0&&"bad lookup");
+    v = jv_invalid_with_msg(jv_string_fmt("Cannot index %s with %s",
+                                          jv_kind_name(jv_get_kind(t)),
+                                          jv_kind_name(jv_get_kind(k))));
+    jv_free(t);
+    jv_free(k);
   }
   return v;
-  // FIXME: invalid indexes, JV_KIND_INVALID
-  /*
-  if (v) 
-    return v;
-  else
-    return jv_null();
-  */
 }
 
 static jv jv_modify(jv t, jv k, jv v) {
-  if (jv_get_kind(k) == JV_KIND_STRING) {
-    if (jv_get_kind(t) == JV_KIND_NULL) {
-      t = jv_object();
-    }
-    if (jv_get_kind(t) == JV_KIND_OBJECT) {
-      t = jv_object_set(t, k, v);
-    } else {
-      assert(0 && "bad mod - not an object");
-    }
-  } else if (jv_get_kind(k) == JV_KIND_NUMBER) {
-    if (jv_get_kind(t) == JV_KIND_NULL) {
-      t = jv_array();
-    }
-    if (jv_get_kind(t) == JV_KIND_ARRAY) {
-      t = jv_array_set(t, (int)jv_number_value(k), v);
-    } else {
-      assert(0 && "bad mod - not an array");
-    }
+  int isnull = jv_get_kind(t) == JV_KIND_NULL;
+  if (jv_get_kind(k) == JV_KIND_STRING && 
+      (jv_get_kind(t) == JV_KIND_OBJECT || isnull)) {
+    if (isnull) t = jv_object();
+    t = jv_object_set(t, k, v);
+  } else if (jv_get_kind(k) == JV_KIND_NUMBER &&
+             (jv_get_kind(t) == JV_KIND_ARRAY || isnull)) {
+    if (isnull) t = jv_array();
+    t = jv_array_set(t, (int)jv_number_value(k), v);
   } else {
-    assert(0 && "bad mod - seriously, wtf");
+    jv err = jv_invalid_with_msg(jv_string_fmt("Cannot update field at %s index of %s",
+                                               jv_kind_name(jv_get_kind(t)),
+                                               jv_kind_name(jv_get_kind(v))));
+    jv_free(t);
+    jv_free(k);
+    jv_free(v);
+    t = err;
   }
   return t;
 }

From 062a6aa6d7b9c8ead18cc9cbbe0f458a7e2b7db9 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 11 Sep 2012 12:24:54 +0100
Subject: [PATCH 063/284] More error handling - locations of refs to undefined
 symbols.

---
 c/compile.c | 40 ++++++++++++++++++++++++++++++++--------
 c/compile.h |  5 ++++-
 c/locfile.h | 26 +++++++++++++++++++++-----
 c/main.c    | 45 ++++++++++++++++++++++++++-------------------
 c/parser.y  | 17 +++++++----------
 5 files changed, 90 insertions(+), 43 deletions(-)

diff --git a/c/compile.c b/c/compile.c
index b7f91aa3..c45d45a1 100644
--- a/c/compile.c
+++ b/c/compile.c
@@ -3,7 +3,7 @@
 #include <stdlib.h>
 #include "opcode.h"
 #include "compile.h"
-
+#include "locfile.h"
 
 struct inst {
   struct inst* next;
@@ -18,6 +18,8 @@ struct inst {
     struct cfunction* cfunc;
   } imm;
 
+  location source;
+
   // Binding
   // An instruction requiring binding (for parameters/variables)
   // is in one of three states:
@@ -45,6 +47,7 @@ static inst* inst_new(opcode op) {
   i->bound_by = 0;
   i->symbol = 0;
   i->subfn = gen_noop();
+  i->source = UNKNOWN_LOCATION;
   return i;
 }
 
@@ -82,6 +85,16 @@ static inst* block_take(block* b) {
   return i;
 }
 
+block gen_location(location loc, block b) {
+  for (inst* i = b.first; i; i = i->next) {
+    if (i->source.start == UNKNOWN_LOCATION.start &&
+        i->source.end == UNKNOWN_LOCATION.end) {
+      i->source = loc;
+    }
+  }
+  return b;
+}
+
 block gen_noop() {
   block b = {0,0};
   return b;
@@ -429,7 +442,8 @@ static int count_cfunctions(block b) {
   return n;
 }
 
-static void compile(struct bytecode* bc, block b) {
+static int compile(struct locfile* locations, struct bytecode* bc, block b) {
+  int errors = 0;
   int pos = 0;
   int var_frame_idx = 0;
   bc->nsubfunctions = 0;
@@ -442,7 +456,10 @@ static void compile(struct bytecode* bc, block b) {
 
     int opflags = opcode_describe(curr->op)->flags;
     if (opflags & OP_HAS_BINDING) {
-      assert(curr->bound_by && "unbound term");
+      if (!curr->bound_by) {
+        locfile_locate(locations, curr->source, "error: %s is not defined", curr->symbol);
+        errors++;
+      }
     }
     if ((opflags & OP_HAS_VARIABLE) &&
         curr->bound_by == curr) {
@@ -472,7 +489,7 @@ static void compile(struct bytecode* bc, block b) {
       bc->subfunctions[curr->imm.intval] = subfn;
       subfn->globals = bc->globals;
       subfn->parent = bc;
-      compile(subfn, curr->subfn);
+      errors += compile(locations, subfn, curr->subfn);
     }
   } else {
     bc->subfunctions = 0;
@@ -483,7 +500,7 @@ static void compile(struct bytecode* bc, block b) {
   pos = 0;
   jv constant_pool = jv_array();
   int maxvar = -1;
-  for (inst* curr = b.first; curr; curr = curr->next) {
+  if (!errors) for (inst* curr = b.first; curr; curr = curr->next) {
     const struct opcode_description* op = opcode_describe(curr->op);
     if (op->length == 0)
       continue;
@@ -551,18 +568,25 @@ static void compile(struct bytecode* bc, block b) {
   }
   bc->constants = constant_pool;
   bc->nlocals = maxvar + 2; // FIXME: frames of size zero?
+  return errors;
 }
 
-struct bytecode* block_compile(block b) {
+int block_compile(block b, struct locfile* locations, struct bytecode** out) {
   struct bytecode* bc = malloc(sizeof(struct bytecode));
   bc->parent = 0;
   bc->globals = malloc(sizeof(struct symbol_table));
   int ncfunc = count_cfunctions(b);
   bc->globals->ncfunctions = 0;
   bc->globals->cfunctions = malloc(sizeof(struct cfunction) * ncfunc);
-  compile(bc, b);
+  int nerrors = compile(locations, bc, b);
   assert(bc->globals->ncfunctions == ncfunc);
-  return bc;
+  if (nerrors > 0) {
+    bytecode_free(bc);
+    *out = 0;
+  } else {
+    *out = bc;
+  }
+  return nerrors;
 }
 
 void block_free(block b) {
diff --git a/c/compile.h b/c/compile.h
index 8f9526b0..bdaf6a88 100644
--- a/c/compile.h
+++ b/c/compile.h
@@ -1,6 +1,7 @@
 #include <stdint.h>
 #include "bytecode.h"
 #include "opcode.h"
+#include "locfile.h"
 
 struct inst;
 typedef struct inst inst;
@@ -11,6 +12,8 @@ typedef struct block {
   inst* last;
 } block;
 
+block gen_location(location, block);
+
 block gen_noop();
 block gen_op_simple(opcode op);
 block gen_op_const(opcode op, jv constant);
@@ -39,7 +42,7 @@ void block_append(block* b, block b2);
 block block_join(block a, block b);
 block block_bind(block binder, block body, int bindflags);
 
-struct bytecode* block_compile(block);
+int block_compile(block, struct locfile*, struct bytecode**);
 
 void block_free(block);
 
diff --git a/c/locfile.h b/c/locfile.h
index 0f605bbb..77b1aef1 100644
--- a/c/locfile.h
+++ b/c/locfile.h
@@ -1,10 +1,15 @@
+#ifndef _LOCFILE_H
+#define _LOCFILE_H
 #include <stdlib.h>
 #include <stdio.h>
 #include <assert.h>
+#include <stdarg.h>
 typedef struct {
   int start, end;
 } location;
 
+static const location UNKNOWN_LOCATION = {-1, -1};
+
 struct locfile {
   const char* data;
   int length;
@@ -48,15 +53,26 @@ static int locfile_line_length(struct locfile* l, int line) {
   return l->linemap[line+1] - l->linemap[line];
 }
 
-static void locfile_locate(struct locfile* l, location loc) {
+static void locfile_locate(struct locfile* l, location loc, const char* fmt, ...) {
+  va_list fmtargs;
+  va_start(fmtargs, fmt);
+  vfprintf(stderr, fmt, fmtargs);
+  va_end(fmtargs);
+  fprintf(stderr, "\n");
+  if (loc.start == -1) {
+    fprintf(stderr, "<unknown location>\n");
+    return;
+  }
   int startline = locfile_get_line(l, loc.start);
   int offset = l->linemap[startline];
-  printf("%.*s\n", locfile_line_length(l, startline), l->data + offset);
-  printf("%*s", loc.start - offset, "");
+  fprintf(stderr, "%.*s\n", locfile_line_length(l, startline), l->data + offset);
+  fprintf(stderr, "%*s", loc.start - offset, "");
   for (int i = loc.start; 
        i < loc.end && i < offset + locfile_line_length(l, startline);
        i++){
-    printf("^");
+    fprintf(stderr, "^");
   }
-  printf("\n");
+  fprintf(stderr, "\n");
 }
+
+#endif
diff --git a/c/main.c b/c/main.c
index 4faf2a0b..f6d9e67f 100644
--- a/c/main.c
+++ b/c/main.c
@@ -1,15 +1,36 @@
 #include <stdio.h>
+#include <string.h>
 #include "compile.h"
 #include "parser.tab.h"
 #include "builtin.h"
 #include "jv.h"
+#include "locfile.h"
 
-int compile(const char* str, block* answer);
+int jq_parse(struct locfile* source, block* answer);
 
 void jq_init(struct bytecode* bc, jv value);
 jv jq_next();
 void jq_teardown();
 
+struct bytecode* jq_compile(const char* str) {
+  struct locfile locations;
+  locfile_init(&locations, str, strlen(str));
+  block program;
+  struct bytecode* bc = 0;
+  int nerrors = jq_parse(&locations, &program);
+  if (nerrors == 0) {
+    block_append(&program, block_join(gen_op_simple(YIELD), gen_op_simple(BACKTRACK)));
+    program = gen_cbinding(&builtins, program);
+    nerrors = block_compile(program, &locations, &bc);
+    block_free(program);
+  }
+  if (nerrors) {
+    fprintf(stderr, "%d compile %s\n", nerrors, nerrors > 1 ? "errors" : "error");
+  }
+  locfile_free(&locations);
+  return bc;
+}
+
 
 void run_program(struct bytecode* bc) {
 #if JQ_DEBUG
@@ -52,14 +73,8 @@ void run_tests() {
     if (skipline(buf)) continue;
     printf("Testing %s\n", buf);
     int pass = 1;
-    block program;
-    int nerrors = compile(buf, &program);
-    assert(nerrors == 0);
-    block_append(&program, gen_op_simple(YIELD));
-    block_append(&program, gen_op_simple(BACKTRACK));
-    program = gen_cbinding(&builtins, program);
-    struct bytecode* bc = block_compile(program);
-    block_free(program);
+    struct bytecode* bc = jq_compile(buf);
+    assert(bc);
     printf("Disassembly:\n");
     dump_disassembly(2, bc);
     printf("\n");
@@ -111,16 +126,8 @@ void run_tests() {
 
 int main(int argc, char* argv[]) {
   if (argc == 1) { run_tests(); return 0; }
-  block blk;
-  int nerrors = compile(argv[1], &blk);
-  if (nerrors > 0) {
-    printf("%d compile %s\n", nerrors, nerrors > 1 ? "errors" : "error");
-    return 1;
-  }
-  block_append(&blk, block_join(gen_op_simple(YIELD), gen_op_simple(BACKTRACK)));
-  blk = gen_cbinding(&builtins, blk);
-  struct bytecode* bc = block_compile(blk);
-  block_free(blk);
+  struct bytecode* bc = jq_compile(argv[1]);
+  if (!bc) return 1;
   run_program(bc);
   bytecode_free(bc);
   return 0;
diff --git a/c/parser.y b/c/parser.y
index 111d8ee7..70fb7116 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -83,8 +83,7 @@
 void yyerror(YYLTYPE* loc, block* answer, int* errors, 
              struct locfile* locations, yyscan_t lexer, const char *s){
   (*errors)++;
-  printf("error: %s\n", s);
-  locfile_locate(locations, *loc);
+  locfile_locate(locations, *loc, "error: %s", s);
 }
 
 int yylex(YYSTYPE* yylval, YYLTYPE* yylloc, block* answer, int* errors, 
@@ -293,11 +292,11 @@ LITERAL {
   block_append(&$$, gen_op_simple(POP));
 } |
 '$' IDENT {
-  $$ = gen_op_var_unbound(LOADV, jv_string_value($2)); 
+  $$ = gen_location(@$, gen_op_var_unbound(LOADV, jv_string_value($2)));
   jv_free($2);
 } | 
 IDENT {
-  $$ = gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, jv_string_value($1)));
+  $$ = gen_location(@$, gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, jv_string_value($1))));
   jv_free($1);
 } |
 IDENT '(' Exp ')' {
@@ -307,6 +306,7 @@ IDENT '(' Exp ')' {
                                                 "lambda",
                                                            block_join($3, gen_op_simple(RET))),
                                          gen_noop(), OP_IS_CALL_PSEUDO)));
+  $$ = gen_location(@1, $$);
   jv_free($1);
 } |
 '(' error ')' { $$ = gen_noop(); } |
@@ -342,17 +342,14 @@ MkDictPair
 | '(' error ')' ':' ExpD { $$ = $5; }
 %%
 
-int compile(const char* str, block* answer) {
+int jq_parse(struct locfile* locations, block* answer) {
   yyscan_t scanner;
   YY_BUFFER_STATE buf;
   jq_yylex_init_extra(0, &scanner);
-  buf = jq_yy_scan_string(str, scanner);
+  buf = jq_yy_scan_bytes(locations->data, locations->length, scanner);
   int errors = 0;
-  struct locfile locations;
-  locfile_init(&locations, str, strlen(str));
   *answer = gen_noop();
-  yyparse(answer, &errors, &locations, scanner);
-  locfile_free(&locations);
+  yyparse(answer, &errors, locations, scanner);
   jq_yy_delete_buffer(buf, scanner);
   jq_yylex_destroy(scanner);
   if (errors > 0) {

From 51a44edc63bf4f1749458faf5ae631e0d5023ba9 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 11 Sep 2012 14:52:10 +0100
Subject: [PATCH 064/284] JSON stream parser.

Allow multiple values on input as concatenated JSON objects,
possibly separated by whitespace.
---
 c/jv.c       |   7 ++++
 c/jv.h       |   2 +
 c/jv_dtoa.h  |   4 +-
 c/jv_parse.c | 116 +++++++++++++++++++++++++++++++++++++++------------
 c/jv_parse.h |  17 +++++++-
 c/jv_print.c |   2 +-
 c/main.c     |  61 +++++++++++++++------------
 7 files changed, 153 insertions(+), 56 deletions(-)

diff --git a/c/jv.c b/c/jv.c
index 214354ce..786e7b26 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -103,6 +103,13 @@ jv jv_invalid_get_msg(jv inv) {
   return x;
 }
 
+int jv_invalid_has_msg(jv inv) {
+  jv msg = jv_invalid_get_msg(inv);
+  int r = jv_get_kind(msg) != JV_KIND_NULL;
+  jv_free(msg);
+  return r;
+}
+
 static void jvp_invalid_free(jv_complex* x) {
   if (jvp_refcnt_dec(x)) {
     jv_free(((jvp_invalid*)x->ptr)->errmsg);
diff --git a/c/jv.h b/c/jv.h
index 3c557c45..48ae0e0f 100644
--- a/c/jv.h
+++ b/c/jv.h
@@ -52,6 +52,8 @@ int jv_equal(jv, jv);
 jv jv_invalid();
 jv jv_invalid_with_msg(jv);
 jv jv_invalid_get_msg(jv);
+int jv_invalid_has_msg(jv);
+
 
 jv jv_null();
 jv jv_true();
diff --git a/c/jv_dtoa.h b/c/jv_dtoa.h
index e9346c0e..3bafcf47 100644
--- a/c/jv_dtoa.h
+++ b/c/jv_dtoa.h
@@ -1,4 +1,5 @@
-
+#ifndef JV_DTOA_H
+#define JV_DTOA_H
 #define Kmax 7
 
 struct Bigint;
@@ -18,3 +19,4 @@ void jvp_freedtoa(struct dtoa_context* C, char *s);
 
 #define JVP_DTOA_FMT_MAX_LEN 32
 char* jvp_dtoa_fmt(struct dtoa_context* C, register char *b, double x);
+#endif
diff --git a/c/jv_parse.c b/c/jv_parse.c
index 7fd4d2d2..e4565ef7 100644
--- a/c/jv_parse.c
+++ b/c/jv_parse.c
@@ -22,11 +22,15 @@ void jv_parser_init(struct jv_parser* p) {
   p->tokenbuf = 0;
   p->tokenlen = p->tokenpos = 0;
   p->st = JV_PARSER_NORMAL;
+  p->curr_buf = 0;
+  p->curr_buf_length = p->curr_buf_pos = p->curr_buf_is_partial = 0;
   jvp_dtoa_context_init(&p->dtoa);
 }
 
 void jv_parser_free(struct jv_parser* p) {
   jv_free(p->next);
+  for (int i=0; i<p->stackpos; i++) 
+    jv_free(p->stack[i]);
   free(p->stack);
   free(p->tokenbuf);
   jvp_dtoa_context_free(&p->dtoa);
@@ -271,13 +275,25 @@ static chclass classify(char c) {
 }
 
 
+static presult OK = "output produced";
 
+static int check_done(struct jv_parser* p, jv* out) {
+  if (p->stackpos == 0 && jv_is_valid(p->next)) {
+    *out = p->next;
+    p->next = jv_invalid();
+    return 1;
+  } else {
+    return 0;
+  }
+}
 
-static pfunc scan(struct jv_parser* p, char ch) {
+static pfunc scan(struct jv_parser* p, char ch, jv* out) {
+  presult answer = 0;
   if (p->st == JV_PARSER_NORMAL) {
     chclass cls = classify(ch);
     if (cls != LITERAL) {
       TRY(check_literal(p));
+      if (check_done(p, out)) answer = OK;
     }
     switch (cls) {
     case LITERAL:
@@ -294,10 +310,12 @@ static pfunc scan(struct jv_parser* p, char ch) {
     case INVALID:
       return "Invalid character";
     }
+    if (check_done(p, out)) answer = OK;
   } else {
     if (ch == '"' && p->st == JV_PARSER_STRING) {
       TRY(found_string(p));
       p->st = JV_PARSER_NORMAL;
+      if (check_done(p, out)) answer = OK;
     } else {
       tokenadd(p, ch);
       if (ch == '\\' && p->st == JV_PARSER_STRING) {
@@ -307,43 +325,87 @@ static pfunc scan(struct jv_parser* p, char ch) {
       }
     }
   }
-  return 0;
+  return answer;
 }
 
-static pfunc finish(struct jv_parser* p) {
-  if (p->st != JV_PARSER_NORMAL)
-    return "Unfinished string";
-  TRY(check_literal(p));
+void jv_parser_set_buf(struct jv_parser* p, const char* buf, int length, int is_partial) {
+  assert((p->curr_buf == 0 || p->curr_buf_pos == p->curr_buf_length)
+         && "previous buffer not exhausted");
+  p->curr_buf = buf;
+  p->curr_buf_length = length;
+  p->curr_buf_pos = 0;
+  p->curr_buf_is_partial = is_partial;
+}
 
-  if (p->stackpos != 0)
-    return "Unfinished JSON term";
-  
-  // this will happen on the empty string
-  if (!jv_is_valid(p->next))
-    return "Expected JSON value";
-  
-  return 0;
+jv jv_parser_next(struct jv_parser* p) {
+  assert(p->curr_buf && "a buffer must be provided");
+  jv value;
+  presult msg = 0;
+  while (!msg && p->curr_buf_pos < p->curr_buf_length) {
+    char ch = p->curr_buf[p->curr_buf_pos++];
+    msg = scan(p, ch, &value);
+  }
+  if (msg == OK) {
+    return value;
+  } else if (msg) {
+    return jv_invalid_with_msg(jv_string(msg));
+  } else if (p->curr_buf_is_partial) {
+    assert(p->curr_buf_pos == p->curr_buf_length);
+    // need another buffer
+    return jv_invalid();
+  } else {
+    assert(p->curr_buf_pos == p->curr_buf_length);
+    // at EOF
+    if (p->st != JV_PARSER_NORMAL) 
+      return jv_invalid_with_msg(jv_string("Unfinished string"));
+    if ((msg = check_literal(p)))
+      return jv_invalid_with_msg(jv_string(msg));
+    if (p->stackpos != 0)
+      return jv_invalid_with_msg(jv_string("Unfinished JSON term"));
+    // p->next is either invalid (nothing here but no syntax error)
+    // or valid (this is the value). either way it's the thing to return
+    value = p->next;
+    p->next = jv_invalid();
+    return value;
+  }
 }
 
 jv jv_parse_sized(const char* string, int length) {
   struct jv_parser parser;
   jv_parser_init(&parser);
-
-  const char* p = string;
-  char ch;
-  presult msg = 0;
-  while (msg == 0 && p < string + length) {
-    ch = *p++;
-    msg = scan(&parser, ch);
-  }
-  if (msg == 0) msg = finish(&parser);
-  jv value;
-  if (msg) {
-    value = jv_invalid_with_msg(jv_string_fmt("%s (while parsing '%s')", msg, string));
+  jv_parser_set_buf(&parser, string, length, 0);
+  jv value = jv_parser_next(&parser);
+  if (jv_is_valid(value)) {
+    jv next = jv_parser_next(&parser);
+    if (jv_is_valid(next)) {
+      // multiple JSON values, we only wanted one
+      jv_free(value);
+      jv_free(next);
+      value = jv_invalid_with_msg(jv_string("Unexpected extra JSON values"));
+    } else if (jv_invalid_has_msg(jv_copy(next))) {
+      // parser error after the first JSON value
+      jv_free(value);
+      value = next;
+    } else {
+      // a single valid JSON value
+      jv_free(next);
+    }
+  } else if (jv_invalid_has_msg(jv_copy(value))) {
+    // parse error, we'll return it
   } else {
-    value = jv_copy(parser.next);
+    // no value at all
+    jv_free(value);
+    value = jv_invalid_with_msg(jv_string("Expected JSON value"));
   }
   jv_parser_free(&parser);
+
+  if (!jv_is_valid(value) && jv_invalid_has_msg(jv_copy(value))) {
+    jv msg = jv_invalid_get_msg(value);
+    value = jv_invalid_with_msg(jv_string_fmt("%s (while parsing '%s')",
+                                              jv_string_value(msg),
+                                              string));
+    jv_free(msg);
+  }
   return value;
 }
 
diff --git a/c/jv_parse.h b/c/jv_parse.h
index 10270766..5b8e7cdf 100644
--- a/c/jv_parse.h
+++ b/c/jv_parse.h
@@ -1,5 +1,12 @@
-
+#ifndef JV_PARSE_H
+#define JV_PARSE_H
+#include "jv_dtoa.h"
 struct jv_parser {
+  const char* curr_buf;
+  int curr_buf_length;
+  int curr_buf_pos;
+  int curr_buf_is_partial;
+
   jv* stack;
   int stackpos;
   int stacklen;
@@ -17,3 +24,11 @@ struct jv_parser {
     JV_PARSER_STRING_ESCAPE
   } st;
 };
+
+void jv_parser_init(struct jv_parser* p);
+void jv_parser_free(struct jv_parser* p);
+
+void jv_parser_set_buf(struct jv_parser* p, const char* buf, int length, int is_partial);
+
+jv jv_parser_next(struct jv_parser* p);
+#endif
diff --git a/c/jv_print.c b/c/jv_print.c
index c2f7f58d..e122a5c8 100644
--- a/c/jv_print.c
+++ b/c/jv_print.c
@@ -10,7 +10,7 @@ static void jv_dump_string(jv str, int ascii_only) {
   assert(jv_get_kind(str) == JV_KIND_STRING);
   const char* i = jv_string_value(str);
   const char* end = i + jv_string_length(jv_copy(str));
-  int c;
+  int c = 0;
   while ((i = jvp_utf8_next(i, end, &c))) {
     assert(c != -1);
     int unicode_escape = 0;
diff --git a/c/main.c b/c/main.c
index f6d9e67f..05288d1b 100644
--- a/c/main.c
+++ b/c/main.c
@@ -4,6 +4,7 @@
 #include "parser.tab.h"
 #include "builtin.h"
 #include "jv.h"
+#include "jv_parse.h"
 #include "locfile.h"
 
 int jq_parse(struct locfile* source, block* answer);
@@ -31,31 +32,6 @@ struct bytecode* jq_compile(const char* str) {
   return bc;
 }
 
-
-void run_program(struct bytecode* bc) {
-#if JQ_DEBUG
-  dump_disassembly(0, bc);
-  printf("\n");
-#endif
-  char buf[409600];
-  fgets(buf, sizeof(buf), stdin);
-  jv value = jv_parse(buf);
-  if (!jv_is_valid(value)) {
-    assert(0 && "couldn't parse input"); //FIXME
-  }
-  jq_init(bc, value);
-  jv result;
-  while (jv_is_valid(result = jq_next())) {
-    jv_dump(result);
-    printf("\n");
-  }
-  jv_free(result);
-  #if JQ_DEBUG
-  printf("end of results\n");
-  #endif
-  jq_teardown();
-}
-
 int skipline(const char* buf) {
   int p = 0;
   while (buf[p] == ' ' || buf[p] == '\t') p++;
@@ -128,7 +104,40 @@ int main(int argc, char* argv[]) {
   if (argc == 1) { run_tests(); return 0; }
   struct bytecode* bc = jq_compile(argv[1]);
   if (!bc) return 1;
-  run_program(bc);
+
+#if JQ_DEBUG
+  dump_disassembly(0, bc);
+  printf("\n");
+#endif
+
+  struct jv_parser parser;
+  jv_parser_init(&parser);
+  while (!feof(stdin)) {
+    char buf[4096];
+    if (!fgets(buf, sizeof(buf), stdin)) buf[0] = 0;
+    jv_parser_set_buf(&parser, buf, strlen(buf), !feof(stdin));
+    jv value;
+    while (jv_is_valid((value = jv_parser_next(&parser)))) {
+      jq_init(bc, value);
+      jv result;
+      while (jv_is_valid(result = jq_next())) {
+        jv_dump(result);
+        printf("\n");
+      }
+      jv_free(result);
+      jq_teardown();
+    }
+    if (jv_invalid_has_msg(jv_copy(value))) {
+      jv msg = jv_invalid_get_msg(value);
+      fprintf(stderr, "parse error: %s\n", jv_string_value(msg));
+      jv_free(msg);
+      break;
+    } else {
+      jv_free(value);
+    }
+  }
+  jv_parser_free(&parser);
+
   bytecode_free(bc);
   return 0;
 }

From d9d6f434079f842674becdea31521f54655d5bdd Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 11 Sep 2012 15:51:12 +0100
Subject: [PATCH 065/284] Pretty-printing of JSON values.

---
 c/bytecode.c |  2 +-
 c/jv.h       |  4 +++-
 c/jv_print.c | 50 +++++++++++++++++++++++++++++++++++---------------
 c/main.c     |  8 ++++----
 4 files changed, 43 insertions(+), 21 deletions(-)

diff --git a/c/bytecode.c b/c/bytecode.c
index 208e82f0..bafd0474 100644
--- a/c/bytecode.c
+++ b/c/bytecode.c
@@ -58,7 +58,7 @@ void dump_operation(struct bytecode* bc, uint16_t* codeptr) {
       printf(" %04d", pc + imm);
     } else if (op->flags & OP_HAS_CONSTANT) {
       printf(" ");
-      jv_dump(jv_array_get(jv_copy(bc->constants), imm));
+      jv_dump(jv_array_get(jv_copy(bc->constants), imm), 0);
     } else if (op->flags & OP_HAS_VARIABLE) {
       uint16_t v = bc->code[pc++];
       printf(" v%d", v);
diff --git a/c/jv.h b/c/jv.h
index 48ae0e0f..ec23262c 100644
--- a/c/jv.h
+++ b/c/jv.h
@@ -102,7 +102,9 @@ jv jv_object_iter_value(jv, int);
 
 int jv_get_refcnt(jv);
 
-void jv_dump(jv);
+enum { JV_PRINT_PRETTY = 1, JV_PRINT_ASCII = 2 };
+void jv_dump(jv, int);
+
 jv jv_parse(const char* string);
 jv jv_parse_sized(const char* string, int length);
 
diff --git a/c/jv_print.c b/c/jv_print.c
index e122a5c8..f1ec92fb 100644
--- a/c/jv_print.c
+++ b/c/jv_print.c
@@ -64,7 +64,9 @@ static void jv_dump_string(jv str, int ascii_only) {
   assert(c != -1);
 }
 
-static void jv_dump_term(struct dtoa_context* C, jv x) {
+enum { INDENT = 2 };
+
+static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent) {
   char buf[JVP_DTOA_FMT_MAX_LEN];
   switch (jv_get_kind(x)) {
   case JV_KIND_INVALID:
@@ -99,33 +101,51 @@ static void jv_dump_term(struct dtoa_context* C, jv x) {
     putchar('"');
     break;
   case JV_KIND_ARRAY: {
-    printf("[");
-    for (int i=0; i<jv_array_length(jv_copy(x)); i++) {
-      if (i!=0) printf(", ");
-      jv_dump(jv_array_get(jv_copy(x), i));
+    if (jv_array_length(jv_copy(x)) == 0) {
+      printf("[]");
+      break;
     }
+    printf("[");
+    if (flags & JV_PRINT_PRETTY) printf("\n%*s", indent+INDENT, "");
+    for (int i=0; i<jv_array_length(jv_copy(x)); i++) {
+      if (i!=0) {
+        if (flags & JV_PRINT_PRETTY) printf(",\n%*s", indent+INDENT, "");
+        else printf(", ");
+      }
+      jv_dump_term(C, jv_array_get(jv_copy(x), i), flags, indent + INDENT);
+    }
+    if (flags & JV_PRINT_PRETTY) printf("\n%*s", indent, "");
     printf("]");
     break;
   }
   case JV_KIND_OBJECT: {
-    printf("{");
-    int first = 1;
-    for (int i = jv_object_iter(x); jv_object_iter_valid(x,i); i = jv_object_iter_next(x,i)) {
-      if (!first) printf(", ");
-      first = 0;
-      jv_dump(jv_object_iter_key(x, i));
-      printf(": ");
-      jv_dump(jv_object_iter_value(x, i));
+    if (jv_object_length(jv_copy(x)) == 0) {
+      printf("{}");
+      break;
     }
+    printf("{");
+    if (flags & JV_PRINT_PRETTY) printf("\n%*s", indent+INDENT, "");
+    int first = 1;
+    jv_object_foreach(i, x) {
+      if (!first) {
+        if (flags & JV_PRINT_PRETTY) printf(",\n%*s", indent+INDENT, "");
+        else printf(", ");
+      }
+      first = 0;
+      jv_dump_term(C, jv_object_iter_key(x, i), flags, indent + INDENT);
+      printf(": ");
+      jv_dump_term(C, jv_object_iter_value(x, i), flags, indent + INDENT);
+    }
+    if (flags & JV_PRINT_PRETTY) printf("\n%*s", indent, "");
     printf("}");
   }
   }
   jv_free(x);
 }
 
-void jv_dump(jv x) {
+void jv_dump(jv x, int flags) {
   struct dtoa_context C;
   jvp_dtoa_context_init(&C);
-  jv_dump_term(&C, x);
+  jv_dump_term(&C, x, flags, 0);
   jvp_dtoa_context_free(&C);
 }
diff --git a/c/main.c b/c/main.c
index 05288d1b..f87a5112 100644
--- a/c/main.c
+++ b/c/main.c
@@ -71,9 +71,9 @@ void run_tests() {
         break;
       } else if (!jv_equal(jv_copy(expected), jv_copy(actual))) {
         printf("Expected ");
-        jv_dump(jv_copy(expected));
+        jv_dump(jv_copy(expected), 0);
         printf(", but got ");
-        jv_dump(jv_copy(actual));
+        jv_dump(jv_copy(actual), 0);
         printf("\n");
         pass = 0;
       }
@@ -84,7 +84,7 @@ void run_tests() {
       jv extra = jq_next();
       if (jv_is_valid(extra)) {
         printf("Superfluous result: ");
-        jv_dump(extra);
+        jv_dump(extra, 0);
         printf("\n");
         pass = 0;
       } else {
@@ -121,7 +121,7 @@ int main(int argc, char* argv[]) {
       jq_init(bc, value);
       jv result;
       while (jv_is_valid(result = jq_next())) {
-        jv_dump(result);
+        jv_dump(result, JV_PRINT_PRETTY);
         printf("\n");
       }
       jv_free(result);

From f6c6ba95ad92ee84725a893df50af938d1b396be Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 11 Sep 2012 16:10:55 +0100
Subject: [PATCH 066/284] Make .[] capable of iteration over objects as well as
 arrays.

Also change an assert to a proper error message if it's given
something silly like a number.
---
 c/execute.c | 46 ++++++++++++++++++++++++++++++++++++----------
 1 file changed, 36 insertions(+), 10 deletions(-)

diff --git a/c/execute.c b/c/execute.c
index cbde413a..8426d3ca 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -326,25 +326,51 @@ jv jq_next() {
     }
 
     case EACH: 
-      stack_push(stackval_root(jv_number(0)));
+      stack_push(stackval_root(jv_number(-1)));
       // fallthrough
     case ON_BACKTRACK(EACH): {
       int idx = jv_number_value(stack_pop().value);
-      stackval array = stack_pop();
-      if (idx >= jv_array_length(jv_copy(array.value))) {
-        jv_free(array.value);
+      stackval container = stack_pop();
+
+      int is_array, keep_going;
+      jv key, value;
+      if (jv_get_kind(container.value) == JV_KIND_ARRAY) {
+        is_array = 1;
+        if (opcode == EACH) idx = 0;
+        else idx = idx + 1;
+        keep_going = idx < jv_array_length(jv_copy(container.value));
+        if (keep_going) {
+          key = jv_number(idx);
+          value = jv_array_get(jv_copy(container.value), idx);
+        }
+      } else if (jv_get_kind(container.value) == JV_KIND_OBJECT) {
+        is_array = 0;
+        if (opcode == EACH) idx = jv_object_iter(container.value);
+        else idx = jv_object_iter_next(container.value, idx);
+        keep_going = jv_object_iter_valid(container.value, idx);
+        if (keep_going) {
+          key = jv_object_iter_key(container.value, idx);
+          value = jv_object_iter_value(container.value, idx);
+        }
+      } else {
+        assert(opcode == EACH);
+        print_error(jv_invalid_with_msg(jv_string_fmt("Cannot iterate over %s",
+                                                      jv_kind_name(jv_get_kind(container.value)))));
+        keep_going = 0;
+      }
+
+      if (!keep_going) {
+        jv_free(container.value);
         goto do_backtrack;
       } else {
         stack_save();
-        stackval array2 = array;
-        array2.value = jv_copy(array2.value);
-        stack_push(array2);
-        stack_push(stackval_root(jv_number(idx+1)));
+        stack_push(container);
+        stack_push(stackval_root(jv_number(idx)));
         frame_push_backtrack(&frame_stk, pc - 1);
         stack_switch();
         
-        stackval sv = {jv_array_get(array.value, idx), 
-                       path_push(array, jv_number(idx))};
+        stackval sv = {value,
+                       path_push(container, key)};
         stack_push(sv);
       }
       break;

From df195b31873010f18883446c6e0e629a594badc5 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 11 Sep 2012 23:55:59 +0100
Subject: [PATCH 067/284] Add update operators (+=, -=, *=, /= and //=)

---
 c/lexer.l  |  7 ++++++-
 c/parser.y | 45 ++++++++++++++++++++++++++++++++++++++-------
 c/testdata | 11 +++++++++++
 3 files changed, 55 insertions(+), 8 deletions(-)

diff --git a/c/lexer.l b/c/lexer.l
index 9c20a953..dd93f497 100644
--- a/c/lexer.l
+++ b/c/lexer.l
@@ -22,7 +22,6 @@
 "==" { return EQ; }
 "as" { return AS; }
 "def" { return DEF; }
-"|=" { return SETPIPE; }
 "if" { return IF; }
 "then" { return THEN; }
 "else" { return ELSE; }
@@ -32,6 +31,12 @@
 "not" { return NOT; }
 "end" { return END; }
 "//" { return DEFINEDOR; }
+"|=" { return SETPIPE; }
+"+=" { return SETPLUS; }
+"-=" { return SETMINUS; }
+"*=" { return SETMULT; }
+"/=" { return SETDIV; }
+"//=" { return SETDEFINEDOR; }
 "."|"="|";"|"["|"]"|","|":"|"("|")"|"{"|"}"|"|"|"+"|"-"|"*"|"/"|"\$" { return yytext[0];}
 
 \"(\\.|[^\\\"])*\" |
diff --git a/c/parser.y b/c/parser.y
index 70fb7116..d8780a87 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -46,7 +46,6 @@
 %token DEFINEDOR "//"
 %token AS "as"
 %token DEF "def"
-%token SETPIPE "|="
 %token IF "if"
 %token THEN "then"
 %token ELSE "else"
@@ -55,14 +54,19 @@
 %token AND "and"
 %token OR "or"
 %token NOT "not"
-
+%token SETPIPE "|="
+%token SETPLUS "+="
+%token SETMINUS "-="
+%token SETMULT "*="
+%token SETDIV "/="
+%token SETDEFINEDOR "//="
 
  /* revolting hack */
 %left ';'
 %left '|'
 %left ','
 %right "//"
-%nonassoc '=' SETPIPE
+%nonassoc '=' SETPIPE SETPLUS SETMINUS SETMULT SETDIV SETDEFINEDOR
 %nonassoc EQ
 %left OR
 %left AND
@@ -138,6 +142,16 @@ static block gen_binop(block a, block b, int op) {
   return c;
 }
 
+static block gen_update(block a, block op, int optype) {
+  block assign = a;
+  block_append(&assign, gen_op_simple(DUP));
+  if (optype) {
+    op = gen_binop(gen_noop(), op, optype);
+  }
+  block_append(&assign, op);
+  return gen_assign(assign);
+}
+
 %}
 
 %%
@@ -198,11 +212,12 @@ Exp "//" Exp {
   $$ = gen_definedor($1, $3);
 } |
 
+Exp "//=" Exp {
+  $$ = gen_update($1, gen_definedor(gen_noop(), $3), 0);
+} |
+
 Exp "|=" Exp {
-  block assign = $1;
-  block_append(&assign, gen_op_simple(DUP));
-  block_append(&assign, $3);
-  $$ = gen_assign(assign);
+  $$ = gen_update($1, $3, 0);
 } |
 
 Exp '|' Exp { 
@@ -217,18 +232,34 @@ Exp '+' Exp {
   $$ = gen_binop($1, $3, '+');
 } |
 
+Exp "+=" Exp {
+  $$ = gen_update($1, $3, '+');
+} |
+
 Exp '-' Exp {
   $$ = gen_binop($1, $3, '-');
 } |
 
+Exp "-=" Exp {
+  $$ = gen_update($1, $3, '-');
+} |
+
 Exp '*' Exp {
   $$ = gen_binop($1, $3, '*');
 } |
 
+Exp "*=" Exp {
+  $$ = gen_update($1, $3, '*');
+} |
+
 Exp '/' Exp {
   $$ = gen_binop($1, $3, '/');
 } |
 
+Exp "/=" Exp {
+  $$ = gen_update($1, $3, '/');
+} |
+
 Exp "==" Exp {
   $$ = gen_binop($1, $3, EQ);
 } |
diff --git a/c/testdata b/c/testdata
index bd1d7f25..e17f2bb7 100644
--- a/c/testdata
+++ b/c/testdata
@@ -270,6 +270,13 @@ def id(x):x; 2000 as $x | def f(x):1 as $x | id([$x, x, x]); def g(x): 100 as $x
 {"foo": 42}
 {"foo": 43}
 
+.[] += 2, .[] *= 2, .[] -= 2, .[] /= 2
+[1,3,5]
+[3,5,7]
+[2,6,10]
+[-1,1,3]
+[0.5, 1.5, 2.5]
+
 .[0].a |= {"old":., "new":(.+1)}
 [{"a":1,"b":2}]
 [{"a":{"old":1, "new":2},"b":2}]
@@ -305,6 +312,10 @@ def inc(x): x |= .+1; inc(.[].a)
 [{"foo":[1,2], "bar": 42}, {"foo":[1], "bar": null}, {"foo":[null,false,3], "bar": 18}, {"foo":[], "bar":42}, {"foo": [null,false,null], "bar": 41}]
 [[1,2], [1], [3], [42], [41]]
 
+.[] //= 42
+["hello",true,false,[false],null]
+["hello",true,42,[false],42]
+
 .[] | [.[0] and .[1], .[0] or .[1]]
 [[true,[]], [false,1], [42,null], [null,false]]
 [true,true]

From cc2fb20ca03ca0cd30c0d9c768ead9b8cb7130f9 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 16 Sep 2012 11:07:36 +0100
Subject: [PATCH 068/284] Hrm. Update operators (//=, +=, etc.) aren't very
 well thought out.

In complex cases, their behaviour is kinda weird. Here's a failing
test for what I think they should do.
---
 c/testdata | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/c/testdata b/c/testdata
index e17f2bb7..a905d2af 100644
--- a/c/testdata
+++ b/c/testdata
@@ -312,9 +312,10 @@ def inc(x): x |= .+1; inc(.[].a)
 [{"foo":[1,2], "bar": 42}, {"foo":[1], "bar": null}, {"foo":[null,false,3], "bar": 18}, {"foo":[], "bar":42}, {"foo": [null,false,null], "bar": 41}]
 [[1,2], [1], [3], [42], [41]]
 
-.[] //= 42
-["hello",true,false,[false],null]
-["hello",true,42,[false],42]
+# FIXME: behaviour of update operators
+# .[] //= .[0]
+# ["hello",true,false,[false],null]
+# ["hello",true,"hello",[false],"hello"]
 
 .[] | [.[0] and .[1], .[0] or .[1]]
 [[true,[]], [false,1], [42,null], [null,false]]

From 539156430aea44c700e40f25557994ecddae6165 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 16 Sep 2012 11:08:42 +0100
Subject: [PATCH 069/284] Builtin function 'length', for
 arrays/objects/strings.

---
 c/builtin.c | 15 +++++++++++++++
 c/testdata  |  3 +++
 2 files changed, 18 insertions(+)

diff --git a/c/builtin.c b/c/builtin.c
index 375e3252..39d3f24d 100644
--- a/c/builtin.c
+++ b/c/builtin.c
@@ -129,6 +129,20 @@ static void f_tonumber(jv input[], jv output[]) {
   }
 }
 
+static void f_length(jv input[], jv output[]) {
+  if (jv_get_kind(input[0]) == JV_KIND_ARRAY) {
+    output[0] = jv_number(jv_array_length(input[0]));
+  } else if (jv_get_kind(input[0]) == JV_KIND_OBJECT) {
+    output[0] = jv_number(jv_object_length(input[0]));
+  } else if (jv_get_kind(input[0]) == JV_KIND_STRING) {
+    output[0] = jv_number(jv_string_length(input[0]));
+  } else {
+    output[0] = jv_invalid_with_msg(jv_string_fmt("Cannot get the length of %s",
+                                                  jv_kind_name(jv_get_kind(input[0]))));
+    jv_free(input[0]);
+  }
+}
+
 struct cfunction function_list[] = {
   {f_true, "true", CALL_BUILTIN_1_1},
   {f_false, "false", CALL_BUILTIN_1_1},
@@ -139,5 +153,6 @@ struct cfunction function_list[] = {
   {f_divide, "_divide", CALL_BUILTIN_3_1},
   {f_tonumber, "tonumber", CALL_BUILTIN_1_1},
   {f_equal, "_equal", CALL_BUILTIN_3_1},
+  {f_length, "length", CALL_BUILTIN_1_1},
 };
 struct symbol_table builtins = {function_list, sizeof(function_list)/sizeof(function_list[0])};
diff --git a/c/testdata b/c/testdata
index a905d2af..f2eb32a2 100644
--- a/c/testdata
+++ b/c/testdata
@@ -203,6 +203,9 @@ null
 [false, false, false, false, false, false, false, true,  false]
 [false, false, false, false, false, false, false, false, true ]
 
+[.[] | length]
+[[], {}, [1,2], {"a":42}, "asdf"]
+[0, 0, 2, 1, 4]
 
 #
 # User-defined functions

From 50ebb036c4bfff28e6288e69751efbd9e7298f4f Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 16 Sep 2012 17:08:56 +0100
Subject: [PATCH 070/284] Bind builtin functions in a slightly less ugly way.

---
 c/builtin.c | 8 ++++++--
 c/builtin.h | 3 ++-
 c/compile.h | 4 ++++
 c/main.c    | 2 +-
 4 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/c/builtin.c b/c/builtin.c
index 39d3f24d..9be18208 100644
--- a/c/builtin.c
+++ b/c/builtin.c
@@ -143,7 +143,7 @@ static void f_length(jv input[], jv output[]) {
   }
 }
 
-struct cfunction function_list[] = {
+static struct cfunction function_list[] = {
   {f_true, "true", CALL_BUILTIN_1_1},
   {f_false, "false", CALL_BUILTIN_1_1},
   {f_null, "null", CALL_BUILTIN_1_1},
@@ -155,4 +155,8 @@ struct cfunction function_list[] = {
   {f_equal, "_equal", CALL_BUILTIN_3_1},
   {f_length, "length", CALL_BUILTIN_1_1},
 };
-struct symbol_table builtins = {function_list, sizeof(function_list)/sizeof(function_list[0])};
+static struct symbol_table builtins = {function_list, sizeof(function_list)/sizeof(function_list[0])};
+
+block builtins_bind(block b) {
+  return gen_cbinding(&builtins, b);
+}
diff --git a/c/builtin.h b/c/builtin.h
index 5b0d3702..fe2ac6ac 100644
--- a/c/builtin.h
+++ b/c/builtin.h
@@ -2,7 +2,8 @@
 #define BUILTIN_H
 
 #include "bytecode.h"
+#include "compile.h"
 
-extern struct symbol_table builtins;
+block builtins_bind(block);
 
 #endif
diff --git a/c/compile.h b/c/compile.h
index bdaf6a88..28249e8f 100644
--- a/c/compile.h
+++ b/c/compile.h
@@ -1,3 +1,5 @@
+#ifndef COMPILE_H
+#define COMPILE_H
 #include <stdint.h>
 #include "bytecode.h"
 #include "opcode.h"
@@ -47,3 +49,5 @@ int block_compile(block, struct locfile*, struct bytecode**);
 void block_free(block);
 
 
+
+#endif
diff --git a/c/main.c b/c/main.c
index f87a5112..b65d820f 100644
--- a/c/main.c
+++ b/c/main.c
@@ -21,7 +21,7 @@ struct bytecode* jq_compile(const char* str) {
   int nerrors = jq_parse(&locations, &program);
   if (nerrors == 0) {
     block_append(&program, block_join(gen_op_simple(YIELD), gen_op_simple(BACKTRACK)));
-    program = gen_cbinding(&builtins, program);
+    program = builtins_bind(program);
     nerrors = block_compile(program, &locations, &bc);
     block_free(program);
   }

From 84ea129f26e46a0e38dd630f6d02cad41b983808 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 17 Sep 2012 19:41:41 +0100
Subject: [PATCH 071/284] Better support for appending strings in JV.

---
 c/jv.c     | 59 ++++++++++++++++++++++++++++++++++++++++--------------
 c/jv.h     |  2 ++
 c/testdata |  4 ++--
 3 files changed, 48 insertions(+), 17 deletions(-)

diff --git a/c/jv.c b/c/jv.c
index 786e7b26..595484e7 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -340,6 +340,7 @@ typedef struct {
   // high 31 bits are length, low bit is a flag 
   // indicating whether hash has been computed.
   uint32_t length_hashed;
+  uint32_t alloc_length;
   char data[];
 } jvp_string;
 
@@ -350,19 +351,19 @@ static jvp_string* jvp_string_ptr(jv_complex* a) {
 static jvp_string* jvp_string_alloc(uint32_t size) {
   jvp_string* s = malloc(sizeof(jvp_string) + size + 1);
   s->refcnt.count = 1;
-  s->length_hashed = size << 1;
+  s->alloc_length = size;
   return s;
 }
 
 static jv_complex jvp_string_new(const char* data, uint32_t length) {
   jvp_string* s = jvp_string_alloc(length);
+  s->length_hashed = length << 1;
   memcpy(s->data, data, length);
   s->data[length] = 0;
   jv_complex r = {&s->refcnt, {0,0}};
   return r;
 }
 
-
 static void jvp_string_free(jv_complex* s) {
   if (jvp_refcnt_dec(s)) {
     jvp_string* str = jvp_string_ptr(s);
@@ -385,16 +386,37 @@ static uint32_t jvp_string_length(jvp_string* s) {
   return s->length_hashed >> 1;
 }
 
-static jv_complex jvp_string_concat(jvp_string* a, jvp_string* b) {
-  uint32_t la = jvp_string_length(a), lb = jvp_string_length(b);
-  jvp_string* s = jvp_string_alloc(la + lb);
-  memcpy(s->data, a->data, la);
-  memcpy(s->data + la, b->data, lb);
-  s->data[la + lb] = 0;
-  jv_complex r = {&s->refcnt, {0,0}};
+static uint32_t jvp_string_remaining_space(jvp_string* s) {
+  uint32_t r = s->alloc_length - jvp_string_length(s);
+  assert(r >= 0);
   return r;
 }
 
+static void jvp_string_append(jv_complex* string, const char* data, uint32_t len) {
+  jvp_string* s = jvp_string_ptr(string);
+  uint32_t currlen = jvp_string_length(s);
+    
+  if (jvp_refcnt_unshared(string) &&
+      jvp_string_remaining_space(s) >= len) {
+    // the next string fits at the end of a
+    memcpy(s->data + currlen, data, len);
+    s->data[currlen + len] = 0;
+    s->length_hashed = (currlen + len) << 1;
+  } else {
+    // allocate a bigger buffer and copy
+    uint32_t allocsz = (currlen + len) * 2;
+    if (allocsz < 32) allocsz = 32;
+    jvp_string* news = jvp_string_alloc(allocsz);
+    news->length_hashed = (currlen + len) << 1;
+    memcpy(news->data, s->data, currlen);
+    memcpy(news->data + currlen, data, len);
+    news->data[currlen + len] = 0;
+    jvp_string_free(string);
+    jv_complex r = {&news->refcnt, {0,0}};
+    *string = r;
+  }
+}
+
 static const uint32_t HASH_SEED = 0x432A9843;
 
 static uint32_t rotl32 (uint32_t x, int8_t r){
@@ -507,15 +529,22 @@ const char* jv_string_value(jv j) {
 }
 
 jv jv_string_concat(jv a, jv b) {
-  jv j;
-  j.kind = JV_KIND_STRING;
-  j.val.complex = jvp_string_concat(jvp_string_ptr(&a.val.complex),
-                                    jvp_string_ptr(&b.val.complex));
-  jv_free(a);
+  jvp_string* sb = jvp_string_ptr(&b.val.complex);
+  jvp_string_append(&a.val.complex, sb->data, jvp_string_length(sb));
   jv_free(b);
-  return j;
+  return a;
 }
 
+jv jv_string_append_buf(jv a, const char* buf, int len) {
+  jvp_string_append(&a.val.complex, buf, len);
+  return a;
+}
+
+jv jv_string_append_str(jv a, const char* str) {
+  return jv_string_append_buf(a, str, strlen(str));
+}
+                        
+                        
 jv jv_string_fmt(const char* fmt, ...) {
   int size = 1024;
   while (1) {
diff --git a/c/jv.h b/c/jv.h
index ec23262c..295369e8 100644
--- a/c/jv.h
+++ b/c/jv.h
@@ -80,6 +80,8 @@ uint32_t jv_string_hash(jv);
 const char* jv_string_value(jv);
 jv jv_string_concat(jv, jv);
 jv jv_string_fmt(const char*, ...);
+jv jv_string_append_buf(jv a, const char* buf, int len);
+jv jv_string_append_str(jv a, const char* str);
 
 jv jv_object();
 jv jv_object_get(jv object, jv key);
diff --git a/c/testdata b/c/testdata
index e17f2bb7..c0afbeae 100644
--- a/c/testdata
+++ b/c/testdata
@@ -159,9 +159,9 @@ null
 "asdfasdf"
 {"a":1, "b":2, "c":3}
 
-"asdf" + "jkl;" + .
+"asdf" + "jkl;" + . + . + .
 "some string"
-"asdfjkl;some string"
+"asdfjkl;some stringsome stringsome string"
 
 "\u0000\u0020\u0000" + .
 "\u0000\u0020\u0000"

From 9c15ad20218cdc03fb825773d6ea40b04c756471 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 17 Sep 2012 20:08:55 +0100
Subject: [PATCH 072/284] Support rendering a JSON value to a string buffer.

---
 c/jv.c       |   1 -
 c/jv.h       |   3 +-
 c/jv_print.c | 146 ++++++++++++++++++++++++++++++++++-----------------
 c/main.c     |   5 ++
 4 files changed, 106 insertions(+), 49 deletions(-)

diff --git a/c/jv.c b/c/jv.c
index 595484e7..51070636 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -544,7 +544,6 @@ jv jv_string_append_str(jv a, const char* str) {
   return jv_string_append_buf(a, str, strlen(str));
 }
                         
-                        
 jv jv_string_fmt(const char* fmt, ...) {
   int size = 1024;
   while (1) {
diff --git a/c/jv.h b/c/jv.h
index 295369e8..e67d614a 100644
--- a/c/jv.h
+++ b/c/jv.h
@@ -105,7 +105,8 @@ jv jv_object_iter_value(jv, int);
 int jv_get_refcnt(jv);
 
 enum { JV_PRINT_PRETTY = 1, JV_PRINT_ASCII = 2 };
-void jv_dump(jv, int);
+void jv_dump(jv, int flags);
+jv jv_dump_string(jv, int flags);
 
 jv jv_parse(const char* string);
 jv jv_parse_sized(const char* string, int length);
diff --git a/c/jv_print.c b/c/jv_print.c
index f1ec92fb..64bf178a 100644
--- a/c/jv_print.c
+++ b/c/jv_print.c
@@ -1,47 +1,70 @@
 #include "jv.h"
 #include <stdio.h>
 #include <float.h>
-#include <math.h>
+#include <string.h>
 
 #include "jv_dtoa.h"
 #include "jv_unicode.h"
 
-static void jv_dump_string(jv str, int ascii_only) {
+static void put_buf(const char* s, int len, FILE* fout, jv* strout) {
+  if (strout) {
+    *strout = jv_string_append_buf(*strout, s, len);
+  } else {
+    fwrite(s, 1, len, fout);
+  }
+}
+
+static void put_char(char c, FILE* fout, jv* strout) {
+  put_buf(&c, 1, fout, strout);
+}
+
+static void put_str(const char* s, FILE* fout, jv* strout) {
+  put_buf(s, strlen(s), fout, strout);
+}
+
+static void put_space(int n, FILE* fout, jv* strout) {
+  while (n--) {
+    put_char(' ', fout, strout);
+  }
+}
+
+static void jvp_dump_string(jv str, int ascii_only, FILE* F, jv* S) {
   assert(jv_get_kind(str) == JV_KIND_STRING);
   const char* i = jv_string_value(str);
   const char* end = i + jv_string_length(jv_copy(str));
   int c = 0;
+  char buf[32];
   while ((i = jvp_utf8_next(i, end, &c))) {
     assert(c != -1);
     int unicode_escape = 0;
     if (0x20 <= c && c <= 0x7E) {
       // printable ASCII
       if (c == '"' || c == '\\') {
-        putchar('\\');
+        put_char('\\', F, S);
       }
-      putchar(c);
+      put_char(c, F, S);
     } else if (c < 0x20 || c == 0x7F) {
       // ASCII control character
       switch (c) {
       case '\b':
-        putchar('\\');
-        putchar('b');
+        put_char('\\', F, S);
+        put_char('b', F, S);
         break;
       case '\t':
-        putchar('\\');
-        putchar('t');
+        put_char('\\', F, S);
+        put_char('t', F, S);
         break;
       case '\r':
-        putchar('\\');
-        putchar('r');
+        put_char('\\', F, S);
+        put_char('r', F, S);
         break;
       case '\n':
-        putchar('\\');
-        putchar('n');
+        put_char('\\', F, S);
+        put_char('n', F, S);
         break;
       case '\f':
-        putchar('\\');
-        putchar('f');
+        put_char('\\', F, S);
+        put_char('f', F, S);
         break;
       default:
         unicode_escape = 1;
@@ -52,13 +75,14 @@ static void jv_dump_string(jv str, int ascii_only) {
     }
     if (unicode_escape) {
       if (c <= 0xffff) {
-        printf("\\u%04x", c);
+        sprintf(buf, "\\u%04x", c);
       } else {
         c -= 0x10000;
-        printf("\\u%04x\\u%04x", 
-               0xD800 | ((c & 0xffc00) >> 10),
-               0xDC00 | (c & 0x003ff));
+        sprintf(buf, "\\u%04x\\u%04x", 
+                0xD800 | ((c & 0xffc00) >> 10),
+                0xDC00 | (c & 0x003ff));
       }
+      put_str(buf, F, S);
     }
   }
   assert(c != -1);
@@ -66,78 +90,97 @@ static void jv_dump_string(jv str, int ascii_only) {
 
 enum { INDENT = 2 };
 
-static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent) {
+static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FILE* F, jv* S) {
   char buf[JVP_DTOA_FMT_MAX_LEN];
   switch (jv_get_kind(x)) {
   case JV_KIND_INVALID:
     assert(0 && "Invalid value");
     break;
   case JV_KIND_NULL:
-    printf("null");
+    put_str("null", F, S);
     break;
   case JV_KIND_FALSE:
-    printf("false");
+    put_str("false", F, S);
     break;
   case JV_KIND_TRUE:
-    printf("true");
+    put_str("true", F, S);
     break;
   case JV_KIND_NUMBER: {
     double d = jv_number_value(x);
     if (d != d) {
       // JSON doesn't have NaN, so we'll render it as "null"
-      printf("null");
+      put_str("null", F, S);
     } else {
       // Normalise infinities to something we can print in valid JSON
       if (d > DBL_MAX) d = DBL_MAX;
       if (d < -DBL_MAX) d = -DBL_MAX;
-      printf("%s", jvp_dtoa_fmt(C, buf, d));
+      put_str(jvp_dtoa_fmt(C, buf, d), F, S);
     }
     break;
   }
   case JV_KIND_STRING:
-    // FIXME: all sorts of broken
-    putchar('"');
-    jv_dump_string(x, 0);
-    putchar('"');
+    put_char('"', F, S);
+    jvp_dump_string(x, 0, F, S);
+    put_char('"', F, S);
     break;
   case JV_KIND_ARRAY: {
     if (jv_array_length(jv_copy(x)) == 0) {
-      printf("[]");
+      put_str("[]", F, S);
       break;
     }
-    printf("[");
-    if (flags & JV_PRINT_PRETTY) printf("\n%*s", indent+INDENT, "");
+    put_str("[", F, S);
+    if (flags & JV_PRINT_PRETTY) {
+      put_char('\n', F, S);
+      put_space(indent+INDENT, F, S);
+    }
     for (int i=0; i<jv_array_length(jv_copy(x)); i++) {
       if (i!=0) {
-        if (flags & JV_PRINT_PRETTY) printf(",\n%*s", indent+INDENT, "");
-        else printf(", ");
+        if (flags & JV_PRINT_PRETTY) {
+          put_str(",\n", F, S);
+          put_space(indent+INDENT, F, S);
+        } else {
+          put_str(", ", F, S);
+        }
       }
-      jv_dump_term(C, jv_array_get(jv_copy(x), i), flags, indent + INDENT);
+      jv_dump_term(C, jv_array_get(jv_copy(x), i), flags, indent + INDENT, F, S);
     }
-    if (flags & JV_PRINT_PRETTY) printf("\n%*s", indent, "");
-    printf("]");
+    if (flags & JV_PRINT_PRETTY) {
+      put_char('\n', F, S);
+      put_space(indent, F, S);
+    }
+    put_char(']', F, S);
     break;
   }
   case JV_KIND_OBJECT: {
     if (jv_object_length(jv_copy(x)) == 0) {
-      printf("{}");
+      put_str("{}", F, S);
       break;
     }
-    printf("{");
-    if (flags & JV_PRINT_PRETTY) printf("\n%*s", indent+INDENT, "");
+    put_char('{', F, S);
+    if (flags & JV_PRINT_PRETTY) {
+      put_char('\n', F, S);
+      put_space(indent+INDENT, F, S);
+    }
     int first = 1;
     jv_object_foreach(i, x) {
       if (!first) {
-        if (flags & JV_PRINT_PRETTY) printf(",\n%*s", indent+INDENT, "");
-        else printf(", ");
+        if (flags & JV_PRINT_PRETTY){
+          put_str(",\n", F, S);
+          put_space(indent+INDENT, F, S);
+        } else {
+          put_str(", ", F, S);
+        }
       }
       first = 0;
-      jv_dump_term(C, jv_object_iter_key(x, i), flags, indent + INDENT);
-      printf(": ");
-      jv_dump_term(C, jv_object_iter_value(x, i), flags, indent + INDENT);
+      jv_dump_term(C, jv_object_iter_key(x, i), flags, indent + INDENT, F, S);
+      put_str(": ", F, S);
+      jv_dump_term(C, jv_object_iter_value(x, i), flags, indent + INDENT, F, S);
     }
-    if (flags & JV_PRINT_PRETTY) printf("\n%*s", indent, "");
-    printf("}");
+    if (flags & JV_PRINT_PRETTY) {
+      put_char('\n', F, S);
+      put_space(indent, F, S);
+    }
+    put_char('}', F, S);
   }
   }
   jv_free(x);
@@ -146,6 +189,15 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent) {
 void jv_dump(jv x, int flags) {
   struct dtoa_context C;
   jvp_dtoa_context_init(&C);
-  jv_dump_term(&C, x, flags, 0);
+  jv_dump_term(&C, x, flags, 0, stdout, 0);
   jvp_dtoa_context_free(&C);
 }
+
+jv jv_dump_string(jv x, int flags) {
+  struct dtoa_context C;
+  jvp_dtoa_context_init(&C);
+  jv s = jv_string("");
+  jv_dump_term(&C, x, flags, 0, 0, &s);
+  jvp_dtoa_context_free(&C);
+  return s;
+}
diff --git a/c/main.c b/c/main.c
index f87a5112..5f19cf86 100644
--- a/c/main.c
+++ b/c/main.c
@@ -77,6 +77,11 @@ void run_tests() {
         printf("\n");
         pass = 0;
       }
+      jv as_string = jv_dump_string(jv_copy(expected), rand());
+      jv reparsed = jv_parse_sized(jv_string_value(as_string), jv_string_length(jv_copy(as_string)));
+      assert(jv_equal(jv_copy(expected), jv_copy(reparsed)));
+      jv_free(as_string);
+      jv_free(reparsed);
       jv_free(expected);
       jv_free(actual);
     }

From 326771f4b4ee1039f5ab8a1eaf0662107949b169 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 17 Sep 2012 20:14:07 +0100
Subject: [PATCH 073/284] Add a "tostring" function.

---
 c/builtin.c | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/c/builtin.c b/c/builtin.c
index 375e3252..97738656 100644
--- a/c/builtin.c
+++ b/c/builtin.c
@@ -129,6 +129,14 @@ static void f_tonumber(jv input[], jv output[]) {
   }
 }
 
+static void f_tostring(jv input[], jv output[]) {
+  if (jv_get_kind(input[0]) == JV_KIND_STRING) {
+    output[0] = input[0];
+  } else {
+    output[0] = jv_dump_string(input[0], 0);
+  }
+}
+
 struct cfunction function_list[] = {
   {f_true, "true", CALL_BUILTIN_1_1},
   {f_false, "false", CALL_BUILTIN_1_1},
@@ -138,6 +146,7 @@ struct cfunction function_list[] = {
   {f_multiply, "_multiply", CALL_BUILTIN_3_1},
   {f_divide, "_divide", CALL_BUILTIN_3_1},
   {f_tonumber, "tonumber", CALL_BUILTIN_1_1},
+  {f_tostring, "tostring", CALL_BUILTIN_1_1},
   {f_equal, "_equal", CALL_BUILTIN_3_1},
 };
 struct symbol_table builtins = {function_list, sizeof(function_list)/sizeof(function_list[0])};

From 3db27b01a1ee58180e1c97592ceac24d0e434f0a Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 17 Sep 2012 20:41:57 +0100
Subject: [PATCH 074/284] First pass at string interpolation.

Requires a lexer hack, but a surprisingly un-hideous one. The lexer
maintains a stack of bracket characters so that it can match
parens/brackets/braces to tell where a subexp nested in a string
actually ends.
---
 c/lexer.l  | 77 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
 c/parser.y | 23 +++++++++++++++-
 2 files changed, 98 insertions(+), 2 deletions(-)

diff --git a/c/lexer.l b/c/lexer.l
index dd93f497..94196146 100644
--- a/c/lexer.l
+++ b/c/lexer.l
@@ -11,11 +11,23 @@
 
 %}
 
+%s IN_PAREN
+%s IN_BRACKET
+%s IN_BRACE
+%s IN_QQINTERP
+%x IN_QQSTRING
+%{
+  static int enter(int opening, int state, yyscan_t yyscanner);
+  static int try_exit(int closing, int state, yyscan_t yyscanner);
+%}
+
 %option noyywrap nounput noinput nodefault
 %option reentrant
 %option extra-type="int"
 %option bison-bridge bison-locations
 %option prefix="jq_yy"
+%option stack
+
 
 %%
 
@@ -37,7 +49,16 @@
 "*=" { return SETMULT; }
 "/=" { return SETDIV; }
 "//=" { return SETDEFINEDOR; }
-"."|"="|";"|"["|"]"|","|":"|"("|")"|"{"|"}"|"|"|"+"|"-"|"*"|"/"|"\$" { return yytext[0];}
+"."|"="|";"|","|":"|"|"|"+"|"-"|"*"|"/"|"\$" { return yytext[0];}
+
+"["|"{"|"(" {
+  return enter(yytext[0], YY_START, yyscanner);
+}
+
+"]"|"}"|")" {
+  return try_exit(yytext[0], YY_START, yyscanner);
+}
+
 
 \"(\\.|[^\\\"])*\" |
 -?[0-9.]+([eE][+-]?[0-9]+)? { 
@@ -48,6 +69,25 @@
   yylval->literal = jv_invalid_with_msg(jv_string("Unterminated string"));
   return LITERAL;
 }
+
+"@(" {
+  yy_push_state(IN_QQSTRING, yyscanner);
+  return QQSTRING_START;
+}
+
+<IN_QQSTRING>{
+  "%(" {
+    return enter(QQSTRING_INTERP_START, YY_START, yyscanner);
+  }
+  [a-z]+ {
+    yylval->literal = jv_string_sized(yytext, yyleng);
+    return QQSTRING_TEXT;
+  }
+  ")" {
+    yy_pop_state(yyscanner);
+    return QQSTRING_END;
+  }
+}
   
 
 [[:alnum:]]+  { yylval->literal = jv_string(yytext); return IDENT;}
@@ -63,3 +103,38 @@
 "false" { return FALSE; }
 "null" { return NULL; }
 */
+static int try_exit(int c, int state, yyscan_t yyscanner) {
+  char match = 0;
+  int ret;
+  switch (state) {
+  case IN_PAREN: match = ret = ')'; break;
+  case IN_BRACKET: match = ret = ']'; break;
+  case IN_BRACE: match = ret = '}'; break;
+
+  case IN_QQINTERP:
+    match = ')'; 
+    ret = QQSTRING_INTERP_END;
+    break;
+  }
+  assert(match);
+  if (match == c) {
+    yy_pop_state(yyscanner);
+    return ret;
+  } else {
+    // FIXME: should we pop? Give a better error at least
+    return INVALID_CHARACTER;
+  }
+}
+
+static int enter(int c, int currstate, yyscan_t yyscanner) {
+  int state = 0;
+  switch (c) {
+  case '(': state = IN_PAREN; break;
+  case '[': state = IN_BRACKET; break;
+  case '{': state = IN_BRACE; break;
+  case QQSTRING_INTERP_START: state = IN_QQINTERP; break;
+  }
+  assert(state);
+  yy_push_state(state, yyscanner);
+  return c;
+}
diff --git a/c/parser.y b/c/parser.y
index d8780a87..2684a26e 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -61,6 +61,12 @@
 %token SETDIV "/="
 %token SETDEFINEDOR "//="
 
+%token QQSTRING_START
+%token <literal> QQSTRING_TEXT
+%token QQSTRING_INTERP_START
+%token QQSTRING_INTERP_END
+%token QQSTRING_END
+
  /* revolting hack */
 %left ';'
 %left '|'
@@ -74,7 +80,7 @@
 %left '*' '/'
 
 
-%type <blk> Exp Term MkDict MkDictPair ExpD ElseBody
+%type <blk> Exp Term MkDict MkDictPair ExpD ElseBody QQString
 %{
 #include "lexer.yy.h"
 #define FAIL(loc, msg)                                   \
@@ -264,11 +270,26 @@ Exp "==" Exp {
   $$ = gen_binop($1, $3, EQ);
 } |
 
+QQSTRING_START QQString QQSTRING_END {
+  $$ = $2;
+} |
+
 Term { 
   $$ = $1; 
 }
 
 
+QQString:
+/* empty */ {
+  $$ = gen_op_const(LOADK, jv_string(""));
+} |
+QQString QQSTRING_TEXT {
+  $$ = gen_binop($1, gen_op_const(LOADK, $2), '+');
+} |
+QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END {
+  $$ = gen_binop($1, $3, '+');
+}
+
 
 ElseBody:
 "elif" Exp "then" Exp ElseBody {

From 297a0679d1f7268e7ef0be8653748f8d22b8bda8 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 17 Sep 2012 20:59:34 +0100
Subject: [PATCH 075/284] Redefine true and false. Define empty, distict from
 null.

This might be the most philosophical commit. I shall ponder it.

true, false, null, empty now defined as bytecoded builtins rather
than calls out to C functions.
---
 c/builtin.c | 57 +++++++++++++++++++++++++++++++++++------------------
 c/testdata  |  4 ++++
 2 files changed, 42 insertions(+), 19 deletions(-)

diff --git a/c/builtin.c b/c/builtin.c
index e8c51cd7..5b329fbd 100644
--- a/c/builtin.c
+++ b/c/builtin.c
@@ -1,19 +1,5 @@
 #include "builtin.h"
-
-static void f_false(jv input[], jv output[]) {
-  jv_free(input[0]);
-  output[0] = jv_false();
-}
-
-static void f_true(jv input[], jv output[]) {
-  jv_free(input[0]);
-  output[0] = jv_true();
-}
-
-static void f_null(jv input[], jv output[]) {
-  jv_free(input[0]);
-  output[0] = jv_null();
-}
+#include "compile.h"
 
 static void f_plus(jv input[], jv output[]) {
   jv_free(input[0]);
@@ -151,10 +137,30 @@ static void f_tostring(jv input[], jv output[]) {
   }
 }
 
-struct cfunction function_list[] = {
-  {f_true, "true", CALL_BUILTIN_1_1},
-  {f_false, "false", CALL_BUILTIN_1_1},
-  {f_null, "null", CALL_BUILTIN_1_1},
+static block j_empty() {
+  return gen_op_block_defn(CLOSURE_CREATE, "empty", gen_op_simple(BACKTRACK));
+}
+
+static block j_false() {
+  return gen_op_block_defn(CLOSURE_CREATE, "false",
+                           block_join(gen_op_const(LOADK, jv_false()),
+                                      gen_op_simple(RET)));
+}
+
+static block j_true() {
+  return gen_op_block_defn(CLOSURE_CREATE, "true",
+                           block_join(gen_op_const(LOADK, jv_true()),
+                                      gen_op_simple(RET)));
+}
+
+static block j_null() {
+  return gen_op_block_defn(CLOSURE_CREATE, "null",
+                           block_join(gen_op_const(LOADK, jv_null()),
+                                      gen_op_simple(RET)));
+}
+
+
+static struct cfunction function_list[] = {
   {f_plus, "_plus", CALL_BUILTIN_3_1},
   {f_minus, "_minus", CALL_BUILTIN_3_1},
   {f_multiply, "_multiply", CALL_BUILTIN_3_1},
@@ -164,8 +170,21 @@ struct cfunction function_list[] = {
   {f_equal, "_equal", CALL_BUILTIN_3_1},
   {f_length, "length", CALL_BUILTIN_1_1},
 };
+
 static struct symbol_table builtins = {function_list, sizeof(function_list)/sizeof(function_list[0])};
 
+typedef block (*bytecoded_builtin)();
+static bytecoded_builtin bytecoded_builtins[] = {
+  j_empty,
+  j_false,
+  j_true,
+  j_null,
+};
+
+
 block builtins_bind(block b) {
+  for (int i=0; i<sizeof(bytecoded_builtins)/sizeof(bytecoded_builtins[0]); i++) {
+    b = block_bind(bytecoded_builtins[i](), b, OP_IS_CALL_PSEUDO);
+  }
   return gen_cbinding(&builtins, b);
 }
diff --git a/c/testdata b/c/testdata
index 8e66a02a..c83ef9c5 100644
--- a/c/testdata
+++ b/c/testdata
@@ -207,6 +207,10 @@ null
 [[], {}, [1,2], {"a":42}, "asdf"]
 [0, 0, 2, 1, 4]
 
+[1,2,empty,3,empty,4]
+null
+[1,2,3,4]
+
 #
 # User-defined functions
 # Oh god.

From 830610cef8d830841bdd2dd4d7bf7cbdf504f20d Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 17 Sep 2012 21:08:43 +0100
Subject: [PATCH 076/284] Make "not" a builtin function rather than syntax.

Fixes a really awkward grammar issue.
---
 c/builtin.c | 7 +++++++
 c/compile.c | 7 +------
 c/compile.h | 2 +-
 c/lexer.l   | 1 -
 c/parser.y  | 5 -----
 c/testdata  | 2 +-
 6 files changed, 10 insertions(+), 14 deletions(-)

diff --git a/c/builtin.c b/c/builtin.c
index 5b329fbd..ddac58f9 100644
--- a/c/builtin.c
+++ b/c/builtin.c
@@ -159,6 +159,12 @@ static block j_null() {
                                       gen_op_simple(RET)));
 }
 
+static block j_not() {
+  return gen_op_block_defn(CLOSURE_CREATE, "not",
+                           block_join(gen_condbranch(gen_op_const(LOADK, jv_false()),
+                                                     gen_op_const(LOADK, jv_true())),
+                                      gen_op_simple(RET)));
+}
 
 static struct cfunction function_list[] = {
   {f_plus, "_plus", CALL_BUILTIN_3_1},
@@ -179,6 +185,7 @@ static bytecoded_builtin bytecoded_builtins[] = {
   j_false,
   j_true,
   j_null,
+  j_not,
 };
 
 
diff --git a/c/compile.c b/c/compile.c
index c45d45a1..023acb95 100644
--- a/c/compile.c
+++ b/c/compile.c
@@ -361,7 +361,7 @@ block gen_definedor(block a, block b) {
   return c;
 }
 
-static block gen_condbranch(block iftrue, block iffalse) {
+block gen_condbranch(block iftrue, block iffalse) {
   block b = gen_noop();
   block_append(&iftrue, gen_op_target(JUMP, iffalse));
   block_append(&b, gen_op_target(JUMP_F, iftrue));
@@ -398,11 +398,6 @@ block gen_or(block a, block b) {
   return code;
 }
 
-block gen_not(block a) {
-  return block_join(a, gen_condbranch(gen_op_const(LOADK, jv_false()),
-                                      gen_op_const(LOADK, jv_true())));
-}
-
 block gen_cond(block cond, block iftrue, block iffalse) {
   block b = gen_op_simple(DUP);
   block_append(&b, cond);
diff --git a/c/compile.h b/c/compile.h
index 28249e8f..411654fe 100644
--- a/c/compile.h
+++ b/c/compile.h
@@ -32,9 +32,9 @@ block gen_both(block a, block b);
 block gen_collect(block expr);
 block gen_assign(block expr);
 block gen_definedor(block a, block b);
+block gen_condbranch(block iftrue, block iffalse);
 block gen_and(block a, block b);
 block gen_or(block a, block b);
-block gen_not(block a);
 
 block gen_cond(block cond, block iftrue, block iffalse);
 
diff --git a/c/lexer.l b/c/lexer.l
index 94196146..412d9065 100644
--- a/c/lexer.l
+++ b/c/lexer.l
@@ -40,7 +40,6 @@
 "elif" { return ELSE_IF; }
 "and" { return AND; }
 "or" { return OR; }
-"not" { return NOT; }
 "end" { return END; }
 "//" { return DEFINEDOR; }
 "|=" { return SETPIPE; }
diff --git a/c/parser.y b/c/parser.y
index 2684a26e..822a3385 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -53,7 +53,6 @@
 %token END "end"
 %token AND "and"
 %token OR "or"
-%token NOT "not"
 %token SETPIPE "|="
 %token SETPLUS "+="
 %token SETMINUS "-="
@@ -210,10 +209,6 @@ Exp "and" Exp {
   $$ = gen_and($1, $3);
 } |
 
-"not" Exp {
-  $$ = gen_not($2);
-} |
-
 Exp "//" Exp {
   $$ = gen_definedor($1, $3);
 } |
diff --git a/c/testdata b/c/testdata
index c83ef9c5..72367bbf 100644
--- a/c/testdata
+++ b/c/testdata
@@ -331,6 +331,6 @@ def inc(x): x |= .+1; inc(.[].a)
 [false,true]
 [false,false]
 
-[.[] | not .]
+[.[] | not]
 [1,0,false,null,true,"hello"]
 [false,false,true,true,false,false]

From eab9c4e587e33ed5e506c5fdc9e3094987220074 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 17 Sep 2012 21:43:10 +0100
Subject: [PATCH 077/284] Fix debugging code in execute.c so that debug jq
 compiles again.

---
 c/execute.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/c/execute.c b/c/execute.c
index 8426d3ca..eba2f1df 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -170,7 +170,7 @@ jv jq_next() {
         param = forkable_stack_peek_next(&data_stk, param);
       }
       if (!param) break;
-      jv_dump(jv_copy(param->sv.value));
+      jv_dump(jv_copy(param->sv.value), 0);
       printf("<%d>", jv_get_refcnt(param->sv.value));
     }
 
@@ -246,7 +246,7 @@ jv jq_next() {
       jv* var = frame_local_var(fp, v);
       #if JQ_DEBUG
       printf("V%d = ", v);
-      jv_dump(jv_copy(*var));
+      jv_dump(jv_copy(*var), 0);
       printf("\n");
       #endif
       stack_push(stackval_replace(stack_pop(), jv_copy(*var)));
@@ -261,7 +261,7 @@ jv jq_next() {
       stackval val = stack_pop();
       #if JQ_DEBUG
       printf("V%d = ", v);
-      jv_dump(jv_copy(val.value));
+      jv_dump(jv_copy(val.value), 0);
       printf("\n");
       #endif
       jv_free(*var);

From cbdeddbab8cd1206a04cab33fab50d1c9b55eaf7 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 17 Sep 2012 22:04:32 +0100
Subject: [PATCH 078/284] Make the code compile with warnings-as-errors.

-Wextra found a bona-fide bug: signed/unsigned comparison in a
stack overflow check.
---
 c/Makefile           | 2 +-
 c/builtin.c          | 2 +-
 c/execute.c          | 4 +---
 c/forkable_stack.h   | 3 ++-
 c/gen_utf8_tables.py | 2 +-
 c/jv.c               | 2 +-
 6 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/c/Makefile b/c/Makefile
index c80642dc..ddd49aea 100644
--- a/c/Makefile
+++ b/c/Makefile
@@ -1,4 +1,4 @@
-CC=gcc -Wall -std=gnu99 -ggdb -Wno-unused-function
+CC=gcc -Werror -Wextra -Wall -Wno-unused-parameter -std=gnu99 -ggdb -Wno-unused-function
 
 .PHONY: all clean
 all: parsertest
diff --git a/c/builtin.c b/c/builtin.c
index ddac58f9..86951890 100644
--- a/c/builtin.c
+++ b/c/builtin.c
@@ -190,7 +190,7 @@ static bytecoded_builtin bytecoded_builtins[] = {
 
 
 block builtins_bind(block b) {
-  for (int i=0; i<sizeof(bytecoded_builtins)/sizeof(bytecoded_builtins[0]); i++) {
+  for (unsigned i=0; i<sizeof(bytecoded_builtins)/sizeof(bytecoded_builtins[0]); i++) {
     b = block_bind(bytecoded_builtins[i](), b, OP_IS_CALL_PSEUDO);
   }
   return gen_cbinding(&builtins, b);
diff --git a/c/execute.c b/c/execute.c
index eba2f1df..6b0948c5 100644
--- a/c/execute.c
+++ b/c/execute.c
@@ -332,10 +332,9 @@ jv jq_next() {
       int idx = jv_number_value(stack_pop().value);
       stackval container = stack_pop();
 
-      int is_array, keep_going;
+      int keep_going;
       jv key, value;
       if (jv_get_kind(container.value) == JV_KIND_ARRAY) {
-        is_array = 1;
         if (opcode == EACH) idx = 0;
         else idx = idx + 1;
         keep_going = idx < jv_array_length(jv_copy(container.value));
@@ -344,7 +343,6 @@ jv jq_next() {
           value = jv_array_get(jv_copy(container.value), idx);
         }
       } else if (jv_get_kind(container.value) == JV_KIND_OBJECT) {
-        is_array = 0;
         if (opcode == EACH) idx = jv_object_iter(container.value);
         else idx = jv_object_iter_next(container.value, idx);
         keep_going = jv_object_iter_valid(container.value, idx);
diff --git a/c/forkable_stack.h b/c/forkable_stack.h
index 3128a6ca..d485d227 100644
--- a/c/forkable_stack.h
+++ b/c/forkable_stack.h
@@ -53,7 +53,8 @@ static void forkable_stack_free(struct forkable_stack* s) {
   s->stk = 0;
 }
 
-static void* forkable_stack_push(struct forkable_stack* s, size_t size) {
+static void* forkable_stack_push(struct forkable_stack* s, size_t sz_size) {
+  int size = (int)sz_size;
   forkable_stack_check(s);
   int curr = s->pos < s->savedlimit ? s->pos : s->savedlimit;
   if (curr - size < 0) {
diff --git a/c/gen_utf8_tables.py b/c/gen_utf8_tables.py
index 9d8dc3c0..2179222d 100644
--- a/c/gen_utf8_tables.py
+++ b/c/gen_utf8_tables.py
@@ -5,7 +5,7 @@ mask = lambda n: (1 << n) - 1
 
 def print_table(type, name, t):
     assert len(t) == 256
-    print "const static",type, name+"[]", "="
+    print "static const",type, name+"[]", "="
     first = True
     for i in range(0,len(t),16):
         print (" {" if i == 0 else "  ") +\
diff --git a/c/jv.c b/c/jv.c
index 51070636..2d91366b 100644
--- a/c/jv.c
+++ b/c/jv.c
@@ -387,8 +387,8 @@ static uint32_t jvp_string_length(jvp_string* s) {
 }
 
 static uint32_t jvp_string_remaining_space(jvp_string* s) {
+  assert(s->alloc_length >= jvp_string_length(s));
   uint32_t r = s->alloc_length - jvp_string_length(s);
-  assert(r >= 0);
   return r;
 }
 

From 49cf2e67feedab2f5eda9575d7b5cc10cb74d385 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 17 Sep 2012 22:32:06 +0100
Subject: [PATCH 079/284] Recursive functions + bugfix for stack reallocation.

---
 c/compile.c        |  7 +++++++
 c/compile.h        |  1 +
 c/forkable_stack.h | 24 ++++++++++++++++--------
 c/parser.y         |  4 ++--
 c/testdata         |  6 ++++++
 5 files changed, 32 insertions(+), 10 deletions(-)

diff --git a/c/compile.c b/c/compile.c
index 023acb95..952aff3b 100644
--- a/c/compile.c
+++ b/c/compile.c
@@ -164,6 +164,13 @@ block gen_op_block_defn(opcode op, const char* name, block block) {
   return inst_block(i);
 }
 
+static void block_bind_subblock(block binder, block body, int bindflags);
+block gen_op_block_defn_rec(opcode op, const char* name, block blk) {
+  block b = gen_op_block_defn(op, name, blk);
+  block_bind_subblock(b, b, OP_IS_CALL_PSEUDO | OP_HAS_BINDING);
+  return b;
+}
+
 block gen_op_block_unbound(opcode op, const char* name) {
   assert(opcode_describe(op)->flags & OP_IS_CALL_PSEUDO);
   inst* i = inst_new(op);
diff --git a/c/compile.h b/c/compile.h
index 411654fe..ce27b4b8 100644
--- a/c/compile.h
+++ b/c/compile.h
@@ -23,6 +23,7 @@ block gen_op_target(opcode op, block target);
 block gen_op_var_unbound(opcode op, const char* name);
 block gen_op_var_bound(opcode op, block binder);
 block gen_op_block_defn(opcode op, const char* name, block block);
+block gen_op_block_defn_rec(opcode op, const char* name, block block);
 block gen_op_block_unbound(opcode op, const char* name);
 block gen_op_call(opcode op, block arglist);
 block gen_op_symbol(opcode op, const char* name);
diff --git a/c/forkable_stack.h b/c/forkable_stack.h
index d485d227..5bfad8a9 100644
--- a/c/forkable_stack.h
+++ b/c/forkable_stack.h
@@ -6,7 +6,9 @@
 #include <string.h>
 
 struct forkable_stack_header {
-  int next;
+  /* distance in bytes between this header and the header
+     of the next object on the stack */
+  int next_delta;
 };
 
 #define FORKABLE_STACK_HEADER struct forkable_stack_header fk_header_
@@ -54,11 +56,12 @@ static void forkable_stack_free(struct forkable_stack* s) {
 }
 
 static void* forkable_stack_push(struct forkable_stack* s, size_t sz_size) {
+  assert(sz_size > 0 && sz_size % sizeof(struct forkable_stack_header) == 0);
   int size = (int)sz_size;
   forkable_stack_check(s);
   int curr = s->pos < s->savedlimit ? s->pos : s->savedlimit;
   if (curr - size < 0) {
-    assert(0);
+    //assert(0);
     int oldlen = s->length;
     s->length = (size + oldlen + 1024) * 2;
     s->stk = realloc(s->stk, s->length);
@@ -68,9 +71,11 @@ static void* forkable_stack_push(struct forkable_stack* s, size_t sz_size) {
     s->savedlimit += shift;
     curr += shift;
   }
-  void* ret = (void*)(s->stk + curr - size);
-  ((struct forkable_stack_header*)ret)->next = s->pos;
-  s->pos = curr - size;
+  int newpos = curr - size;
+  assert(newpos < s->pos);
+  void* ret = (void*)(s->stk + newpos);
+  ((struct forkable_stack_header*)ret)->next_delta = s->pos - newpos;
+  s->pos = newpos;
   forkable_stack_check(s);
   return ret;
 }
@@ -84,8 +89,11 @@ static void* forkable_stack_peek(struct forkable_stack* s) {
 static void* forkable_stack_peek_next(struct forkable_stack* s, void* top) {
   forkable_stack_check(s);
   struct forkable_stack_header* elem = top;
-  if (elem->next < s->length) {
-    return (void*)(s->stk + elem->next);
+  int elempos = (char*)top - s->stk;
+  assert(elempos >= 0 && elempos < s->length);
+  assert(elempos + elem->next_delta <= s->length);
+  if (elempos + elem->next_delta < s->length) {
+    return (void*)(s->stk + elempos + elem->next_delta);
   } else {
     return 0;
   }
@@ -100,7 +108,7 @@ static int forkable_stack_pop_will_free(struct forkable_stack* s) {
 static void forkable_stack_pop(struct forkable_stack* s) {
   forkable_stack_check(s);
   struct forkable_stack_header* elem = forkable_stack_peek(s);
-  s->pos = elem->next;
+  s->pos += elem->next_delta;
 }
 
 
diff --git a/c/parser.y b/c/parser.y
index 822a3385..4492d185 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -165,14 +165,14 @@ program: Exp { *answer = $1; }
 Exp:
 "def" IDENT ':' Exp ';' Exp {
   block body = block_join($4, gen_op_simple(RET));
-  $$ = block_bind(gen_op_block_defn(CLOSURE_CREATE, jv_string_value($2), body), 
+  $$ = block_bind(gen_op_block_defn_rec(CLOSURE_CREATE, jv_string_value($2), body), 
                   $6, OP_IS_CALL_PSEUDO);
   jv_free($2);
 } |
 
 "def" IDENT '(' IDENT ')' ':' Exp ';' Exp {
   block body = block_bind(gen_op_block_unbound(CLOSURE_PARAM, jv_string_value($4)), block_join($7, gen_op_simple(RET)), OP_IS_CALL_PSEUDO);
-  $$ = block_bind(gen_op_block_defn(CLOSURE_CREATE, jv_string_value($2), body), $9, OP_IS_CALL_PSEUDO);
+  $$ = block_bind(gen_op_block_defn_rec(CLOSURE_CREATE, jv_string_value($2), body), $9, OP_IS_CALL_PSEUDO);
   jv_free($2);
   jv_free($4);
 } |
diff --git a/c/testdata b/c/testdata
index 72367bbf..7357ccb2 100644
--- a/c/testdata
+++ b/c/testdata
@@ -262,6 +262,12 @@ def id(x):x; 2000 as $x | def f(x):1 as $x | id([$x, x, x]); def g(x): 100 as $x
 999999999
 [[110.0, 130.0], [210.0, 130.0], [110.0, 230.0], [210.0, 230.0], [120.0, 160.0], [220.0, 160.0], [120.0, 260.0], [220.0, 260.0]]
 
+# test recursion
+def fac: if . == 1 then 1 else . * (. - 1 | fac) end; [.[] | fac]
+[1,2,3,4]
+[1,2,6,24]
+
+
 #
 # Assignment
 #

From f13865d7a11d1aa6322a28e46eaaa463d823f44e Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 17 Sep 2012 22:37:51 +0100
Subject: [PATCH 080/284] Fix a precedence bug.

a == b or c == d should obviously parse as (a==b) or (c==d).
---
 c/parser.y | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/c/parser.y b/c/parser.y
index 4492d185..fd5dfbc7 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -72,9 +72,9 @@
 %left ','
 %right "//"
 %nonassoc '=' SETPIPE SETPLUS SETMINUS SETMULT SETDIV SETDEFINEDOR
-%nonassoc EQ
 %left OR
 %left AND
+%nonassoc EQ
 %left '+' '-'
 %left '*' '/'
 

From 7d8d97933fda9e3a35eb850da6274fef9884a710 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 17 Sep 2012 23:06:48 +0100
Subject: [PATCH 081/284] Builtin function 'type'.

---
 c/builtin.c | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/c/builtin.c b/c/builtin.c
index 86951890..74264f40 100644
--- a/c/builtin.c
+++ b/c/builtin.c
@@ -137,6 +137,11 @@ static void f_tostring(jv input[], jv output[]) {
   }
 }
 
+static void f_type(jv input[], jv output[]) {
+  output[0] = jv_string(jv_kind_name(jv_get_kind(input[0])));
+  jv_free(input[0]);
+}
+
 static block j_empty() {
   return gen_op_block_defn(CLOSURE_CREATE, "empty", gen_op_simple(BACKTRACK));
 }
@@ -175,6 +180,7 @@ static struct cfunction function_list[] = {
   {f_tostring, "tostring", CALL_BUILTIN_1_1},
   {f_equal, "_equal", CALL_BUILTIN_3_1},
   {f_length, "length", CALL_BUILTIN_1_1},
+  {f_type, "type", CALL_BUILTIN_1_1},
 };
 
 static struct symbol_table builtins = {function_list, sizeof(function_list)/sizeof(function_list[0])};

From 5b9bb64a888bbf45e1cfe0dae3159e9bb80e3009 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 18 Sep 2012 09:43:44 +0100
Subject: [PATCH 082/284] -Werror was a little overzealous.

Older versions of gcc warn about random things. -Werror makes the
built fail on such compilers.
---
 c/Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/c/Makefile b/c/Makefile
index ddd49aea..7f58c617 100644
--- a/c/Makefile
+++ b/c/Makefile
@@ -1,4 +1,4 @@
-CC=gcc -Werror -Wextra -Wall -Wno-unused-parameter -std=gnu99 -ggdb -Wno-unused-function
+CC=gcc -Wextra -Wall -Wno-missing-field-initializers -Wno-unused-parameter -std=gnu99 -ggdb -Wno-unused-function
 
 .PHONY: all clean
 all: parsertest

From 940f8c427097d15d8d9227ce0b0c9c78360c4325 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 18 Sep 2012 10:17:38 +0100
Subject: [PATCH 083/284] Builtin functions defined in jq.

---
 c/builtin.c | 25 +++++++++++++++++++++---
 c/compile.c | 15 ++++++++++++++-
 c/compile.h |  1 +
 c/main.c    |  3 +--
 c/parser.y  | 55 +++++++++++++++++++++++++++++++++++++++--------------
 5 files changed, 79 insertions(+), 20 deletions(-)

diff --git a/c/builtin.c b/c/builtin.c
index 74264f40..6d0235e7 100644
--- a/c/builtin.c
+++ b/c/builtin.c
@@ -1,5 +1,9 @@
+#include <string.h>
 #include "builtin.h"
 #include "compile.h"
+#include "parser.h"
+#include "locfile.h"
+
 
 static void f_plus(jv input[], jv output[]) {
   jv_free(input[0]);
@@ -183,7 +187,7 @@ static struct cfunction function_list[] = {
   {f_type, "type", CALL_BUILTIN_1_1},
 };
 
-static struct symbol_table builtins = {function_list, sizeof(function_list)/sizeof(function_list[0])};
+static struct symbol_table cbuiltins = {function_list, sizeof(function_list)/sizeof(function_list[0])};
 
 typedef block (*bytecoded_builtin)();
 static bytecoded_builtin bytecoded_builtins[] = {
@@ -194,10 +198,25 @@ static bytecoded_builtin bytecoded_builtins[] = {
   j_not,
 };
 
+static const char* jq_builtins[] = {
+  "def map(f): [.[] | f];"
+};
+
 
 block builtins_bind(block b) {
+  block builtins = gen_noop();
   for (unsigned i=0; i<sizeof(bytecoded_builtins)/sizeof(bytecoded_builtins[0]); i++) {
-    b = block_bind(bytecoded_builtins[i](), b, OP_IS_CALL_PSEUDO);
+    block_append(&builtins, bytecoded_builtins[i]());
   }
-  return gen_cbinding(&builtins, b);
+  for (unsigned i=0; i<sizeof(jq_builtins)/sizeof(jq_builtins[0]); i++) {
+    struct locfile src;
+    locfile_init(&src, jq_builtins[i], strlen(jq_builtins[i]));
+    block funcs;
+    int nerrors = jq_parse_library(&src, &funcs);
+    assert(!nerrors);
+    block_append(&builtins, funcs);
+    locfile_free(&src);
+  }
+  b = block_bind(builtins, b, OP_IS_CALL_PSEUDO);
+  return gen_cbinding(&cbuiltins, b);
 }
diff --git a/c/compile.c b/c/compile.c
index 952aff3b..719a2706 100644
--- a/c/compile.c
+++ b/c/compile.c
@@ -237,6 +237,16 @@ block block_join(block a, block b) {
   return c;
 }
 
+int block_has_only_binders(block binders, int bindflags) {
+  bindflags |= OP_HAS_BINDING;
+  for (inst* curr = binders.first; curr; curr = curr->next) {
+    if ((opcode_describe(curr->op)->flags & bindflags) != bindflags) {
+      return 0;
+    }
+  }
+  return 1;
+}
+
 static void block_bind_subblock(block binder, block body, int bindflags) {
   assert(block_is_single(binder));
   assert((opcode_describe(binder.first->op)->flags & bindflags) == bindflags);
@@ -260,8 +270,11 @@ static void block_bind_subblock(block binder, block body, int bindflags) {
 }
 
 block block_bind(block binder, block body, int bindflags) {
+  assert(block_has_only_binders(binder, bindflags));
   bindflags |= OP_HAS_BINDING;
-  block_bind_subblock(binder, body, bindflags);
+  for (inst* curr = binder.first; curr; curr = curr->next) {
+    block_bind_subblock(inst_block(curr), body, bindflags);
+  }
   return block_join(binder, body);
 }
 
diff --git a/c/compile.h b/c/compile.h
index ce27b4b8..5390420b 100644
--- a/c/compile.h
+++ b/c/compile.h
@@ -43,6 +43,7 @@ block gen_cbinding(struct symbol_table* functions, block b);
 
 void block_append(block* b, block b2);
 block block_join(block a, block b);
+int block_has_only_binders(block, int bindflags);
 block block_bind(block binder, block body, int bindflags);
 
 int block_compile(block, struct locfile*, struct bytecode**);
diff --git a/c/main.c b/c/main.c
index c9188b3e..0a9eefe8 100644
--- a/c/main.c
+++ b/c/main.c
@@ -1,13 +1,12 @@
 #include <stdio.h>
 #include <string.h>
 #include "compile.h"
-#include "parser.tab.h"
 #include "builtin.h"
 #include "jv.h"
 #include "jv_parse.h"
 #include "locfile.h"
+#include "parser.h"
 
-int jq_parse(struct locfile* source, block* answer);
 
 void jq_init(struct bytecode* bc, jv value);
 jv jq_next();
diff --git a/c/parser.y b/c/parser.y
index fd5dfbc7..73972e79 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -79,7 +79,7 @@
 %left '*' '/'
 
 
-%type <blk> Exp Term MkDict MkDictPair ExpD ElseBody QQString
+%type <blk> Exp Term MkDict MkDictPair ExpD ElseBody QQString FuncDef FuncDefs
 %{
 #include "lexer.yy.h"
 #define FAIL(loc, msg)                                   \
@@ -160,21 +160,25 @@ static block gen_update(block a, block op, int optype) {
 %}
 
 %%
-program: Exp { *answer = $1; }
+TopLevel:
+Exp {
+  *answer = $1;
+} |
+FuncDefs {
+  *answer = $1;
+} 
+
+FuncDefs:
+/* empty */ {
+  $$ = gen_noop();
+} |
+FuncDef FuncDefs {
+  $$ = block_join($1, $2);
+}
 
 Exp:
-"def" IDENT ':' Exp ';' Exp {
-  block body = block_join($4, gen_op_simple(RET));
-  $$ = block_bind(gen_op_block_defn_rec(CLOSURE_CREATE, jv_string_value($2), body), 
-                  $6, OP_IS_CALL_PSEUDO);
-  jv_free($2);
-} |
-
-"def" IDENT '(' IDENT ')' ':' Exp ';' Exp {
-  block body = block_bind(gen_op_block_unbound(CLOSURE_PARAM, jv_string_value($4)), block_join($7, gen_op_simple(RET)), OP_IS_CALL_PSEUDO);
-  $$ = block_bind(gen_op_block_defn_rec(CLOSURE_CREATE, jv_string_value($2), body), $9, OP_IS_CALL_PSEUDO);
-  jv_free($2);
-  jv_free($4);
+FuncDef Exp %prec ';' {
+  $$ = block_bind($1, $2, OP_IS_CALL_PSEUDO);
 } |
 
 Term "as" '$' IDENT '|' Exp {
@@ -273,6 +277,19 @@ Term {
   $$ = $1; 
 }
 
+FuncDef:
+"def" IDENT ':' Exp ';' {
+  block body = block_join($4, gen_op_simple(RET));
+  $$ = gen_op_block_defn_rec(CLOSURE_CREATE, jv_string_value($2), body);
+  jv_free($2);
+} |
+
+"def" IDENT '(' IDENT ')' ':' Exp ';' {
+  block body = block_bind(gen_op_block_unbound(CLOSURE_PARAM, jv_string_value($4)), block_join($7, gen_op_simple(RET)), OP_IS_CALL_PSEUDO);
+  $$ = gen_op_block_defn_rec(CLOSURE_CREATE, jv_string_value($2), body);
+  jv_free($2);
+  jv_free($4);
+}
 
 QQString:
 /* empty */ {
@@ -405,3 +422,13 @@ int jq_parse(struct locfile* locations, block* answer) {
   }
   return errors;
 }
+
+int jq_parse_library(struct locfile* locations, block* answer) {
+  int errs = jq_parse(locations, answer);
+  if (errs) return errs;
+  if (!block_has_only_binders(*answer, OP_IS_CALL_PSEUDO)) {
+    locfile_locate(locations, UNKNOWN_LOCATION, "error: library should only have function definitions, not a main expression");
+    return 1;
+  }
+  return 0;
+}

From 8f0c91c03289b25e8cad82270f9fea0c2eab7b7b Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 18 Sep 2012 12:58:29 +0100
Subject: [PATCH 084/284] Add a missing file from prev commit

---
 c/parser.h | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 c/parser.h

diff --git a/c/parser.h b/c/parser.h
new file mode 100644
index 00000000..25eff019
--- /dev/null
+++ b/c/parser.h
@@ -0,0 +1,7 @@
+#ifndef PARSER_H
+#define PARSER_H
+
+int jq_parse(struct locfile* source, block* answer);
+int jq_parse_library(struct locfile* locations, block* answer);
+
+#endif

From 8041ce31192af8b54e83691372f23b0b9637234c Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 18 Sep 2012 12:58:39 +0100
Subject: [PATCH 085/284] Add the builtin 'select' function.

---
 c/builtin.c | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/c/builtin.c b/c/builtin.c
index 6d0235e7..f291a95e 100644
--- a/c/builtin.c
+++ b/c/builtin.c
@@ -199,24 +199,25 @@ static bytecoded_builtin bytecoded_builtins[] = {
 };
 
 static const char* jq_builtins[] = {
-  "def map(f): [.[] | f];"
+  "def map(f): [.[] | f];",
+  "def select(f): if f then . else empty end;",
 };
 
 
 block builtins_bind(block b) {
-  block builtins = gen_noop();
-  for (unsigned i=0; i<sizeof(bytecoded_builtins)/sizeof(bytecoded_builtins[0]); i++) {
-    block_append(&builtins, bytecoded_builtins[i]());
-  }
-  for (unsigned i=0; i<sizeof(jq_builtins)/sizeof(jq_builtins[0]); i++) {
+  for (int i=(int)(sizeof(jq_builtins)/sizeof(jq_builtins[0]))-1; i>=0; i--) {
     struct locfile src;
     locfile_init(&src, jq_builtins[i], strlen(jq_builtins[i]));
     block funcs;
     int nerrors = jq_parse_library(&src, &funcs);
     assert(!nerrors);
-    block_append(&builtins, funcs);
+    b = block_bind(funcs, b, OP_IS_CALL_PSEUDO);
     locfile_free(&src);
   }
+  block builtins = gen_noop();
+  for (unsigned i=0; i<sizeof(bytecoded_builtins)/sizeof(bytecoded_builtins[0]); i++) {
+    block_append(&builtins, bytecoded_builtins[i]());
+  }
   b = block_bind(builtins, b, OP_IS_CALL_PSEUDO);
   return gen_cbinding(&cbuiltins, b);
 }

From 25cbab056b1f73e96b636c88779a92400d92dc15 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 18 Sep 2012 13:22:22 +0100
Subject: [PATCH 086/284] Slightly better string interpolation.

---
 c/lexer.l  | 24 +++++++++++++++++++++---
 c/parser.y |  8 ++++++--
 2 files changed, 27 insertions(+), 5 deletions(-)

diff --git a/c/lexer.l b/c/lexer.l
index 412d9065..07cba83c 100644
--- a/c/lexer.l
+++ b/c/lexer.l
@@ -78,14 +78,32 @@
   "%(" {
     return enter(QQSTRING_INTERP_START, YY_START, yyscanner);
   }
-  [a-z]+ {
-    yylval->literal = jv_string_sized(yytext, yyleng);
-    return QQSTRING_TEXT;
+  "%"[^(] {
+    return INVALID_CHARACTER;
   }
   ")" {
     yy_pop_state(yyscanner);
     return QQSTRING_END;
   }
+  "\\"[)%] {
+    char text[2] = {yytext[1], 0};
+    yylval->literal = jv_string(text);
+    return QQSTRING_TEXT;
+  }
+  (\\[^u)%]|\\u[a-zA-Z0-9]{0,4})+ {
+    /* pass escapes to the json parser */
+    jv escapes = jv_string_fmt("\"%.*s\"", yyleng, yytext);
+    yylval->literal = jv_parse_sized(jv_string_value(escapes), jv_string_length(jv_copy(escapes)));
+    jv_free(escapes);
+    return QQSTRING_TEXT;
+  }
+  [^\\)%]+ {
+    yylval->literal = jv_string_sized(yytext, yyleng);
+    return QQSTRING_TEXT;
+  }
+  . {
+    return INVALID_CHARACTER;
+  }
 }
   
 
diff --git a/c/parser.y b/c/parser.y
index 73972e79..b47c3574 100644
--- a/c/parser.y
+++ b/c/parser.y
@@ -102,7 +102,7 @@ int yylex(YYSTYPE* yylval, YYLTYPE* yylloc, block* answer, int* errors,
     if (tok == INVALID_CHARACTER) {
       FAIL(*yylloc, "Invalid character");
     } else {
-      if (tok == LITERAL && !jv_is_valid(yylval->literal)) {
+      if ((tok == LITERAL || tok == QQSTRING_TEXT) && !jv_is_valid(yylval->literal)) {
         jv msg = jv_invalid_get_msg(jv_copy(yylval->literal));
         if (jv_get_kind(msg) == JV_KIND_STRING) {
           FAIL(*yylloc, jv_string_value(msg));
@@ -147,6 +147,10 @@ static block gen_binop(block a, block b, int op) {
   return c;
 }
 
+static block gen_format(block a) {
+  return block_join(a, gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, "tostring")));
+}
+ 
 static block gen_update(block a, block op, int optype) {
   block assign = a;
   block_append(&assign, gen_op_simple(DUP));
@@ -299,7 +303,7 @@ QQString QQSTRING_TEXT {
   $$ = gen_binop($1, gen_op_const(LOADK, $2), '+');
 } |
 QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END {
-  $$ = gen_binop($1, $3, '+');
+  $$ = gen_binop($1, gen_format($3), '+');
 }
 
 

From a4eea165bbab6d13f89b59707e835d58b7014a66 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 18 Sep 2012 17:44:43 +0100
Subject: [PATCH 087/284] Move everything around - delete old Haskell code,
 clean up build.

---
 .gitignore                                 |   8 +-
 JQ.hs                                      | 157 ---------------------
 Lexer.x                                    | 101 -------------
 Main.hs                                    |  22 ---
 c/Makefile => Makefile                     |  20 +--
 Parser.y                                   |  78 ----------
 c/builtin.c => builtin.c                   |   0
 c/builtin.h => builtin.h                   |   0
 c/bytecode.c => bytecode.c                 |   0
 c/bytecode.h => bytecode.h                 |   0
 c/compile.c => compile.c                   |   0
 c/compile.h => compile.h                   |   0
 c/execute.c => execute.c                   |   0
 c/forkable_stack.h => forkable_stack.h     |   0
 c/frame_layout.h => frame_layout.h         |   0
 c/gen_utf8_tables.py => gen_utf8_tables.py |   0
 c/jv.c => jv.c                             |   0
 c/jv.h => jv.h                             |   0
 c/jv_dtoa.c => jv_dtoa.c                   |   0
 c/jv_dtoa.h => jv_dtoa.h                   |   0
 c/jv_parse.c => jv_parse.c                 |   0
 c/jv_parse.h => jv_parse.h                 |   0
 c/jv_print.c => jv_print.c                 |   0
 c/jv_test.c => jv_test.c                   |   0
 c/jv_unicode.c => jv_unicode.c             |   2 +-
 c/jv_unicode.h => jv_unicode.h             |   0
 c/lexer.l => lexer.l                       |   2 +-
 c/locfile.h => locfile.h                   |   0
 c/main.c => main.c                         |   0
 c/opcode.c => opcode.c                     |   0
 c/opcode.h => opcode.h                     |   0
 c/opcode_list.h => opcode_list.h           |   0
 c/parser.h => parser.h                     |   0
 c/parser.y => parser.y                     |   2 +-
 c/testdata => testdata                     |   0
 35 files changed, 16 insertions(+), 376 deletions(-)
 delete mode 100644 JQ.hs
 delete mode 100644 Lexer.x
 delete mode 100644 Main.hs
 rename c/Makefile => Makefile (50%)
 delete mode 100644 Parser.y
 rename c/builtin.c => builtin.c (100%)
 rename c/builtin.h => builtin.h (100%)
 rename c/bytecode.c => bytecode.c (100%)
 rename c/bytecode.h => bytecode.h (100%)
 rename c/compile.c => compile.c (100%)
 rename c/compile.h => compile.h (100%)
 rename c/execute.c => execute.c (100%)
 rename c/forkable_stack.h => forkable_stack.h (100%)
 rename c/frame_layout.h => frame_layout.h (100%)
 rename c/gen_utf8_tables.py => gen_utf8_tables.py (100%)
 rename c/jv.c => jv.c (100%)
 rename c/jv.h => jv.h (100%)
 rename c/jv_dtoa.c => jv_dtoa.c (100%)
 rename c/jv_dtoa.h => jv_dtoa.h (100%)
 rename c/jv_parse.c => jv_parse.c (100%)
 rename c/jv_parse.h => jv_parse.h (100%)
 rename c/jv_print.c => jv_print.c (100%)
 rename c/jv_test.c => jv_test.c (100%)
 rename c/jv_unicode.c => jv_unicode.c (98%)
 rename c/jv_unicode.h => jv_unicode.h (100%)
 rename c/lexer.l => lexer.l (98%)
 rename c/locfile.h => locfile.h (100%)
 rename c/main.c => main.c (100%)
 rename c/opcode.c => opcode.c (100%)
 rename c/opcode.h => opcode.h (100%)
 rename c/opcode_list.h => opcode_list.h (100%)
 rename c/parser.h => parser.h (100%)
 rename c/parser.y => parser.y (99%)
 rename c/testdata => testdata (100%)

diff --git a/.gitignore b/.gitignore
index 130e618d..50e45cc8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,12 +1,10 @@
 *.o
 *~
 
-# Autogenerated by flex/bison
-lexer.yy.*
-parser.tab.*
-parser.info
+# Autogenerated
+*.gen.*
 
 # Test binaries
 jv_test
 jv_parse
-parsertest
\ No newline at end of file
+parsertest*~
diff --git a/JQ.hs b/JQ.hs
deleted file mode 100644
index ca8df794..00000000
--- a/JQ.hs
+++ /dev/null
@@ -1,157 +0,0 @@
-module JQ where
-import Text.JSON
-import Text.JSON.String
-import Data.Maybe
-import Data.List (sortBy,sort,groupBy)
-import Data.Function (on)
-import Data.Ord (comparing)
-import Control.Monad
-import Control.Monad.Writer
-import Control.Monad.List
-import Control.Monad.Reader
-
-type Path = [Either Int String]
-
-type Program = JSValue -> [(JSValue, Path)]
-
-type JQ = ReaderT JSValue (WriterT Path [])
-
-runJQ :: JQ a -> JSValue -> [a]
-runJQ prog val = map fst $ runWriterT $ runReaderT prog val
-
-(>|) :: JQ JSValue -> JQ a -> JQ a
-a >| b = do
-  val <- a
-  local (const val) b
-
-collect :: JQ a -> JQ [a]
-collect prog = do
-  arg <- ask
-  return $ runJQ prog arg
-  
-collectPaths :: JQ a -> JQ [(a,Path)]
-collectPaths prog = do
-  arg <- ask
-  return $ runWriterT $ runReaderT prog arg
-
-insert :: JSValue -> (JSValue, Path) -> JSValue
-insert base (replace, []) = replace
-insert (JSArray values) (replace, ((Left n):rest)) = JSArray values'
-    where
-      (left, (_:right)) = splitAt n values
-      values' = left ++ [replace] ++ right
-insert (JSObject obj) (replace, ((Right k):rest))= JSObject $ toJSObject obj'
-    where
-      withoutK = filter ((/= k) . fst) $ fromJSObject obj
-      obj' = (k, replace):withoutK
-
-
-eqj a b = JSBool $ a == b
-
-
-liftp :: (JSValue -> JSValue) -> JQ JSValue
-liftp f = liftM f ask
-
-idp = undefined
-failp t = []
-
-constp :: JSValue -> Program
-constp t t' = idp t
-
-anyj :: [JSValue] -> Bool
-anyj values = any isTrue values
-  where
-    isTrue (JSBool False) = False
-    isTrue (JSNull) = False
-    isTrue _ = True
-
-selectp prog = do
-  match <- collect prog
-  guard $ anyj match
-  ask
-
-constStr :: String -> JQ JSValue
-constStr = return . JSString . toJSString
-
-constInt :: Int -> JQ JSValue
-constInt = return . JSRational False . toRational
-
-updatep p = do
-  t <- ask
-  liftM (foldl insert t) $ collectPaths p
-
-arrayp prog = liftM JSArray $ collect prog
-
-
-childp' :: JSValue -> JQ JSValue
-childp' (JSArray values) = msum [tell [Left i] >> return v | (v,i) <- zip values [0..]]
-childp' (JSObject obj) = msum [tell [Right k] >> return v | (k,v) <- fromJSObject obj]
-childp' _ = mzero
-
-childp = ask >>= childp'
-
---findp :: Program -> Program
-findp prog = do
-  found <- collect prog
-  if anyj found then ask else childp >| findp prog
-
-groupp prog = do
-  list <- ask
-  case list of
-    JSArray values -> do
-      marked <- forM values $ \v -> do 
-        m <- collect (return v >| prog)
-        return (m,v)
-      msum $
-        map (return . JSArray . map snd) $ 
-        groupBy ((==) `on` fst) $ 
-        sortBy (comparing fst) $ 
-        marked
-    _ -> return JSNull
-
-
-  
-
-withArray f (JSArray values) = JSArray $ f values
-withArray f x = x
-
-callp "select" [p] = selectp p
-callp "find" [p] = findp p
-callp "set" [p] = updatep p
-callp "sort" [] = liftp (withArray sort)
-callp "group" [p] = groupp p
-
-lookupj :: JSValue -> JSValue -> JQ JSValue
-lookupj (JSArray values) (JSRational _ n) = do
-  let idx = round n
-  tell [Left idx]
-  if idx >= 0 && idx < length values
-    then return $ values !! idx
-    else return $ JSNull
-lookupj (JSObject obj) (JSString s) = do
-  tell [Right (fromJSString s)]
-  case (lookup (fromJSString s) (fromJSObject obj)) of
-    Just x -> return x
-    Nothing -> return JSNull
-lookupj _ _ = mzero
-
-
-plusj (JSRational _ n1) (JSRational _ n2) = JSRational True (n1 + n2)
-plusj (JSString s1) (JSString s2) = JSString $ toJSString (fromJSString s1 ++ fromJSString s2)
-plusj (JSArray a1) (JSArray a2) = JSArray $ a1 ++ a2
-
-
-js :: JSON a => a -> JSValue
-js = showJSON
-
-index s = do
-  v <- ask
-  lookupj v (js s)
-
-
-dictp progs = do
-  liftM (JSObject . toJSObject) $ forM progs $ \(k,v) -> do
-    JSString k' <- k
-    v' <- v
-    return (fromJSString k', v')
-
diff --git a/Lexer.x b/Lexer.x
deleted file mode 100644
index 700c69e6..00000000
--- a/Lexer.x
+++ /dev/null
@@ -1,101 +0,0 @@
-{
-module Lexer where
-import Control.Monad.Error
-}
-
-%wrapper "monadUserState"
-
-$digit = 0-9
-$alpha = [a-zA-Z_]
-@reserved = "."|"["|"]"|","|":"|"("|")"|"{"|"}"|"|"|"=="|"+"
-@ident = $alpha [$alpha $digit]*
-@string = \" ($printable)* \"
-
-
-tokens :- 
-
-<0> $white+             ;
-<0> @reserved           { tok TRes }
-<0> @ident              { tok TIdent }
-<0> $digit+             { tok $ TInt . read }
-
-
-<0> \"                  { enterString }
-<string> \"             { leaveString }
-<string> ($printable # [\"\\]) { pushString id }
-<string> \\ [\"\\\/]    { pushString (drop 1) }
-<string> \\ [nrt]       { pushString (escape . drop 1) }
---<string> \\ 'u' [0-9a-fA-F]{4}
---                        { pushString (parseUnicode . drop 2) }
-
--- @string { \s -> TString $ init $ tail s}
-
-
-{
-  
-escape :: String -> String
-escape "r" = "\r"
-escape "n" = "\n"
-escape "t" = "\t"
-
-getState :: Alex AlexState
-getState = Alex $ \s -> Right (s, s)
-
-getUserState :: Alex AlexUserState
-getUserState = liftM alex_ust getState
-
-setUserState :: AlexUserState -> Alex ()
-setUserState s' = Alex $ \s -> Right (s{alex_ust = s'}, ()) 
-
-alexEOF = return $ Nothing
-
-enterString input len = do
-  setUserState []
-  alexSetStartCode string
-  skip input len
-
-pushString f i@(p, _, s) len = do
-  buf <- getUserState
-  setUserState (buf ++ [f $ take len s])
-  skip i len
-  
-leaveString input len = do
-  s <- getUserState
-  alexSetStartCode 0
-  return $ Just $ TString $ concat s
-  
-
-tok f (p,_,s) len = return $ Just $ f (take len s)
-data Token = TRes String | TString String | TIdent String | TInt Int
-
-instance Show Token where
-  show (TRes t) = "token " ++ t
-  show (TString t) = "string " ++ t
-  show (TIdent t) = "identifier " ++ t
-  show (TInt t) = "integer " ++ show t
-
-
-type AlexUserState = [String]
-
-alexInitUserState = undefined
-
-wrapError (Alex scanner) = Alex $ \s -> case scanner s of
-  Left message -> Left (message ++ " at " ++ showpos (alex_pos s))
-    where
-      showpos (AlexPn off line col) = "line " ++ show line ++ ", column " ++ show col
-  x -> x
-
-scanner = do
-  tok <- wrapError alexMonadScan
-  case tok of
-    Nothing -> do
-      s <- getState
-      case alex_scd s of
-        0 -> return []
-        string -> alexError "Unterminated string literal"
-    Just tok -> liftM (tok:) scanner
-
-runLexer :: String -> Either String [Token]
-runLexer input = runAlex input scanner
-
-}
\ No newline at end of file
diff --git a/Main.hs b/Main.hs
deleted file mode 100644
index 695520cb..00000000
--- a/Main.hs
+++ /dev/null
@@ -1,22 +0,0 @@
-import Parser
-import Lexer
-import JQ
-import Text.JSON
-import Text.JSON.String
-import System.Environment
-import Control.Monad
-import System.IO
-
-
-parseJS :: String -> JSValue
-parseJS s = case runGetJSON readJSValue s of
-  Left err -> error err
-  Right val -> val
-
-  
-main = do
-  [program] <- getArgs
-  json <- liftM parseJS $ hGetContents stdin
-  case runLexer program >>= runParser of
-    Left err -> putStrLn err
-    Right program -> mapM_ (putStrLn . encode) (runJQ program json)
\ No newline at end of file
diff --git a/c/Makefile b/Makefile
similarity index 50%
rename from c/Makefile
rename to Makefile
index 7f58c617..db63b777 100644
--- a/c/Makefile
+++ b/Makefile
@@ -8,23 +8,23 @@ clean:
 	sed 's/.*`\(.*\)'\''.*/\1/' | grep -v '^all$$' | \
 	xargs rm
 
-jv_utf8_tables.h: gen_utf8_tables.py
+jv_utf8_tables.gen.h: gen_utf8_tables.py
 	python $^ > $@
 
-lexer.yy.c: lexer.l
-	flex -o lexer.yy.c --header-file=lexer.yy.h lexer.l
-lexer.yy.h: lexer.yy.c
+lexer.gen.c: lexer.l
+	flex -o lexer.gen.c --header-file=lexer.gen.h lexer.l
+lexer.gen.h: lexer.gen.c
 
-parser.tab.c: parser.y lexer.yy.h
-	bison -W -d parser.y -v --report-file=parser.info
-parser.tab.h: parser.tab.c
+parser.gen.c: parser.y lexer.gen.h
+	bison -W -d parser.y -v --report-file=parser.gen.info -o $@
+parser.gen.h: parser.gen.c
 
-jv_unicode.c: jv_utf8_tables.h
+jv_unicode.c: jv_utf8_tables.gen.h
 
-parsertest: parser.tab.c lexer.yy.c main.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c
+parsertest: parser.gen.c lexer.gen.c main.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c
 	$(CC) -DJQ_DEBUG=1 -o $@ $^
 
-jq: parser.tab.c lexer.yy.c main.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c
+jq: parser.gen.c lexer.gen.c main.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c
 	$(CC) -DJQ_DEBUG=0 -o $@ $^
 
 jv_test: jv_test.c jv.c jv_print.c jv_dtoa.c jv_unicode.c
diff --git a/Parser.y b/Parser.y
deleted file mode 100644
index 544fe5b4..00000000
--- a/Parser.y
+++ /dev/null
@@ -1,78 +0,0 @@
-{
-module Parser where
-import Lexer
-import JQ
-import Text.JSON
-import Debug.Trace
-import Data.List
-import Control.Monad.Error
-import Control.Monad.Reader
-}
-
-%name runParser Exp
-%tokentype { Token }
-
-%monad { Either String }
-%error { \t -> fail $ "parse error: unexpected " ++ if null t then [] else (show $ head t) }
-
-%token
-  '|' { TRes "|" }
-  '.' { TRes "." }
-  '[' { TRes "[" }
-  ']' { TRes "]" }
-  '{' { TRes "{" }
-  '}' { TRes "}" }
-  '(' { TRes "(" }
-  ')' { TRes ")" }
-  ',' { TRes "," }
-  ':' { TRes ":" }
-  '==' { TRes "==" }
-  '+' { TRes "+" }
-  Ident { TIdent $$ }
-  String { TString $$ }
-  Int { TInt $$ }
-
-%left '|'
-%left ','
-%nonassoc '=='
-%left '+'
-
-%%
-
-Exp 
-  : Exp '|' Exp         { $1 >| $3 }
-  | Exp ',' Exp         { $1 `mplus` $3 }
-  | Exp '==' Exp        { liftM2 eqj $1 $3 }
-  | Exp '+' Exp         { liftM2 plusj $1 $3 }
-  | Term                { $1 }
-
-ExpD
-  : ExpD '|' ExpD       { $1 >| $3 }
-  | ExpD '==' ExpD      { liftM2 eqj $1 $3 }
-  | Term                { $1 }
-
-
-Term 
-  : '.'                 { ask }
-  | Term '.' Ident      { $1 >| index $3 }
-  | '.' Ident           { index $2 }
-  | String              { constStr $1 }
-  | Term '[' Exp ']'    { do {t <- $1; i <- $3; lookupj t i} }
-  | Term '[' ']'        { $1 >| childp }
-  | '(' Exp ')'         { $2 }
-  | '[' Exp ']'         { arrayp $2 }
-  | Int                 { constInt $1 }
-  | '{' MkDict '}'      { dictp $2 }
-  | Ident '(' Exp ')'   { callp $1 [$3] }
-  | Ident               { callp $1 [] }
-
-MkDict
-  :                     { [] }
-  | MkDictPair          { [$1] }
-  | MkDictPair ',' MkDict { $1:$3 }
- 
-MkDictPair
-  : Ident ':' ExpD      { (constStr $1, $3) }
-  | Ident               { (constStr $1, index $1) }
-  | String ':' ExpD     { (constStr $1, $3) }
-  | '(' Exp ')' ':' ExpD{ ($2, $5) }
diff --git a/c/builtin.c b/builtin.c
similarity index 100%
rename from c/builtin.c
rename to builtin.c
diff --git a/c/builtin.h b/builtin.h
similarity index 100%
rename from c/builtin.h
rename to builtin.h
diff --git a/c/bytecode.c b/bytecode.c
similarity index 100%
rename from c/bytecode.c
rename to bytecode.c
diff --git a/c/bytecode.h b/bytecode.h
similarity index 100%
rename from c/bytecode.h
rename to bytecode.h
diff --git a/c/compile.c b/compile.c
similarity index 100%
rename from c/compile.c
rename to compile.c
diff --git a/c/compile.h b/compile.h
similarity index 100%
rename from c/compile.h
rename to compile.h
diff --git a/c/execute.c b/execute.c
similarity index 100%
rename from c/execute.c
rename to execute.c
diff --git a/c/forkable_stack.h b/forkable_stack.h
similarity index 100%
rename from c/forkable_stack.h
rename to forkable_stack.h
diff --git a/c/frame_layout.h b/frame_layout.h
similarity index 100%
rename from c/frame_layout.h
rename to frame_layout.h
diff --git a/c/gen_utf8_tables.py b/gen_utf8_tables.py
similarity index 100%
rename from c/gen_utf8_tables.py
rename to gen_utf8_tables.py
diff --git a/c/jv.c b/jv.c
similarity index 100%
rename from c/jv.c
rename to jv.c
diff --git a/c/jv.h b/jv.h
similarity index 100%
rename from c/jv.h
rename to jv.h
diff --git a/c/jv_dtoa.c b/jv_dtoa.c
similarity index 100%
rename from c/jv_dtoa.c
rename to jv_dtoa.c
diff --git a/c/jv_dtoa.h b/jv_dtoa.h
similarity index 100%
rename from c/jv_dtoa.h
rename to jv_dtoa.h
diff --git a/c/jv_parse.c b/jv_parse.c
similarity index 100%
rename from c/jv_parse.c
rename to jv_parse.c
diff --git a/c/jv_parse.h b/jv_parse.h
similarity index 100%
rename from c/jv_parse.h
rename to jv_parse.h
diff --git a/c/jv_print.c b/jv_print.c
similarity index 100%
rename from c/jv_print.c
rename to jv_print.c
diff --git a/c/jv_test.c b/jv_test.c
similarity index 100%
rename from c/jv_test.c
rename to jv_test.c
diff --git a/c/jv_unicode.c b/jv_unicode.c
similarity index 98%
rename from c/jv_unicode.c
rename to jv_unicode.c
index 375ad367..b1417a2a 100644
--- a/c/jv_unicode.c
+++ b/jv_unicode.c
@@ -1,7 +1,7 @@
 #include <stdio.h>
 #include <assert.h>
 #include "jv_unicode.h"
-#include "jv_utf8_tables.h"
+#include "jv_utf8_tables.gen.h"
 
 const char* jvp_utf8_next(const char* in, const char* end, int* codepoint) {
   if (in == end) {
diff --git a/c/jv_unicode.h b/jv_unicode.h
similarity index 100%
rename from c/jv_unicode.h
rename to jv_unicode.h
diff --git a/c/lexer.l b/lexer.l
similarity index 98%
rename from c/lexer.l
rename to lexer.l
index 07cba83c..e604adab 100644
--- a/c/lexer.l
+++ b/lexer.l
@@ -1,6 +1,6 @@
 %{
 #include "compile.h"
-#include "parser.tab.h"  /* Generated by bison. */
+#include "parser.gen.h"  /* Generated by bison. */
 
 #define YY_USER_ACTION                           \
   do {                                           \
diff --git a/c/locfile.h b/locfile.h
similarity index 100%
rename from c/locfile.h
rename to locfile.h
diff --git a/c/main.c b/main.c
similarity index 100%
rename from c/main.c
rename to main.c
diff --git a/c/opcode.c b/opcode.c
similarity index 100%
rename from c/opcode.c
rename to opcode.c
diff --git a/c/opcode.h b/opcode.h
similarity index 100%
rename from c/opcode.h
rename to opcode.h
diff --git a/c/opcode_list.h b/opcode_list.h
similarity index 100%
rename from c/opcode_list.h
rename to opcode_list.h
diff --git a/c/parser.h b/parser.h
similarity index 100%
rename from c/parser.h
rename to parser.h
diff --git a/c/parser.y b/parser.y
similarity index 99%
rename from c/parser.y
rename to parser.y
index b47c3574..0fda65bd 100644
--- a/c/parser.y
+++ b/parser.y
@@ -81,7 +81,7 @@
 
 %type <blk> Exp Term MkDict MkDictPair ExpD ElseBody QQString FuncDef FuncDefs
 %{
-#include "lexer.yy.h"
+#include "lexer.gen.h"
 #define FAIL(loc, msg)                                   \
   do {                                                   \
     location l = loc;                                    \
diff --git a/c/testdata b/testdata
similarity index 100%
rename from c/testdata
rename to testdata

From cf134909fd20021f4f7628f1eb7c1ad11c4a4e62 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 18 Sep 2012 17:51:53 +0100
Subject: [PATCH 088/284] Documentation. Copious.

---
 docs/.gitignore                               |    6 +
 docs/Rakefile                                 |   54 +
 docs/content/1.tutorial/default.yml           |  239 +
 docs/content/2.download/default.yml           |   52 +
 docs/content/3.manual/manual.yml              |  688 ++
 docs/content/index/index.yml                  |   12 +
 docs/public/.htaccess                         |   28 +
 .../bootstrap/css/bootstrap-responsive.css    | 1058 +++
 .../css/bootstrap-responsive.min.css          |    9 +
 docs/public/bootstrap/css/bootstrap.css       | 5774 +++++++++++++++++
 docs/public/bootstrap/css/bootstrap.min.css   |    9 +
 .../img/glyphicons-halflings-white.png        |  Bin 0 -> 8777 bytes
 .../bootstrap/img/glyphicons-halflings.png    |  Bin 0 -> 12799 bytes
 docs/public/bootstrap/js/bootstrap.js         | 2027 ++++++
 docs/public/bootstrap/js/bootstrap.min.js     |    6 +
 docs/public/css/base.scss                     |   72 +
 docs/public/jq.png                            |  Bin 0 -> 8195 bytes
 docs/public/robots.txt                        |    2 +
 docs/site.yml                                 |   11 +
 docs/templates/default.liquid                 |   34 +
 docs/templates/index.liquid                   |   38 +
 docs/templates/manual.liquid                  |  109 +
 docs/templates/shared/_footer.liquid          |    5 +
 docs/templates/shared/_head.liquid            |   12 +
 docs/templates/shared/_header.liquid          |   24 +
 25 files changed, 10269 insertions(+)
 create mode 100644 docs/.gitignore
 create mode 100644 docs/Rakefile
 create mode 100644 docs/content/1.tutorial/default.yml
 create mode 100644 docs/content/2.download/default.yml
 create mode 100644 docs/content/3.manual/manual.yml
 create mode 100644 docs/content/index/index.yml
 create mode 100644 docs/public/.htaccess
 create mode 100644 docs/public/bootstrap/css/bootstrap-responsive.css
 create mode 100644 docs/public/bootstrap/css/bootstrap-responsive.min.css
 create mode 100644 docs/public/bootstrap/css/bootstrap.css
 create mode 100644 docs/public/bootstrap/css/bootstrap.min.css
 create mode 100644 docs/public/bootstrap/img/glyphicons-halflings-white.png
 create mode 100644 docs/public/bootstrap/img/glyphicons-halflings.png
 create mode 100644 docs/public/bootstrap/js/bootstrap.js
 create mode 100644 docs/public/bootstrap/js/bootstrap.min.js
 create mode 100644 docs/public/css/base.scss
 create mode 100644 docs/public/jq.png
 create mode 100644 docs/public/robots.txt
 create mode 100644 docs/site.yml
 create mode 100644 docs/templates/default.liquid
 create mode 100644 docs/templates/index.liquid
 create mode 100644 docs/templates/manual.liquid
 create mode 100644 docs/templates/shared/_footer.liquid
 create mode 100644 docs/templates/shared/_head.liquid
 create mode 100644 docs/templates/shared/_header.liquid

diff --git a/docs/.gitignore b/docs/.gitignore
new file mode 100644
index 00000000..4e01195c
--- /dev/null
+++ b/docs/.gitignore
@@ -0,0 +1,6 @@
+.DS_Store
+.sass-cache
+output/*
+
+# Autogenerated from public/css/base.scss
+public/css/base.css
\ No newline at end of file
diff --git a/docs/Rakefile b/docs/Rakefile
new file mode 100644
index 00000000..b4e1d6d1
--- /dev/null
+++ b/docs/Rakefile
@@ -0,0 +1,54 @@
+require 'bonsai'
+require 'liquid'
+require 'maruku'
+require 'json'
+
+module ExtraFilters
+  def markdownify(input)
+    Maruku.new(input).to_html
+  end
+
+  def sanitize(input)
+    input.gsub(/[^a-zA-Z0-9_]/,"")
+  end
+
+  def json(input)
+    input.to_json
+  end
+  
+  def unique(input)
+    @n = (@n || 0) + 1
+    input + @n.to_s
+  end
+end
+
+Liquid::Template.register_filter(ExtraFilters)
+
+
+task :serve do
+  begin
+    Bonsai.log "Press Control+C to quit"
+    
+    require 'rack'
+    require 'sinatra'
+    require 'watch'
+    require 'launchy'
+    
+    Bonsai.root_dir = Dir.pwd
+    
+    server = fork {        
+      app = Rack::Builder.app {
+        use Bonsai::StaticPassThrough, :root => Bonsai.root_dir + "/output", :urls => ["/"]
+        run Bonsai::DevelopmentServer
+      }
+      Rack::Handler.default.run(app, :Port => 5000) do
+        Launchy.open("http://localhost:5000/")
+      end
+    }    
+    Watch.new("{content,templates,public}/**/*") { Bonsai::Exporter.process! }
+  rescue Interrupt
+    Process.kill("QUIT", server)
+    Process.wait(server)
+    exit
+  end
+end
diff --git a/docs/content/1.tutorial/default.yml b/docs/content/1.tutorial/default.yml
new file mode 100644
index 00000000..5ba2df15
--- /dev/null
+++ b/docs/content/1.tutorial/default.yml
@@ -0,0 +1,239 @@
+headline: Tutorial
+body:
+  - text: |
+    
+      Twitter have a JSON API, so let's play with that. This URL gets
+      us the last 5 tweets about JSON:
+      
+  - command: "curl 'http://search.twitter.com/search.json?q=json&rpp=5&include_entities=true'"
+    result: |
+      {"completed_in":0.108,"max_id":247677287108067328,"max_id_str":"247677287108067328","next_page":"?page=2&max_id=247677287108067328&q=json&rpp=5&include_entities=1","page":1,"query":"json","refresh_url":"?since_id=247677287108067328&q=json&include_entities=1","results":[{"created_at":"Mon, 17 Sep 2012 12:44:01 +0000","entities":{"hashtags":[],"urls":[{"url":"http:\/\/t.co\/XRvh1ZVw","expanded_url":"http:\/\/jase.im\/Ri7I0M","display_url":"jase.im\/Ri7I0M","indices":[112,132]}],"user_mentions":[{"screen_name":"imagemechanics","name":"Jason Cotterell","id":57271393,"id_str":"57271393","indices":[3,18]}]},"from_user":"_AaronNg","from_user_id":79771704,"from_user_id_str":"79771704","from_user_name":"NgChenChong","geo":null,"id":247677287108067328,"id_str":"247677287108067328","iso_language_code":"en","metadata":{"result_type":"recent"},"profile_image_url":"http:\/\/a0.twimg.com\/profile_images\/2523558403\/ek8mo4j4beq84iw28gjl_normal.jpeg","profile_image_url_https":"https:\/\/si0.twimg.com\/profile_images\/2523558403\/ek8mo4j4beq84iw28gjl_normal.jpeg","source":"&lt;a href=&quot;http:\/\/twitter.com\/&quot;&gt;web&lt;\/a&gt;","text":"RT @imagemechanics: iPhone 5 website teardown: How Apple compresses video using JPEG, JSON, and &lt;canvas&gt;.\nhttp:\/\/t.co\/XRvh1ZVw","to_user":null,"to_user_id":0,"to_user_id_str":"0","to_user_name":null}, ...
+
+  - text: |
+
+      There's lots of info and no whitespace, so to make it a bit more
+      legible we pipe it through jq, telling jq to just spit the input
+      back at us using the expression `.`:
+
+    
+  - command: "curl 'http://search.twitter.com/search.json?q=json&rpp=5&include_entities=true' | jq '.'"
+    result: |
+
+      {
+        "since_id_str": "0",
+        "since_id": 0,
+        "results_per_page": 5,
+        "completed_in": 0.108,
+        "max_id": 247677287108067330,
+        "max_id_str": "247677287108067328",
+        "next_page": "?page=2&max_id=247677287108067328&q=json&rpp=5&include_entities=1",
+        "page": 1,
+        "query": "json",
+        "refresh_url": "?since_id=247677287108067328&q=json&include_entities=1",
+        "results": [
+          {
+            "from_user_name": "NgChenChong",
+            "from_user_id_str": "79771704",
+            "from_user_id": 79771704,
+            "from_user": "_AaronNg",
+            "iso_language_code": "en",
+            "text": "RT @imagemechanics: iPhone 5 website teardown: How Apple compresses video using JPEG, JSON, and &lt;canvas&gt;.\nhttp://t.co/XRvh1ZVw",
+            "to_user": null
+            /* lots more fields... */
+          },
+          /* lots more results... */
+        ]
+      }
+
+    
+  - text: |
+          
+      Let's pull out the first tweet:
+          
+          
+  - command: "curl 'http://search.twitter.com/search.json?q=json&rpp=5&include_entities=true' | jq '.results[0]'"
+    result: |
+      {
+        "from_user_name": "NgChenChong",
+        "from_user_id_str": "79771704",
+        "from_user_id": 79771704,
+        "from_user": "_AaronNg",
+        "iso_language_code": "en",
+        "text": "RT @imagemechanics: iPhone 5 website teardown: How Apple compresses video using JPEG, JSON, and &lt;canvas&gt;.\nhttp://t.co/XRvh1ZVw",
+        "to_user": null
+        /* lots more fields... */
+      },
+          
+  - text: |
+
+      For the rest of the examples, I'll leave out the `curl` command - it's not going to change.
+
+    
+      There's still a lot of info we don't care about there, so we'll
+      restrict it down to the most interesting fields.
+          
+
+  - command: "jq '.results[0] | {from_user, text}'"
+    result: |
+      {
+        "text": "RT @imagemechanics: iPhone 5 website teardown: How Apple compresses video using JPEG, JSON, and &lt;canvas&gt;.\nhttp://t.co/XRvh1ZVw",
+        "from_user": "_AaronNg"
+      }
+      
+  - text: |
+    
+      The `|` operator in jq feeds the output of one filter
+      (`.results[0]` which gets the first element of the results
+      array) into the input of another (`{from_user, text}` which
+      builds an object of those two fields).
+    
+      Now let's get the rest of the tweets:
+    
+          
+
+  - command: "jq '.results[] | {from_user, text}'"
+    result: |
+      {
+        "text": "RT @imagemechanics: iPhone 5 website teardown: How Apple compresses video using JPEG, JSON, and &lt;canvas&gt;.\nhttp://t.co/XRvh1ZVw",
+        "from_user": "_AaronNg"
+      }
+      {
+        "text": "RT @_kud: iPhone 5 website teardown: How Apple compresses video using JPEG, JSON, and &lt;canvas&gt; -- http://t.co/Lhp92IqD",
+        "from_user": "blouerat"
+      }
+      {
+        "text": "Dynamic Forms Mobile App by pmadiset: Few Forms details are hosted on our server in the form of JSON. This JSON ... http://t.co/7KALdWaX",
+        "from_user": "cebu_iphone"
+      }
+      {
+        "text": "iPhone 5 website insanity - Video compressing using JPEG, JSON, and &lt;canvas&gt; http://t.co/28Jesbio (Oh #Apple, U So #Awesome...)",
+        "from_user": "dieswaytoofast"
+      }
+      {
+        "text": "RT @umutm: A very nice web-based JSON editor - http://t.co/M70snaIf",
+        "from_user": "Leolik"
+      }
+         
+          
+  - text: |
+    
+      `.results[]` returns each element of the results array, one at a
+      time, which are all fed into `{from_user, text}`.
+
+
+      Data in jq is represented as streams of JSON values - every jq
+      expression runs for each value in its input stream, and can
+      produce any number of values to its output stream.
+
+      Streams are serialised by just separating JSON values with
+      whitespace. This is a `cat`-friendly format - you can just join
+      two JSON streams together and get a valid JSON stream.
+    
+      If you want to get the output as a single array, you can tell jq to
+      "collect" all of the answers by wrapping the filter in square
+      brackets:
+
+  - command: "jq '[.results[] | {from_user, text}]'"
+    result: |
+      [
+        {
+          "text": "RT @imagemechanics: iPhone 5 website teardown: How Apple compresses video using JPEG, JSON, and &lt;canvas&gt;.\nhttp://t.co/XRvh1ZVw",
+          "from_user": "_AaronNg"
+        },
+        {
+          "text": "RT @_kud: iPhone 5 website teardown: How Apple compresses video using JPEG, JSON, and &lt;canvas&gt; -- http://t.co/Lhp92IqD",
+          "from_user": "blouerat"
+        },
+        {
+          "text": "Dynamic Forms Mobile App by pmadiset: Few Forms details are hosted on our server in the form of JSON. This JSON ... http://t.co/7KALdWaX",
+          "from_user": "cebu_iphone"
+        },
+        {
+          "text": "iPhone 5 website insanity - Video compressing using JPEG, JSON, and &lt;canvas&gt; http://t.co/28Jesbio (Oh #Apple, U So #Awesome...)",
+          "from_user": "dieswaytoofast"
+        },
+        {
+          "text": "RT @umutm: A very nice web-based JSON editor - http://t.co/M70snaIf",
+          "from_user": "Leolik"
+        }
+      ]
+          
+          
+  - text: |
+
+      - - -
+    
+      Next, let's try getting the URLs out of those API results as
+      well. In each tweet, the Twitter API includes a field called
+      "entities" which looks like this:
+
+          {
+            "user_mentions": [],
+            "urls": [{
+                "indices": [83, 103],
+                "display_url": "bit.ly/StniqT",
+                "expanded_url": "http://bit.ly/StniqT",
+                "url": "http://t.co/28Jesbio"
+            }],
+            "hashtags": [
+              {"indices": [108, 114], "text": "Apple" },
+              {"indices": [121, 129], "text": "Awesome"}
+            ]
+          }
+
+      We want to pull out all of the "url" fields inside that array of url
+      objects, and make a simple list of strings to go along with the
+      "from_user" and "text" fields we already have.
+    
+          
+
+  - command: "jq '.results[] | {from_user, text, urls: [.entities.urls[].url]}'"
+    result: |
+      {
+       "urls": [
+         "http://t.co/XRvh1ZVw"
+       ],
+       "text": "RT @imagemechanics: iPhone 5 website teardown: How Apple compresses video using JPEG, JSON, and &lt;canvas&gt;.\nhttp://t.co/XRvh1ZVw",
+        "from_user": "_AaronNg"
+      }
+      {
+        "urls": [
+          "http://t.co/Lhp92IqD"
+        ],
+        "text": "RT @_kud: iPhone 5 website teardown: How Apple compresses video using JPEG, JSON, and &lt;canvas&gt; -- http://t.co/Lhp92IqD",
+        "from_user": "blouerat"
+      }
+      {
+        "urls": [
+          "http://t.co/7KALdWaX"
+        ],
+        "text": "Dynamic Forms Mobile App by pmadiset: Few Forms details are hosted on our server in the form of JSON. This JSON ... http://t.co/7KALdWaX",
+        "from_user": "cebu_iphone"
+      }
+      {
+        "urls": [
+          "http://t.co/28Jesbio"
+        ],
+        "text": "iPhone 5 website insanity - Video compressing using JPEG, JSON, and &lt;canvas&gt; http://t.co/28Jesbio (Oh #Apple, U So #Awesome...)",
+        "from_user": "dieswaytoofast"
+      }
+      {
+        "urls": [
+          "http://t.co/M70snaIf"
+        ],
+        "text": "RT @umutm: A very nice web-based JSON editor - http://t.co/M70snaIf",
+        "from_user": "Leolik"
+      }
+    
+          
+  - text: |
+    
+      Here we're making an object as before, but this time the urls
+      field is being set to `[.entities.urls[].url]`, which collects
+      all of the URLs defined in the entities object.
+
+  - text: |
+
+      - - -
+
+      asdf
\ No newline at end of file
diff --git a/docs/content/2.download/default.yml b/docs/content/2.download/default.yml
new file mode 100644
index 00000000..03c9cb7f
--- /dev/null
+++ b/docs/content/2.download/default.yml
@@ -0,0 +1,52 @@
+headline: Download jq
+body:
+
+  - text: |
+
+      jq is written in C and has no runtime dependencies, so it should be
+      possible to build it for nearly any platform. Prebuilt binaries are
+      available for Linux (64-bit x86) and OS X.
+    
+       * [Download binary for 64-bit Linux](/download/linux/x68_64/jq)
+       * [Download binary for OS X](/download/osx/64/jq)
+       * [Download source](/download/source/jq.tgz)
+
+      jq is licensed under the MIT license. For all of the gory
+      details, read the file `COPYING` in the source distribution.
+       
+      Hacking on jq
+      =============
+
+      If you want to work on jq, grab the source from
+      [https://github.com/stedolan/jq](https://github.com/stedolan/jq).
+        
+
+      To build it from a git clone, you'll need to install a few
+      packages first:
+
+       * [Flex](http://www.gnu.org/software/flex/)
+       * [Bison](http://www.gnu.org/software/bison/)
+       * [Python](http://www.python.org)
+       * [GCC](http://gcc.gnu.org)
+       * [Make](http://www.gnu.org/software/make)
+
+      Most of these aren't necessary if you're just trying to compile
+      jq from the released tarball - that version has the
+      non-platform-specific build steps already done, so you'll only
+      need a C compiler and `make` to finish it off.
+
+      For Linux systems, these will all be in your system's package
+      manager, and if you do development on the machine they're most
+      likely already installed. I have no idea how to get these
+      installed on OS X, you're on your own there.
+
+      `flex` and `bison` are used to generate the lexer and parser for
+      jq, and some python scripts generate the UTF8 encoding tables
+      needed for JSON parsing.
+   
+      Building the documentation
+      --
+
+      jq's documentation is compiled into static HTML using
+      [Bonsai](http://www.tinytree.info). To view the documentation
+      locally, run `rake serve` from the docs/ subdirectory.
\ No newline at end of file
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
new file mode 100644
index 00000000..20793976
--- /dev/null
+++ b/docs/content/3.manual/manual.yml
@@ -0,0 +1,688 @@
+headline: jq Manual
+sections:
+  - title: Basics
+    body: "{ some *intro* text \n\n\n}\n"
+    entries:
+      - title: "`.`"
+        body: |
+          
+          The absolute simplest (and least interesting) jq expression
+          is `.`. This is a jq expression that takes its input and
+          produces it unchanged as output.
+
+          Since jq by default pretty-prints all output, this trivial
+          program can be a useful way of formatting JSON output from,
+          say, `curl`.
+
+        examples:
+          - program: '.'
+            input: '"Hello, world!"'
+            output: ['"Hello, world!"']
+
+      - title: "`.foo`"
+        body: |
+          
+          The simplest *useful* jq expression is .foo. When given a
+          JSON object (aka dictionary or hash) as input, it produces
+          the value at the key "foo", or null if there\'s none present.
+
+        examples:
+          - program: '.foo'
+            input: '{"foo": 42, "bar": "less interesting data"}'
+            output: [42]
+          - program: '.foo'
+            input: '{"notfoo": true, "alsonotfoo": false}'
+            output: ['null']
+
+      - title: "`.[foo]`"
+        body: |
+          
+          You can also look up fields of an object using syntax like
+          `.["foo"]` (.foo above is a shorthand version of this). This
+          one works for arrays as well, if the key is an
+          integer. Arrays are zero-based (like javascript), so .[2]
+          returns the third element of the array.
+
+        examples:
+          - program: '.[0]'
+            input: '[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]'
+            output: ['{"name":"JSON", "good":true}']
+
+          - program: '.[2]'
+            input: '[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]'
+            output: ['null']
+
+      - title: "`.[]`"
+        body: |
+          
+          If you use the `.[foo]` syntax, but omit the index
+          entirely, it will return *all* of the elements of an
+          array. Running `.[]` with the input `[1,2,3]` will produce the
+          numbers as three seperate results, rather than as a single
+          array.
+
+        examples:
+          - program: '.[]'
+            input: '[{name":"JSON", "good":true}, {"name":"XML", "good":false}]'
+            output:
+              - '{"name":"JSON", "good":true}'
+              - '{"name":"XML", "good":false}'
+
+          - program: '.[]'
+            input: '[]'
+            output: []
+
+      - title: "`,`"
+        body: |
+          
+          If two jq expressions are separated by a comma, then the
+          input will be fed into both and there will be multiple
+          outputs: first, all of the outputs produced by the left
+          expression, and then all of the outputs produced by the
+          right. For instance, jq expression `.foo, .bar`, produces
+          both the "foo" fields and "bar" fields as separate outputs.
+
+        examples:
+          - program: '.foo, .bar'
+            input: '{"foo": 42, "bar": "something else", "baz": true}'
+            output: ['42', '"something else"']
+
+          - program: "[.user, .projects[]]"
+            input: '{"user":"stedolan", "projects": ["jq", "wikiflow"]}'
+            output: ['"stedolan"', '"jq"', '"wikiflow"']            
+            
+          - program: '.[4,2]'
+            input: '["a","b","c","d","e"]'
+            output: ['"d"', '"c"']
+          
+      - title: "`|`"
+        body: |
+          The | operator combines two jq expressions by feeding the output(s) of
+          the one on the left into the input of the one on the right. It\'s
+          pretty much the same as the Unix shell\'s pipe, if you\'re used to
+          that. 
+
+          If the one on the left produces multiple results, the one on
+          the right will be run for each of those results. So, the
+          expression `.[] | .foo` retrieves the "foo" field of each
+          element of the input array.
+
+        examples:
+          - program: '.[] | .name'
+            input: '[{name":"JSON", "good":true}, {"name":"XML", "good":false}]'
+            output: ['"JSON"', '"XML"']
+
+  - title: Types and Values
+    body: |
+      
+      jq supports the same set of datatypes as JSON - numbers,
+      strings, booleans, arrays, objects (which in JSON-speak are
+      hashes with only string keys), and "null".
+
+      Booleans, null, strings and numbers are written the same way as
+      in javascript. Just like everything else in jq, these simple
+      values take an input and produce an output - `42` is a valid jq
+      expression that takes an input, ignores it, and returns 42
+      instead.
+
+    entries:
+      - title: Array construction - `[]`
+        body: |
+        
+          As in JSON, `[]` is used to construct arrays, as in
+          `[1,2,3]`. The elements of the arrays can be any jq
+          expression. All of the results produced by all of the
+          expressions are collected into one big array. You can use it
+          to construct an array out of a known quantity of values (as
+          in `[.foo, .bar, .baz]`) or to "collect" all the results of a
+          jq expression into an array (as in `[.items[].name]`)
+        
+          Once you understand the "," operator, you can look at jq\'s array
+          syntax in a different light: the expression [1,2,3] is not using a
+          built-in syntax for comma-separated arrays, but is instead applying
+          the `[]` operator (collect results) to the expression 1,2,3 (which
+          produces three different results).
+
+          If you have a jq expression `X` that produces four results,
+          then the expression `[X]` will produce a single result, an
+          array of four elements.
+
+        examples:
+          - program: "[.user, .projects[]]"
+            input: '{"user":"stedolan", "projects": ["jq", "wikiflow"]}'
+            output: ['["stedolan", "jq", "wikiflow"]']
+      - title: Objects - `{}`
+        body: |
+
+          Like JSON, `{}` is for constructing objects (aka
+          dictionaries or hashes), as in: `{"a": 42, "b": 17}`.
+          
+          If the keys are "sensible" (all alphabetic characters), then
+          the quotes can be left off. The value can be any expression
+          (although you may need to wrap it in parentheses if it\'s a
+          complicated one), which gets applied to the {} expression\'s
+          input (remember, all jq expressions have an input and an
+          output).
+          
+              {foo: .bar}
+          
+          will produce the JSON object `{"foo": 42}` if given the JSON
+          object `{"bar":42, "baz":43}`. You can use this to select
+          particular fields of an object: if the input is an object
+          with "user", "title", "id", and "content" fields and you
+          just want "user" and "title", you can write
+          
+              {user: .user, title: .title}
+          
+          Because that\'s so common, there\'s a shortcut syntax: `{user, title}`.
+          
+          If one of the expressions produces multiple results,
+          multiple dictionaries will be produced. If the input\'s
+          
+              {"user":"stedolan","titles":["JQ Primer", "More JQ"]}
+          
+          then the expression
+          
+              {user, title: .titles[]}
+          
+          will produce two outputs: 
+          
+              {"user":"stedolan", "title": "JQ Primer"}
+              {"user":"stedolan", "title": "More JQ"}
+          
+          Putting parentheses around the key means it will be evaluated as an
+          expression. With the same input as above,
+          
+              {(.user): .titles}
+          
+          produces
+          
+              {"stedolan": ["JQ Primer", "More JQ"]}
+              
+        examples:
+          - program: '{user, title: .titles[]}'
+            input: '{"user":"stedolan","titles":["JQ Primer", "More JQ"]}'
+            output:
+              - '{"user":"stedolan", "title": "JQ Primer"}'
+              - '{"user":"stedolan", "title": "More JQ"}'
+          - program: '{(.user): .titles}'
+            input: '{"user":"stedolan","titles":["JQ Primer", "More JQ"]}'
+            output: ['{"stedolan": ["JQ Primer", "More JQ"]}']
+
+  - title: Builtin operators and functions
+    body: |
+
+      Some jq operator (for instance, `+`) do different things
+      depending on the type of their arguments (arrays, numbers,
+      etc.). However, jq never does implicit type conversions. If you
+      try to add a string to an object you'll get an error message and
+      no result.
+      
+    entries:
+      - title: Addition - `+`
+        body: |
+
+          The operator `+` takes two jq expressions, applies them both
+          to the same input, and adds the results together. What
+          "adding" means depends on the types involved:
+
+          - **Numbers** are added by normal arithmetic.
+
+          - **Arrays** are added by being concatenated into a larger array.
+
+          - **Strings** are added by being joined into a larger string.
+          
+          - **Objects** are added by merging, that is, inserting all
+              the key-value pairs from both objects into a single
+              combined object. If both objects contain a value for the
+              same key, the object on the right of the `+` wins.
+
+        examples:
+          - program: '.a + 1'
+            input: '{"a": 7}'
+            output: '{"a": 8}'
+          - program: '.a + .b'
+            input: '{"a": [1,2], "b": [3,4]}'
+            output: ['[1,2,3,4]']
+          - program: '{a: 1} + {b: 2} + {c: 3} + {a: 42}'
+            input: 'null'
+            output: ['{"a": 42, "b": 2, "c": 3}']
+
+      - title: Subtraction - `-`
+        body: |
+
+          As well as normal arithmetic subtraction on numbers, the `-`
+          operator can be used on arrays to remove all occurences of
+          the second array's elements from the first array.
+
+        examples:
+          - program: '4 - .a'
+            input: '{"a":3}'
+            output: ['1']
+          - program: . - ["xml", "yaml"]
+            input: '["xml", "yaml", "json"]'
+            output: ['["json"]']
+
+      - title: Multiplication, division - `*` and `/`
+        body: |
+
+          These operators only work on numbers, and do the expected.
+
+        examples:
+          - program: '10 / . * 3'
+            input: 5
+            output: [6]
+
+      - title: `length`
+        body: |
+
+          The builtin function `length` gets the length of various
+          different types of value:
+
+          - The length of a **string** is the number of Unicode
+            codepoints it contains (which will be the same as its
+            JSON-encoded length in bytes if it's pure ASCII).
+
+          - The length of an **array** is the number of elements.
+
+          - The length of an **object** is the number of key-value pairs.
+
+          - The length of **null** is zero.
+
+        examples:
+          - program: '.[] | length'
+            input: '[[1,2], "string", {"a":2}, null]'
+            output: [2, 6, 1, 0]
+
+      - title: `tonumber`
+        body: |
+
+          The `tonumber` function parses its input as a number. It
+          will convert correctly-formatted strings to their numeric
+          equivalent, leave numbers alone, and give an error on all other input.
+
+        examples:
+          - program: '.[] | tonumber'
+            input: '[1, "1"]'
+            output: [1,1]
+
+      - title: `tostring`
+        body: |
+
+          The `tostring` function prints its input as a
+          string. Strings are left unchanged, and all other values are
+          JSON-encoded.
+
+        examples:
+          - program: '.[] | tostring'
+            input: '[1, "1", [1]]'
+            output: ['"1"', '"1"', '"[1]"']
+
+      - title: "String interpolation - `@(text)`"
+        body: |
+
+          jq supports an alternative syntax for strings. Instead of
+          "foo", you can write `@(foo)`. When using this syntax,
+          `%(expression)` may be used to insert the value of
+          `expression` into the string (converted with `tostring`).
+
+          String interpolation does not occur for normal double-quoted
+          strings (like `"foo"`) in order to be fully compatible with
+          JSON.
+
+          All of the usual JSON escapes (`\n`, `\r` and the like) work
+          inside `@()`-quoted strings, as well as `\%` and `\)` if
+          those characters are needed literally.
+
+        examples:
+          - program: '@(The input was %(.), which is one less than %(.+1))'
+            input: '42'
+            output: ['"The input was 42, which is one less than 43"']
+          
+              
+
+              
+
+        
+  - title: Conditionals and Comparisons
+    entries:
+      - title: `==`, `!=`
+        body: |
+
+          The expression 'a == b' will produce 'true' if the result of a and b
+          are equal (that is, if they represent equivalent JSON documents) and
+          'false' otherwise. In particular, strings are never considered equal
+          to numbers. If you're coming from Javascript, jq's == is like
+          Javascript's === - considering values equal only when they have the
+          same type as well as the same value.
+          
+          != is "not equal", and 'a != b' returns the opposite value of 'a == b'
+
+        examples:
+          - program: '.[] == 1'
+            input: '[1, 1.0, "1", "banana"]'
+            output: ['[true, true, false, false]']
+          
+      - title: if-then-else
+        body: |
+
+          `if A then B else C end` will act the same as `B` if `A`
+          produces a value other than false or null, but act the same
+          as `C` otherwise.
+          
+          Checking for false or null is a simpler notion of
+          "truthiness" than is found in Javascript or Python, but it
+          means that you'll sometimes have to be more explicit about
+          the condition you want: you can't test whether, e.g. a
+          string is empty using `if .name then A else B end`, you'll
+          need something more like 'if (.name | count) > 0 then A else
+          B end' instead.
+          
+          If the condition A produces multiple results, it is
+          considered "true" if any of those results is not false or
+          null. If it produces zero results, it's considered false.
+          
+          More cases can be added to an if using `elif A then B` syntax.
+
+        examples:
+          - program: |-
+              if . == 0 then
+                "zero"
+              elif . == 1 then
+                "one"
+              else
+                "many"
+              end
+            input: 2
+            output: ['"many"']
+
+      - title: and/or/not
+        body: |
+
+          jq supports the normal Boolean operators and/or/not. They have the
+          same standard of truth as if expressions - false and null are
+          considered "false values", and anything else is a "true value".
+
+          If an operand of one of these operators produces multiple
+          results, the operator itself will produce a result for each input.
+
+          `not` is in fact a builtin function rather than an operator,
+          so it is called as a filter to which things can be piped
+          rather than with special syntax, as in `.foo and .bar |
+          not`.
+          
+          These three only produce the values "true" and "false", and
+          so are only useful for genuine Boolean operations, rather
+          than the common Perl/Python/Ruby idiom of
+          "value_that_may_be_null or default". If you want to use this
+          form of "or", picking between two values rather than
+          evaluating a condition, see the "//" operator below.
+          
+        examples:
+          - program: '42 and "a string"'
+            input: 'null'
+            output: ['true']
+          - program: '(true, false) or false'
+            input: 'null'
+            output: ['true', 'false']
+          - program: '(true, false) and (true, false)'
+            input: 'null'
+            output: ['true', 'false', 'false', 'false']
+          - program: '[true, false | not]'
+            input: 'null'
+            output: ['[false, true]']
+
+      - title: Alternative operator - `//`
+        body: |
+
+          A jq expression of the form `a // b` produces the same
+          results as `a`, if `a` produces results other than `false`
+          and `null`. Otherwise, `a // b` produces the same results as `b`.
+
+          This is useful for providing defaults: `.foo or 1` will
+          evaluate to `1` if there's no `.foo` element in the
+          input. It's similar to how `or` is sometimes used in Python
+          (jq's `or` operator is reserved for strictly Boolean
+          operations).
+
+        examples:
+          - program: '.foo // 42'
+            input: '{"foo": 19}'
+            output: [19]
+          - program: '.foo // 42'
+            input: '{}'
+            output: [42]
+          
+  - title: Variables and Functions
+    body: |
+      Variables are an absolute necessity in most programming languages, but
+      they're relegated to an "advanced feature" in jq.
+
+      In most languages, variables are the only means of passing around
+      data. If you calculate a value, and you want to use it more than once,
+      you'll need to store it in a variable. To pass a value to another part
+      of the program, you'll need that part of the program to define a
+      variable (as a function parameter, object member, or whatever) in
+      which to place the data.
+
+      It is also possible to define functions in jq, although this is
+      is a feature whose biggest use is defining jq's standard library
+      (many jq functions such as `map` and `find` are in fact written
+      in jq).
+
+    entries:
+      - title: Variables
+        body: |
+          
+          In jq, all jq expressions have an input and an output, so manual
+          plumbing is not necessary to pass a value from one part of a program
+          to the next. Many expressions, for instance `a + b`, pass their input
+          to two distinct subexpressions (here `a` and `b` are both passed the
+          same input), so variables aren't usually necessary in order to use a
+          value twice.
+          
+          For instance, calculating the average value of an array of numbers
+          requires a few variables in most languages - at least one to hold the
+          array, perhaps one for each element or for a loop counter. In jq, it's
+          simply `add / length` - the `sum` expression is given the array and
+          produces its sum, and the `count` expression is given the array and
+          produces its length.
+          
+          So, there's generally a cleaner way to solve most problems in jq that
+          defining variables. Still, sometimes they do make things easier, so jq
+          lets you define variables using `expression as $variable`. All
+          variable names start with `$`. Here's a slightly uglier version of the
+          array-averaging example:
+          
+              length as $array_length | add / $array_length
+          
+          We'll need a more complicated problem to find a situation where using
+          variables actually makes our lives easier.
+          
+          
+          Suppose we have an array of blog posts, with "author" and "title"
+          fields, and another object which is used to map author usernames to
+          real names. Our input looks like:
+          
+              {"posts": [{"title": "Frist psot", "author": "anon"},
+                         {"title": "A well-written article", "author": "person1"}],
+               "realnames": {"anon": "Anonymous Coward",
+                             "person1": "Person McPherson"}}
+          
+          We want to produce the posts with the author field containing a real
+          name, as in:
+          
+              {"title": "Frist psot", "author": "Anonymous Coward"}
+              {"title": "A well-written article", "author": "Person McPherson"}
+          
+          We use a variable, $names, to store the realnames object, so that we
+          can refer to it later when looking up author usernames:
+          
+              .realnames as $names | .posts[] | {title, author: $names[.author]}
+          
+          The expression "asdf as $x" runs asdf, puts the result in $x, and
+          returns the original input. Apart from the side-effect of binding the
+          variable, it has the same effect as ".".
+          
+          Variables are scoped over the rest of the expression that defines
+          them, so 
+          
+              .realnames as $names | (.posts[] | {title, author: $names[.author]})
+          
+          will work, but 
+          
+              (.realnames as $names | .posts[]) | {title, author: $names[.author]}
+          
+          won't.
+
+        examples:
+          - program: '.bar as $x | .foo | . + $x'
+            input: '{"foo":10, "bar":200}'
+            output: ['210']
+
+      - title: 'Defining Functions'
+        body: |
+          
+          You can give a jq expression a name using "def" syntax:
+
+              def increment: . + 1;
+          
+          From then on, `increment` is usable as a filter just like a
+          builtin function (in fact, this is how some of the builtins
+          are defined). A function may take arguments:
+
+              def map(f): [.[] | f];
+
+          Arguments are passed as jq expressions, not as values. The
+          same argument may be referenced multiple times with
+          different inputs (here `f` is run for each element of the
+          input array). Arguments to a function work more like
+          callbacks than like value arguments.
+
+          If you want the value-argument behaviour for defining simple
+          functions, you can just use a variable:
+
+              def addvalue(f): f as $value | map(, + $value);
+
+          With that definition, `addvalue(.foo)` will add the current
+          input's `.foo` field to each element of the array.
+
+        examples:
+          - program: 'def addvalue(f): map(. + [$value]); addvalue(.[0])'
+            input: '[[1,2],[10,20]]'
+            output: ['[[1,2,1], [10,20,10]]']
+          - program: 'def addvalue(f): f as $x | map (. + $x); addvalue(.[0])'
+            input: '[[1,2],[10,20]]'
+            output: ['[[1,2,[1,2]], [10,20,[1,2]]]']
+      
+
+  - title: Assignment
+    body: |
+
+      Assignment works a little differently in jq than in most
+      programming languages. jq doesn't distinguish between references
+      to and copies of something - two objects or arrays are either
+      equal or not equal, without any further notion of being "the
+      same object" or "not the same object".
+
+      If an object has two fields which are arrays, `.foo` and `.bar`,
+      and you append something to `.foo`, then `.bar` will not get
+      bigger. Even if you've just set `.bar = .foo`. If you're used to
+      programming in languages like Python, Java, Ruby, Javascript,
+      etc. then you can think of it as though jq does a full deep copy
+      of every object before it does the assignment (for performance,
+      it doesn't actually do that, but that's the general idea).
+
+    entries:
+      - title: "`=`"
+        body: |
+          
+          The jq expression `.foo = 1` will take as input an object
+          and produce as output an object with the "foo" field set to
+          1. There is no notion of "modifying" or "changing" something
+          in jq - all jq values are immutable. For instance,
+          
+           .foo = .bar | .foo.baz = 1
+          
+          will not have the side-effect of setting .bar.baz to be set
+          to 1, as the similar-looking program in Javascript, Python,
+          Ruby or other languages would. Unlike these languages (but
+          like Haskell and some other functional languages), there is
+          no notion of two arrays or objects being "the same array" or
+          "the same object". They can be equal, or not equal, but if
+          we change one of them in no circumstances will the other
+          change behind our backs.
+          
+          This means that it's impossible to build circular values in
+          jq (such as an array whose first element is itself). This is
+          quite intentional, and ensures that anything a jq program
+          can produce can be represented in JSON.
+
+      - title: "`|=`"
+        body: |
+          As well as the assignment operator '=', jq provides the "update"
+          operator '|=', which takes a jq expression on the right-hand side and
+          works out the new value for the property being assigned to by running
+          the old value through this expression. For instance, .foo |= .+1 will
+          build an object with the "foo" field set to the input's "foo" plus 1.
+          
+          This example should show the difference between '=' and '|=':
+          
+          Provide input '{"a": {"b": 10}, "b": 20}' to the programs:
+          
+          .a = .b
+          .a |= .b
+          
+          The former will set the "a" field of the input to the "b" field of the
+          input, and produce the output {"a": 20}. The latter will set the "a"
+          field of the input to the "a" field's "b" field, producing {"a": 10}.
+
+      - title: "`+=`, `-=`, `*=`, `/=`, `//=`"
+        body: |
+
+          jq has a few operators of the form `a op= b`, which are all
+          equivalent to `a |= . op b`. So, `+= 1` can be used to increment values.
+
+        examples:
+          - program: .foo += 1
+            input: '{"foo": 42}'
+            output: ['{"foo": 43}']
+        
+      - title: Complex assignments
+        body: |
+          Lots more things are allowed on the left-hand side of a jq assignment
+          than in most langauges. We've already seen simple field accesses on
+          the left hand side, and it's no surprise that array accesses work just
+          as well:
+          
+              .posts[0].title = "JQ Manual"
+          
+          What may come as a surprise is that the expression on the left may
+          produce multiple results, referring to different points in the input
+          document:
+          
+              .posts[].comments |= . + ["this is great"]
+          
+          That example appends the string "this is great" to the "comments"
+          array of each post in the input (where the input is an object with a
+          field "posts" which is an array of posts).
+          
+          When jq encounters an assignment like 'a = b', it records the "path"
+          taken to select a part of the input document while executing a. This
+          path is then used to find which part of the input to change while
+          executing the assignment. Any jq expression may be used on the
+          left-hand side of an equals - whichever paths it selects from the
+          input will be where the assignment is performed.
+          
+          This is a very powerful operation. Suppose we wanted to add a comment
+          to blog posts, using the same "blog" input above. This time, we only
+          want to comment on the posts written by "stedolan". We can find those
+          posts using the "select" function described earlier:
+          
+              .posts[] | select(.author == "stedolan")
+          
+          The paths provided by this operation point to each of the posts that
+          "stedolan" wrote, and we can comment on each of them in the same way
+          that we did before:
+          
+              (.posts[] | select(.author == "stedolan") | .comments) |= . + ["terrible."]
diff --git a/docs/content/index/index.yml b/docs/content/index/index.yml
new file mode 100644
index 00000000..f0e7196e
--- /dev/null
+++ b/docs/content/index/index.yml
@@ -0,0 +1,12 @@
+headline: jq
+
+blurb: |
+  
+  jq is a command-line JSON processor.
+  
+body: |
+
+
+  
+  Go read the [tutorial](/tutorial) for more, or the [manual](/manual)
+  for *way* more.
\ No newline at end of file
diff --git a/docs/public/.htaccess b/docs/public/.htaccess
new file mode 100644
index 00000000..7142064d
--- /dev/null
+++ b/docs/public/.htaccess
@@ -0,0 +1,28 @@
+DirectoryIndex index.html
+FileETag All
+
+# Compress all static assets
+<IfModule mod_deflate.c>
+	# compress content with type html, text, and css
+  AddOutputFilterByType DEFLATE text/css text/html text/javascript application/javascript application/x-javascript text/js text/plain text/xml
+
+	<IfModule mod_headers.c>
+		# properly handle requests coming from behind proxies
+		Header append Vary User-Agent
+	</IfModule>
+</IfModule>
+
+# Cache, aggressively 
+<IfModule mod_expires.c>
+  ExpiresActive On
+  ExpiresDefault "access plus 10 days"
+
+	<FilesMatch "\.(eot|ttf|otf)$">
+		ExpiresDefault "access plus 10 years"
+	</filesMatch>
+</IfModule>
+
+# Mime-types
+AddType application/vnd.ms-fontobject .eot
+AddType font/ttf .ttf
+AddType font/otf .otf
\ No newline at end of file
diff --git a/docs/public/bootstrap/css/bootstrap-responsive.css b/docs/public/bootstrap/css/bootstrap-responsive.css
new file mode 100644
index 00000000..9259d26d
--- /dev/null
+++ b/docs/public/bootstrap/css/bootstrap-responsive.css
@@ -0,0 +1,1058 @@
+/*!
+ * Bootstrap Responsive v2.1.1
+ *
+ * Copyright 2012 Twitter, Inc
+ * Licensed under the Apache License v2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Designed and built with all the love in the world @twitter by @mdo and @fat.
+ */
+
+.clearfix {
+  *zoom: 1;
+}
+
+.clearfix:before,
+.clearfix:after {
+  display: table;
+  line-height: 0;
+  content: "";
+}
+
+.clearfix:after {
+  clear: both;
+}
+
+.hide-text {
+  font: 0/0 a;
+  color: transparent;
+  text-shadow: none;
+  background-color: transparent;
+  border: 0;
+}
+
+.input-block-level {
+  display: block;
+  width: 100%;
+  min-height: 30px;
+  -webkit-box-sizing: border-box;
+     -moz-box-sizing: border-box;
+          box-sizing: border-box;
+}
+
+.hidden {
+  display: none;
+  visibility: hidden;
+}
+
+.visible-phone {
+  display: none !important;
+}
+
+.visible-tablet {
+  display: none !important;
+}
+
+.hidden-desktop {
+  display: none !important;
+}
+
+.visible-desktop {
+  display: inherit !important;
+}
+
+@media (min-width: 768px) and (max-width: 979px) {
+  .hidden-desktop {
+    display: inherit !important;
+  }
+  .visible-desktop {
+    display: none !important ;
+  }
+  .visible-tablet {
+    display: inherit !important;
+  }
+  .hidden-tablet {
+    display: none !important;
+  }
+}
+
+@media (max-width: 767px) {
+  .hidden-desktop {
+    display: inherit !important;
+  }
+  .visible-desktop {
+    display: none !important;
+  }
+  .visible-phone {
+    display: inherit !important;
+  }
+  .hidden-phone {
+    display: none !important;
+  }
+}
+
+@media (min-width: 1200px) {
+  .row {
+    margin-left: -30px;
+    *zoom: 1;
+  }
+  .row:before,
+  .row:after {
+    display: table;
+    line-height: 0;
+    content: "";
+  }
+  .row:after {
+    clear: both;
+  }
+  [class*="span"] {
+    float: left;
+    min-height: 1px;
+    margin-left: 30px;
+  }
+  .container,
+  .navbar-static-top .container,
+  .navbar-fixed-top .container,
+  .navbar-fixed-bottom .container {
+    width: 1170px;
+  }
+  .span12 {
+    width: 1170px;
+  }
+  .span11 {
+    width: 1070px;
+  }
+  .span10 {
+    width: 970px;
+  }
+  .span9 {
+    width: 870px;
+  }
+  .span8 {
+    width: 770px;
+  }
+  .span7 {
+    width: 670px;
+  }
+  .span6 {
+    width: 570px;
+  }
+  .span5 {
+    width: 470px;
+  }
+  .span4 {
+    width: 370px;
+  }
+  .span3 {
+    width: 270px;
+  }
+  .span2 {
+    width: 170px;
+  }
+  .span1 {
+    width: 70px;
+  }
+  .offset12 {
+    margin-left: 1230px;
+  }
+  .offset11 {
+    margin-left: 1130px;
+  }
+  .offset10 {
+    margin-left: 1030px;
+  }
+  .offset9 {
+    margin-left: 930px;
+  }
+  .offset8 {
+    margin-left: 830px;
+  }
+  .offset7 {
+    margin-left: 730px;
+  }
+  .offset6 {
+    margin-left: 630px;
+  }
+  .offset5 {
+    margin-left: 530px;
+  }
+  .offset4 {
+    margin-left: 430px;
+  }
+  .offset3 {
+    margin-left: 330px;
+  }
+  .offset2 {
+    margin-left: 230px;
+  }
+  .offset1 {
+    margin-left: 130px;
+  }
+  .row-fluid {
+    width: 100%;
+    *zoom: 1;
+  }
+  .row-fluid:before,
+  .row-fluid:after {
+    display: table;
+    line-height: 0;
+    content: "";
+  }
+  .row-fluid:after {
+    clear: both;
+  }
+  .row-fluid [class*="span"] {
+    display: block;
+    float: left;
+    width: 100%;
+    min-height: 30px;
+    margin-left: 2.564102564102564%;
+    *margin-left: 2.5109110747408616%;
+    -webkit-box-sizing: border-box;
+       -moz-box-sizing: border-box;
+            box-sizing: border-box;
+  }
+  .row-fluid [class*="span"]:first-child {
+    margin-left: 0;
+  }
+  .row-fluid .span12 {
+    width: 100%;
+    *width: 99.94680851063829%;
+  }
+  .row-fluid .span11 {
+    width: 91.45299145299145%;
+    *width: 91.39979996362975%;
+  }
+  .row-fluid .span10 {
+    width: 82.90598290598291%;
+    *width: 82.8527914166212%;
+  }
+  .row-fluid .span9 {
+    width: 74.35897435897436%;
+    *width: 74.30578286961266%;
+  }
+  .row-fluid .span8 {
+    width: 65.81196581196582%;
+    *width: 65.75877432260411%;
+  }
+  .row-fluid .span7 {
+    width: 57.26495726495726%;
+    *width: 57.21176577559556%;
+  }
+  .row-fluid .span6 {
+    width: 48.717948717948715%;
+    *width: 48.664757228587014%;
+  }
+  .row-fluid .span5 {
+    width: 40.17094017094017%;
+    *width: 40.11774868157847%;
+  }
+  .row-fluid .span4 {
+    width: 31.623931623931625%;
+    *width: 31.570740134569924%;
+  }
+  .row-fluid .span3 {
+    width: 23.076923076923077%;
+    *width: 23.023731587561375%;
+  }
+  .row-fluid .span2 {
+    width: 14.52991452991453%;
+    *width: 14.476723040552828%;
+  }
+  .row-fluid .span1 {
+    width: 5.982905982905983%;
+    *width: 5.929714493544281%;
+  }
+  .row-fluid .offset12 {
+    margin-left: 105.12820512820512%;
+    *margin-left: 105.02182214948171%;
+  }
+  .row-fluid .offset12:first-child {
+    margin-left: 102.56410256410257%;
+    *margin-left: 102.45771958537915%;
+  }
+  .row-fluid .offset11 {
+    margin-left: 96.58119658119658%;
+    *margin-left: 96.47481360247316%;
+  }
+  .row-fluid .offset11:first-child {
+    margin-left: 94.01709401709402%;
+    *margin-left: 93.91071103837061%;
+  }
+  .row-fluid .offset10 {
+    margin-left: 88.03418803418803%;
+    *margin-left: 87.92780505546462%;
+  }
+  .row-fluid .offset10:first-child {
+    margin-left: 85.47008547008548%;
+    *margin-left: 85.36370249136206%;
+  }
+  .row-fluid .offset9 {
+    margin-left: 79.48717948717949%;
+    *margin-left: 79.38079650845607%;
+  }
+  .row-fluid .offset9:first-child {
+    margin-left: 76.92307692307693%;
+    *margin-left: 76.81669394435352%;
+  }
+  .row-fluid .offset8 {
+    margin-left: 70.94017094017094%;
+    *margin-left: 70.83378796144753%;
+  }
+  .row-fluid .offset8:first-child {
+    margin-left: 68.37606837606839%;
+    *margin-left: 68.26968539734497%;
+  }
+  .row-fluid .offset7 {
+    margin-left: 62.393162393162385%;
+    *margin-left: 62.28677941443899%;
+  }
+  .row-fluid .offset7:first-child {
+    margin-left: 59.82905982905982%;
+    *margin-left: 59.72267685033642%;
+  }
+  .row-fluid .offset6 {
+    margin-left: 53.84615384615384%;
+    *margin-left: 53.739770867430444%;
+  }
+  .row-fluid .offset6:first-child {
+    margin-left: 51.28205128205128%;
+    *margin-left: 51.175668303327875%;
+  }
+  .row-fluid .offset5 {
+    margin-left: 45.299145299145295%;
+    *margin-left: 45.1927623204219%;
+  }
+  .row-fluid .offset5:first-child {
+    margin-left: 42.73504273504273%;
+    *margin-left: 42.62865975631933%;
+  }
+  .row-fluid .offset4 {
+    margin-left: 36.75213675213675%;
+    *margin-left: 36.645753773413354%;
+  }
+  .row-fluid .offset4:first-child {
+    margin-left: 34.18803418803419%;
+    *margin-left: 34.081651209310785%;
+  }
+  .row-fluid .offset3 {
+    margin-left: 28.205128205128204%;
+    *margin-left: 28.0987452264048%;
+  }
+  .row-fluid .offset3:first-child {
+    margin-left: 25.641025641025642%;
+    *margin-left: 25.53464266230224%;
+  }
+  .row-fluid .offset2 {
+    margin-left: 19.65811965811966%;
+    *margin-left: 19.551736679396257%;
+  }
+  .row-fluid .offset2:first-child {
+    margin-left: 17.094017094017094%;
+    *margin-left: 16.98763411529369%;
+  }
+  .row-fluid .offset1 {
+    margin-left: 11.11111111111111%;
+    *margin-left: 11.004728132387708%;
+  }
+  .row-fluid .offset1:first-child {
+    margin-left: 8.547008547008547%;
+    *margin-left: 8.440625568285142%;
+  }
+  input,
+  textarea,
+  .uneditable-input {
+    margin-left: 0;
+  }
+  .controls-row [class*="span"] + [class*="span"] {
+    margin-left: 30px;
+  }
+  input.span12,
+  textarea.span12,
+  .uneditable-input.span12 {
+    width: 1156px;
+  }
+  input.span11,
+  textarea.span11,
+  .uneditable-input.span11 {
+    width: 1056px;
+  }
+  input.span10,
+  textarea.span10,
+  .uneditable-input.span10 {
+    width: 956px;
+  }
+  input.span9,
+  textarea.span9,
+  .uneditable-input.span9 {
+    width: 856px;
+  }
+  input.span8,
+  textarea.span8,
+  .uneditable-input.span8 {
+    width: 756px;
+  }
+  input.span7,
+  textarea.span7,
+  .uneditable-input.span7 {
+    width: 656px;
+  }
+  input.span6,
+  textarea.span6,
+  .uneditable-input.span6 {
+    width: 556px;
+  }
+  input.span5,
+  textarea.span5,
+  .uneditable-input.span5 {
+    width: 456px;
+  }
+  input.span4,
+  textarea.span4,
+  .uneditable-input.span4 {
+    width: 356px;
+  }
+  input.span3,
+  textarea.span3,
+  .uneditable-input.span3 {
+    width: 256px;
+  }
+  input.span2,
+  textarea.span2,
+  .uneditable-input.span2 {
+    width: 156px;
+  }
+  input.span1,
+  textarea.span1,
+  .uneditable-input.span1 {
+    width: 56px;
+  }
+  .thumbnails {
+    margin-left: -30px;
+  }
+  .thumbnails > li {
+    margin-left: 30px;
+  }
+  .row-fluid .thumbnails {
+    margin-left: 0;
+  }
+}
+
+@media (min-width: 768px) and (max-width: 979px) {
+  .row {
+    margin-left: -20px;
+    *zoom: 1;
+  }
+  .row:before,
+  .row:after {
+    display: table;
+    line-height: 0;
+    content: "";
+  }
+  .row:after {
+    clear: both;
+  }
+  [class*="span"] {
+    float: left;
+    min-height: 1px;
+    margin-left: 20px;
+  }
+  .container,
+  .navbar-static-top .container,
+  .navbar-fixed-top .container,
+  .navbar-fixed-bottom .container {
+    width: 724px;
+  }
+  .span12 {
+    width: 724px;
+  }
+  .span11 {
+    width: 662px;
+  }
+  .span10 {
+    width: 600px;
+  }
+  .span9 {
+    width: 538px;
+  }
+  .span8 {
+    width: 476px;
+  }
+  .span7 {
+    width: 414px;
+  }
+  .span6 {
+    width: 352px;
+  }
+  .span5 {
+    width: 290px;
+  }
+  .span4 {
+    width: 228px;
+  }
+  .span3 {
+    width: 166px;
+  }
+  .span2 {
+    width: 104px;
+  }
+  .span1 {
+    width: 42px;
+  }
+  .offset12 {
+    margin-left: 764px;
+  }
+  .offset11 {
+    margin-left: 702px;
+  }
+  .offset10 {
+    margin-left: 640px;
+  }
+  .offset9 {
+    margin-left: 578px;
+  }
+  .offset8 {
+    margin-left: 516px;
+  }
+  .offset7 {
+    margin-left: 454px;
+  }
+  .offset6 {
+    margin-left: 392px;
+  }
+  .offset5 {
+    margin-left: 330px;
+  }
+  .offset4 {
+    margin-left: 268px;
+  }
+  .offset3 {
+    margin-left: 206px;
+  }
+  .offset2 {
+    margin-left: 144px;
+  }
+  .offset1 {
+    margin-left: 82px;
+  }
+  .row-fluid {
+    width: 100%;
+    *zoom: 1;
+  }
+  .row-fluid:before,
+  .row-fluid:after {
+    display: table;
+    line-height: 0;
+    content: "";
+  }
+  .row-fluid:after {
+    clear: both;
+  }
+  .row-fluid [class*="span"] {
+    display: block;
+    float: left;
+    width: 100%;
+    min-height: 30px;
+    margin-left: 2.7624309392265194%;
+    *margin-left: 2.709239449864817%;
+    -webkit-box-sizing: border-box;
+       -moz-box-sizing: border-box;
+            box-sizing: border-box;
+  }
+  .row-fluid [class*="span"]:first-child {
+    margin-left: 0;
+  }
+  .row-fluid .span12 {
+    width: 100%;
+    *width: 99.94680851063829%;
+  }
+  .row-fluid .span11 {
+    width: 91.43646408839778%;
+    *width: 91.38327259903608%;
+  }
+  .row-fluid .span10 {
+    width: 82.87292817679558%;
+    *width: 82.81973668743387%;
+  }
+  .row-fluid .span9 {
+    width: 74.30939226519337%;
+    *width: 74.25620077583166%;
+  }
+  .row-fluid .span8 {
+    width: 65.74585635359117%;
+    *width: 65.69266486422946%;
+  }
+  .row-fluid .span7 {
+    width: 57.18232044198895%;
+    *width: 57.12912895262725%;
+  }
+  .row-fluid .span6 {
+    width: 48.61878453038674%;
+    *width: 48.56559304102504%;
+  }
+  .row-fluid .span5 {
+    width: 40.05524861878453%;
+    *width: 40.00205712942283%;
+  }
+  .row-fluid .span4 {
+    width: 31.491712707182323%;
+    *width: 31.43852121782062%;
+  }
+  .row-fluid .span3 {
+    width: 22.92817679558011%;
+    *width: 22.87498530621841%;
+  }
+  .row-fluid .span2 {
+    width: 14.3646408839779%;
+    *width: 14.311449394616199%;
+  }
+  .row-fluid .span1 {
+    width: 5.801104972375691%;
+    *width: 5.747913483013988%;
+  }
+  .row-fluid .offset12 {
+    margin-left: 105.52486187845304%;
+    *margin-left: 105.41847889972962%;
+  }
+  .row-fluid .offset12:first-child {
+    margin-left: 102.76243093922652%;
+    *margin-left: 102.6560479605031%;
+  }
+  .row-fluid .offset11 {
+    margin-left: 96.96132596685082%;
+    *margin-left: 96.8549429881274%;
+  }
+  .row-fluid .offset11:first-child {
+    margin-left: 94.1988950276243%;
+    *margin-left: 94.09251204890089%;
+  }
+  .row-fluid .offset10 {
+    margin-left: 88.39779005524862%;
+    *margin-left: 88.2914070765252%;
+  }
+  .row-fluid .offset10:first-child {
+    margin-left: 85.6353591160221%;
+    *margin-left: 85.52897613729868%;
+  }
+  .row-fluid .offset9 {
+    margin-left: 79.8342541436464%;
+    *margin-left: 79.72787116492299%;
+  }
+  .row-fluid .offset9:first-child {
+    margin-left: 77.07182320441989%;
+    *margin-left: 76.96544022569647%;
+  }
+  .row-fluid .offset8 {
+    margin-left: 71.2707182320442%;
+    *margin-left: 71.16433525332079%;
+  }
+  .row-fluid .offset8:first-child {
+    margin-left: 68.50828729281768%;
+    *margin-left: 68.40190431409427%;
+  }
+  .row-fluid .offset7 {
+    margin-left: 62.70718232044199%;
+    *margin-left: 62.600799341718584%;
+  }
+  .row-fluid .offset7:first-child {
+    margin-left: 59.94475138121547%;
+    *margin-left: 59.838368402492065%;
+  }
+  .row-fluid .offset6 {
+    margin-left: 54.14364640883978%;
+    *margin-left: 54.037263430116376%;
+  }
+  .row-fluid .offset6:first-child {
+    margin-left: 51.38121546961326%;
+    *margin-left: 51.27483249088986%;
+  }
+  .row-fluid .offset5 {
+    margin-left: 45.58011049723757%;
+    *margin-left: 45.47372751851417%;
+  }
+  .row-fluid .offset5:first-child {
+    margin-left: 42.81767955801105%;
+    *margin-left: 42.71129657928765%;
+  }
+  .row-fluid .offset4 {
+    margin-left: 37.01657458563536%;
+    *margin-left: 36.91019160691196%;
+  }
+  .row-fluid .offset4:first-child {
+    margin-left: 34.25414364640884%;
+    *margin-left: 34.14776066768544%;
+  }
+  .row-fluid .offset3 {
+    margin-left: 28.45303867403315%;
+    *margin-left: 28.346655695309746%;
+  }
+  .row-fluid .offset3:first-child {
+    margin-left: 25.69060773480663%;
+    *margin-left: 25.584224756083227%;
+  }
+  .row-fluid .offset2 {
+    margin-left: 19.88950276243094%;
+    *margin-left: 19.783119783707537%;
+  }
+  .row-fluid .offset2:first-child {
+    margin-left: 17.12707182320442%;
+    *margin-left: 17.02068884448102%;
+  }
+  .row-fluid .offset1 {
+    margin-left: 11.32596685082873%;
+    *margin-left: 11.219583872105325%;
+  }
+  .row-fluid .offset1:first-child {
+    margin-left: 8.56353591160221%;
+    *margin-left: 8.457152932878806%;
+  }
+  input,
+  textarea,
+  .uneditable-input {
+    margin-left: 0;
+  }
+  .controls-row [class*="span"] + [class*="span"] {
+    margin-left: 20px;
+  }
+  input.span12,
+  textarea.span12,
+  .uneditable-input.span12 {
+    width: 710px;
+  }
+  input.span11,
+  textarea.span11,
+  .uneditable-input.span11 {
+    width: 648px;
+  }
+  input.span10,
+  textarea.span10,
+  .uneditable-input.span10 {
+    width: 586px;
+  }
+  input.span9,
+  textarea.span9,
+  .uneditable-input.span9 {
+    width: 524px;
+  }
+  input.span8,
+  textarea.span8,
+  .uneditable-input.span8 {
+    width: 462px;
+  }
+  input.span7,
+  textarea.span7,
+  .uneditable-input.span7 {
+    width: 400px;
+  }
+  input.span6,
+  textarea.span6,
+  .uneditable-input.span6 {
+    width: 338px;
+  }
+  input.span5,
+  textarea.span5,
+  .uneditable-input.span5 {
+    width: 276px;
+  }
+  input.span4,
+  textarea.span4,
+  .uneditable-input.span4 {
+    width: 214px;
+  }
+  input.span3,
+  textarea.span3,
+  .uneditable-input.span3 {
+    width: 152px;
+  }
+  input.span2,
+  textarea.span2,
+  .uneditable-input.span2 {
+    width: 90px;
+  }
+  input.span1,
+  textarea.span1,
+  .uneditable-input.span1 {
+    width: 28px;
+  }
+}
+
+@media (max-width: 767px) {
+  body {
+    padding-right: 20px;
+    padding-left: 20px;
+  }
+  .navbar-fixed-top,
+  .navbar-fixed-bottom,
+  .navbar-static-top {
+    margin-right: -20px;
+    margin-left: -20px;
+  }
+  .container-fluid {
+    padding: 0;
+  }
+  .dl-horizontal dt {
+    float: none;
+    width: auto;
+    clear: none;
+    text-align: left;
+  }
+  .dl-horizontal dd {
+    margin-left: 0;
+  }
+  .container {
+    width: auto;
+  }
+  .row-fluid {
+    width: 100%;
+  }
+  .row,
+  .thumbnails {
+    margin-left: 0;
+  }
+  .thumbnails > li {
+    float: none;
+    margin-left: 0;
+  }
+  [class*="span"],
+  .row-fluid [class*="span"] {
+    display: block;
+    float: none;
+    width: 100%;
+    margin-left: 0;
+    -webkit-box-sizing: border-box;
+       -moz-box-sizing: border-box;
+            box-sizing: border-box;
+  }
+  .span12,
+  .row-fluid .span12 {
+    width: 100%;
+    -webkit-box-sizing: border-box;
+       -moz-box-sizing: border-box;
+            box-sizing: border-box;
+  }
+  .input-large,
+  .input-xlarge,
+  .input-xxlarge,
+  input[class*="span"],
+  select[class*="span"],
+  textarea[class*="span"],
+  .uneditable-input {
+    display: block;
+    width: 100%;
+    min-height: 30px;
+    -webkit-box-sizing: border-box;
+       -moz-box-sizing: border-box;
+            box-sizing: border-box;
+  }
+  .input-prepend input,
+  .input-append input,
+  .input-prepend input[class*="span"],
+  .input-append input[class*="span"] {
+    display: inline-block;
+    width: auto;
+  }
+  .controls-row [class*="span"] + [class*="span"] {
+    margin-left: 0;
+  }
+  .modal {
+    position: fixed;
+    top: 20px;
+    right: 20px;
+    left: 20px;
+    width: auto;
+    margin: 0;
+  }
+  .modal.fade.in {
+    top: auto;
+  }
+}
+
+@media (max-width: 480px) {
+  .nav-collapse {
+    -webkit-transform: translate3d(0, 0, 0);
+  }
+  .page-header h1 small {
+    display: block;
+    line-height: 20px;
+  }
+  input[type="checkbox"],
+  input[type="radio"] {
+    border: 1px solid #ccc;
+  }
+  .form-horizontal .control-label {
+    float: none;
+    width: auto;
+    padding-top: 0;
+    text-align: left;
+  }
+  .form-horizontal .controls {
+    margin-left: 0;
+  }
+  .form-horizontal .control-list {
+    padding-top: 0;
+  }
+  .form-horizontal .form-actions {
+    padding-right: 10px;
+    padding-left: 10px;
+  }
+  .modal {
+    top: 10px;
+    right: 10px;
+    left: 10px;
+  }
+  .modal-header .close {
+    padding: 10px;
+    margin: -10px;
+  }
+  .carousel-caption {
+    position: static;
+  }
+}
+
+@media (max-width: 979px) {
+  body {
+    padding-top: 0;
+  }
+  .navbar-fixed-top,
+  .navbar-fixed-bottom {
+    position: static;
+  }
+  .navbar-fixed-top {
+    margin-bottom: 20px;
+  }
+  .navbar-fixed-bottom {
+    margin-top: 20px;
+  }
+  .navbar-fixed-top .navbar-inner,
+  .navbar-fixed-bottom .navbar-inner {
+    padding: 5px;
+  }
+  .navbar .container {
+    width: auto;
+    padding: 0;
+  }
+  .navbar .brand {
+    padding-right: 10px;
+    padding-left: 10px;
+    margin: 0 0 0 -5px;
+  }
+  .nav-collapse {
+    clear: both;
+  }
+  .nav-collapse .nav {
+    float: none;
+    margin: 0 0 10px;
+  }
+  .nav-collapse .nav > li {
+    float: none;
+  }
+  .nav-collapse .nav > li > a {
+    margin-bottom: 2px;
+  }
+  .nav-collapse .nav > .divider-vertical {
+    display: none;
+  }
+  .nav-collapse .nav .nav-header {
+    color: #777777;
+    text-shadow: none;
+  }
+  .nav-collapse .nav > li > a,
+  .nav-collapse .dropdown-menu a {
+    padding: 9px 15px;
+    font-weight: bold;
+    color: #777777;
+    -webkit-border-radius: 3px;
+       -moz-border-radius: 3px;
+            border-radius: 3px;
+  }
+  .nav-collapse .btn {
+    padding: 4px 10px 4px;
+    font-weight: normal;
+    -webkit-border-radius: 4px;
+       -moz-border-radius: 4px;
+            border-radius: 4px;
+  }
+  .nav-collapse .dropdown-menu li + li a {
+    margin-bottom: 2px;
+  }
+  .nav-collapse .nav > li > a:hover,
+  .nav-collapse .dropdown-menu a:hover {
+    background-color: #f2f2f2;
+  }
+  .navbar-inverse .nav-collapse .nav > li > a:hover,
+  .navbar-inverse .nav-collapse .dropdown-menu a:hover {
+    background-color: #111111;
+  }
+  .nav-collapse.in .btn-group {
+    padding: 0;
+    margin-top: 5px;
+  }
+  .nav-collapse .dropdown-menu {
+    position: static;
+    top: auto;
+    left: auto;
+    display: block;
+    float: none;
+    max-width: none;
+    padding: 0;
+    margin: 0 15px;
+    background-color: transparent;
+    border: none;
+    -webkit-border-radius: 0;
+       -moz-border-radius: 0;
+            border-radius: 0;
+    -webkit-box-shadow: none;
+       -moz-box-shadow: none;
+            box-shadow: none;
+  }
+  .nav-collapse .dropdown-menu:before,
+  .nav-collapse .dropdown-menu:after {
+    display: none;
+  }
+  .nav-collapse .dropdown-menu .divider {
+    display: none;
+  }
+  .nav-collapse .nav > li > .dropdown-menu:before,
+  .nav-collapse .nav > li > .dropdown-menu:after {
+    display: none;
+  }
+  .nav-collapse .navbar-form,
+  .nav-collapse .navbar-search {
+    float: none;
+    padding: 10px 15px;
+    margin: 10px 0;
+    border-top: 1px solid #f2f2f2;
+    border-bottom: 1px solid #f2f2f2;
+    -webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.1), 0 1px 0 rgba(255, 255, 255, 0.1);
+       -moz-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.1), 0 1px 0 rgba(255, 255, 255, 0.1);
+            box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.1), 0 1px 0 rgba(255, 255, 255, 0.1);
+  }
+  .navbar-inverse .nav-collapse .navbar-form,
+  .navbar-inverse .nav-collapse .navbar-search {
+    border-top-color: #111111;
+    border-bottom-color: #111111;
+  }
+  .navbar .nav-collapse .nav.pull-right {
+    float: none;
+    margin-left: 0;
+  }
+  .nav-collapse,
+  .nav-collapse.collapse {
+    height: 0;
+    overflow: hidden;
+  }
+  .navbar .btn-navbar {
+    display: block;
+  }
+  .navbar-static .navbar-inner {
+    padding-right: 10px;
+    padding-left: 10px;
+  }
+}
+
+@media (min-width: 980px) {
+  .nav-collapse.collapse {
+    height: auto !important;
+    overflow: visible !important;
+  }
+}
diff --git a/docs/public/bootstrap/css/bootstrap-responsive.min.css b/docs/public/bootstrap/css/bootstrap-responsive.min.css
new file mode 100644
index 00000000..7b0158da
--- /dev/null
+++ b/docs/public/bootstrap/css/bootstrap-responsive.min.css
@@ -0,0 +1,9 @@
+/*!
+ * Bootstrap Responsive v2.1.1
+ *
+ * Copyright 2012 Twitter, Inc
+ * Licensed under the Apache License v2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Designed and built with all the love in the world @twitter by @mdo and @fat.
+ */.clearfix{*zoom:1}.clearfix:before,.clearfix:after{display:table;line-height:0;content:""}.clearfix:after{clear:both}.hide-text{font:0/0 a;color:transparent;text-shadow:none;background-color:transparent;border:0}.input-block-level{display:block;width:100%;min-height:30px;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}.hidden{display:none;visibility:hidden}.visible-phone{display:none!important}.visible-tablet{display:none!important}.hidden-desktop{display:none!important}.visible-desktop{display:inherit!important}@media(min-width:768px) and (max-width:979px){.hidden-desktop{display:inherit!important}.visible-desktop{display:none!important}.visible-tablet{display:inherit!important}.hidden-tablet{display:none!important}}@media(max-width:767px){.hidden-desktop{display:inherit!important}.visible-desktop{display:none!important}.visible-phone{display:inherit!important}.hidden-phone{display:none!important}}@media(min-width:1200px){.row{margin-left:-30px;*zoom:1}.row:before,.row:after{display:table;line-height:0;content:""}.row:after{clear:both}[class*="span"]{float:left;min-height:1px;margin-left:30px}.container,.navbar-static-top .container,.navbar-fixed-top .container,.navbar-fixed-bottom .container{width:1170px}.span12{width:1170px}.span11{width:1070px}.span10{width:970px}.span9{width:870px}.span8{width:770px}.span7{width:670px}.span6{width:570px}.span5{width:470px}.span4{width:370px}.span3{width:270px}.span2{width:170px}.span1{width:70px}.offset12{margin-left:1230px}.offset11{margin-left:1130px}.offset10{margin-left:1030px}.offset9{margin-left:930px}.offset8{margin-left:830px}.offset7{margin-left:730px}.offset6{margin-left:630px}.offset5{margin-left:530px}.offset4{margin-left:430px}.offset3{margin-left:330px}.offset2{margin-left:230px}.offset1{margin-left:130px}.row-fluid{width:100%;*zoom:1}.row-fluid:before,.row-fluid:after{display:table;line-height:0;content:""}.row-fluid:after{clear:both}.row-fluid [class*="span"]{display:block;float:left;width:100%;min-height:30px;margin-left:2.564102564102564%;*margin-left:2.5109110747408616%;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}.row-fluid [class*="span"]:first-child{margin-left:0}.row-fluid .span12{width:100%;*width:99.94680851063829%}.row-fluid .span11{width:91.45299145299145%;*width:91.39979996362975%}.row-fluid .span10{width:82.90598290598291%;*width:82.8527914166212%}.row-fluid .span9{width:74.35897435897436%;*width:74.30578286961266%}.row-fluid .span8{width:65.81196581196582%;*width:65.75877432260411%}.row-fluid .span7{width:57.26495726495726%;*width:57.21176577559556%}.row-fluid .span6{width:48.717948717948715%;*width:48.664757228587014%}.row-fluid .span5{width:40.17094017094017%;*width:40.11774868157847%}.row-fluid .span4{width:31.623931623931625%;*width:31.570740134569924%}.row-fluid .span3{width:23.076923076923077%;*width:23.023731587561375%}.row-fluid .span2{width:14.52991452991453%;*width:14.476723040552828%}.row-fluid .span1{width:5.982905982905983%;*width:5.929714493544281%}.row-fluid .offset12{margin-left:105.12820512820512%;*margin-left:105.02182214948171%}.row-fluid .offset12:first-child{margin-left:102.56410256410257%;*margin-left:102.45771958537915%}.row-fluid .offset11{margin-left:96.58119658119658%;*margin-left:96.47481360247316%}.row-fluid .offset11:first-child{margin-left:94.01709401709402%;*margin-left:93.91071103837061%}.row-fluid .offset10{margin-left:88.03418803418803%;*margin-left:87.92780505546462%}.row-fluid .offset10:first-child{margin-left:85.47008547008548%;*margin-left:85.36370249136206%}.row-fluid .offset9{margin-left:79.48717948717949%;*margin-left:79.38079650845607%}.row-fluid .offset9:first-child{margin-left:76.92307692307693%;*margin-left:76.81669394435352%}.row-fluid .offset8{margin-left:70.94017094017094%;*margin-left:70.83378796144753%}.row-fluid .offset8:first-child{margin-left:68.37606837606839%;*margin-left:68.26968539734497%}.row-fluid .offset7{margin-left:62.393162393162385%;*margin-left:62.28677941443899%}.row-fluid .offset7:first-child{margin-left:59.82905982905982%;*margin-left:59.72267685033642%}.row-fluid .offset6{margin-left:53.84615384615384%;*margin-left:53.739770867430444%}.row-fluid .offset6:first-child{margin-left:51.28205128205128%;*margin-left:51.175668303327875%}.row-fluid .offset5{margin-left:45.299145299145295%;*margin-left:45.1927623204219%}.row-fluid .offset5:first-child{margin-left:42.73504273504273%;*margin-left:42.62865975631933%}.row-fluid .offset4{margin-left:36.75213675213675%;*margin-left:36.645753773413354%}.row-fluid .offset4:first-child{margin-left:34.18803418803419%;*margin-left:34.081651209310785%}.row-fluid .offset3{margin-left:28.205128205128204%;*margin-left:28.0987452264048%}.row-fluid .offset3:first-child{margin-left:25.641025641025642%;*margin-left:25.53464266230224%}.row-fluid .offset2{margin-left:19.65811965811966%;*margin-left:19.551736679396257%}.row-fluid .offset2:first-child{margin-left:17.094017094017094%;*margin-left:16.98763411529369%}.row-fluid .offset1{margin-left:11.11111111111111%;*margin-left:11.004728132387708%}.row-fluid .offset1:first-child{margin-left:8.547008547008547%;*margin-left:8.440625568285142%}input,textarea,.uneditable-input{margin-left:0}.controls-row [class*="span"]+[class*="span"]{margin-left:30px}input.span12,textarea.span12,.uneditable-input.span12{width:1156px}input.span11,textarea.span11,.uneditable-input.span11{width:1056px}input.span10,textarea.span10,.uneditable-input.span10{width:956px}input.span9,textarea.span9,.uneditable-input.span9{width:856px}input.span8,textarea.span8,.uneditable-input.span8{width:756px}input.span7,textarea.span7,.uneditable-input.span7{width:656px}input.span6,textarea.span6,.uneditable-input.span6{width:556px}input.span5,textarea.span5,.uneditable-input.span5{width:456px}input.span4,textarea.span4,.uneditable-input.span4{width:356px}input.span3,textarea.span3,.uneditable-input.span3{width:256px}input.span2,textarea.span2,.uneditable-input.span2{width:156px}input.span1,textarea.span1,.uneditable-input.span1{width:56px}.thumbnails{margin-left:-30px}.thumbnails>li{margin-left:30px}.row-fluid .thumbnails{margin-left:0}}@media(min-width:768px) and (max-width:979px){.row{margin-left:-20px;*zoom:1}.row:before,.row:after{display:table;line-height:0;content:""}.row:after{clear:both}[class*="span"]{float:left;min-height:1px;margin-left:20px}.container,.navbar-static-top .container,.navbar-fixed-top .container,.navbar-fixed-bottom .container{width:724px}.span12{width:724px}.span11{width:662px}.span10{width:600px}.span9{width:538px}.span8{width:476px}.span7{width:414px}.span6{width:352px}.span5{width:290px}.span4{width:228px}.span3{width:166px}.span2{width:104px}.span1{width:42px}.offset12{margin-left:764px}.offset11{margin-left:702px}.offset10{margin-left:640px}.offset9{margin-left:578px}.offset8{margin-left:516px}.offset7{margin-left:454px}.offset6{margin-left:392px}.offset5{margin-left:330px}.offset4{margin-left:268px}.offset3{margin-left:206px}.offset2{margin-left:144px}.offset1{margin-left:82px}.row-fluid{width:100%;*zoom:1}.row-fluid:before,.row-fluid:after{display:table;line-height:0;content:""}.row-fluid:after{clear:both}.row-fluid [class*="span"]{display:block;float:left;width:100%;min-height:30px;margin-left:2.7624309392265194%;*margin-left:2.709239449864817%;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}.row-fluid [class*="span"]:first-child{margin-left:0}.row-fluid .span12{width:100%;*width:99.94680851063829%}.row-fluid .span11{width:91.43646408839778%;*width:91.38327259903608%}.row-fluid .span10{width:82.87292817679558%;*width:82.81973668743387%}.row-fluid .span9{width:74.30939226519337%;*width:74.25620077583166%}.row-fluid .span8{width:65.74585635359117%;*width:65.69266486422946%}.row-fluid .span7{width:57.18232044198895%;*width:57.12912895262725%}.row-fluid .span6{width:48.61878453038674%;*width:48.56559304102504%}.row-fluid .span5{width:40.05524861878453%;*width:40.00205712942283%}.row-fluid .span4{width:31.491712707182323%;*width:31.43852121782062%}.row-fluid .span3{width:22.92817679558011%;*width:22.87498530621841%}.row-fluid .span2{width:14.3646408839779%;*width:14.311449394616199%}.row-fluid .span1{width:5.801104972375691%;*width:5.747913483013988%}.row-fluid .offset12{margin-left:105.52486187845304%;*margin-left:105.41847889972962%}.row-fluid .offset12:first-child{margin-left:102.76243093922652%;*margin-left:102.6560479605031%}.row-fluid .offset11{margin-left:96.96132596685082%;*margin-left:96.8549429881274%}.row-fluid .offset11:first-child{margin-left:94.1988950276243%;*margin-left:94.09251204890089%}.row-fluid .offset10{margin-left:88.39779005524862%;*margin-left:88.2914070765252%}.row-fluid .offset10:first-child{margin-left:85.6353591160221%;*margin-left:85.52897613729868%}.row-fluid .offset9{margin-left:79.8342541436464%;*margin-left:79.72787116492299%}.row-fluid .offset9:first-child{margin-left:77.07182320441989%;*margin-left:76.96544022569647%}.row-fluid .offset8{margin-left:71.2707182320442%;*margin-left:71.16433525332079%}.row-fluid .offset8:first-child{margin-left:68.50828729281768%;*margin-left:68.40190431409427%}.row-fluid .offset7{margin-left:62.70718232044199%;*margin-left:62.600799341718584%}.row-fluid .offset7:first-child{margin-left:59.94475138121547%;*margin-left:59.838368402492065%}.row-fluid .offset6{margin-left:54.14364640883978%;*margin-left:54.037263430116376%}.row-fluid .offset6:first-child{margin-left:51.38121546961326%;*margin-left:51.27483249088986%}.row-fluid .offset5{margin-left:45.58011049723757%;*margin-left:45.47372751851417%}.row-fluid .offset5:first-child{margin-left:42.81767955801105%;*margin-left:42.71129657928765%}.row-fluid .offset4{margin-left:37.01657458563536%;*margin-left:36.91019160691196%}.row-fluid .offset4:first-child{margin-left:34.25414364640884%;*margin-left:34.14776066768544%}.row-fluid .offset3{margin-left:28.45303867403315%;*margin-left:28.346655695309746%}.row-fluid .offset3:first-child{margin-left:25.69060773480663%;*margin-left:25.584224756083227%}.row-fluid .offset2{margin-left:19.88950276243094%;*margin-left:19.783119783707537%}.row-fluid .offset2:first-child{margin-left:17.12707182320442%;*margin-left:17.02068884448102%}.row-fluid .offset1{margin-left:11.32596685082873%;*margin-left:11.219583872105325%}.row-fluid .offset1:first-child{margin-left:8.56353591160221%;*margin-left:8.457152932878806%}input,textarea,.uneditable-input{margin-left:0}.controls-row [class*="span"]+[class*="span"]{margin-left:20px}input.span12,textarea.span12,.uneditable-input.span12{width:710px}input.span11,textarea.span11,.uneditable-input.span11{width:648px}input.span10,textarea.span10,.uneditable-input.span10{width:586px}input.span9,textarea.span9,.uneditable-input.span9{width:524px}input.span8,textarea.span8,.uneditable-input.span8{width:462px}input.span7,textarea.span7,.uneditable-input.span7{width:400px}input.span6,textarea.span6,.uneditable-input.span6{width:338px}input.span5,textarea.span5,.uneditable-input.span5{width:276px}input.span4,textarea.span4,.uneditable-input.span4{width:214px}input.span3,textarea.span3,.uneditable-input.span3{width:152px}input.span2,textarea.span2,.uneditable-input.span2{width:90px}input.span1,textarea.span1,.uneditable-input.span1{width:28px}}@media(max-width:767px){body{padding-right:20px;padding-left:20px}.navbar-fixed-top,.navbar-fixed-bottom,.navbar-static-top{margin-right:-20px;margin-left:-20px}.container-fluid{padding:0}.dl-horizontal dt{float:none;width:auto;clear:none;text-align:left}.dl-horizontal dd{margin-left:0}.container{width:auto}.row-fluid{width:100%}.row,.thumbnails{margin-left:0}.thumbnails>li{float:none;margin-left:0}[class*="span"],.row-fluid [class*="span"]{display:block;float:none;width:100%;margin-left:0;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}.span12,.row-fluid .span12{width:100%;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}.input-large,.input-xlarge,.input-xxlarge,input[class*="span"],select[class*="span"],textarea[class*="span"],.uneditable-input{display:block;width:100%;min-height:30px;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}.input-prepend input,.input-append input,.input-prepend input[class*="span"],.input-append input[class*="span"]{display:inline-block;width:auto}.controls-row [class*="span"]+[class*="span"]{margin-left:0}.modal{position:fixed;top:20px;right:20px;left:20px;width:auto;margin:0}.modal.fade.in{top:auto}}@media(max-width:480px){.nav-collapse{-webkit-transform:translate3d(0,0,0)}.page-header h1 small{display:block;line-height:20px}input[type="checkbox"],input[type="radio"]{border:1px solid #ccc}.form-horizontal .control-label{float:none;width:auto;padding-top:0;text-align:left}.form-horizontal .controls{margin-left:0}.form-horizontal .control-list{padding-top:0}.form-horizontal .form-actions{padding-right:10px;padding-left:10px}.modal{top:10px;right:10px;left:10px}.modal-header .close{padding:10px;margin:-10px}.carousel-caption{position:static}}@media(max-width:979px){body{padding-top:0}.navbar-fixed-top,.navbar-fixed-bottom{position:static}.navbar-fixed-top{margin-bottom:20px}.navbar-fixed-bottom{margin-top:20px}.navbar-fixed-top .navbar-inner,.navbar-fixed-bottom .navbar-inner{padding:5px}.navbar .container{width:auto;padding:0}.navbar .brand{padding-right:10px;padding-left:10px;margin:0 0 0 -5px}.nav-collapse{clear:both}.nav-collapse .nav{float:none;margin:0 0 10px}.nav-collapse .nav>li{float:none}.nav-collapse .nav>li>a{margin-bottom:2px}.nav-collapse .nav>.divider-vertical{display:none}.nav-collapse .nav .nav-header{color:#777;text-shadow:none}.nav-collapse .nav>li>a,.nav-collapse .dropdown-menu a{padding:9px 15px;font-weight:bold;color:#777;-webkit-border-radius:3px;-moz-border-radius:3px;border-radius:3px}.nav-collapse .btn{padding:4px 10px 4px;font-weight:normal;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px}.nav-collapse .dropdown-menu li+li a{margin-bottom:2px}.nav-collapse .nav>li>a:hover,.nav-collapse .dropdown-menu a:hover{background-color:#f2f2f2}.navbar-inverse .nav-collapse .nav>li>a:hover,.navbar-inverse .nav-collapse .dropdown-menu a:hover{background-color:#111}.nav-collapse.in .btn-group{padding:0;margin-top:5px}.nav-collapse .dropdown-menu{position:static;top:auto;left:auto;display:block;float:none;max-width:none;padding:0;margin:0 15px;background-color:transparent;border:0;-webkit-border-radius:0;-moz-border-radius:0;border-radius:0;-webkit-box-shadow:none;-moz-box-shadow:none;box-shadow:none}.nav-collapse .dropdown-menu:before,.nav-collapse .dropdown-menu:after{display:none}.nav-collapse .dropdown-menu .divider{display:none}.nav-collapse .nav>li>.dropdown-menu:before,.nav-collapse .nav>li>.dropdown-menu:after{display:none}.nav-collapse .navbar-form,.nav-collapse .navbar-search{float:none;padding:10px 15px;margin:10px 0;border-top:1px solid #f2f2f2;border-bottom:1px solid #f2f2f2;-webkit-box-shadow:inset 0 1px 0 rgba(255,255,255,0.1),0 1px 0 rgba(255,255,255,0.1);-moz-box-shadow:inset 0 1px 0 rgba(255,255,255,0.1),0 1px 0 rgba(255,255,255,0.1);box-shadow:inset 0 1px 0 rgba(255,255,255,0.1),0 1px 0 rgba(255,255,255,0.1)}.navbar-inverse .nav-collapse .navbar-form,.navbar-inverse .nav-collapse .navbar-search{border-top-color:#111;border-bottom-color:#111}.navbar .nav-collapse .nav.pull-right{float:none;margin-left:0}.nav-collapse,.nav-collapse.collapse{height:0;overflow:hidden}.navbar .btn-navbar{display:block}.navbar-static .navbar-inner{padding-right:10px;padding-left:10px}}@media(min-width:980px){.nav-collapse.collapse{height:auto!important;overflow:visible!important}}
diff --git a/docs/public/bootstrap/css/bootstrap.css b/docs/public/bootstrap/css/bootstrap.css
new file mode 100644
index 00000000..9fa6f766
--- /dev/null
+++ b/docs/public/bootstrap/css/bootstrap.css
@@ -0,0 +1,5774 @@
+/*!
+ * Bootstrap v2.1.1
+ *
+ * Copyright 2012 Twitter, Inc
+ * Licensed under the Apache License v2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Designed and built with all the love in the world @twitter by @mdo and @fat.
+ */
+
+article,
+aside,
+details,
+figcaption,
+figure,
+footer,
+header,
+hgroup,
+nav,
+section {
+  display: block;
+}
+
+audio,
+canvas,
+video {
+  display: inline-block;
+  *display: inline;
+  *zoom: 1;
+}
+
+audio:not([controls]) {
+  display: none;
+}
+
+html {
+  font-size: 100%;
+  -webkit-text-size-adjust: 100%;
+      -ms-text-size-adjust: 100%;
+}
+
+a:focus {
+  outline: thin dotted #333;
+  outline: 5px auto -webkit-focus-ring-color;
+  outline-offset: -2px;
+}
+
+a:hover,
+a:active {
+  outline: 0;
+}
+
+sub,
+sup {
+  position: relative;
+  font-size: 75%;
+  line-height: 0;
+  vertical-align: baseline;
+}
+
+sup {
+  top: -0.5em;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+img {
+  width: auto\9;
+  height: auto;
+  max-width: 100%;
+  vertical-align: middle;
+  border: 0;
+  -ms-interpolation-mode: bicubic;
+}
+
+#map_canvas img {
+  max-width: none;
+}
+
+button,
+input,
+select,
+textarea {
+  margin: 0;
+  font-size: 100%;
+  vertical-align: middle;
+}
+
+button,
+input {
+  *overflow: visible;
+  line-height: normal;
+}
+
+button::-moz-focus-inner,
+input::-moz-focus-inner {
+  padding: 0;
+  border: 0;
+}
+
+button,
+input[type="button"],
+input[type="reset"],
+input[type="submit"] {
+  cursor: pointer;
+  -webkit-appearance: button;
+}
+
+input[type="search"] {
+  -webkit-box-sizing: content-box;
+     -moz-box-sizing: content-box;
+          box-sizing: content-box;
+  -webkit-appearance: textfield;
+}
+
+input[type="search"]::-webkit-search-decoration,
+input[type="search"]::-webkit-search-cancel-button {
+  -webkit-appearance: none;
+}
+
+textarea {
+  overflow: auto;
+  vertical-align: top;
+}
+
+.clearfix {
+  *zoom: 1;
+}
+
+.clearfix:before,
+.clearfix:after {
+  display: table;
+  line-height: 0;
+  content: "";
+}
+
+.clearfix:after {
+  clear: both;
+}
+
+.hide-text {
+  font: 0/0 a;
+  color: transparent;
+  text-shadow: none;
+  background-color: transparent;
+  border: 0;
+}
+
+.input-block-level {
+  display: block;
+  width: 100%;
+  min-height: 30px;
+  -webkit-box-sizing: border-box;
+     -moz-box-sizing: border-box;
+          box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+  font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+  font-size: 14px;
+  line-height: 20px;
+  color: #333333;
+  background-color: #ffffff;
+}
+
+a {
+  color: #0088cc;
+  text-decoration: none;
+}
+
+a:hover {
+  color: #005580;
+  text-decoration: underline;
+}
+
+.img-rounded {
+  -webkit-border-radius: 6px;
+     -moz-border-radius: 6px;
+          border-radius: 6px;
+}
+
+.img-polaroid {
+  padding: 4px;
+  background-color: #fff;
+  border: 1px solid #ccc;
+  border: 1px solid rgba(0, 0, 0, 0.2);
+  -webkit-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+     -moz-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+          box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+}
+
+.img-circle {
+  -webkit-border-radius: 500px;
+     -moz-border-radius: 500px;
+          border-radius: 500px;
+}
+
+.row {
+  margin-left: -20px;
+  *zoom: 1;
+}
+
+.row:before,
+.row:after {
+  display: table;
+  line-height: 0;
+  content: "";
+}
+
+.row:after {
+  clear: both;
+}
+
+[class*="span"] {
+  float: left;
+  min-height: 1px;
+  margin-left: 20px;
+}
+
+.container,
+.navbar-static-top .container,
+.navbar-fixed-top .container,
+.navbar-fixed-bottom .container {
+  width: 940px;
+}
+
+.span12 {
+  width: 940px;
+}
+
+.span11 {
+  width: 860px;
+}
+
+.span10 {
+  width: 780px;
+}
+
+.span9 {
+  width: 700px;
+}
+
+.span8 {
+  width: 620px;
+}
+
+.span7 {
+  width: 540px;
+}
+
+.span6 {
+  width: 460px;
+}
+
+.span5 {
+  width: 380px;
+}
+
+.span4 {
+  width: 300px;
+}
+
+.span3 {
+  width: 220px;
+}
+
+.span2 {
+  width: 140px;
+}
+
+.span1 {
+  width: 60px;
+}
+
+.offset12 {
+  margin-left: 980px;
+}
+
+.offset11 {
+  margin-left: 900px;
+}
+
+.offset10 {
+  margin-left: 820px;
+}
+
+.offset9 {
+  margin-left: 740px;
+}
+
+.offset8 {
+  margin-left: 660px;
+}
+
+.offset7 {
+  margin-left: 580px;
+}
+
+.offset6 {
+  margin-left: 500px;
+}
+
+.offset5 {
+  margin-left: 420px;
+}
+
+.offset4 {
+  margin-left: 340px;
+}
+
+.offset3 {
+  margin-left: 260px;
+}
+
+.offset2 {
+  margin-left: 180px;
+}
+
+.offset1 {
+  margin-left: 100px;
+}
+
+.row-fluid {
+  width: 100%;
+  *zoom: 1;
+}
+
+.row-fluid:before,
+.row-fluid:after {
+  display: table;
+  line-height: 0;
+  content: "";
+}
+
+.row-fluid:after {
+  clear: both;
+}
+
+.row-fluid [class*="span"] {
+  display: block;
+  float: left;
+  width: 100%;
+  min-height: 30px;
+  margin-left: 2.127659574468085%;
+  *margin-left: 2.074468085106383%;
+  -webkit-box-sizing: border-box;
+     -moz-box-sizing: border-box;
+          box-sizing: border-box;
+}
+
+.row-fluid [class*="span"]:first-child {
+  margin-left: 0;
+}
+
+.row-fluid .span12 {
+  width: 100%;
+  *width: 99.94680851063829%;
+}
+
+.row-fluid .span11 {
+  width: 91.48936170212765%;
+  *width: 91.43617021276594%;
+}
+
+.row-fluid .span10 {
+  width: 82.97872340425532%;
+  *width: 82.92553191489361%;
+}
+
+.row-fluid .span9 {
+  width: 74.46808510638297%;
+  *width: 74.41489361702126%;
+}
+
+.row-fluid .span8 {
+  width: 65.95744680851064%;
+  *width: 65.90425531914893%;
+}
+
+.row-fluid .span7 {
+  width: 57.44680851063829%;
+  *width: 57.39361702127659%;
+}
+
+.row-fluid .span6 {
+  width: 48.93617021276595%;
+  *width: 48.88297872340425%;
+}
+
+.row-fluid .span5 {
+  width: 40.42553191489362%;
+  *width: 40.37234042553192%;
+}
+
+.row-fluid .span4 {
+  width: 31.914893617021278%;
+  *width: 31.861702127659576%;
+}
+
+.row-fluid .span3 {
+  width: 23.404255319148934%;
+  *width: 23.351063829787233%;
+}
+
+.row-fluid .span2 {
+  width: 14.893617021276595%;
+  *width: 14.840425531914894%;
+}
+
+.row-fluid .span1 {
+  width: 6.382978723404255%;
+  *width: 6.329787234042553%;
+}
+
+.row-fluid .offset12 {
+  margin-left: 104.25531914893617%;
+  *margin-left: 104.14893617021275%;
+}
+
+.row-fluid .offset12:first-child {
+  margin-left: 102.12765957446808%;
+  *margin-left: 102.02127659574467%;
+}
+
+.row-fluid .offset11 {
+  margin-left: 95.74468085106382%;
+  *margin-left: 95.6382978723404%;
+}
+
+.row-fluid .offset11:first-child {
+  margin-left: 93.61702127659574%;
+  *margin-left: 93.51063829787232%;
+}
+
+.row-fluid .offset10 {
+  margin-left: 87.23404255319149%;
+  *margin-left: 87.12765957446807%;
+}
+
+.row-fluid .offset10:first-child {
+  margin-left: 85.1063829787234%;
+  *margin-left: 84.99999999999999%;
+}
+
+.row-fluid .offset9 {
+  margin-left: 78.72340425531914%;
+  *margin-left: 78.61702127659572%;
+}
+
+.row-fluid .offset9:first-child {
+  margin-left: 76.59574468085106%;
+  *margin-left: 76.48936170212764%;
+}
+
+.row-fluid .offset8 {
+  margin-left: 70.2127659574468%;
+  *margin-left: 70.10638297872339%;
+}
+
+.row-fluid .offset8:first-child {
+  margin-left: 68.08510638297872%;
+  *margin-left: 67.9787234042553%;
+}
+
+.row-fluid .offset7 {
+  margin-left: 61.70212765957446%;
+  *margin-left: 61.59574468085106%;
+}
+
+.row-fluid .offset7:first-child {
+  margin-left: 59.574468085106375%;
+  *margin-left: 59.46808510638297%;
+}
+
+.row-fluid .offset6 {
+  margin-left: 53.191489361702125%;
+  *margin-left: 53.085106382978715%;
+}
+
+.row-fluid .offset6:first-child {
+  margin-left: 51.063829787234035%;
+  *margin-left: 50.95744680851063%;
+}
+
+.row-fluid .offset5 {
+  margin-left: 44.68085106382979%;
+  *margin-left: 44.57446808510638%;
+}
+
+.row-fluid .offset5:first-child {
+  margin-left: 42.5531914893617%;
+  *margin-left: 42.4468085106383%;
+}
+
+.row-fluid .offset4 {
+  margin-left: 36.170212765957444%;
+  *margin-left: 36.06382978723405%;
+}
+
+.row-fluid .offset4:first-child {
+  margin-left: 34.04255319148936%;
+  *margin-left: 33.93617021276596%;
+}
+
+.row-fluid .offset3 {
+  margin-left: 27.659574468085104%;
+  *margin-left: 27.5531914893617%;
+}
+
+.row-fluid .offset3:first-child {
+  margin-left: 25.53191489361702%;
+  *margin-left: 25.425531914893618%;
+}
+
+.row-fluid .offset2 {
+  margin-left: 19.148936170212764%;
+  *margin-left: 19.04255319148936%;
+}
+
+.row-fluid .offset2:first-child {
+  margin-left: 17.02127659574468%;
+  *margin-left: 16.914893617021278%;
+}
+
+.row-fluid .offset1 {
+  margin-left: 10.638297872340425%;
+  *margin-left: 10.53191489361702%;
+}
+
+.row-fluid .offset1:first-child {
+  margin-left: 8.51063829787234%;
+  *margin-left: 8.404255319148938%;
+}
+
+[class*="span"].hide,
+.row-fluid [class*="span"].hide {
+  display: none;
+}
+
+[class*="span"].pull-right,
+.row-fluid [class*="span"].pull-right {
+  float: right;
+}
+
+.container {
+  margin-right: auto;
+  margin-left: auto;
+  *zoom: 1;
+}
+
+.container:before,
+.container:after {
+  display: table;
+  line-height: 0;
+  content: "";
+}
+
+.container:after {
+  clear: both;
+}
+
+.container-fluid {
+  padding-right: 20px;
+  padding-left: 20px;
+  *zoom: 1;
+}
+
+.container-fluid:before,
+.container-fluid:after {
+  display: table;
+  line-height: 0;
+  content: "";
+}
+
+.container-fluid:after {
+  clear: both;
+}
+
+p {
+  margin: 0 0 10px;
+}
+
+.lead {
+  margin-bottom: 20px;
+  font-size: 21px;
+  font-weight: 200;
+  line-height: 30px;
+}
+
+small {
+  font-size: 85%;
+}
+
+strong {
+  font-weight: bold;
+}
+
+em {
+  font-style: italic;
+}
+
+cite {
+  font-style: normal;
+}
+
+.muted {
+  color: #999999;
+}
+
+.text-warning {
+  color: #c09853;
+}
+
+.text-error {
+  color: #b94a48;
+}
+
+.text-info {
+  color: #3a87ad;
+}
+
+.text-success {
+  color: #468847;
+}
+
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+  margin: 10px 0;
+  font-family: inherit;
+  font-weight: bold;
+  line-height: 1;
+  color: inherit;
+  text-rendering: optimizelegibility;
+}
+
+h1 small,
+h2 small,
+h3 small,
+h4 small,
+h5 small,
+h6 small {
+  font-weight: normal;
+  line-height: 1;
+  color: #999999;
+}
+
+h1 {
+  font-size: 36px;
+  line-height: 40px;
+}
+
+h2 {
+  font-size: 30px;
+  line-height: 40px;
+}
+
+h3 {
+  font-size: 24px;
+  line-height: 40px;
+}
+
+h4 {
+  font-size: 18px;
+  line-height: 20px;
+}
+
+h5 {
+  font-size: 14px;
+  line-height: 20px;
+}
+
+h6 {
+  font-size: 12px;
+  line-height: 20px;
+}
+
+h1 small {
+  font-size: 24px;
+}
+
+h2 small {
+  font-size: 18px;
+}
+
+h3 small {
+  font-size: 14px;
+}
+
+h4 small {
+  font-size: 14px;
+}
+
+.page-header {
+  padding-bottom: 9px;
+  margin: 20px 0 30px;
+  border-bottom: 1px solid #eeeeee;
+}
+
+ul,
+ol {
+  padding: 0;
+  margin: 0 0 10px 25px;
+}
+
+ul ul,
+ul ol,
+ol ol,
+ol ul {
+  margin-bottom: 0;
+}
+
+li {
+  line-height: 20px;
+}
+
+ul.unstyled,
+ol.unstyled {
+  margin-left: 0;
+  list-style: none;
+}
+
+dl {
+  margin-bottom: 20px;
+}
+
+dt,
+dd {
+  line-height: 20px;
+}
+
+dt {
+  font-weight: bold;
+}
+
+dd {
+  margin-left: 10px;
+}
+
+.dl-horizontal {
+  *zoom: 1;
+}
+
+.dl-horizontal:before,
+.dl-horizontal:after {
+  display: table;
+  line-height: 0;
+  content: "";
+}
+
+.dl-horizontal:after {
+  clear: both;
+}
+
+.dl-horizontal dt {
+  float: left;
+  width: 160px;
+  overflow: hidden;
+  clear: left;
+  text-align: right;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.dl-horizontal dd {
+  margin-left: 180px;
+}
+
+hr {
+  margin: 20px 0;
+  border: 0;
+  border-top: 1px solid #eeeeee;
+  border-bottom: 1px solid #ffffff;
+}
+
+abbr[title] {
+  cursor: help;
+  border-bottom: 1px dotted #999999;
+}
+
+abbr.initialism {
+  font-size: 90%;
+  text-transform: uppercase;
+}
+
+blockquote {
+  padding: 0 0 0 15px;
+  margin: 0 0 20px;
+  border-left: 5px solid #eeeeee;
+}
+
+blockquote p {
+  margin-bottom: 0;
+  font-size: 16px;
+  font-weight: 300;
+  line-height: 25px;
+}
+
+blockquote small {
+  display: block;
+  line-height: 20px;
+  color: #999999;
+}
+
+blockquote small:before {
+  content: '\2014 \00A0';
+}
+
+blockquote.pull-right {
+  float: right;
+  padding-right: 15px;
+  padding-left: 0;
+  border-right: 5px solid #eeeeee;
+  border-left: 0;
+}
+
+blockquote.pull-right p,
+blockquote.pull-right small {
+  text-align: right;
+}
+
+blockquote.pull-right small:before {
+  content: '';
+}
+
+blockquote.pull-right small:after {
+  content: '\00A0 \2014';
+}
+
+q:before,
+q:after,
+blockquote:before,
+blockquote:after {
+  content: "";
+}
+
+address {
+  display: block;
+  margin-bottom: 20px;
+  font-style: normal;
+  line-height: 20px;
+}
+
+code,
+pre {
+  padding: 0 3px 2px;
+  font-family: Monaco, Menlo, Consolas, "Courier New", monospace;
+  font-size: 12px;
+  color: #333333;
+  -webkit-border-radius: 3px;
+     -moz-border-radius: 3px;
+          border-radius: 3px;
+}
+
+code {
+  padding: 2px 4px;
+  color: #d14;
+  background-color: #f7f7f9;
+  border: 1px solid #e1e1e8;
+}
+
+pre {
+  display: block;
+  padding: 9.5px;
+  margin: 0 0 10px;
+  font-size: 13px;
+  line-height: 20px;
+  word-break: break-all;
+  word-wrap: break-word;
+  white-space: pre;
+  white-space: pre-wrap;
+  background-color: #f5f5f5;
+  border: 1px solid #ccc;
+  border: 1px solid rgba(0, 0, 0, 0.15);
+  -webkit-border-radius: 4px;
+     -moz-border-radius: 4px;
+          border-radius: 4px;
+}
+
+pre.prettyprint {
+  margin-bottom: 20px;
+}
+
+pre code {
+  padding: 0;
+  color: inherit;
+  background-color: transparent;
+  border: 0;
+}
+
+.pre-scrollable {
+  max-height: 340px;
+  overflow-y: scroll;
+}
+
+form {
+  margin: 0 0 20px;
+}
+
+fieldset {
+  padding: 0;
+  margin: 0;
+  border: 0;
+}
+
+legend {
+  display: block;
+  width: 100%;
+  padding: 0;
+  margin-bottom: 20px;
+  font-size: 21px;
+  line-height: 40px;
+  color: #333333;
+  border: 0;
+  border-bottom: 1px solid #e5e5e5;
+}
+
+legend small {
+  font-size: 15px;
+  color: #999999;
+}
+
+label,
+input,
+button,
+select,
+textarea {
+  font-size: 14px;
+  font-weight: normal;
+  line-height: 20px;
+}
+
+input,
+button,
+select,
+textarea {
+  font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+}
+
+label {
+  display: block;
+  margin-bottom: 5px;
+}
+
+select,
+textarea,
+input[type="text"],
+input[type="password"],
+input[type="datetime"],
+input[type="datetime-local"],
+input[type="date"],
+input[type="month"],
+input[type="time"],
+input[type="week"],
+input[type="number"],
+input[type="email"],
+input[type="url"],
+input[type="search"],
+input[type="tel"],
+input[type="color"],
+.uneditable-input {
+  display: inline-block;
+  height: 20px;
+  padding: 4px 6px;
+  margin-bottom: 9px;
+  font-size: 14px;
+  line-height: 20px;
+  color: #555555;
+  -webkit-border-radius: 3px;
+     -moz-border-radius: 3px;
+          border-radius: 3px;
+}
+
+input,
+textarea,
+.uneditable-input {
+  width: 206px;
+}
+
+textarea {
+  height: auto;
+}
+
+textarea,
+input[type="text"],
+input[type="password"],
+input[type="datetime"],
+input[type="datetime-local"],
+input[type="date"],
+input[type="month"],
+input[type="time"],
+input[type="week"],
+input[type="number"],
+input[type="email"],
+input[type="url"],
+input[type="search"],
+input[type="tel"],
+input[type="color"],
+.uneditable-input {
+  background-color: #ffffff;
+  border: 1px solid #cccccc;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  -webkit-transition: border linear 0.2s, box-shadow linear 0.2s;
+     -moz-transition: border linear 0.2s, box-shadow linear 0.2s;
+       -o-transition: border linear 0.2s, box-shadow linear 0.2s;
+          transition: border linear 0.2s, box-shadow linear 0.2s;
+}
+
+textarea:focus,
+input[type="text"]:focus,
+input[type="password"]:focus,
+input[type="datetime"]:focus,
+input[type="datetime-local"]:focus,
+input[type="date"]:focus,
+input[type="month"]:focus,
+input[type="time"]:focus,
+input[type="week"]:focus,
+input[type="number"]:focus,
+input[type="email"]:focus,
+input[type="url"]:focus,
+input[type="search"]:focus,
+input[type="tel"]:focus,
+input[type="color"]:focus,
+.uneditable-input:focus {
+  border-color: rgba(82, 168, 236, 0.8);
+  outline: 0;
+  outline: thin dotted \9;
+  /* IE6-9 */
+
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 8px rgba(82, 168, 236, 0.6);
+     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 8px rgba(82, 168, 236, 0.6);
+          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 8px rgba(82, 168, 236, 0.6);
+}
+
+input[type="radio"],
+input[type="checkbox"] {
+  margin: 4px 0 0;
+  margin-top: 1px \9;
+  *margin-top: 0;
+  line-height: normal;
+  cursor: pointer;
+}
+
+input[type="file"],
+input[type="image"],
+input[type="submit"],
+input[type="reset"],
+input[type="button"],
+input[type="radio"],
+input[type="checkbox"] {
+  width: auto;
+}
+
+select,
+input[type="file"] {
+  height: 30px;
+  /* In IE7, the height of the select element cannot be changed by height, only font-size */
+
+  *margin-top: 4px;
+  /* For IE7, add top margin to align select with labels */
+
+  line-height: 30px;
+}
+
+select {
+  width: 220px;
+  background-color: #ffffff;
+  border: 1px solid #cccccc;
+}
+
+select[multiple],
+select[size] {
+  height: auto;
+}
+
+select:focus,
+input[type="file"]:focus,
+input[type="radio"]:focus,
+input[type="checkbox"]:focus {
+  outline: thin dotted #333;
+  outline: 5px auto -webkit-focus-ring-color;
+  outline-offset: -2px;
+}
+
+.uneditable-input,
+.uneditable-textarea {
+  color: #999999;
+  cursor: not-allowed;
+  background-color: #fcfcfc;
+  border-color: #cccccc;
+  -webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.025);
+     -moz-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.025);
+          box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.025);
+}
+
+.uneditable-input {
+  overflow: hidden;
+  white-space: nowrap;
+}
+
+.uneditable-textarea {
+  width: auto;
+  height: auto;
+}
+
+input:-moz-placeholder,
+textarea:-moz-placeholder {
+  color: #999999;
+}
+
+input:-ms-input-placeholder,
+textarea:-ms-input-placeholder {
+  color: #999999;
+}
+
+input::-webkit-input-placeholder,
+textarea::-webkit-input-placeholder {
+  color: #999999;
+}
+
+.radio,
+.checkbox {
+  min-height: 18px;
+  padding-left: 18px;
+}
+
+.radio input[type="radio"],
+.checkbox input[type="checkbox"] {
+  float: left;
+  margin-left: -18px;
+}
+
+.controls > .radio:first-child,
+.controls > .checkbox:first-child {
+  padding-top: 5px;
+}
+
+.radio.inline,
+.checkbox.inline {
+  display: inline-block;
+  padding-top: 5px;
+  margin-bottom: 0;
+  vertical-align: middle;
+}
+
+.radio.inline + .radio.inline,
+.checkbox.inline + .checkbox.inline {
+  margin-left: 10px;
+}
+
+.input-mini {
+  width: 60px;
+}
+
+.input-small {
+  width: 90px;
+}
+
+.input-medium {
+  width: 150px;
+}
+
+.input-large {
+  width: 210px;
+}
+
+.input-xlarge {
+  width: 270px;
+}
+
+.input-xxlarge {
+  width: 530px;
+}
+
+input[class*="span"],
+select[class*="span"],
+textarea[class*="span"],
+.uneditable-input[class*="span"],
+.row-fluid input[class*="span"],
+.row-fluid select[class*="span"],
+.row-fluid textarea[class*="span"],
+.row-fluid .uneditable-input[class*="span"] {
+  float: none;
+  margin-left: 0;
+}
+
+.input-append input[class*="span"],
+.input-append .uneditable-input[class*="span"],
+.input-prepend input[class*="span"],
+.input-prepend .uneditable-input[class*="span"],
+.row-fluid input[class*="span"],
+.row-fluid select[class*="span"],
+.row-fluid textarea[class*="span"],
+.row-fluid .uneditable-input[class*="span"],
+.row-fluid .input-prepend [class*="span"],
+.row-fluid .input-append [class*="span"] {
+  display: inline-block;
+}
+
+input,
+textarea,
+.uneditable-input {
+  margin-left: 0;
+}
+
+.controls-row [class*="span"] + [class*="span"] {
+  margin-left: 20px;
+}
+
+input.span12,
+textarea.span12,
+.uneditable-input.span12 {
+  width: 926px;
+}
+
+input.span11,
+textarea.span11,
+.uneditable-input.span11 {
+  width: 846px;
+}
+
+input.span10,
+textarea.span10,
+.uneditable-input.span10 {
+  width: 766px;
+}
+
+input.span9,
+textarea.span9,
+.uneditable-input.span9 {
+  width: 686px;
+}
+
+input.span8,
+textarea.span8,
+.uneditable-input.span8 {
+  width: 606px;
+}
+
+input.span7,
+textarea.span7,
+.uneditable-input.span7 {
+  width: 526px;
+}
+
+input.span6,
+textarea.span6,
+.uneditable-input.span6 {
+  width: 446px;
+}
+
+input.span5,
+textarea.span5,
+.uneditable-input.span5 {
+  width: 366px;
+}
+
+input.span4,
+textarea.span4,
+.uneditable-input.span4 {
+  width: 286px;
+}
+
+input.span3,
+textarea.span3,
+.uneditable-input.span3 {
+  width: 206px;
+}
+
+input.span2,
+textarea.span2,
+.uneditable-input.span2 {
+  width: 126px;
+}
+
+input.span1,
+textarea.span1,
+.uneditable-input.span1 {
+  width: 46px;
+}
+
+.controls-row {
+  *zoom: 1;
+}
+
+.controls-row:before,
+.controls-row:after {
+  display: table;
+  line-height: 0;
+  content: "";
+}
+
+.controls-row:after {
+  clear: both;
+}
+
+.controls-row [class*="span"] {
+  float: left;
+}
+
+input[disabled],
+select[disabled],
+textarea[disabled],
+input[readonly],
+select[readonly],
+textarea[readonly] {
+  cursor: not-allowed;
+  background-color: #eeeeee;
+}
+
+input[type="radio"][disabled],
+input[type="checkbox"][disabled],
+input[type="radio"][readonly],
+input[type="checkbox"][readonly] {
+  background-color: transparent;
+}
+
+.control-group.warning > label,
+.control-group.warning .help-block,
+.control-group.warning .help-inline {
+  color: #c09853;
+}
+
+.control-group.warning .checkbox,
+.control-group.warning .radio,
+.control-group.warning input,
+.control-group.warning select,
+.control-group.warning textarea {
+  color: #c09853;
+}
+
+.control-group.warning input,
+.control-group.warning select,
+.control-group.warning textarea {
+  border-color: #c09853;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+}
+
+.control-group.warning input:focus,
+.control-group.warning select:focus,
+.control-group.warning textarea:focus {
+  border-color: #a47e3c;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #dbc59e;
+     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #dbc59e;
+          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #dbc59e;
+}
+
+.control-group.warning .input-prepend .add-on,
+.control-group.warning .input-append .add-on {
+  color: #c09853;
+  background-color: #fcf8e3;
+  border-color: #c09853;
+}
+
+.control-group.error > label,
+.control-group.error .help-block,
+.control-group.error .help-inline {
+  color: #b94a48;
+}
+
+.control-group.error .checkbox,
+.control-group.error .radio,
+.control-group.error input,
+.control-group.error select,
+.control-group.error textarea {
+  color: #b94a48;
+}
+
+.control-group.error input,
+.control-group.error select,
+.control-group.error textarea {
+  border-color: #b94a48;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+}
+
+.control-group.error input:focus,
+.control-group.error select:focus,
+.control-group.error textarea:focus {
+  border-color: #953b39;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #d59392;
+     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #d59392;
+          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #d59392;
+}
+
+.control-group.error .input-prepend .add-on,
+.control-group.error .input-append .add-on {
+  color: #b94a48;
+  background-color: #f2dede;
+  border-color: #b94a48;
+}
+
+.control-group.success > label,
+.control-group.success .help-block,
+.control-group.success .help-inline {
+  color: #468847;
+}
+
+.control-group.success .checkbox,
+.control-group.success .radio,
+.control-group.success input,
+.control-group.success select,
+.control-group.success textarea {
+  color: #468847;
+}
+
+.control-group.success input,
+.control-group.success select,
+.control-group.success textarea {
+  border-color: #468847;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+}
+
+.control-group.success input:focus,
+.control-group.success select:focus,
+.control-group.success textarea:focus {
+  border-color: #356635;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #7aba7b;
+     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #7aba7b;
+          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #7aba7b;
+}
+
+.control-group.success .input-prepend .add-on,
+.control-group.success .input-append .add-on {
+  color: #468847;
+  background-color: #dff0d8;
+  border-color: #468847;
+}
+
+.control-group.info > label,
+.control-group.info .help-block,
+.control-group.info .help-inline {
+  color: #3a87ad;
+}
+
+.control-group.info .checkbox,
+.control-group.info .radio,
+.control-group.info input,
+.control-group.info select,
+.control-group.info textarea {
+  color: #3a87ad;
+}
+
+.control-group.info input,
+.control-group.info select,
+.control-group.info textarea {
+  border-color: #3a87ad;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+}
+
+.control-group.info input:focus,
+.control-group.info select:focus,
+.control-group.info textarea:focus {
+  border-color: #2d6987;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #7ab5d3;
+     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #7ab5d3;
+          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #7ab5d3;
+}
+
+.control-group.info .input-prepend .add-on,
+.control-group.info .input-append .add-on {
+  color: #3a87ad;
+  background-color: #d9edf7;
+  border-color: #3a87ad;
+}
+
+input:focus:required:invalid,
+textarea:focus:required:invalid,
+select:focus:required:invalid {
+  color: #b94a48;
+  border-color: #ee5f5b;
+}
+
+input:focus:required:invalid:focus,
+textarea:focus:required:invalid:focus,
+select:focus:required:invalid:focus {
+  border-color: #e9322d;
+  -webkit-box-shadow: 0 0 6px #f8b9b7;
+     -moz-box-shadow: 0 0 6px #f8b9b7;
+          box-shadow: 0 0 6px #f8b9b7;
+}
+
+.form-actions {
+  padding: 19px 20px 20px;
+  margin-top: 20px;
+  margin-bottom: 20px;
+  background-color: #f5f5f5;
+  border-top: 1px solid #e5e5e5;
+  *zoom: 1;
+}
+
+.form-actions:before,
+.form-actions:after {
+  display: table;
+  line-height: 0;
+  content: "";
+}
+
+.form-actions:after {
+  clear: both;
+}
+
+.help-block,
+.help-inline {
+  color: #595959;
+}
+
+.help-block {
+  display: block;
+  margin-bottom: 10px;
+}
+
+.help-inline {
+  display: inline-block;
+  *display: inline;
+  padding-left: 5px;
+  vertical-align: middle;
+  *zoom: 1;
+}
+
+.input-append,
+.input-prepend {
+  margin-bottom: 5px;
+  font-size: 0;
+  white-space: nowrap;
+}
+
+.input-append input,
+.input-prepend input,
+.input-append select,
+.input-prepend select,
+.input-append .uneditable-input,
+.input-prepend .uneditable-input {
+  position: relative;
+  margin-bottom: 0;
+  *margin-left: 0;
+  font-size: 14px;
+  vertical-align: top;
+  -webkit-border-radius: 0 3px 3px 0;
+     -moz-border-radius: 0 3px 3px 0;
+          border-radius: 0 3px 3px 0;
+}
+
+.input-append input:focus,
+.input-prepend input:focus,
+.input-append select:focus,
+.input-prepend select:focus,
+.input-append .uneditable-input:focus,
+.input-prepend .uneditable-input:focus {
+  z-index: 2;
+}
+
+.input-append .add-on,
+.input-prepend .add-on {
+  display: inline-block;
+  width: auto;
+  height: 20px;
+  min-width: 16px;
+  padding: 4px 5px;
+  font-size: 14px;
+  font-weight: normal;
+  line-height: 20px;
+  text-align: center;
+  text-shadow: 0 1px 0 #ffffff;
+  background-color: #eeeeee;
+  border: 1px solid #ccc;
+}
+
+.input-append .add-on,
+.input-prepend .add-on,
+.input-append .btn,
+.input-prepend .btn {
+  vertical-align: top;
+  -webkit-border-radius: 0;
+     -moz-border-radius: 0;
+          border-radius: 0;
+}
+
+.input-append .active,
+.input-prepend .active {
+  background-color: #a9dba9;
+  border-color: #46a546;
+}
+
+.input-prepend .add-on,
+.input-prepend .btn {
+  margin-right: -1px;
+}
+
+.input-prepend .add-on:first-child,
+.input-prepend .btn:first-child {
+  -webkit-border-radius: 3px 0 0 3px;
+     -moz-border-radius: 3px 0 0 3px;
+          border-radius: 3px 0 0 3px;
+}
+
+.input-append input,
+.input-append select,
+.input-append .uneditable-input {
+  -webkit-border-radius: 3px 0 0 3px;
+     -moz-border-radius: 3px 0 0 3px;
+          border-radius: 3px 0 0 3px;
+}
+
+.input-append .add-on,
+.input-append .btn {
+  margin-left: -1px;
+}
+
+.input-append .add-on:last-child,
+.input-append .btn:last-child {
+  -webkit-border-radius: 0 3px 3px 0;
+     -moz-border-radius: 0 3px 3px 0;
+          border-radius: 0 3px 3px 0;
+}
+
+.input-prepend.input-append input,
+.input-prepend.input-append select,
+.input-prepend.input-append .uneditable-input {
+  -webkit-border-radius: 0;
+     -moz-border-radius: 0;
+          border-radius: 0;
+}
+
+.input-prepend.input-append .add-on:first-child,
+.input-prepend.input-append .btn:first-child {
+  margin-right: -1px;
+  -webkit-border-radius: 3px 0 0 3px;
+     -moz-border-radius: 3px 0 0 3px;
+          border-radius: 3px 0 0 3px;
+}
+
+.input-prepend.input-append .add-on:last-child,
+.input-prepend.input-append .btn:last-child {
+  margin-left: -1px;
+  -webkit-border-radius: 0 3px 3px 0;
+     -moz-border-radius: 0 3px 3px 0;
+          border-radius: 0 3px 3px 0;
+}
+
+input.search-query {
+  padding-right: 14px;
+  padding-right: 4px \9;
+  padding-left: 14px;
+  padding-left: 4px \9;
+  /* IE7-8 doesn't have border-radius, so don't indent the padding */
+
+  margin-bottom: 0;
+  -webkit-border-radius: 15px;
+     -moz-border-radius: 15px;
+          border-radius: 15px;
+}
+
+/* Allow for input prepend/append in search forms */
+
+.form-search .input-append .search-query,
+.form-search .input-prepend .search-query {
+  -webkit-border-radius: 0;
+     -moz-border-radius: 0;
+          border-radius: 0;
+}
+
+.form-search .input-append .search-query {
+  -webkit-border-radius: 14px 0 0 14px;
+     -moz-border-radius: 14px 0 0 14px;
+          border-radius: 14px 0 0 14px;
+}
+
+.form-search .input-append .btn {
+  -webkit-border-radius: 0 14px 14px 0;
+     -moz-border-radius: 0 14px 14px 0;
+          border-radius: 0 14px 14px 0;
+}
+
+.form-search .input-prepend .search-query {
+  -webkit-border-radius: 0 14px 14px 0;
+     -moz-border-radius: 0 14px 14px 0;
+          border-radius: 0 14px 14px 0;
+}
+
+.form-search .input-prepend .btn {
+  -webkit-border-radius: 14px 0 0 14px;
+     -moz-border-radius: 14px 0 0 14px;
+          border-radius: 14px 0 0 14px;
+}
+
+.form-search input,
+.form-inline input,
+.form-horizontal input,
+.form-search textarea,
+.form-inline textarea,
+.form-horizontal textarea,
+.form-search select,
+.form-inline select,
+.form-horizontal select,
+.form-search .help-inline,
+.form-inline .help-inline,
+.form-horizontal .help-inline,
+.form-search .uneditable-input,
+.form-inline .uneditable-input,
+.form-horizontal .uneditable-input,
+.form-search .input-prepend,
+.form-inline .input-prepend,
+.form-horizontal .input-prepend,
+.form-search .input-append,
+.form-inline .input-append,
+.form-horizontal .input-append {
+  display: inline-block;
+  *display: inline;
+  margin-bottom: 0;
+  vertical-align: middle;
+  *zoom: 1;
+}
+
+.form-search .hide,
+.form-inline .hide,
+.form-horizontal .hide {
+  display: none;
+}
+
+.form-search label,
+.form-inline label,
+.form-search .btn-group,
+.form-inline .btn-group {
+  display: inline-block;
+}
+
+.form-search .input-append,
+.form-inline .input-append,
+.form-search .input-prepend,
+.form-inline .input-prepend {
+  margin-bottom: 0;
+}
+
+.form-search .radio,
+.form-search .checkbox,
+.form-inline .radio,
+.form-inline .checkbox {
+  padding-left: 0;
+  margin-bottom: 0;
+  vertical-align: middle;
+}
+
+.form-search .radio input[type="radio"],
+.form-search .checkbox input[type="checkbox"],
+.form-inline .radio input[type="radio"],
+.form-inline .checkbox input[type="checkbox"] {
+  float: left;
+  margin-right: 3px;
+  margin-left: 0;
+}
+
+.control-group {
+  margin-bottom: 10px;
+}
+
+legend + .control-group {
+  margin-top: 20px;
+  -webkit-margin-top-collapse: separate;
+}
+
+.form-horizontal .control-group {
+  margin-bottom: 20px;
+  *zoom: 1;
+}
+
+.form-horizontal .control-group:before,
+.form-horizontal .control-group:after {
+  display: table;
+  line-height: 0;
+  content: "";
+}
+
+.form-horizontal .control-group:after {
+  clear: both;
+}
+
+.form-horizontal .control-label {
+  float: left;
+  width: 160px;
+  padding-top: 5px;
+  text-align: right;
+}
+
+.form-horizontal .controls {
+  *display: inline-block;
+  *padding-left: 20px;
+  margin-left: 180px;
+  *margin-left: 0;
+}
+
+.form-horizontal .controls:first-child {
+  *padding-left: 180px;
+}
+
+.form-horizontal .help-block {
+  margin-bottom: 0;
+}
+
+.form-horizontal input + .help-block,
+.form-horizontal select + .help-block,
+.form-horizontal textarea + .help-block {
+  margin-top: 10px;
+}
+
+.form-horizontal .form-actions {
+  padding-left: 180px;
+}
+
+table {
+  max-width: 100%;
+  background-color: transparent;
+  border-collapse: collapse;
+  border-spacing: 0;
+}
+
+.table {
+  width: 100%;
+  margin-bottom: 20px;
+}
+
+.table th,
+.table td {
+  padding: 8px;
+  line-height: 20px;
+  text-align: left;
+  vertical-align: top;
+  border-top: 1px solid #dddddd;
+}
+
+.table th {
+  font-weight: bold;
+}
+
+.table thead th {
+  vertical-align: bottom;
+}
+
+.table caption + thead tr:first-child th,
+.table caption + thead tr:first-child td,
+.table colgroup + thead tr:first-child th,
+.table colgroup + thead tr:first-child td,
+.table thead:first-child tr:first-child th,
+.table thead:first-child tr:first-child td {
+  border-top: 0;
+}
+
+.table tbody + tbody {
+  border-top: 2px solid #dddddd;
+}
+
+.table-condensed th,
+.table-condensed td {
+  padding: 4px 5px;
+}
+
+.table-bordered {
+  border: 1px solid #dddddd;
+  border-collapse: separate;
+  *border-collapse: collapse;
+  border-left: 0;
+  -webkit-border-radius: 4px;
+     -moz-border-radius: 4px;
+          border-radius: 4px;
+}
+
+.table-bordered th,
+.table-bordered td {
+  border-left: 1px solid #dddddd;
+}
+
+.table-bordered caption + thead tr:first-child th,
+.table-bordered caption + tbody tr:first-child th,
+.table-bordered caption + tbody tr:first-child td,
+.table-bordered colgroup + thead tr:first-child th,
+.table-bordered colgroup + tbody tr:first-child th,
+.table-bordered colgroup + tbody tr:first-child td,
+.table-bordered thead:first-child tr:first-child th,
+.table-bordered tbody:first-child tr:first-child th,
+.table-bordered tbody:first-child tr:first-child td {
+  border-top: 0;
+}
+
+.table-bordered thead:first-child tr:first-child th:first-child,
+.table-bordered tbody:first-child tr:first-child td:first-child {
+  -webkit-border-top-left-radius: 4px;
+          border-top-left-radius: 4px;
+  -moz-border-radius-topleft: 4px;
+}
+
+.table-bordered thead:first-child tr:first-child th:last-child,
+.table-bordered tbody:first-child tr:first-child td:last-child {
+  -webkit-border-top-right-radius: 4px;
+          border-top-right-radius: 4px;
+  -moz-border-radius-topright: 4px;
+}
+
+.table-bordered thead:last-child tr:last-child th:first-child,
+.table-bordered tbody:last-child tr:last-child td:first-child,
+.table-bordered tfoot:last-child tr:last-child td:first-child {
+  -webkit-border-radius: 0 0 0 4px;
+     -moz-border-radius: 0 0 0 4px;
+          border-radius: 0 0 0 4px;
+  -webkit-border-bottom-left-radius: 4px;
+          border-bottom-left-radius: 4px;
+  -moz-border-radius-bottomleft: 4px;
+}
+
+.table-bordered thead:last-child tr:last-child th:last-child,
+.table-bordered tbody:last-child tr:last-child td:last-child,
+.table-bordered tfoot:last-child tr:last-child td:last-child {
+  -webkit-border-bottom-right-radius: 4px;
+          border-bottom-right-radius: 4px;
+  -moz-border-radius-bottomright: 4px;
+}
+
+.table-bordered caption + thead tr:first-child th:first-child,
+.table-bordered caption + tbody tr:first-child td:first-child,
+.table-bordered colgroup + thead tr:first-child th:first-child,
+.table-bordered colgroup + tbody tr:first-child td:first-child {
+  -webkit-border-top-left-radius: 4px;
+          border-top-left-radius: 4px;
+  -moz-border-radius-topleft: 4px;
+}
+
+.table-bordered caption + thead tr:first-child th:last-child,
+.table-bordered caption + tbody tr:first-child td:last-child,
+.table-bordered colgroup + thead tr:first-child th:last-child,
+.table-bordered colgroup + tbody tr:first-child td:last-child {
+  -webkit-border-top-right-radius: 4px;
+          border-top-right-radius: 4px;
+  -moz-border-radius-topleft: 4px;
+}
+
+.table-striped tbody tr:nth-child(odd) td,
+.table-striped tbody tr:nth-child(odd) th {
+  background-color: #f9f9f9;
+}
+
+.table-hover tbody tr:hover td,
+.table-hover tbody tr:hover th {
+  background-color: #f5f5f5;
+}
+
+table [class*=span],
+.row-fluid table [class*=span] {
+  display: table-cell;
+  float: none;
+  margin-left: 0;
+}
+
+.table .span1 {
+  float: none;
+  width: 44px;
+  margin-left: 0;
+}
+
+.table .span2 {
+  float: none;
+  width: 124px;
+  margin-left: 0;
+}
+
+.table .span3 {
+  float: none;
+  width: 204px;
+  margin-left: 0;
+}
+
+.table .span4 {
+  float: none;
+  width: 284px;
+  margin-left: 0;
+}
+
+.table .span5 {
+  float: none;
+  width: 364px;
+  margin-left: 0;
+}
+
+.table .span6 {
+  float: none;
+  width: 444px;
+  margin-left: 0;
+}
+
+.table .span7 {
+  float: none;
+  width: 524px;
+  margin-left: 0;
+}
+
+.table .span8 {
+  float: none;
+  width: 604px;
+  margin-left: 0;
+}
+
+.table .span9 {
+  float: none;
+  width: 684px;
+  margin-left: 0;
+}
+
+.table .span10 {
+  float: none;
+  width: 764px;
+  margin-left: 0;
+}
+
+.table .span11 {
+  float: none;
+  width: 844px;
+  margin-left: 0;
+}
+
+.table .span12 {
+  float: none;
+  width: 924px;
+  margin-left: 0;
+}
+
+.table .span13 {
+  float: none;
+  width: 1004px;
+  margin-left: 0;
+}
+
+.table .span14 {
+  float: none;
+  width: 1084px;
+  margin-left: 0;
+}
+
+.table .span15 {
+  float: none;
+  width: 1164px;
+  margin-left: 0;
+}
+
+.table .span16 {
+  float: none;
+  width: 1244px;
+  margin-left: 0;
+}
+
+.table .span17 {
+  float: none;
+  width: 1324px;
+  margin-left: 0;
+}
+
+.table .span18 {
+  float: none;
+  width: 1404px;
+  margin-left: 0;
+}
+
+.table .span19 {
+  float: none;
+  width: 1484px;
+  margin-left: 0;
+}
+
+.table .span20 {
+  float: none;
+  width: 1564px;
+  margin-left: 0;
+}
+
+.table .span21 {
+  float: none;
+  width: 1644px;
+  margin-left: 0;
+}
+
+.table .span22 {
+  float: none;
+  width: 1724px;
+  margin-left: 0;
+}
+
+.table .span23 {
+  float: none;
+  width: 1804px;
+  margin-left: 0;
+}
+
+.table .span24 {
+  float: none;
+  width: 1884px;
+  margin-left: 0;
+}
+
+.table tbody tr.success td {
+  background-color: #dff0d8;
+}
+
+.table tbody tr.error td {
+  background-color: #f2dede;
+}
+
+.table tbody tr.warning td {
+  background-color: #fcf8e3;
+}
+
+.table tbody tr.info td {
+  background-color: #d9edf7;
+}
+
+.table-hover tbody tr.success:hover td {
+  background-color: #d0e9c6;
+}
+
+.table-hover tbody tr.error:hover td {
+  background-color: #ebcccc;
+}
+
+.table-hover tbody tr.warning:hover td {
+  background-color: #faf2cc;
+}
+
+.table-hover tbody tr.info:hover td {
+  background-color: #c4e3f3;
+}
+
+[class^="icon-"],
+[class*=" icon-"] {
+  display: inline-block;
+  width: 14px;
+  height: 14px;
+  margin-top: 1px;
+  *margin-right: .3em;
+  line-height: 14px;
+  vertical-align: text-top;
+  background-image: url("../img/glyphicons-halflings.png");
+  background-position: 14px 14px;
+  background-repeat: no-repeat;
+}
+
+/* White icons with optional class, or on hover/active states of certain elements */
+
+.icon-white,
+.nav-tabs > .active > a > [class^="icon-"],
+.nav-tabs > .active > a > [class*=" icon-"],
+.nav-pills > .active > a > [class^="icon-"],
+.nav-pills > .active > a > [class*=" icon-"],
+.nav-list > .active > a > [class^="icon-"],
+.nav-list > .active > a > [class*=" icon-"],
+.navbar-inverse .nav > .active > a > [class^="icon-"],
+.navbar-inverse .nav > .active > a > [class*=" icon-"],
+.dropdown-menu > li > a:hover > [class^="icon-"],
+.dropdown-menu > li > a:hover > [class*=" icon-"],
+.dropdown-menu > .active > a > [class^="icon-"],
+.dropdown-menu > .active > a > [class*=" icon-"] {
+  background-image: url("../img/glyphicons-halflings-white.png");
+}
+
+.icon-glass {
+  background-position: 0      0;
+}
+
+.icon-music {
+  background-position: -24px 0;
+}
+
+.icon-search {
+  background-position: -48px 0;
+}
+
+.icon-envelope {
+  background-position: -72px 0;
+}
+
+.icon-heart {
+  background-position: -96px 0;
+}
+
+.icon-star {
+  background-position: -120px 0;
+}
+
+.icon-star-empty {
+  background-position: -144px 0;
+}
+
+.icon-user {
+  background-position: -168px 0;
+}
+
+.icon-film {
+  background-position: -192px 0;
+}
+
+.icon-th-large {
+  background-position: -216px 0;
+}
+
+.icon-th {
+  background-position: -240px 0;
+}
+
+.icon-th-list {
+  background-position: -264px 0;
+}
+
+.icon-ok {
+  background-position: -288px 0;
+}
+
+.icon-remove {
+  background-position: -312px 0;
+}
+
+.icon-zoom-in {
+  background-position: -336px 0;
+}
+
+.icon-zoom-out {
+  background-position: -360px 0;
+}
+
+.icon-off {
+  background-position: -384px 0;
+}
+
+.icon-signal {
+  background-position: -408px 0;
+}
+
+.icon-cog {
+  background-position: -432px 0;
+}
+
+.icon-trash {
+  background-position: -456px 0;
+}
+
+.icon-home {
+  background-position: 0 -24px;
+}
+
+.icon-file {
+  background-position: -24px -24px;
+}
+
+.icon-time {
+  background-position: -48px -24px;
+}
+
+.icon-road {
+  background-position: -72px -24px;
+}
+
+.icon-download-alt {
+  background-position: -96px -24px;
+}
+
+.icon-download {
+  background-position: -120px -24px;
+}
+
+.icon-upload {
+  background-position: -144px -24px;
+}
+
+.icon-inbox {
+  background-position: -168px -24px;
+}
+
+.icon-play-circle {
+  background-position: -192px -24px;
+}
+
+.icon-repeat {
+  background-position: -216px -24px;
+}
+
+.icon-refresh {
+  background-position: -240px -24px;
+}
+
+.icon-list-alt {
+  background-position: -264px -24px;
+}
+
+.icon-lock {
+  background-position: -287px -24px;
+}
+
+.icon-flag {
+  background-position: -312px -24px;
+}
+
+.icon-headphones {
+  background-position: -336px -24px;
+}
+
+.icon-volume-off {
+  background-position: -360px -24px;
+}
+
+.icon-volume-down {
+  background-position: -384px -24px;
+}
+
+.icon-volume-up {
+  background-position: -408px -24px;
+}
+
+.icon-qrcode {
+  background-position: -432px -24px;
+}
+
+.icon-barcode {
+  background-position: -456px -24px;
+}
+
+.icon-tag {
+  background-position: 0 -48px;
+}
+
+.icon-tags {
+  background-position: -25px -48px;
+}
+
+.icon-book {
+  background-position: -48px -48px;
+}
+
+.icon-bookmark {
+  background-position: -72px -48px;
+}
+
+.icon-print {
+  background-position: -96px -48px;
+}
+
+.icon-camera {
+  background-position: -120px -48px;
+}
+
+.icon-font {
+  background-position: -144px -48px;
+}
+
+.icon-bold {
+  background-position: -167px -48px;
+}
+
+.icon-italic {
+  background-position: -192px -48px;
+}
+
+.icon-text-height {
+  background-position: -216px -48px;
+}
+
+.icon-text-width {
+  background-position: -240px -48px;
+}
+
+.icon-align-left {
+  background-position: -264px -48px;
+}
+
+.icon-align-center {
+  background-position: -288px -48px;
+}
+
+.icon-align-right {
+  background-position: -312px -48px;
+}
+
+.icon-align-justify {
+  background-position: -336px -48px;
+}
+
+.icon-list {
+  background-position: -360px -48px;
+}
+
+.icon-indent-left {
+  background-position: -384px -48px;
+}
+
+.icon-indent-right {
+  background-position: -408px -48px;
+}
+
+.icon-facetime-video {
+  background-position: -432px -48px;
+}
+
+.icon-picture {
+  background-position: -456px -48px;
+}
+
+.icon-pencil {
+  background-position: 0 -72px;
+}
+
+.icon-map-marker {
+  background-position: -24px -72px;
+}
+
+.icon-adjust {
+  background-position: -48px -72px;
+}
+
+.icon-tint {
+  background-position: -72px -72px;
+}
+
+.icon-edit {
+  background-position: -96px -72px;
+}
+
+.icon-share {
+  background-position: -120px -72px;
+}
+
+.icon-check {
+  background-position: -144px -72px;
+}
+
+.icon-move {
+  background-position: -168px -72px;
+}
+
+.icon-step-backward {
+  background-position: -192px -72px;
+}
+
+.icon-fast-backward {
+  background-position: -216px -72px;
+}
+
+.icon-backward {
+  background-position: -240px -72px;
+}
+
+.icon-play {
+  background-position: -264px -72px;
+}
+
+.icon-pause {
+  background-position: -288px -72px;
+}
+
+.icon-stop {
+  background-position: -312px -72px;
+}
+
+.icon-forward {
+  background-position: -336px -72px;
+}
+
+.icon-fast-forward {
+  background-position: -360px -72px;
+}
+
+.icon-step-forward {
+  background-position: -384px -72px;
+}
+
+.icon-eject {
+  background-position: -408px -72px;
+}
+
+.icon-chevron-left {
+  background-position: -432px -72px;
+}
+
+.icon-chevron-right {
+  background-position: -456px -72px;
+}
+
+.icon-plus-sign {
+  background-position: 0 -96px;
+}
+
+.icon-minus-sign {
+  background-position: -24px -96px;
+}
+
+.icon-remove-sign {
+  background-position: -48px -96px;
+}
+
+.icon-ok-sign {
+  background-position: -72px -96px;
+}
+
+.icon-question-sign {
+  background-position: -96px -96px;
+}
+
+.icon-info-sign {
+  background-position: -120px -96px;
+}
+
+.icon-screenshot {
+  background-position: -144px -96px;
+}
+
+.icon-remove-circle {
+  background-position: -168px -96px;
+}
+
+.icon-ok-circle {
+  background-position: -192px -96px;
+}
+
+.icon-ban-circle {
+  background-position: -216px -96px;
+}
+
+.icon-arrow-left {
+  background-position: -240px -96px;
+}
+
+.icon-arrow-right {
+  background-position: -264px -96px;
+}
+
+.icon-arrow-up {
+  background-position: -289px -96px;
+}
+
+.icon-arrow-down {
+  background-position: -312px -96px;
+}
+
+.icon-share-alt {
+  background-position: -336px -96px;
+}
+
+.icon-resize-full {
+  background-position: -360px -96px;
+}
+
+.icon-resize-small {
+  background-position: -384px -96px;
+}
+
+.icon-plus {
+  background-position: -408px -96px;
+}
+
+.icon-minus {
+  background-position: -433px -96px;
+}
+
+.icon-asterisk {
+  background-position: -456px -96px;
+}
+
+.icon-exclamation-sign {
+  background-position: 0 -120px;
+}
+
+.icon-gift {
+  background-position: -24px -120px;
+}
+
+.icon-leaf {
+  background-position: -48px -120px;
+}
+
+.icon-fire {
+  background-position: -72px -120px;
+}
+
+.icon-eye-open {
+  background-position: -96px -120px;
+}
+
+.icon-eye-close {
+  background-position: -120px -120px;
+}
+
+.icon-warning-sign {
+  background-position: -144px -120px;
+}
+
+.icon-plane {
+  background-position: -168px -120px;
+}
+
+.icon-calendar {
+  background-position: -192px -120px;
+}
+
+.icon-random {
+  width: 16px;
+  background-position: -216px -120px;
+}
+
+.icon-comment {
+  background-position: -240px -120px;
+}
+
+.icon-magnet {
+  background-position: -264px -120px;
+}
+
+.icon-chevron-up {
+  background-position: -288px -120px;
+}
+
+.icon-chevron-down {
+  background-position: -313px -119px;
+}
+
+.icon-retweet {
+  background-position: -336px -120px;
+}
+
+.icon-shopping-cart {
+  background-position: -360px -120px;
+}
+
+.icon-folder-close {
+  background-position: -384px -120px;
+}
+
+.icon-folder-open {
+  width: 16px;
+  background-position: -408px -120px;
+}
+
+.icon-resize-vertical {
+  background-position: -432px -119px;
+}
+
+.icon-resize-horizontal {
+  background-position: -456px -118px;
+}
+
+.icon-hdd {
+  background-position: 0 -144px;
+}
+
+.icon-bullhorn {
+  background-position: -24px -144px;
+}
+
+.icon-bell {
+  background-position: -48px -144px;
+}
+
+.icon-certificate {
+  background-position: -72px -144px;
+}
+
+.icon-thumbs-up {
+  background-position: -96px -144px;
+}
+
+.icon-thumbs-down {
+  background-position: -120px -144px;
+}
+
+.icon-hand-right {
+  background-position: -144px -144px;
+}
+
+.icon-hand-left {
+  background-position: -168px -144px;
+}
+
+.icon-hand-up {
+  background-position: -192px -144px;
+}
+
+.icon-hand-down {
+  background-position: -216px -144px;
+}
+
+.icon-circle-arrow-right {
+  background-position: -240px -144px;
+}
+
+.icon-circle-arrow-left {
+  background-position: -264px -144px;
+}
+
+.icon-circle-arrow-up {
+  background-position: -288px -144px;
+}
+
+.icon-circle-arrow-down {
+  background-position: -312px -144px;
+}
+
+.icon-globe {
+  background-position: -336px -144px;
+}
+
+.icon-wrench {
+  background-position: -360px -144px;
+}
+
+.icon-tasks {
+  background-position: -384px -144px;
+}
+
+.icon-filter {
+  background-position: -408px -144px;
+}
+
+.icon-briefcase {
+  background-position: -432px -144px;
+}
+
+.icon-fullscreen {
+  background-position: -456px -144px;
+}
+
+.dropup,
+.dropdown {
+  position: relative;
+}
+
+.dropdown-toggle {
+  *margin-bottom: -3px;
+}
+
+.dropdown-toggle:active,
+.open .dropdown-toggle {
+  outline: 0;
+}
+
+.caret {
+  display: inline-block;
+  width: 0;
+  height: 0;
+  vertical-align: top;
+  border-top: 4px solid #000000;
+  border-right: 4px solid transparent;
+  border-left: 4px solid transparent;
+  content: "";
+}
+
+.dropdown .caret {
+  margin-top: 8px;
+  margin-left: 2px;
+}
+
+.dropdown-menu {
+  position: absolute;
+  top: 100%;
+  left: 0;
+  z-index: 1000;
+  display: none;
+  float: left;
+  min-width: 160px;
+  padding: 5px 0;
+  margin: 2px 0 0;
+  list-style: none;
+  background-color: #ffffff;
+  border: 1px solid #ccc;
+  border: 1px solid rgba(0, 0, 0, 0.2);
+  *border-right-width: 2px;
+  *border-bottom-width: 2px;
+  -webkit-border-radius: 6px;
+     -moz-border-radius: 6px;
+          border-radius: 6px;
+  -webkit-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
+     -moz-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
+          box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
+  -webkit-background-clip: padding-box;
+     -moz-background-clip: padding;
+          background-clip: padding-box;
+}
+
+.dropdown-menu.pull-right {
+  right: 0;
+  left: auto;
+}
+
+.dropdown-menu .divider {
+  *width: 100%;
+  height: 1px;
+  margin: 9px 1px;
+  *margin: -5px 0 5px;
+  overflow: hidden;
+  background-color: #e5e5e5;
+  border-bottom: 1px solid #ffffff;
+}
+
+.dropdown-menu a {
+  display: block;
+  padding: 3px 20px;
+  clear: both;
+  font-weight: normal;
+  line-height: 20px;
+  color: #333333;
+  white-space: nowrap;
+}
+
+.dropdown-menu li > a:hover,
+.dropdown-menu li > a:focus,
+.dropdown-submenu:hover > a {
+  color: #ffffff;
+  text-decoration: none;
+  background-color: #0088cc;
+  background-color: #0081c2;
+  background-image: -moz-linear-gradient(top, #0088cc, #0077b3);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#0088cc), to(#0077b3));
+  background-image: -webkit-linear-gradient(top, #0088cc, #0077b3);
+  background-image: -o-linear-gradient(top, #0088cc, #0077b3);
+  background-image: linear-gradient(to bottom, #0088cc, #0077b3);
+  background-repeat: repeat-x;
+  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff0088cc', endColorstr='#ff0077b3', GradientType=0);
+}
+
+.dropdown-menu .active > a,
+.dropdown-menu .active > a:hover {
+  color: #ffffff;
+  text-decoration: none;
+  background-color: #0088cc;
+  background-color: #0081c2;
+  background-image: linear-gradient(to bottom, #0088cc, #0077b3);
+  background-image: -moz-linear-gradient(top, #0088cc, #0077b3);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#0088cc), to(#0077b3));
+  background-image: -webkit-linear-gradient(top, #0088cc, #0077b3);
+  background-image: -o-linear-gradient(top, #0088cc, #0077b3);
+  background-repeat: repeat-x;
+  outline: 0;
+  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff0088cc', endColorstr='#ff0077b3', GradientType=0);
+}
+
+.dropdown-menu .disabled > a,
+.dropdown-menu .disabled > a:hover {
+  color: #999999;
+}
+
+.dropdown-menu .disabled > a:hover {
+  text-decoration: none;
+  cursor: default;
+  background-color: transparent;
+}
+
+.open {
+  *z-index: 1000;
+}
+
+.open > .dropdown-menu {
+  display: block;
+}
+
+.pull-right > .dropdown-menu {
+  right: 0;
+  left: auto;
+}
+
+.dropup .caret,
+.navbar-fixed-bottom .dropdown .caret {
+  border-top: 0;
+  border-bottom: 4px solid #000000;
+  content: "";
+}
+
+.dropup .dropdown-menu,
+.navbar-fixed-bottom .dropdown .dropdown-menu {
+  top: auto;
+  bottom: 100%;
+  margin-bottom: 1px;
+}
+
+.dropdown-submenu {
+  position: relative;
+}
+
+.dropdown-submenu > .dropdown-menu {
+  top: 0;
+  left: 100%;
+  margin-top: -6px;
+  margin-left: -1px;
+  -webkit-border-radius: 0 6px 6px 6px;
+     -moz-border-radius: 0 6px 6px 6px;
+          border-radius: 0 6px 6px 6px;
+}
+
+.dropdown-submenu:hover > .dropdown-menu {
+  display: block;
+}
+
+.dropdown-submenu > a:after {
+  display: block;
+  float: right;
+  width: 0;
+  height: 0;
+  margin-top: 5px;
+  margin-right: -10px;
+  border-color: transparent;
+  border-left-color: #cccccc;
+  border-style: solid;
+  border-width: 5px 0 5px 5px;
+  content: " ";
+}
+
+.dropdown-submenu:hover > a:after {
+  border-left-color: #ffffff;
+}
+
+.dropdown .dropdown-menu .nav-header {
+  padding-right: 20px;
+  padding-left: 20px;
+}
+
+.typeahead {
+  margin-top: 2px;
+  -webkit-border-radius: 4px;
+     -moz-border-radius: 4px;
+          border-radius: 4px;
+}
+
+.well {
+  min-height: 20px;
+  padding: 19px;
+  margin-bottom: 20px;
+  background-color: #f5f5f5;
+  border: 1px solid #e3e3e3;
+  -webkit-border-radius: 4px;
+     -moz-border-radius: 4px;
+          border-radius: 4px;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05);
+     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05);
+          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05);
+}
+
+.well blockquote {
+  border-color: #ddd;
+  border-color: rgba(0, 0, 0, 0.15);
+}
+
+.well-large {
+  padding: 24px;
+  -webkit-border-radius: 6px;
+     -moz-border-radius: 6px;
+          border-radius: 6px;
+}
+
+.well-small {
+  padding: 9px;
+  -webkit-border-radius: 3px;
+     -moz-border-radius: 3px;
+          border-radius: 3px;
+}
+
+.fade {
+  opacity: 0;
+  -webkit-transition: opacity 0.15s linear;
+     -moz-transition: opacity 0.15s linear;
+       -o-transition: opacity 0.15s linear;
+          transition: opacity 0.15s linear;
+}
+
+.fade.in {
+  opacity: 1;
+}
+
+.collapse {
+  position: relative;
+  height: 0;
+  overflow: hidden;
+  -webkit-transition: height 0.35s ease;
+     -moz-transition: height 0.35s ease;
+       -o-transition: height 0.35s ease;
+          transition: height 0.35s ease;
+}
+
+.collapse.in {
+  height: auto;
+}
+
+.close {
+  float: right;
+  font-size: 20px;
+  font-weight: bold;
+  line-height: 20px;
+  color: #000000;
+  text-shadow: 0 1px 0 #ffffff;
+  opacity: 0.2;
+  filter: alpha(opacity=20);
+}
+
+.close:hover {
+  color: #000000;
+  text-decoration: none;
+  cursor: pointer;
+  opacity: 0.4;
+  filter: alpha(opacity=40);
+}
+
+button.close {
+  padding: 0;
+  cursor: pointer;
+  background: transparent;
+  border: 0;
+  -webkit-appearance: none;
+}
+
+.btn {
+  display: inline-block;
+  *display: inline;
+  padding: 4px 14px;
+  margin-bottom: 0;
+  *margin-left: .3em;
+  font-size: 14px;
+  line-height: 20px;
+  *line-height: 20px;
+  color: #333333;
+  text-align: center;
+  text-shadow: 0 1px 1px rgba(255, 255, 255, 0.75);
+  vertical-align: middle;
+  cursor: pointer;
+  background-color: #f5f5f5;
+  *background-color: #e6e6e6;
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#ffffff), to(#e6e6e6));
+  background-image: -webkit-linear-gradient(top, #ffffff, #e6e6e6);
+  background-image: -o-linear-gradient(top, #ffffff, #e6e6e6);
+  background-image: linear-gradient(to bottom, #ffffff, #e6e6e6);
+  background-image: -moz-linear-gradient(top, #ffffff, #e6e6e6);
+  background-repeat: repeat-x;
+  border: 1px solid #bbbbbb;
+  *border: 0;
+  border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
+  border-color: #e6e6e6 #e6e6e6 #bfbfbf;
+  border-bottom-color: #a2a2a2;
+  -webkit-border-radius: 4px;
+     -moz-border-radius: 4px;
+          border-radius: 4px;
+  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ffffffff', endColorstr='#ffe6e6e6', GradientType=0);
+  filter: progid:dximagetransform.microsoft.gradient(enabled=false);
+  *zoom: 1;
+  -webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
+     -moz-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
+          box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
+}
+
+.btn:hover,
+.btn:active,
+.btn.active,
+.btn.disabled,
+.btn[disabled] {
+  color: #333333;
+  background-color: #e6e6e6;
+  *background-color: #d9d9d9;
+}
+
+.btn:active,
+.btn.active {
+  background-color: #cccccc \9;
+}
+
+.btn:first-child {
+  *margin-left: 0;
+}
+
+.btn:hover {
+  color: #333333;
+  text-decoration: none;
+  background-color: #e6e6e6;
+  *background-color: #d9d9d9;
+  /* Buttons in IE7 don't get borders, so darken on hover */
+
+  background-position: 0 -15px;
+  -webkit-transition: background-position 0.1s linear;
+     -moz-transition: background-position 0.1s linear;
+       -o-transition: background-position 0.1s linear;
+          transition: background-position 0.1s linear;
+}
+
+.btn:focus {
+  outline: thin dotted #333;
+  outline: 5px auto -webkit-focus-ring-color;
+  outline-offset: -2px;
+}
+
+.btn.active,
+.btn:active {
+  background-color: #e6e6e6;
+  background-color: #d9d9d9 \9;
+  background-image: none;
+  outline: 0;
+  -webkit-box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05);
+     -moz-box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05);
+          box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05);
+}
+
+.btn.disabled,
+.btn[disabled] {
+  cursor: default;
+  background-color: #e6e6e6;
+  background-image: none;
+  opacity: 0.65;
+  filter: alpha(opacity=65);
+  -webkit-box-shadow: none;
+     -moz-box-shadow: none;
+          box-shadow: none;
+}
+
+.btn-large {
+  padding: 9px 14px;
+  font-size: 16px;
+  line-height: normal;
+  -webkit-border-radius: 5px;
+     -moz-border-radius: 5px;
+          border-radius: 5px;
+}
+
+.btn-large [class^="icon-"] {
+  margin-top: 2px;
+}
+
+.btn-small {
+  padding: 3px 9px;
+  font-size: 12px;
+  line-height: 18px;
+}
+
+.btn-small [class^="icon-"] {
+  margin-top: 0;
+}
+
+.btn-mini {
+  padding: 2px 6px;
+  font-size: 11px;
+  line-height: 17px;
+}
+
+.btn-block {
+  display: block;
+  width: 100%;
+  padding-right: 0;
+  padding-left: 0;
+  -webkit-box-sizing: border-box;
+     -moz-box-sizing: border-box;
+          box-sizing: border-box;
+}
+
+.btn-block + .btn-block {
+  margin-top: 5px;
+}
+
+input[type="submit"].btn-block,
+input[type="reset"].btn-block,
+input[type="button"].btn-block {
+  width: 100%;
+}
+
+.btn-primary.active,
+.btn-warning.active,
+.btn-danger.active,
+.btn-success.active,
+.btn-info.active,
+.btn-inverse.active {
+  color: rgba(255, 255, 255, 0.75);
+}
+
+.btn {
+  border-color: #c5c5c5;
+  border-color: rgba(0, 0, 0, 0.15) rgba(0, 0, 0, 0.15) rgba(0, 0, 0, 0.25);
+}
+
+.btn-primary {
+  color: #ffffff;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+  background-color: #006dcc;
+  *background-color: #0044cc;
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#0088cc), to(#0044cc));
+  background-image: -webkit-linear-gradient(top, #0088cc, #0044cc);
+  background-image: -o-linear-gradient(top, #0088cc, #0044cc);
+  background-image: linear-gradient(to bottom, #0088cc, #0044cc);
+  background-image: -moz-linear-gradient(top, #0088cc, #0044cc);
+  background-repeat: repeat-x;
+  border-color: #0044cc #0044cc #002a80;
+  border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
+  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff0088cc', endColorstr='#ff0044cc', GradientType=0);
+  filter: progid:dximagetransform.microsoft.gradient(enabled=false);
+}
+
+.btn-primary:hover,
+.btn-primary:active,
+.btn-primary.active,
+.btn-primary.disabled,
+.btn-primary[disabled] {
+  color: #ffffff;
+  background-color: #0044cc;
+  *background-color: #003bb3;
+}
+
+.btn-primary:active,
+.btn-primary.active {
+  background-color: #003399 \9;
+}
+
+.btn-warning {
+  color: #ffffff;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+  background-color: #faa732;
+  *background-color: #f89406;
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#fbb450), to(#f89406));
+  background-image: -webkit-linear-gradient(top, #fbb450, #f89406);
+  background-image: -o-linear-gradient(top, #fbb450, #f89406);
+  background-image: linear-gradient(to bottom, #fbb450, #f89406);
+  background-image: -moz-linear-gradient(top, #fbb450, #f89406);
+  background-repeat: repeat-x;
+  border-color: #f89406 #f89406 #ad6704;
+  border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
+  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#fffbb450', endColorstr='#fff89406', GradientType=0);
+  filter: progid:dximagetransform.microsoft.gradient(enabled=false);
+}
+
+.btn-warning:hover,
+.btn-warning:active,
+.btn-warning.active,
+.btn-warning.disabled,
+.btn-warning[disabled] {
+  color: #ffffff;
+  background-color: #f89406;
+  *background-color: #df8505;
+}
+
+.btn-warning:active,
+.btn-warning.active {
+  background-color: #c67605 \9;
+}
+
+.btn-danger {
+  color: #ffffff;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+  background-color: #da4f49;
+  *background-color: #bd362f;
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#ee5f5b), to(#bd362f));
+  background-image: -webkit-linear-gradient(top, #ee5f5b, #bd362f);
+  background-image: -o-linear-gradient(top, #ee5f5b, #bd362f);
+  background-image: linear-gradient(to bottom, #ee5f5b, #bd362f);
+  background-image: -moz-linear-gradient(top, #ee5f5b, #bd362f);
+  background-repeat: repeat-x;
+  border-color: #bd362f #bd362f #802420;
+  border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
+  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ffee5f5b', endColorstr='#ffbd362f', GradientType=0);
+  filter: progid:dximagetransform.microsoft.gradient(enabled=false);
+}
+
+.btn-danger:hover,
+.btn-danger:active,
+.btn-danger.active,
+.btn-danger.disabled,
+.btn-danger[disabled] {
+  color: #ffffff;
+  background-color: #bd362f;
+  *background-color: #a9302a;
+}
+
+.btn-danger:active,
+.btn-danger.active {
+  background-color: #942a25 \9;
+}
+
+.btn-success {
+  color: #ffffff;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+  background-color: #5bb75b;
+  *background-color: #51a351;
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#62c462), to(#51a351));
+  background-image: -webkit-linear-gradient(top, #62c462, #51a351);
+  background-image: -o-linear-gradient(top, #62c462, #51a351);
+  background-image: linear-gradient(to bottom, #62c462, #51a351);
+  background-image: -moz-linear-gradient(top, #62c462, #51a351);
+  background-repeat: repeat-x;
+  border-color: #51a351 #51a351 #387038;
+  border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
+  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff62c462', endColorstr='#ff51a351', GradientType=0);
+  filter: progid:dximagetransform.microsoft.gradient(enabled=false);
+}
+
+.btn-success:hover,
+.btn-success:active,
+.btn-success.active,
+.btn-success.disabled,
+.btn-success[disabled] {
+  color: #ffffff;
+  background-color: #51a351;
+  *background-color: #499249;
+}
+
+.btn-success:active,
+.btn-success.active {
+  background-color: #408140 \9;
+}
+
+.btn-info {
+  color: #ffffff;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+  background-color: #49afcd;
+  *background-color: #2f96b4;
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#5bc0de), to(#2f96b4));
+  background-image: -webkit-linear-gradient(top, #5bc0de, #2f96b4);
+  background-image: -o-linear-gradient(top, #5bc0de, #2f96b4);
+  background-image: linear-gradient(to bottom, #5bc0de, #2f96b4);
+  background-image: -moz-linear-gradient(top, #5bc0de, #2f96b4);
+  background-repeat: repeat-x;
+  border-color: #2f96b4 #2f96b4 #1f6377;
+  border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
+  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff5bc0de', endColorstr='#ff2f96b4', GradientType=0);
+  filter: progid:dximagetransform.microsoft.gradient(enabled=false);
+}
+
+.btn-info:hover,
+.btn-info:active,
+.btn-info.active,
+.btn-info.disabled,
+.btn-info[disabled] {
+  color: #ffffff;
+  background-color: #2f96b4;
+  *background-color: #2a85a0;
+}
+
+.btn-info:active,
+.btn-info.active {
+  background-color: #24748c \9;
+}
+
+.btn-inverse {
+  color: #ffffff;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+  background-color: #363636;
+  *background-color: #222222;
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#444444), to(#222222));
+  background-image: -webkit-linear-gradient(top, #444444, #222222);
+  background-image: -o-linear-gradient(top, #444444, #222222);
+  background-image: linear-gradient(to bottom, #444444, #222222);
+  background-image: -moz-linear-gradient(top, #444444, #222222);
+  background-repeat: repeat-x;
+  border-color: #222222 #222222 #000000;
+  border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
+  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff444444', endColorstr='#ff222222', GradientType=0);
+  filter: progid:dximagetransform.microsoft.gradient(enabled=false);
+}
+
+.btn-inverse:hover,
+.btn-inverse:active,
+.btn-inverse.active,
+.btn-inverse.disabled,
+.btn-inverse[disabled] {
+  color: #ffffff;
+  background-color: #222222;
+  *background-color: #151515;
+}
+
+.btn-inverse:active,
+.btn-inverse.active {
+  background-color: #080808 \9;
+}
+
+button.btn,
+input[type="submit"].btn {
+  *padding-top: 3px;
+  *padding-bottom: 3px;
+}
+
+button.btn::-moz-focus-inner,
+input[type="submit"].btn::-moz-focus-inner {
+  padding: 0;
+  border: 0;
+}
+
+button.btn.btn-large,
+input[type="submit"].btn.btn-large {
+  *padding-top: 7px;
+  *padding-bottom: 7px;
+}
+
+button.btn.btn-small,
+input[type="submit"].btn.btn-small {
+  *padding-top: 3px;
+  *padding-bottom: 3px;
+}
+
+button.btn.btn-mini,
+input[type="submit"].btn.btn-mini {
+  *padding-top: 1px;
+  *padding-bottom: 1px;
+}
+
+.btn-link,
+.btn-link:active,
+.btn-link[disabled] {
+  background-color: transparent;
+  background-image: none;
+  -webkit-box-shadow: none;
+     -moz-box-shadow: none;
+          box-shadow: none;
+}
+
+.btn-link {
+  color: #0088cc;
+  cursor: pointer;
+  border-color: transparent;
+  -webkit-border-radius: 0;
+     -moz-border-radius: 0;
+          border-radius: 0;
+}
+
+.btn-link:hover {
+  color: #005580;
+  text-decoration: underline;
+  background-color: transparent;
+}
+
+.btn-link[disabled]:hover {
+  color: #333333;
+  text-decoration: none;
+}
+
+.btn-group {
+  position: relative;
+  *margin-left: .3em;
+  font-size: 0;
+  white-space: nowrap;
+  vertical-align: middle;
+}
+
+.btn-group:first-child {
+  *margin-left: 0;
+}
+
+.btn-group + .btn-group {
+  margin-left: 5px;
+}
+
+.btn-toolbar {
+  margin-top: 10px;
+  margin-bottom: 10px;
+  font-size: 0;
+}
+
+.btn-toolbar .btn-group {
+  display: inline-block;
+  *display: inline;
+  /* IE7 inline-block hack */
+
+  *zoom: 1;
+}
+
+.btn-toolbar .btn + .btn,
+.btn-toolbar .btn-group + .btn,
+.btn-toolbar .btn + .btn-group {
+  margin-left: 5px;
+}
+
+.btn-group > .btn {
+  position: relative;
+  -webkit-border-radius: 0;
+     -moz-border-radius: 0;
+          border-radius: 0;
+}
+
+.btn-group > .btn + .btn {
+  margin-left: -1px;
+}
+
+.btn-group > .btn,
+.btn-group > .dropdown-menu {
+  font-size: 14px;
+}
+
+.btn-group > .btn-mini {
+  font-size: 11px;
+}
+
+.btn-group > .btn-small {
+  font-size: 12px;
+}
+
+.btn-group > .btn-large {
+  font-size: 16px;
+}
+
+.btn-group > .btn:first-child {
+  margin-left: 0;
+  -webkit-border-bottom-left-radius: 4px;
+          border-bottom-left-radius: 4px;
+  -webkit-border-top-left-radius: 4px;
+          border-top-left-radius: 4px;
+  -moz-border-radius-bottomleft: 4px;
+  -moz-border-radius-topleft: 4px;
+}
+
+.btn-group > .btn:last-child,
+.btn-group > .dropdown-toggle {
+  -webkit-border-top-right-radius: 4px;
+          border-top-right-radius: 4px;
+  -webkit-border-bottom-right-radius: 4px;
+          border-bottom-right-radius: 4px;
+  -moz-border-radius-topright: 4px;
+  -moz-border-radius-bottomright: 4px;
+}
+
+.btn-group > .btn.large:first-child {
+  margin-left: 0;
+  -webkit-border-bottom-left-radius: 6px;
+          border-bottom-left-radius: 6px;
+  -webkit-border-top-left-radius: 6px;
+          border-top-left-radius: 6px;
+  -moz-border-radius-bottomleft: 6px;
+  -moz-border-radius-topleft: 6px;
+}
+
+.btn-group > .btn.large:last-child,
+.btn-group > .large.dropdown-toggle {
+  -webkit-border-top-right-radius: 6px;
+          border-top-right-radius: 6px;
+  -webkit-border-bottom-right-radius: 6px;
+          border-bottom-right-radius: 6px;
+  -moz-border-radius-topright: 6px;
+  -moz-border-radius-bottomright: 6px;
+}
+
+.btn-group > .btn:hover,
+.btn-group > .btn:focus,
+.btn-group > .btn:active,
+.btn-group > .btn.active {
+  z-index: 2;
+}
+
+.btn-group .dropdown-toggle:active,
+.btn-group.open .dropdown-toggle {
+  outline: 0;
+}
+
+.btn-group > .btn + .dropdown-toggle {
+  *padding-top: 5px;
+  padding-right: 8px;
+  *padding-bottom: 5px;
+  padding-left: 8px;
+  -webkit-box-shadow: inset 1px 0 0 rgba(255, 255, 255, 0.125), inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
+     -moz-box-shadow: inset 1px 0 0 rgba(255, 255, 255, 0.125), inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
+          box-shadow: inset 1px 0 0 rgba(255, 255, 255, 0.125), inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
+}
+
+.btn-group > .btn-mini + .dropdown-toggle {
+  *padding-top: 2px;
+  padding-right: 5px;
+  *padding-bottom: 2px;
+  padding-left: 5px;
+}
+
+.btn-group > .btn-small + .dropdown-toggle {
+  *padding-top: 5px;
+  *padding-bottom: 4px;
+}
+
+.btn-group > .btn-large + .dropdown-toggle {
+  *padding-top: 7px;
+  padding-right: 12px;
+  *padding-bottom: 7px;
+  padding-left: 12px;
+}
+
+.btn-group.open .dropdown-toggle {
+  background-image: none;
+  -webkit-box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05);
+     -moz-box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05);
+          box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05);
+}
+
+.btn-group.open .btn.dropdown-toggle {
+  background-color: #e6e6e6;
+}
+
+.btn-group.open .btn-primary.dropdown-toggle {
+  background-color: #0044cc;
+}
+
+.btn-group.open .btn-warning.dropdown-toggle {
+  background-color: #f89406;
+}
+
+.btn-group.open .btn-danger.dropdown-toggle {
+  background-color: #bd362f;
+}
+
+.btn-group.open .btn-success.dropdown-toggle {
+  background-color: #51a351;
+}
+
+.btn-group.open .btn-info.dropdown-toggle {
+  background-color: #2f96b4;
+}
+
+.btn-group.open .btn-inverse.dropdown-toggle {
+  background-color: #222222;
+}
+
+.btn .caret {
+  margin-top: 8px;
+  margin-left: 0;
+}
+
+.btn-mini .caret,
+.btn-small .caret,
+.btn-large .caret {
+  margin-top: 6px;
+}
+
+.btn-large .caret {
+  border-top-width: 5px;
+  border-right-width: 5px;
+  border-left-width: 5px;
+}
+
+.dropup .btn-large .caret {
+  border-top: 0;
+  border-bottom: 5px solid #000000;
+}
+
+.btn-primary .caret,
+.btn-warning .caret,
+.btn-danger .caret,
+.btn-info .caret,
+.btn-success .caret,
+.btn-inverse .caret {
+  border-top-color: #ffffff;
+  border-bottom-color: #ffffff;
+}
+
+.btn-group-vertical {
+  display: inline-block;
+  *display: inline;
+  /* IE7 inline-block hack */
+
+  *zoom: 1;
+}
+
+.btn-group-vertical .btn {
+  display: block;
+  float: none;
+  width: 100%;
+  -webkit-border-radius: 0;
+     -moz-border-radius: 0;
+          border-radius: 0;
+}
+
+.btn-group-vertical .btn + .btn {
+  margin-top: -1px;
+  margin-left: 0;
+}
+
+.btn-group-vertical .btn:first-child {
+  -webkit-border-radius: 4px 4px 0 0;
+     -moz-border-radius: 4px 4px 0 0;
+          border-radius: 4px 4px 0 0;
+}
+
+.btn-group-vertical .btn:last-child {
+  -webkit-border-radius: 0 0 4px 4px;
+     -moz-border-radius: 0 0 4px 4px;
+          border-radius: 0 0 4px 4px;
+}
+
+.btn-group-vertical .btn-large:first-child {
+  -webkit-border-radius: 6px 6px 0 0;
+     -moz-border-radius: 6px 6px 0 0;
+          border-radius: 6px 6px 0 0;
+}
+
+.btn-group-vertical .btn-large:last-child {
+  -webkit-border-radius: 0 0 6px 6px;
+     -moz-border-radius: 0 0 6px 6px;
+          border-radius: 0 0 6px 6px;
+}
+
+.alert {
+  padding: 8px 35px 8px 14px;
+  margin-bottom: 20px;
+  color: #c09853;
+  text-shadow: 0 1px 0 rgba(255, 255, 255, 0.5);
+  background-color: #fcf8e3;
+  border: 1px solid #fbeed5;
+  -webkit-border-radius: 4px;
+     -moz-border-radius: 4px;
+          border-radius: 4px;
+}
+
+.alert h4 {
+  margin: 0;
+}
+
+.alert .close {
+  position: relative;
+  top: -2px;
+  right: -21px;
+  line-height: 20px;
+}
+
+.alert-success {
+  color: #468847;
+  background-color: #dff0d8;
+  border-color: #d6e9c6;
+}
+
+.alert-danger,
+.alert-error {
+  color: #b94a48;
+  background-color: #f2dede;
+  border-color: #eed3d7;
+}
+
+.alert-info {
+  color: #3a87ad;
+  background-color: #d9edf7;
+  border-color: #bce8f1;
+}
+
+.alert-block {
+  padding-top: 14px;
+  padding-bottom: 14px;
+}
+
+.alert-block > p,
+.alert-block > ul {
+  margin-bottom: 0;
+}
+
+.alert-block p + p {
+  margin-top: 5px;
+}
+
+.nav {
+  margin-bottom: 20px;
+  margin-left: 0;
+  list-style: none;
+}
+
+.nav > li > a {
+  display: block;
+}
+
+.nav > li > a:hover {
+  text-decoration: none;
+  background-color: #eeeeee;
+}
+
+.nav > .pull-right {
+  float: right;
+}
+
+.nav-header {
+  display: block;
+  padding: 3px 15px;
+  font-size: 11px;
+  font-weight: bold;
+  line-height: 20px;
+  color: #999999;
+  text-shadow: 0 1px 0 rgba(255, 255, 255, 0.5);
+  text-transform: uppercase;
+}
+
+.nav li + .nav-header {
+  margin-top: 9px;
+}
+
+.nav-list {
+  padding-right: 15px;
+  padding-left: 15px;
+  margin-bottom: 0;
+}
+
+.nav-list > li > a,
+.nav-list .nav-header {
+  margin-right: -15px;
+  margin-left: -15px;
+  text-shadow: 0 1px 0 rgba(255, 255, 255, 0.5);
+}
+
+.nav-list > li > a {
+  padding: 3px 15px;
+}
+
+.nav-list > .active > a,
+.nav-list > .active > a:hover {
+  color: #ffffff;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.2);
+  background-color: #0088cc;
+}
+
+.nav-list [class^="icon-"] {
+  margin-right: 2px;
+}
+
+.nav-list .divider {
+  *width: 100%;
+  height: 1px;
+  margin: 9px 1px;
+  *margin: -5px 0 5px;
+  overflow: hidden;
+  background-color: #e5e5e5;
+  border-bottom: 1px solid #ffffff;
+}
+
+.nav-tabs,
+.nav-pills {
+  *zoom: 1;
+}
+
+.nav-tabs:before,
+.nav-pills:before,
+.nav-tabs:after,
+.nav-pills:after {
+  display: table;
+  line-height: 0;
+  content: "";
+}
+
+.nav-tabs:after,
+.nav-pills:after {
+  clear: both;
+}
+
+.nav-tabs > li,
+.nav-pills > li {
+  float: left;
+}
+
+.nav-tabs > li > a,
+.nav-pills > li > a {
+  padding-right: 12px;
+  padding-left: 12px;
+  margin-right: 2px;
+  line-height: 14px;
+}
+
+.nav-tabs {
+  border-bottom: 1px solid #ddd;
+}
+
+.nav-tabs > li {
+  margin-bottom: -1px;
+}
+
+.nav-tabs > li > a {
+  padding-top: 8px;
+  padding-bottom: 8px;
+  line-height: 20px;
+  border: 1px solid transparent;
+  -webkit-border-radius: 4px 4px 0 0;
+     -moz-border-radius: 4px 4px 0 0;
+          border-radius: 4px 4px 0 0;
+}
+
+.nav-tabs > li > a:hover {
+  border-color: #eeeeee #eeeeee #dddddd;
+}
+
+.nav-tabs > .active > a,
+.nav-tabs > .active > a:hover {
+  color: #555555;
+  cursor: default;
+  background-color: #ffffff;
+  border: 1px solid #ddd;
+  border-bottom-color: transparent;
+}
+
+.nav-pills > li > a {
+  padding-top: 8px;
+  padding-bottom: 8px;
+  margin-top: 2px;
+  margin-bottom: 2px;
+  -webkit-border-radius: 5px;
+     -moz-border-radius: 5px;
+          border-radius: 5px;
+}
+
+.nav-pills > .active > a,
+.nav-pills > .active > a:hover {
+  color: #ffffff;
+  background-color: #0088cc;
+}
+
+.nav-stacked > li {
+  float: none;
+}
+
+.nav-stacked > li > a {
+  margin-right: 0;
+}
+
+.nav-tabs.nav-stacked {
+  border-bottom: 0;
+}
+
+.nav-tabs.nav-stacked > li > a {
+  border: 1px solid #ddd;
+  -webkit-border-radius: 0;
+     -moz-border-radius: 0;
+          border-radius: 0;
+}
+
+.nav-tabs.nav-stacked > li:first-child > a {
+  -webkit-border-top-right-radius: 4px;
+          border-top-right-radius: 4px;
+  -webkit-border-top-left-radius: 4px;
+          border-top-left-radius: 4px;
+  -moz-border-radius-topright: 4px;
+  -moz-border-radius-topleft: 4px;
+}
+
+.nav-tabs.nav-stacked > li:last-child > a {
+  -webkit-border-bottom-right-radius: 4px;
+          border-bottom-right-radius: 4px;
+  -webkit-border-bottom-left-radius: 4px;
+          border-bottom-left-radius: 4px;
+  -moz-border-radius-bottomright: 4px;
+  -moz-border-radius-bottomleft: 4px;
+}
+
+.nav-tabs.nav-stacked > li > a:hover {
+  z-index: 2;
+  border-color: #ddd;
+}
+
+.nav-pills.nav-stacked > li > a {
+  margin-bottom: 3px;
+}
+
+.nav-pills.nav-stacked > li:last-child > a {
+  margin-bottom: 1px;
+}
+
+.nav-tabs .dropdown-menu {
+  -webkit-border-radius: 0 0 6px 6px;
+     -moz-border-radius: 0 0 6px 6px;
+          border-radius: 0 0 6px 6px;
+}
+
+.nav-pills .dropdown-menu {
+  -webkit-border-radius: 6px;
+     -moz-border-radius: 6px;
+          border-radius: 6px;
+}
+
+.nav .dropdown-toggle .caret {
+  margin-top: 6px;
+  border-top-color: #0088cc;
+  border-bottom-color: #0088cc;
+}
+
+.nav .dropdown-toggle:hover .caret {
+  border-top-color: #005580;
+  border-bottom-color: #005580;
+}
+
+/* move down carets for tabs */
+
+.nav-tabs .dropdown-toggle .caret {
+  margin-top: 8px;
+}
+
+.nav .active .dropdown-toggle .caret {
+  border-top-color: #fff;
+  border-bottom-color: #fff;
+}
+
+.nav-tabs .active .dropdown-toggle .caret {
+  border-top-color: #555555;
+  border-bottom-color: #555555;
+}
+
+.nav > .dropdown.active > a:hover {
+  cursor: pointer;
+}
+
+.nav-tabs .open .dropdown-toggle,
+.nav-pills .open .dropdown-toggle,
+.nav > li.dropdown.open.active > a:hover {
+  color: #ffffff;
+  background-color: #999999;
+  border-color: #999999;
+}
+
+.nav li.dropdown.open .caret,
+.nav li.dropdown.open.active .caret,
+.nav li.dropdown.open a:hover .caret {
+  border-top-color: #ffffff;
+  border-bottom-color: #ffffff;
+  opacity: 1;
+  filter: alpha(opacity=100);
+}
+
+.tabs-stacked .open > a:hover {
+  border-color: #999999;
+}
+
+.tabbable {
+  *zoom: 1;
+}
+
+.tabbable:before,
+.tabbable:after {
+  display: table;
+  line-height: 0;
+  content: "";
+}
+
+.tabbable:after {
+  clear: both;
+}
+
+.tab-content {
+  overflow: auto;
+}
+
+.tabs-below > .nav-tabs,
+.tabs-right > .nav-tabs,
+.tabs-left > .nav-tabs {
+  border-bottom: 0;
+}
+
+.tab-content > .tab-pane,
+.pill-content > .pill-pane {
+  display: none;
+}
+
+.tab-content > .active,
+.pill-content > .active {
+  display: block;
+}
+
+.tabs-below > .nav-tabs {
+  border-top: 1px solid #ddd;
+}
+
+.tabs-below > .nav-tabs > li {
+  margin-top: -1px;
+  margin-bottom: 0;
+}
+
+.tabs-below > .nav-tabs > li > a {
+  -webkit-border-radius: 0 0 4px 4px;
+     -moz-border-radius: 0 0 4px 4px;
+          border-radius: 0 0 4px 4px;
+}
+
+.tabs-below > .nav-tabs > li > a:hover {
+  border-top-color: #ddd;
+  border-bottom-color: transparent;
+}
+
+.tabs-below > .nav-tabs > .active > a,
+.tabs-below > .nav-tabs > .active > a:hover {
+  border-color: transparent #ddd #ddd #ddd;
+}
+
+.tabs-left > .nav-tabs > li,
+.tabs-right > .nav-tabs > li {
+  float: none;
+}
+
+.tabs-left > .nav-tabs > li > a,
+.tabs-right > .nav-tabs > li > a {
+  min-width: 74px;
+  margin-right: 0;
+  margin-bottom: 3px;
+}
+
+.tabs-left > .nav-tabs {
+  float: left;
+  margin-right: 19px;
+  border-right: 1px solid #ddd;
+}
+
+.tabs-left > .nav-tabs > li > a {
+  margin-right: -1px;
+  -webkit-border-radius: 4px 0 0 4px;
+     -moz-border-radius: 4px 0 0 4px;
+          border-radius: 4px 0 0 4px;
+}
+
+.tabs-left > .nav-tabs > li > a:hover {
+  border-color: #eeeeee #dddddd #eeeeee #eeeeee;
+}
+
+.tabs-left > .nav-tabs .active > a,
+.tabs-left > .nav-tabs .active > a:hover {
+  border-color: #ddd transparent #ddd #ddd;
+  *border-right-color: #ffffff;
+}
+
+.tabs-right > .nav-tabs {
+  float: right;
+  margin-left: 19px;
+  border-left: 1px solid #ddd;
+}
+
+.tabs-right > .nav-tabs > li > a {
+  margin-left: -1px;
+  -webkit-border-radius: 0 4px 4px 0;
+     -moz-border-radius: 0 4px 4px 0;
+          border-radius: 0 4px 4px 0;
+}
+
+.tabs-right > .nav-tabs > li > a:hover {
+  border-color: #eeeeee #eeeeee #eeeeee #dddddd;
+}
+
+.tabs-right > .nav-tabs .active > a,
+.tabs-right > .nav-tabs .active > a:hover {
+  border-color: #ddd #ddd #ddd transparent;
+  *border-left-color: #ffffff;
+}
+
+.nav > .disabled > a {
+  color: #999999;
+}
+
+.nav > .disabled > a:hover {
+  text-decoration: none;
+  cursor: default;
+  background-color: transparent;
+}
+
+.navbar {
+  *position: relative;
+  *z-index: 2;
+  margin-bottom: 20px;
+  overflow: visible;
+  color: #777777;
+}
+
+.navbar-inner {
+  min-height: 40px;
+  padding-right: 20px;
+  padding-left: 20px;
+  background-color: #fafafa;
+  background-image: -moz-linear-gradient(top, #ffffff, #f2f2f2);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#ffffff), to(#f2f2f2));
+  background-image: -webkit-linear-gradient(top, #ffffff, #f2f2f2);
+  background-image: -o-linear-gradient(top, #ffffff, #f2f2f2);
+  background-image: linear-gradient(to bottom, #ffffff, #f2f2f2);
+  background-repeat: repeat-x;
+  border: 1px solid #d4d4d4;
+  -webkit-border-radius: 4px;
+     -moz-border-radius: 4px;
+          border-radius: 4px;
+  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ffffffff', endColorstr='#fff2f2f2', GradientType=0);
+  *zoom: 1;
+  -webkit-box-shadow: 0 1px 4px rgba(0, 0, 0, 0.065);
+     -moz-box-shadow: 0 1px 4px rgba(0, 0, 0, 0.065);
+          box-shadow: 0 1px 4px rgba(0, 0, 0, 0.065);
+}
+
+.navbar-inner:before,
+.navbar-inner:after {
+  display: table;
+  line-height: 0;
+  content: "";
+}
+
+.navbar-inner:after {
+  clear: both;
+}
+
+.navbar .container {
+  width: auto;
+}
+
+.nav-collapse.collapse {
+  height: auto;
+}
+
+.navbar .brand {
+  display: block;
+  float: left;
+  padding: 10px 20px 10px;
+  margin-left: -20px;
+  font-size: 20px;
+  font-weight: 200;
+  color: #777777;
+  text-shadow: 0 1px 0 #ffffff;
+}
+
+.navbar .brand:hover {
+  text-decoration: none;
+}
+
+.navbar-text {
+  margin-bottom: 0;
+  line-height: 40px;
+}
+
+.navbar-link {
+  color: #777777;
+}
+
+.navbar-link:hover {
+  color: #333333;
+}
+
+.navbar .divider-vertical {
+  height: 40px;
+  margin: 0 9px;
+  border-right: 1px solid #ffffff;
+  border-left: 1px solid #f2f2f2;
+}
+
+.navbar .btn,
+.navbar .btn-group {
+  margin-top: 5px;
+}
+
+.navbar .btn-group .btn,
+.navbar .input-prepend .btn,
+.navbar .input-append .btn {
+  margin-top: 0;
+}
+
+.navbar-form {
+  margin-bottom: 0;
+  *zoom: 1;
+}
+
+.navbar-form:before,
+.navbar-form:after {
+  display: table;
+  line-height: 0;
+  content: "";
+}
+
+.navbar-form:after {
+  clear: both;
+}
+
+.navbar-form input,
+.navbar-form select,
+.navbar-form .radio,
+.navbar-form .checkbox {
+  margin-top: 5px;
+}
+
+.navbar-form input,
+.navbar-form select,
+.navbar-form .btn {
+  display: inline-block;
+  margin-bottom: 0;
+}
+
+.navbar-form input[type="image"],
+.navbar-form input[type="checkbox"],
+.navbar-form input[type="radio"] {
+  margin-top: 3px;
+}
+
+.navbar-form .input-append,
+.navbar-form .input-prepend {
+  margin-top: 6px;
+  white-space: nowrap;
+}
+
+.navbar-form .input-append input,
+.navbar-form .input-prepend input {
+  margin-top: 0;
+}
+
+.navbar-search {
+  position: relative;
+  float: left;
+  margin-top: 5px;
+  margin-bottom: 0;
+}
+
+.navbar-search .search-query {
+  padding: 4px 14px;
+  margin-bottom: 0;
+  font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+  font-size: 13px;
+  font-weight: normal;
+  line-height: 1;
+  -webkit-border-radius: 15px;
+     -moz-border-radius: 15px;
+          border-radius: 15px;
+}
+
+.navbar-static-top {
+  position: static;
+  width: 100%;
+  margin-bottom: 0;
+}
+
+.navbar-static-top .navbar-inner {
+  -webkit-border-radius: 0;
+     -moz-border-radius: 0;
+          border-radius: 0;
+}
+
+.navbar-fixed-top,
+.navbar-fixed-bottom {
+  position: fixed;
+  right: 0;
+  left: 0;
+  z-index: 1030;
+  margin-bottom: 0;
+}
+
+.navbar-fixed-top .navbar-inner,
+.navbar-static-top .navbar-inner {
+  border-width: 0 0 1px;
+}
+
+.navbar-fixed-bottom .navbar-inner {
+  border-width: 1px 0 0;
+}
+
+.navbar-fixed-top .navbar-inner,
+.navbar-fixed-bottom .navbar-inner {
+  padding-right: 0;
+  padding-left: 0;
+  -webkit-border-radius: 0;
+     -moz-border-radius: 0;
+          border-radius: 0;
+}
+
+.navbar-static-top .container,
+.navbar-fixed-top .container,
+.navbar-fixed-bottom .container {
+  width: 940px;
+}
+
+.navbar-fixed-top {
+  top: 0;
+}
+
+.navbar-fixed-top .navbar-inner,
+.navbar-static-top .navbar-inner {
+  -webkit-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.1), 0 1px 10px rgba(0, 0, 0, 0.1);
+     -moz-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.1), 0 1px 10px rgba(0, 0, 0, 0.1);
+          box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.1), 0 1px 10px rgba(0, 0, 0, 0.1);
+}
+
+.navbar-fixed-bottom {
+  bottom: 0;
+}
+
+.navbar-fixed-bottom .navbar-inner {
+  -webkit-box-shadow: inset 0 1px 0 rgba(0, 0, 0, 0.1), 0 -1px 10px rgba(0, 0, 0, 0.1);
+     -moz-box-shadow: inset 0 1px 0 rgba(0, 0, 0, 0.1), 0 -1px 10px rgba(0, 0, 0, 0.1);
+          box-shadow: inset 0 1px 0 rgba(0, 0, 0, 0.1), 0 -1px 10px rgba(0, 0, 0, 0.1);
+}
+
+.navbar .nav {
+  position: relative;
+  left: 0;
+  display: block;
+  float: left;
+  margin: 0 10px 0 0;
+}
+
+.navbar .nav.pull-right {
+  float: right;
+  margin-right: 0;
+}
+
+.navbar .nav > li {
+  float: left;
+}
+
+.navbar .nav > li > a {
+  float: none;
+  padding: 10px 15px 10px;
+  color: #777777;
+  text-decoration: none;
+  text-shadow: 0 1px 0 #ffffff;
+}
+
+.navbar .nav .dropdown-toggle .caret {
+  margin-top: 8px;
+}
+
+.navbar .nav > li > a:focus,
+.navbar .nav > li > a:hover {
+  color: #333333;
+  text-decoration: none;
+  background-color: transparent;
+}
+
+.navbar .nav > .active > a,
+.navbar .nav > .active > a:hover,
+.navbar .nav > .active > a:focus {
+  color: #555555;
+  text-decoration: none;
+  background-color: #e5e5e5;
+  -webkit-box-shadow: inset 0 3px 8px rgba(0, 0, 0, 0.125);
+     -moz-box-shadow: inset 0 3px 8px rgba(0, 0, 0, 0.125);
+          box-shadow: inset 0 3px 8px rgba(0, 0, 0, 0.125);
+}
+
+.navbar .btn-navbar {
+  display: none;
+  float: right;
+  padding: 7px 10px;
+  margin-right: 5px;
+  margin-left: 5px;
+  color: #ffffff;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+  background-color: #ededed;
+  *background-color: #e5e5e5;
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#f2f2f2), to(#e5e5e5));
+  background-image: -webkit-linear-gradient(top, #f2f2f2, #e5e5e5);
+  background-image: -o-linear-gradient(top, #f2f2f2, #e5e5e5);
+  background-image: linear-gradient(to bottom, #f2f2f2, #e5e5e5);
+  background-image: -moz-linear-gradient(top, #f2f2f2, #e5e5e5);
+  background-repeat: repeat-x;
+  border-color: #e5e5e5 #e5e5e5 #bfbfbf;
+  border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
+  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#fff2f2f2', endColorstr='#ffe5e5e5', GradientType=0);
+  filter: progid:dximagetransform.microsoft.gradient(enabled=false);
+  -webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.1), 0 1px 0 rgba(255, 255, 255, 0.075);
+     -moz-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.1), 0 1px 0 rgba(255, 255, 255, 0.075);
+          box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.1), 0 1px 0 rgba(255, 255, 255, 0.075);
+}
+
+.navbar .btn-navbar:hover,
+.navbar .btn-navbar:active,
+.navbar .btn-navbar.active,
+.navbar .btn-navbar.disabled,
+.navbar .btn-navbar[disabled] {
+  color: #ffffff;
+  background-color: #e5e5e5;
+  *background-color: #d9d9d9;
+}
+
+.navbar .btn-navbar:active,
+.navbar .btn-navbar.active {
+  background-color: #cccccc \9;
+}
+
+.navbar .btn-navbar .icon-bar {
+  display: block;
+  width: 18px;
+  height: 2px;
+  background-color: #f5f5f5;
+  -webkit-border-radius: 1px;
+     -moz-border-radius: 1px;
+          border-radius: 1px;
+  -webkit-box-shadow: 0 1px 0 rgba(0, 0, 0, 0.25);
+     -moz-box-shadow: 0 1px 0 rgba(0, 0, 0, 0.25);
+          box-shadow: 0 1px 0 rgba(0, 0, 0, 0.25);
+}
+
+.btn-navbar .icon-bar + .icon-bar {
+  margin-top: 3px;
+}
+
+.navbar .nav > li > .dropdown-menu:before {
+  position: absolute;
+  top: -7px;
+  left: 9px;
+  display: inline-block;
+  border-right: 7px solid transparent;
+  border-bottom: 7px solid #ccc;
+  border-left: 7px solid transparent;
+  border-bottom-color: rgba(0, 0, 0, 0.2);
+  content: '';
+}
+
+.navbar .nav > li > .dropdown-menu:after {
+  position: absolute;
+  top: -6px;
+  left: 10px;
+  display: inline-block;
+  border-right: 6px solid transparent;
+  border-bottom: 6px solid #ffffff;
+  border-left: 6px solid transparent;
+  content: '';
+}
+
+.navbar-fixed-bottom .nav > li > .dropdown-menu:before {
+  top: auto;
+  bottom: -7px;
+  border-top: 7px solid #ccc;
+  border-bottom: 0;
+  border-top-color: rgba(0, 0, 0, 0.2);
+}
+
+.navbar-fixed-bottom .nav > li > .dropdown-menu:after {
+  top: auto;
+  bottom: -6px;
+  border-top: 6px solid #ffffff;
+  border-bottom: 0;
+}
+
+.navbar .nav li.dropdown.open > .dropdown-toggle,
+.navbar .nav li.dropdown.active > .dropdown-toggle,
+.navbar .nav li.dropdown.open.active > .dropdown-toggle {
+  color: #555555;
+  background-color: #e5e5e5;
+}
+
+.navbar .nav li.dropdown > .dropdown-toggle .caret {
+  border-top-color: #777777;
+  border-bottom-color: #777777;
+}
+
+.navbar .nav li.dropdown.open > .dropdown-toggle .caret,
+.navbar .nav li.dropdown.active > .dropdown-toggle .caret,
+.navbar .nav li.dropdown.open.active > .dropdown-toggle .caret {
+  border-top-color: #555555;
+  border-bottom-color: #555555;
+}
+
+.navbar .pull-right > li > .dropdown-menu,
+.navbar .nav > li > .dropdown-menu.pull-right {
+  right: 0;
+  left: auto;
+}
+
+.navbar .pull-right > li > .dropdown-menu:before,
+.navbar .nav > li > .dropdown-menu.pull-right:before {
+  right: 12px;
+  left: auto;
+}
+
+.navbar .pull-right > li > .dropdown-menu:after,
+.navbar .nav > li > .dropdown-menu.pull-right:after {
+  right: 13px;
+  left: auto;
+}
+
+.navbar .pull-right > li > .dropdown-menu .dropdown-menu,
+.navbar .nav > li > .dropdown-menu.pull-right .dropdown-menu {
+  right: 100%;
+  left: auto;
+  margin-right: -1px;
+  margin-left: 0;
+  -webkit-border-radius: 6px 0 6px 6px;
+     -moz-border-radius: 6px 0 6px 6px;
+          border-radius: 6px 0 6px 6px;
+}
+
+.navbar-inverse {
+  color: #999999;
+}
+
+.navbar-inverse .navbar-inner {
+  background-color: #1b1b1b;
+  background-image: -moz-linear-gradient(top, #222222, #111111);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#222222), to(#111111));
+  background-image: -webkit-linear-gradient(top, #222222, #111111);
+  background-image: -o-linear-gradient(top, #222222, #111111);
+  background-image: linear-gradient(to bottom, #222222, #111111);
+  background-repeat: repeat-x;
+  border-color: #252525;
+  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff222222', endColorstr='#ff111111', GradientType=0);
+}
+
+.navbar-inverse .brand,
+.navbar-inverse .nav > li > a {
+  color: #999999;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+}
+
+.navbar-inverse .brand:hover,
+.navbar-inverse .nav > li > a:hover {
+  color: #ffffff;
+}
+
+.navbar-inverse .nav > li > a:focus,
+.navbar-inverse .nav > li > a:hover {
+  color: #ffffff;
+  background-color: transparent;
+}
+
+.navbar-inverse .nav .active > a,
+.navbar-inverse .nav .active > a:hover,
+.navbar-inverse .nav .active > a:focus {
+  color: #ffffff;
+  background-color: #111111;
+}
+
+.navbar-inverse .navbar-link {
+  color: #999999;
+}
+
+.navbar-inverse .navbar-link:hover {
+  color: #ffffff;
+}
+
+.navbar-inverse .divider-vertical {
+  border-right-color: #222222;
+  border-left-color: #111111;
+}
+
+.navbar-inverse .nav li.dropdown.open > .dropdown-toggle,
+.navbar-inverse .nav li.dropdown.active > .dropdown-toggle,
+.navbar-inverse .nav li.dropdown.open.active > .dropdown-toggle {
+  color: #ffffff;
+  background-color: #111111;
+}
+
+.navbar-inverse .nav li.dropdown > .dropdown-toggle .caret {
+  border-top-color: #999999;
+  border-bottom-color: #999999;
+}
+
+.navbar-inverse .nav li.dropdown.open > .dropdown-toggle .caret,
+.navbar-inverse .nav li.dropdown.active > .dropdown-toggle .caret,
+.navbar-inverse .nav li.dropdown.open.active > .dropdown-toggle .caret {
+  border-top-color: #ffffff;
+  border-bottom-color: #ffffff;
+}
+
+.navbar-inverse .navbar-search .search-query {
+  color: #ffffff;
+  background-color: #515151;
+  border-color: #111111;
+  -webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1), 0 1px 0 rgba(255, 255, 255, 0.15);
+     -moz-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1), 0 1px 0 rgba(255, 255, 255, 0.15);
+          box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1), 0 1px 0 rgba(255, 255, 255, 0.15);
+  -webkit-transition: none;
+     -moz-transition: none;
+       -o-transition: none;
+          transition: none;
+}
+
+.navbar-inverse .navbar-search .search-query:-moz-placeholder {
+  color: #cccccc;
+}
+
+.navbar-inverse .navbar-search .search-query:-ms-input-placeholder {
+  color: #cccccc;
+}
+
+.navbar-inverse .navbar-search .search-query::-webkit-input-placeholder {
+  color: #cccccc;
+}
+
+.navbar-inverse .navbar-search .search-query:focus,
+.navbar-inverse .navbar-search .search-query.focused {
+  padding: 5px 15px;
+  color: #333333;
+  text-shadow: 0 1px 0 #ffffff;
+  background-color: #ffffff;
+  border: 0;
+  outline: 0;
+  -webkit-box-shadow: 0 0 3px rgba(0, 0, 0, 0.15);
+     -moz-box-shadow: 0 0 3px rgba(0, 0, 0, 0.15);
+          box-shadow: 0 0 3px rgba(0, 0, 0, 0.15);
+}
+
+.navbar-inverse .btn-navbar {
+  color: #ffffff;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+  background-color: #0e0e0e;
+  *background-color: #040404;
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#151515), to(#040404));
+  background-image: -webkit-linear-gradient(top, #151515, #040404);
+  background-image: -o-linear-gradient(top, #151515, #040404);
+  background-image: linear-gradient(to bottom, #151515, #040404);
+  background-image: -moz-linear-gradient(top, #151515, #040404);
+  background-repeat: repeat-x;
+  border-color: #040404 #040404 #000000;
+  border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
+  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff151515', endColorstr='#ff040404', GradientType=0);
+  filter: progid:dximagetransform.microsoft.gradient(enabled=false);
+}
+
+.navbar-inverse .btn-navbar:hover,
+.navbar-inverse .btn-navbar:active,
+.navbar-inverse .btn-navbar.active,
+.navbar-inverse .btn-navbar.disabled,
+.navbar-inverse .btn-navbar[disabled] {
+  color: #ffffff;
+  background-color: #040404;
+  *background-color: #000000;
+}
+
+.navbar-inverse .btn-navbar:active,
+.navbar-inverse .btn-navbar.active {
+  background-color: #000000 \9;
+}
+
+.breadcrumb {
+  padding: 8px 15px;
+  margin: 0 0 20px;
+  list-style: none;
+  background-color: #f5f5f5;
+  -webkit-border-radius: 4px;
+     -moz-border-radius: 4px;
+          border-radius: 4px;
+}
+
+.breadcrumb li {
+  display: inline-block;
+  *display: inline;
+  text-shadow: 0 1px 0 #ffffff;
+  *zoom: 1;
+}
+
+.breadcrumb .divider {
+  padding: 0 5px;
+  color: #ccc;
+}
+
+.breadcrumb .active {
+  color: #999999;
+}
+
+.pagination {
+  height: 40px;
+  margin: 20px 0;
+}
+
+.pagination ul {
+  display: inline-block;
+  *display: inline;
+  margin-bottom: 0;
+  margin-left: 0;
+  -webkit-border-radius: 3px;
+     -moz-border-radius: 3px;
+          border-radius: 3px;
+  *zoom: 1;
+  -webkit-box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+     -moz-box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+          box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+}
+
+.pagination ul > li {
+  display: inline;
+}
+
+.pagination ul > li > a,
+.pagination ul > li > span {
+  float: left;
+  padding: 0 14px;
+  line-height: 38px;
+  text-decoration: none;
+  background-color: #ffffff;
+  border: 1px solid #dddddd;
+  border-left-width: 0;
+}
+
+.pagination ul > li > a:hover,
+.pagination ul > .active > a,
+.pagination ul > .active > span {
+  background-color: #f5f5f5;
+}
+
+.pagination ul > .active > a,
+.pagination ul > .active > span {
+  color: #999999;
+  cursor: default;
+}
+
+.pagination ul > .disabled > span,
+.pagination ul > .disabled > a,
+.pagination ul > .disabled > a:hover {
+  color: #999999;
+  cursor: default;
+  background-color: transparent;
+}
+
+.pagination ul > li:first-child > a,
+.pagination ul > li:first-child > span {
+  border-left-width: 1px;
+  -webkit-border-radius: 3px 0 0 3px;
+     -moz-border-radius: 3px 0 0 3px;
+          border-radius: 3px 0 0 3px;
+}
+
+.pagination ul > li:last-child > a,
+.pagination ul > li:last-child > span {
+  -webkit-border-radius: 0 3px 3px 0;
+     -moz-border-radius: 0 3px 3px 0;
+          border-radius: 0 3px 3px 0;
+}
+
+.pagination-centered {
+  text-align: center;
+}
+
+.pagination-right {
+  text-align: right;
+}
+
+.pager {
+  margin: 20px 0;
+  text-align: center;
+  list-style: none;
+  *zoom: 1;
+}
+
+.pager:before,
+.pager:after {
+  display: table;
+  line-height: 0;
+  content: "";
+}
+
+.pager:after {
+  clear: both;
+}
+
+.pager li {
+  display: inline;
+}
+
+.pager a,
+.pager span {
+  display: inline-block;
+  padding: 5px 14px;
+  background-color: #fff;
+  border: 1px solid #ddd;
+  -webkit-border-radius: 15px;
+     -moz-border-radius: 15px;
+          border-radius: 15px;
+}
+
+.pager a:hover {
+  text-decoration: none;
+  background-color: #f5f5f5;
+}
+
+.pager .next a,
+.pager .next span {
+  float: right;
+}
+
+.pager .previous a {
+  float: left;
+}
+
+.pager .disabled a,
+.pager .disabled a:hover,
+.pager .disabled span {
+  color: #999999;
+  cursor: default;
+  background-color: #fff;
+}
+
+.modal-open .modal .dropdown-menu {
+  z-index: 2050;
+}
+
+.modal-open .modal .dropdown.open {
+  *z-index: 2050;
+}
+
+.modal-open .modal .popover {
+  z-index: 2060;
+}
+
+.modal-open .modal .tooltip {
+  z-index: 2080;
+}
+
+.modal-backdrop {
+  position: fixed;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  z-index: 1040;
+  background-color: #000000;
+}
+
+.modal-backdrop.fade {
+  opacity: 0;
+}
+
+.modal-backdrop,
+.modal-backdrop.fade.in {
+  opacity: 0.8;
+  filter: alpha(opacity=80);
+}
+
+.modal {
+  position: fixed;
+  top: 50%;
+  left: 50%;
+  z-index: 1050;
+  width: 560px;
+  margin: -250px 0 0 -280px;
+  overflow: auto;
+  background-color: #ffffff;
+  border: 1px solid #999;
+  border: 1px solid rgba(0, 0, 0, 0.3);
+  *border: 1px solid #999;
+  -webkit-border-radius: 6px;
+     -moz-border-radius: 6px;
+          border-radius: 6px;
+  -webkit-box-shadow: 0 3px 7px rgba(0, 0, 0, 0.3);
+     -moz-box-shadow: 0 3px 7px rgba(0, 0, 0, 0.3);
+          box-shadow: 0 3px 7px rgba(0, 0, 0, 0.3);
+  -webkit-background-clip: padding-box;
+     -moz-background-clip: padding-box;
+          background-clip: padding-box;
+}
+
+.modal.fade {
+  top: -25%;
+  -webkit-transition: opacity 0.3s linear, top 0.3s ease-out;
+     -moz-transition: opacity 0.3s linear, top 0.3s ease-out;
+       -o-transition: opacity 0.3s linear, top 0.3s ease-out;
+          transition: opacity 0.3s linear, top 0.3s ease-out;
+}
+
+.modal.fade.in {
+  top: 50%;
+}
+
+.modal-header {
+  padding: 9px 15px;
+  border-bottom: 1px solid #eee;
+}
+
+.modal-header .close {
+  margin-top: 2px;
+}
+
+.modal-header h3 {
+  margin: 0;
+  line-height: 30px;
+}
+
+.modal-body {
+  max-height: 400px;
+  padding: 15px;
+  overflow-y: auto;
+}
+
+.modal-form {
+  margin-bottom: 0;
+}
+
+.modal-footer {
+  padding: 14px 15px 15px;
+  margin-bottom: 0;
+  text-align: right;
+  background-color: #f5f5f5;
+  border-top: 1px solid #ddd;
+  -webkit-border-radius: 0 0 6px 6px;
+     -moz-border-radius: 0 0 6px 6px;
+          border-radius: 0 0 6px 6px;
+  *zoom: 1;
+  -webkit-box-shadow: inset 0 1px 0 #ffffff;
+     -moz-box-shadow: inset 0 1px 0 #ffffff;
+          box-shadow: inset 0 1px 0 #ffffff;
+}
+
+.modal-footer:before,
+.modal-footer:after {
+  display: table;
+  line-height: 0;
+  content: "";
+}
+
+.modal-footer:after {
+  clear: both;
+}
+
+.modal-footer .btn + .btn {
+  margin-bottom: 0;
+  margin-left: 5px;
+}
+
+.modal-footer .btn-group .btn + .btn {
+  margin-left: -1px;
+}
+
+.tooltip {
+  position: absolute;
+  z-index: 1030;
+  display: block;
+  padding: 5px;
+  font-size: 11px;
+  opacity: 0;
+  filter: alpha(opacity=0);
+  visibility: visible;
+}
+
+.tooltip.in {
+  opacity: 0.8;
+  filter: alpha(opacity=80);
+}
+
+.tooltip.top {
+  margin-top: -3px;
+}
+
+.tooltip.right {
+  margin-left: 3px;
+}
+
+.tooltip.bottom {
+  margin-top: 3px;
+}
+
+.tooltip.left {
+  margin-left: -3px;
+}
+
+.tooltip-inner {
+  max-width: 200px;
+  padding: 3px 8px;
+  color: #ffffff;
+  text-align: center;
+  text-decoration: none;
+  background-color: #000000;
+  -webkit-border-radius: 4px;
+     -moz-border-radius: 4px;
+          border-radius: 4px;
+}
+
+.tooltip-arrow {
+  position: absolute;
+  width: 0;
+  height: 0;
+  border-color: transparent;
+  border-style: solid;
+}
+
+.tooltip.top .tooltip-arrow {
+  bottom: 0;
+  left: 50%;
+  margin-left: -5px;
+  border-top-color: #000000;
+  border-width: 5px 5px 0;
+}
+
+.tooltip.right .tooltip-arrow {
+  top: 50%;
+  left: 0;
+  margin-top: -5px;
+  border-right-color: #000000;
+  border-width: 5px 5px 5px 0;
+}
+
+.tooltip.left .tooltip-arrow {
+  top: 50%;
+  right: 0;
+  margin-top: -5px;
+  border-left-color: #000000;
+  border-width: 5px 0 5px 5px;
+}
+
+.tooltip.bottom .tooltip-arrow {
+  top: 0;
+  left: 50%;
+  margin-left: -5px;
+  border-bottom-color: #000000;
+  border-width: 0 5px 5px;
+}
+
+.popover {
+  position: absolute;
+  top: 0;
+  left: 0;
+  z-index: 1010;
+  display: none;
+  width: 236px;
+  padding: 1px;
+  background-color: #ffffff;
+  border: 1px solid #ccc;
+  border: 1px solid rgba(0, 0, 0, 0.2);
+  -webkit-border-radius: 6px;
+     -moz-border-radius: 6px;
+          border-radius: 6px;
+  -webkit-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
+     -moz-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
+          box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
+  -webkit-background-clip: padding-box;
+     -moz-background-clip: padding;
+          background-clip: padding-box;
+}
+
+.popover.top {
+  margin-bottom: 10px;
+}
+
+.popover.right {
+  margin-left: 10px;
+}
+
+.popover.bottom {
+  margin-top: 10px;
+}
+
+.popover.left {
+  margin-right: 10px;
+}
+
+.popover-title {
+  padding: 8px 14px;
+  margin: 0;
+  font-size: 14px;
+  font-weight: normal;
+  line-height: 18px;
+  background-color: #f7f7f7;
+  border-bottom: 1px solid #ebebeb;
+  -webkit-border-radius: 5px 5px 0 0;
+     -moz-border-radius: 5px 5px 0 0;
+          border-radius: 5px 5px 0 0;
+}
+
+.popover-content {
+  padding: 9px 14px;
+}
+
+.popover-content p,
+.popover-content ul,
+.popover-content ol {
+  margin-bottom: 0;
+}
+
+.popover .arrow,
+.popover .arrow:after {
+  position: absolute;
+  display: inline-block;
+  width: 0;
+  height: 0;
+  border-color: transparent;
+  border-style: solid;
+}
+
+.popover .arrow:after {
+  z-index: -1;
+  content: "";
+}
+
+.popover.top .arrow {
+  bottom: -10px;
+  left: 50%;
+  margin-left: -10px;
+  border-top-color: #ffffff;
+  border-width: 10px 10px 0;
+}
+
+.popover.top .arrow:after {
+  bottom: -1px;
+  left: -11px;
+  border-top-color: rgba(0, 0, 0, 0.25);
+  border-width: 11px 11px 0;
+}
+
+.popover.right .arrow {
+  top: 50%;
+  left: -10px;
+  margin-top: -10px;
+  border-right-color: #ffffff;
+  border-width: 10px 10px 10px 0;
+}
+
+.popover.right .arrow:after {
+  bottom: -11px;
+  left: -1px;
+  border-right-color: rgba(0, 0, 0, 0.25);
+  border-width: 11px 11px 11px 0;
+}
+
+.popover.bottom .arrow {
+  top: -10px;
+  left: 50%;
+  margin-left: -10px;
+  border-bottom-color: #ffffff;
+  border-width: 0 10px 10px;
+}
+
+.popover.bottom .arrow:after {
+  top: -1px;
+  left: -11px;
+  border-bottom-color: rgba(0, 0, 0, 0.25);
+  border-width: 0 11px 11px;
+}
+
+.popover.left .arrow {
+  top: 50%;
+  right: -10px;
+  margin-top: -10px;
+  border-left-color: #ffffff;
+  border-width: 10px 0 10px 10px;
+}
+
+.popover.left .arrow:after {
+  right: -1px;
+  bottom: -11px;
+  border-left-color: rgba(0, 0, 0, 0.25);
+  border-width: 11px 0 11px 11px;
+}
+
+.thumbnails {
+  margin-left: -20px;
+  list-style: none;
+  *zoom: 1;
+}
+
+.thumbnails:before,
+.thumbnails:after {
+  display: table;
+  line-height: 0;
+  content: "";
+}
+
+.thumbnails:after {
+  clear: both;
+}
+
+.row-fluid .thumbnails {
+  margin-left: 0;
+}
+
+.thumbnails > li {
+  float: left;
+  margin-bottom: 20px;
+  margin-left: 20px;
+}
+
+.thumbnail {
+  display: block;
+  padding: 4px;
+  line-height: 20px;
+  border: 1px solid #ddd;
+  -webkit-border-radius: 4px;
+     -moz-border-radius: 4px;
+          border-radius: 4px;
+  -webkit-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.055);
+     -moz-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.055);
+          box-shadow: 0 1px 3px rgba(0, 0, 0, 0.055);
+  -webkit-transition: all 0.2s ease-in-out;
+     -moz-transition: all 0.2s ease-in-out;
+       -o-transition: all 0.2s ease-in-out;
+          transition: all 0.2s ease-in-out;
+}
+
+a.thumbnail:hover {
+  border-color: #0088cc;
+  -webkit-box-shadow: 0 1px 4px rgba(0, 105, 214, 0.25);
+     -moz-box-shadow: 0 1px 4px rgba(0, 105, 214, 0.25);
+          box-shadow: 0 1px 4px rgba(0, 105, 214, 0.25);
+}
+
+.thumbnail > img {
+  display: block;
+  max-width: 100%;
+  margin-right: auto;
+  margin-left: auto;
+}
+
+.thumbnail .caption {
+  padding: 9px;
+  color: #555555;
+}
+
+.label,
+.badge {
+  font-size: 11.844px;
+  font-weight: bold;
+  line-height: 14px;
+  color: #ffffff;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+  white-space: nowrap;
+  vertical-align: baseline;
+  background-color: #999999;
+}
+
+.label {
+  padding: 1px 4px 2px;
+  -webkit-border-radius: 3px;
+     -moz-border-radius: 3px;
+          border-radius: 3px;
+}
+
+.badge {
+  padding: 1px 9px 2px;
+  -webkit-border-radius: 9px;
+     -moz-border-radius: 9px;
+          border-radius: 9px;
+}
+
+a.label:hover,
+a.badge:hover {
+  color: #ffffff;
+  text-decoration: none;
+  cursor: pointer;
+}
+
+.label-important,
+.badge-important {
+  background-color: #b94a48;
+}
+
+.label-important[href],
+.badge-important[href] {
+  background-color: #953b39;
+}
+
+.label-warning,
+.badge-warning {
+  background-color: #f89406;
+}
+
+.label-warning[href],
+.badge-warning[href] {
+  background-color: #c67605;
+}
+
+.label-success,
+.badge-success {
+  background-color: #468847;
+}
+
+.label-success[href],
+.badge-success[href] {
+  background-color: #356635;
+}
+
+.label-info,
+.badge-info {
+  background-color: #3a87ad;
+}
+
+.label-info[href],
+.badge-info[href] {
+  background-color: #2d6987;
+}
+
+.label-inverse,
+.badge-inverse {
+  background-color: #333333;
+}
+
+.label-inverse[href],
+.badge-inverse[href] {
+  background-color: #1a1a1a;
+}
+
+.btn .label,
+.btn .badge {
+  position: relative;
+  top: -1px;
+}
+
+.btn-mini .label,
+.btn-mini .badge {
+  top: 0;
+}
+
+@-webkit-keyframes progress-bar-stripes {
+  from {
+    background-position: 40px 0;
+  }
+  to {
+    background-position: 0 0;
+  }
+}
+
+@-moz-keyframes progress-bar-stripes {
+  from {
+    background-position: 40px 0;
+  }
+  to {
+    background-position: 0 0;
+  }
+}
+
+@-ms-keyframes progress-bar-stripes {
+  from {
+    background-position: 40px 0;
+  }
+  to {
+    background-position: 0 0;
+  }
+}
+
+@-o-keyframes progress-bar-stripes {
+  from {
+    background-position: 0 0;
+  }
+  to {
+    background-position: 40px 0;
+  }
+}
+
+@keyframes progress-bar-stripes {
+  from {
+    background-position: 40px 0;
+  }
+  to {
+    background-position: 0 0;
+  }
+}
+
+.progress {
+  height: 20px;
+  margin-bottom: 20px;
+  overflow: hidden;
+  background-color: #f7f7f7;
+  background-image: -moz-linear-gradient(top, #f5f5f5, #f9f9f9);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#f5f5f5), to(#f9f9f9));
+  background-image: -webkit-linear-gradient(top, #f5f5f5, #f9f9f9);
+  background-image: -o-linear-gradient(top, #f5f5f5, #f9f9f9);
+  background-image: linear-gradient(to bottom, #f5f5f5, #f9f9f9);
+  background-repeat: repeat-x;
+  -webkit-border-radius: 4px;
+     -moz-border-radius: 4px;
+          border-radius: 4px;
+  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#fff5f5f5', endColorstr='#fff9f9f9', GradientType=0);
+  -webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
+     -moz-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
+          box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
+}
+
+.progress .bar {
+  float: left;
+  width: 0;
+  height: 100%;
+  font-size: 12px;
+  color: #ffffff;
+  text-align: center;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+  background-color: #0e90d2;
+  background-image: -moz-linear-gradient(top, #149bdf, #0480be);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#149bdf), to(#0480be));
+  background-image: -webkit-linear-gradient(top, #149bdf, #0480be);
+  background-image: -o-linear-gradient(top, #149bdf, #0480be);
+  background-image: linear-gradient(to bottom, #149bdf, #0480be);
+  background-repeat: repeat-x;
+  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff149bdf', endColorstr='#ff0480be', GradientType=0);
+  -webkit-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
+     -moz-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
+          box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
+  -webkit-box-sizing: border-box;
+     -moz-box-sizing: border-box;
+          box-sizing: border-box;
+  -webkit-transition: width 0.6s ease;
+     -moz-transition: width 0.6s ease;
+       -o-transition: width 0.6s ease;
+          transition: width 0.6s ease;
+}
+
+.progress .bar + .bar {
+  -webkit-box-shadow: inset 1px 0 0 rgba(0, 0, 0, 0.15), inset 0 -1px 0 rgba(0, 0, 0, 0.15);
+     -moz-box-shadow: inset 1px 0 0 rgba(0, 0, 0, 0.15), inset 0 -1px 0 rgba(0, 0, 0, 0.15);
+          box-shadow: inset 1px 0 0 rgba(0, 0, 0, 0.15), inset 0 -1px 0 rgba(0, 0, 0, 0.15);
+}
+
+.progress-striped .bar {
+  background-color: #149bdf;
+  background-image: -webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));
+  background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: -moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  -webkit-background-size: 40px 40px;
+     -moz-background-size: 40px 40px;
+       -o-background-size: 40px 40px;
+          background-size: 40px 40px;
+}
+
+.progress.active .bar {
+  -webkit-animation: progress-bar-stripes 2s linear infinite;
+     -moz-animation: progress-bar-stripes 2s linear infinite;
+      -ms-animation: progress-bar-stripes 2s linear infinite;
+       -o-animation: progress-bar-stripes 2s linear infinite;
+          animation: progress-bar-stripes 2s linear infinite;
+}
+
+.progress-danger .bar,
+.progress .bar-danger {
+  background-color: #dd514c;
+  background-image: -moz-linear-gradient(top, #ee5f5b, #c43c35);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#ee5f5b), to(#c43c35));
+  background-image: -webkit-linear-gradient(top, #ee5f5b, #c43c35);
+  background-image: -o-linear-gradient(top, #ee5f5b, #c43c35);
+  background-image: linear-gradient(to bottom, #ee5f5b, #c43c35);
+  background-repeat: repeat-x;
+  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ffee5f5b', endColorstr='#ffc43c35', GradientType=0);
+}
+
+.progress-danger.progress-striped .bar,
+.progress-striped .bar-danger {
+  background-color: #ee5f5b;
+  background-image: -webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));
+  background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: -moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+}
+
+.progress-success .bar,
+.progress .bar-success {
+  background-color: #5eb95e;
+  background-image: -moz-linear-gradient(top, #62c462, #57a957);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#62c462), to(#57a957));
+  background-image: -webkit-linear-gradient(top, #62c462, #57a957);
+  background-image: -o-linear-gradient(top, #62c462, #57a957);
+  background-image: linear-gradient(to bottom, #62c462, #57a957);
+  background-repeat: repeat-x;
+  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff62c462', endColorstr='#ff57a957', GradientType=0);
+}
+
+.progress-success.progress-striped .bar,
+.progress-striped .bar-success {
+  background-color: #62c462;
+  background-image: -webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));
+  background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: -moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+}
+
+.progress-info .bar,
+.progress .bar-info {
+  background-color: #4bb1cf;
+  background-image: -moz-linear-gradient(top, #5bc0de, #339bb9);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#5bc0de), to(#339bb9));
+  background-image: -webkit-linear-gradient(top, #5bc0de, #339bb9);
+  background-image: -o-linear-gradient(top, #5bc0de, #339bb9);
+  background-image: linear-gradient(to bottom, #5bc0de, #339bb9);
+  background-repeat: repeat-x;
+  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff5bc0de', endColorstr='#ff339bb9', GradientType=0);
+}
+
+.progress-info.progress-striped .bar,
+.progress-striped .bar-info {
+  background-color: #5bc0de;
+  background-image: -webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));
+  background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: -moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+}
+
+.progress-warning .bar,
+.progress .bar-warning {
+  background-color: #faa732;
+  background-image: -moz-linear-gradient(top, #fbb450, #f89406);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#fbb450), to(#f89406));
+  background-image: -webkit-linear-gradient(top, #fbb450, #f89406);
+  background-image: -o-linear-gradient(top, #fbb450, #f89406);
+  background-image: linear-gradient(to bottom, #fbb450, #f89406);
+  background-repeat: repeat-x;
+  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#fffbb450', endColorstr='#fff89406', GradientType=0);
+}
+
+.progress-warning.progress-striped .bar,
+.progress-striped .bar-warning {
+  background-color: #fbb450;
+  background-image: -webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));
+  background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: -moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+}
+
+.accordion {
+  margin-bottom: 20px;
+}
+
+.accordion-group {
+  margin-bottom: 2px;
+  border: 1px solid #e5e5e5;
+  -webkit-border-radius: 4px;
+     -moz-border-radius: 4px;
+          border-radius: 4px;
+}
+
+.accordion-heading {
+  border-bottom: 0;
+}
+
+.accordion-heading .accordion-toggle {
+  display: block;
+  padding: 8px 15px;
+}
+
+.accordion-toggle {
+  cursor: pointer;
+}
+
+.accordion-inner {
+  padding: 9px 15px;
+  border-top: 1px solid #e5e5e5;
+}
+
+.carousel {
+  position: relative;
+  margin-bottom: 20px;
+  line-height: 1;
+}
+
+.carousel-inner {
+  position: relative;
+  width: 100%;
+  overflow: hidden;
+}
+
+.carousel .item {
+  position: relative;
+  display: none;
+  -webkit-transition: 0.6s ease-in-out left;
+     -moz-transition: 0.6s ease-in-out left;
+       -o-transition: 0.6s ease-in-out left;
+          transition: 0.6s ease-in-out left;
+}
+
+.carousel .item > img {
+  display: block;
+  line-height: 1;
+}
+
+.carousel .active,
+.carousel .next,
+.carousel .prev {
+  display: block;
+}
+
+.carousel .active {
+  left: 0;
+}
+
+.carousel .next,
+.carousel .prev {
+  position: absolute;
+  top: 0;
+  width: 100%;
+}
+
+.carousel .next {
+  left: 100%;
+}
+
+.carousel .prev {
+  left: -100%;
+}
+
+.carousel .next.left,
+.carousel .prev.right {
+  left: 0;
+}
+
+.carousel .active.left {
+  left: -100%;
+}
+
+.carousel .active.right {
+  left: 100%;
+}
+
+.carousel-control {
+  position: absolute;
+  top: 40%;
+  left: 15px;
+  width: 40px;
+  height: 40px;
+  margin-top: -20px;
+  font-size: 60px;
+  font-weight: 100;
+  line-height: 30px;
+  color: #ffffff;
+  text-align: center;
+  background: #222222;
+  border: 3px solid #ffffff;
+  -webkit-border-radius: 23px;
+     -moz-border-radius: 23px;
+          border-radius: 23px;
+  opacity: 0.5;
+  filter: alpha(opacity=50);
+}
+
+.carousel-control.right {
+  right: 15px;
+  left: auto;
+}
+
+.carousel-control:hover {
+  color: #ffffff;
+  text-decoration: none;
+  opacity: 0.9;
+  filter: alpha(opacity=90);
+}
+
+.carousel-caption {
+  position: absolute;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  padding: 15px;
+  background: #333333;
+  background: rgba(0, 0, 0, 0.75);
+}
+
+.carousel-caption h4,
+.carousel-caption p {
+  line-height: 20px;
+  color: #ffffff;
+}
+
+.carousel-caption h4 {
+  margin: 0 0 5px;
+}
+
+.carousel-caption p {
+  margin-bottom: 0;
+}
+
+.hero-unit {
+  padding: 60px;
+  margin-bottom: 30px;
+  background-color: #eeeeee;
+  -webkit-border-radius: 6px;
+     -moz-border-radius: 6px;
+          border-radius: 6px;
+}
+
+.hero-unit h1 {
+  margin-bottom: 0;
+  font-size: 60px;
+  line-height: 1;
+  letter-spacing: -1px;
+  color: inherit;
+}
+
+.hero-unit p {
+  font-size: 18px;
+  font-weight: 200;
+  line-height: 30px;
+  color: inherit;
+}
+
+.pull-right {
+  float: right;
+}
+
+.pull-left {
+  float: left;
+}
+
+.hide {
+  display: none;
+}
+
+.show {
+  display: block;
+}
+
+.invisible {
+  visibility: hidden;
+}
+
+.affix {
+  position: fixed;
+}
diff --git a/docs/public/bootstrap/css/bootstrap.min.css b/docs/public/bootstrap/css/bootstrap.min.css
new file mode 100644
index 00000000..31d8b960
--- /dev/null
+++ b/docs/public/bootstrap/css/bootstrap.min.css
@@ -0,0 +1,9 @@
+/*!
+ * Bootstrap v2.1.1
+ *
+ * Copyright 2012 Twitter, Inc
+ * Licensed under the Apache License v2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Designed and built with all the love in the world @twitter by @mdo and @fat.
+ */article,aside,details,figcaption,figure,footer,header,hgroup,nav,section{display:block}audio,canvas,video{display:inline-block;*display:inline;*zoom:1}audio:not([controls]){display:none}html{font-size:100%;-webkit-text-size-adjust:100%;-ms-text-size-adjust:100%}a:focus{outline:thin dotted #333;outline:5px auto -webkit-focus-ring-color;outline-offset:-2px}a:hover,a:active{outline:0}sub,sup{position:relative;font-size:75%;line-height:0;vertical-align:baseline}sup{top:-0.5em}sub{bottom:-0.25em}img{width:auto\9;height:auto;max-width:100%;vertical-align:middle;border:0;-ms-interpolation-mode:bicubic}#map_canvas img{max-width:none}button,input,select,textarea{margin:0;font-size:100%;vertical-align:middle}button,input{*overflow:visible;line-height:normal}button::-moz-focus-inner,input::-moz-focus-inner{padding:0;border:0}button,input[type="button"],input[type="reset"],input[type="submit"]{cursor:pointer;-webkit-appearance:button}input[type="search"]{-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;-webkit-appearance:textfield}input[type="search"]::-webkit-search-decoration,input[type="search"]::-webkit-search-cancel-button{-webkit-appearance:none}textarea{overflow:auto;vertical-align:top}.clearfix{*zoom:1}.clearfix:before,.clearfix:after{display:table;line-height:0;content:""}.clearfix:after{clear:both}.hide-text{font:0/0 a;color:transparent;text-shadow:none;background-color:transparent;border:0}.input-block-level{display:block;width:100%;min-height:30px;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}body{margin:0;font-family:"Helvetica Neue",Helvetica,Arial,sans-serif;font-size:14px;line-height:20px;color:#333;background-color:#fff}a{color:#08c;text-decoration:none}a:hover{color:#005580;text-decoration:underline}.img-rounded{-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px}.img-polaroid{padding:4px;background-color:#fff;border:1px solid #ccc;border:1px solid rgba(0,0,0,0.2);-webkit-box-shadow:0 1px 3px rgba(0,0,0,0.1);-moz-box-shadow:0 1px 3px rgba(0,0,0,0.1);box-shadow:0 1px 3px rgba(0,0,0,0.1)}.img-circle{-webkit-border-radius:500px;-moz-border-radius:500px;border-radius:500px}.row{margin-left:-20px;*zoom:1}.row:before,.row:after{display:table;line-height:0;content:""}.row:after{clear:both}[class*="span"]{float:left;min-height:1px;margin-left:20px}.container,.navbar-static-top .container,.navbar-fixed-top .container,.navbar-fixed-bottom .container{width:940px}.span12{width:940px}.span11{width:860px}.span10{width:780px}.span9{width:700px}.span8{width:620px}.span7{width:540px}.span6{width:460px}.span5{width:380px}.span4{width:300px}.span3{width:220px}.span2{width:140px}.span1{width:60px}.offset12{margin-left:980px}.offset11{margin-left:900px}.offset10{margin-left:820px}.offset9{margin-left:740px}.offset8{margin-left:660px}.offset7{margin-left:580px}.offset6{margin-left:500px}.offset5{margin-left:420px}.offset4{margin-left:340px}.offset3{margin-left:260px}.offset2{margin-left:180px}.offset1{margin-left:100px}.row-fluid{width:100%;*zoom:1}.row-fluid:before,.row-fluid:after{display:table;line-height:0;content:""}.row-fluid:after{clear:both}.row-fluid [class*="span"]{display:block;float:left;width:100%;min-height:30px;margin-left:2.127659574468085%;*margin-left:2.074468085106383%;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}.row-fluid [class*="span"]:first-child{margin-left:0}.row-fluid .span12{width:100%;*width:99.94680851063829%}.row-fluid .span11{width:91.48936170212765%;*width:91.43617021276594%}.row-fluid .span10{width:82.97872340425532%;*width:82.92553191489361%}.row-fluid .span9{width:74.46808510638297%;*width:74.41489361702126%}.row-fluid .span8{width:65.95744680851064%;*width:65.90425531914893%}.row-fluid .span7{width:57.44680851063829%;*width:57.39361702127659%}.row-fluid .span6{width:48.93617021276595%;*width:48.88297872340425%}.row-fluid .span5{width:40.42553191489362%;*width:40.37234042553192%}.row-fluid .span4{width:31.914893617021278%;*width:31.861702127659576%}.row-fluid .span3{width:23.404255319148934%;*width:23.351063829787233%}.row-fluid .span2{width:14.893617021276595%;*width:14.840425531914894%}.row-fluid .span1{width:6.382978723404255%;*width:6.329787234042553%}.row-fluid .offset12{margin-left:104.25531914893617%;*margin-left:104.14893617021275%}.row-fluid .offset12:first-child{margin-left:102.12765957446808%;*margin-left:102.02127659574467%}.row-fluid .offset11{margin-left:95.74468085106382%;*margin-left:95.6382978723404%}.row-fluid .offset11:first-child{margin-left:93.61702127659574%;*margin-left:93.51063829787232%}.row-fluid .offset10{margin-left:87.23404255319149%;*margin-left:87.12765957446807%}.row-fluid .offset10:first-child{margin-left:85.1063829787234%;*margin-left:84.99999999999999%}.row-fluid .offset9{margin-left:78.72340425531914%;*margin-left:78.61702127659572%}.row-fluid .offset9:first-child{margin-left:76.59574468085106%;*margin-left:76.48936170212764%}.row-fluid .offset8{margin-left:70.2127659574468%;*margin-left:70.10638297872339%}.row-fluid .offset8:first-child{margin-left:68.08510638297872%;*margin-left:67.9787234042553%}.row-fluid .offset7{margin-left:61.70212765957446%;*margin-left:61.59574468085106%}.row-fluid .offset7:first-child{margin-left:59.574468085106375%;*margin-left:59.46808510638297%}.row-fluid .offset6{margin-left:53.191489361702125%;*margin-left:53.085106382978715%}.row-fluid .offset6:first-child{margin-left:51.063829787234035%;*margin-left:50.95744680851063%}.row-fluid .offset5{margin-left:44.68085106382979%;*margin-left:44.57446808510638%}.row-fluid .offset5:first-child{margin-left:42.5531914893617%;*margin-left:42.4468085106383%}.row-fluid .offset4{margin-left:36.170212765957444%;*margin-left:36.06382978723405%}.row-fluid .offset4:first-child{margin-left:34.04255319148936%;*margin-left:33.93617021276596%}.row-fluid .offset3{margin-left:27.659574468085104%;*margin-left:27.5531914893617%}.row-fluid .offset3:first-child{margin-left:25.53191489361702%;*margin-left:25.425531914893618%}.row-fluid .offset2{margin-left:19.148936170212764%;*margin-left:19.04255319148936%}.row-fluid .offset2:first-child{margin-left:17.02127659574468%;*margin-left:16.914893617021278%}.row-fluid .offset1{margin-left:10.638297872340425%;*margin-left:10.53191489361702%}.row-fluid .offset1:first-child{margin-left:8.51063829787234%;*margin-left:8.404255319148938%}[class*="span"].hide,.row-fluid [class*="span"].hide{display:none}[class*="span"].pull-right,.row-fluid [class*="span"].pull-right{float:right}.container{margin-right:auto;margin-left:auto;*zoom:1}.container:before,.container:after{display:table;line-height:0;content:""}.container:after{clear:both}.container-fluid{padding-right:20px;padding-left:20px;*zoom:1}.container-fluid:before,.container-fluid:after{display:table;line-height:0;content:""}.container-fluid:after{clear:both}p{margin:0 0 10px}.lead{margin-bottom:20px;font-size:21px;font-weight:200;line-height:30px}small{font-size:85%}strong{font-weight:bold}em{font-style:italic}cite{font-style:normal}.muted{color:#999}.text-warning{color:#c09853}.text-error{color:#b94a48}.text-info{color:#3a87ad}.text-success{color:#468847}h1,h2,h3,h4,h5,h6{margin:10px 0;font-family:inherit;font-weight:bold;line-height:1;color:inherit;text-rendering:optimizelegibility}h1 small,h2 small,h3 small,h4 small,h5 small,h6 small{font-weight:normal;line-height:1;color:#999}h1{font-size:36px;line-height:40px}h2{font-size:30px;line-height:40px}h3{font-size:24px;line-height:40px}h4{font-size:18px;line-height:20px}h5{font-size:14px;line-height:20px}h6{font-size:12px;line-height:20px}h1 small{font-size:24px}h2 small{font-size:18px}h3 small{font-size:14px}h4 small{font-size:14px}.page-header{padding-bottom:9px;margin:20px 0 30px;border-bottom:1px solid #eee}ul,ol{padding:0;margin:0 0 10px 25px}ul ul,ul ol,ol ol,ol ul{margin-bottom:0}li{line-height:20px}ul.unstyled,ol.unstyled{margin-left:0;list-style:none}dl{margin-bottom:20px}dt,dd{line-height:20px}dt{font-weight:bold}dd{margin-left:10px}.dl-horizontal{*zoom:1}.dl-horizontal:before,.dl-horizontal:after{display:table;line-height:0;content:""}.dl-horizontal:after{clear:both}.dl-horizontal dt{float:left;width:160px;overflow:hidden;clear:left;text-align:right;text-overflow:ellipsis;white-space:nowrap}.dl-horizontal dd{margin-left:180px}hr{margin:20px 0;border:0;border-top:1px solid #eee;border-bottom:1px solid #fff}abbr[title]{cursor:help;border-bottom:1px dotted #999}abbr.initialism{font-size:90%;text-transform:uppercase}blockquote{padding:0 0 0 15px;margin:0 0 20px;border-left:5px solid #eee}blockquote p{margin-bottom:0;font-size:16px;font-weight:300;line-height:25px}blockquote small{display:block;line-height:20px;color:#999}blockquote small:before{content:'\2014 \00A0'}blockquote.pull-right{float:right;padding-right:15px;padding-left:0;border-right:5px solid #eee;border-left:0}blockquote.pull-right p,blockquote.pull-right small{text-align:right}blockquote.pull-right small:before{content:''}blockquote.pull-right small:after{content:'\00A0 \2014'}q:before,q:after,blockquote:before,blockquote:after{content:""}address{display:block;margin-bottom:20px;font-style:normal;line-height:20px}code,pre{padding:0 3px 2px;font-family:Monaco,Menlo,Consolas,"Courier New",monospace;font-size:12px;color:#333;-webkit-border-radius:3px;-moz-border-radius:3px;border-radius:3px}code{padding:2px 4px;color:#d14;background-color:#f7f7f9;border:1px solid #e1e1e8}pre{display:block;padding:9.5px;margin:0 0 10px;font-size:13px;line-height:20px;word-break:break-all;word-wrap:break-word;white-space:pre;white-space:pre-wrap;background-color:#f5f5f5;border:1px solid #ccc;border:1px solid rgba(0,0,0,0.15);-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px}pre.prettyprint{margin-bottom:20px}pre code{padding:0;color:inherit;background-color:transparent;border:0}.pre-scrollable{max-height:340px;overflow-y:scroll}form{margin:0 0 20px}fieldset{padding:0;margin:0;border:0}legend{display:block;width:100%;padding:0;margin-bottom:20px;font-size:21px;line-height:40px;color:#333;border:0;border-bottom:1px solid #e5e5e5}legend small{font-size:15px;color:#999}label,input,button,select,textarea{font-size:14px;font-weight:normal;line-height:20px}input,button,select,textarea{font-family:"Helvetica Neue",Helvetica,Arial,sans-serif}label{display:block;margin-bottom:5px}select,textarea,input[type="text"],input[type="password"],input[type="datetime"],input[type="datetime-local"],input[type="date"],input[type="month"],input[type="time"],input[type="week"],input[type="number"],input[type="email"],input[type="url"],input[type="search"],input[type="tel"],input[type="color"],.uneditable-input{display:inline-block;height:20px;padding:4px 6px;margin-bottom:9px;font-size:14px;line-height:20px;color:#555;-webkit-border-radius:3px;-moz-border-radius:3px;border-radius:3px}input,textarea,.uneditable-input{width:206px}textarea{height:auto}textarea,input[type="text"],input[type="password"],input[type="datetime"],input[type="datetime-local"],input[type="date"],input[type="month"],input[type="time"],input[type="week"],input[type="number"],input[type="email"],input[type="url"],input[type="search"],input[type="tel"],input[type="color"],.uneditable-input{background-color:#fff;border:1px solid #ccc;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);-webkit-transition:border linear .2s,box-shadow linear .2s;-moz-transition:border linear .2s,box-shadow linear .2s;-o-transition:border linear .2s,box-shadow linear .2s;transition:border linear .2s,box-shadow linear .2s}textarea:focus,input[type="text"]:focus,input[type="password"]:focus,input[type="datetime"]:focus,input[type="datetime-local"]:focus,input[type="date"]:focus,input[type="month"]:focus,input[type="time"]:focus,input[type="week"]:focus,input[type="number"]:focus,input[type="email"]:focus,input[type="url"]:focus,input[type="search"]:focus,input[type="tel"]:focus,input[type="color"]:focus,.uneditable-input:focus{border-color:rgba(82,168,236,0.8);outline:0;outline:thin dotted \9;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 8px rgba(82,168,236,0.6);-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 8px rgba(82,168,236,0.6);box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 8px rgba(82,168,236,0.6)}input[type="radio"],input[type="checkbox"]{margin:4px 0 0;margin-top:1px \9;*margin-top:0;line-height:normal;cursor:pointer}input[type="file"],input[type="image"],input[type="submit"],input[type="reset"],input[type="button"],input[type="radio"],input[type="checkbox"]{width:auto}select,input[type="file"]{height:30px;*margin-top:4px;line-height:30px}select{width:220px;background-color:#fff;border:1px solid #ccc}select[multiple],select[size]{height:auto}select:focus,input[type="file"]:focus,input[type="radio"]:focus,input[type="checkbox"]:focus{outline:thin dotted #333;outline:5px auto -webkit-focus-ring-color;outline-offset:-2px}.uneditable-input,.uneditable-textarea{color:#999;cursor:not-allowed;background-color:#fcfcfc;border-color:#ccc;-webkit-box-shadow:inset 0 1px 2px rgba(0,0,0,0.025);-moz-box-shadow:inset 0 1px 2px rgba(0,0,0,0.025);box-shadow:inset 0 1px 2px rgba(0,0,0,0.025)}.uneditable-input{overflow:hidden;white-space:nowrap}.uneditable-textarea{width:auto;height:auto}input:-moz-placeholder,textarea:-moz-placeholder{color:#999}input:-ms-input-placeholder,textarea:-ms-input-placeholder{color:#999}input::-webkit-input-placeholder,textarea::-webkit-input-placeholder{color:#999}.radio,.checkbox{min-height:18px;padding-left:18px}.radio input[type="radio"],.checkbox input[type="checkbox"]{float:left;margin-left:-18px}.controls>.radio:first-child,.controls>.checkbox:first-child{padding-top:5px}.radio.inline,.checkbox.inline{display:inline-block;padding-top:5px;margin-bottom:0;vertical-align:middle}.radio.inline+.radio.inline,.checkbox.inline+.checkbox.inline{margin-left:10px}.input-mini{width:60px}.input-small{width:90px}.input-medium{width:150px}.input-large{width:210px}.input-xlarge{width:270px}.input-xxlarge{width:530px}input[class*="span"],select[class*="span"],textarea[class*="span"],.uneditable-input[class*="span"],.row-fluid input[class*="span"],.row-fluid select[class*="span"],.row-fluid textarea[class*="span"],.row-fluid .uneditable-input[class*="span"]{float:none;margin-left:0}.input-append input[class*="span"],.input-append .uneditable-input[class*="span"],.input-prepend input[class*="span"],.input-prepend .uneditable-input[class*="span"],.row-fluid input[class*="span"],.row-fluid select[class*="span"],.row-fluid textarea[class*="span"],.row-fluid .uneditable-input[class*="span"],.row-fluid .input-prepend [class*="span"],.row-fluid .input-append [class*="span"]{display:inline-block}input,textarea,.uneditable-input{margin-left:0}.controls-row [class*="span"]+[class*="span"]{margin-left:20px}input.span12,textarea.span12,.uneditable-input.span12{width:926px}input.span11,textarea.span11,.uneditable-input.span11{width:846px}input.span10,textarea.span10,.uneditable-input.span10{width:766px}input.span9,textarea.span9,.uneditable-input.span9{width:686px}input.span8,textarea.span8,.uneditable-input.span8{width:606px}input.span7,textarea.span7,.uneditable-input.span7{width:526px}input.span6,textarea.span6,.uneditable-input.span6{width:446px}input.span5,textarea.span5,.uneditable-input.span5{width:366px}input.span4,textarea.span4,.uneditable-input.span4{width:286px}input.span3,textarea.span3,.uneditable-input.span3{width:206px}input.span2,textarea.span2,.uneditable-input.span2{width:126px}input.span1,textarea.span1,.uneditable-input.span1{width:46px}.controls-row{*zoom:1}.controls-row:before,.controls-row:after{display:table;line-height:0;content:""}.controls-row:after{clear:both}.controls-row [class*="span"]{float:left}input[disabled],select[disabled],textarea[disabled],input[readonly],select[readonly],textarea[readonly]{cursor:not-allowed;background-color:#eee}input[type="radio"][disabled],input[type="checkbox"][disabled],input[type="radio"][readonly],input[type="checkbox"][readonly]{background-color:transparent}.control-group.warning>label,.control-group.warning .help-block,.control-group.warning .help-inline{color:#c09853}.control-group.warning .checkbox,.control-group.warning .radio,.control-group.warning input,.control-group.warning select,.control-group.warning textarea{color:#c09853}.control-group.warning input,.control-group.warning select,.control-group.warning textarea{border-color:#c09853;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);box-shadow:inset 0 1px 1px rgba(0,0,0,0.075)}.control-group.warning input:focus,.control-group.warning select:focus,.control-group.warning textarea:focus{border-color:#a47e3c;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #dbc59e;-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #dbc59e;box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #dbc59e}.control-group.warning .input-prepend .add-on,.control-group.warning .input-append .add-on{color:#c09853;background-color:#fcf8e3;border-color:#c09853}.control-group.error>label,.control-group.error .help-block,.control-group.error .help-inline{color:#b94a48}.control-group.error .checkbox,.control-group.error .radio,.control-group.error input,.control-group.error select,.control-group.error textarea{color:#b94a48}.control-group.error input,.control-group.error select,.control-group.error textarea{border-color:#b94a48;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);box-shadow:inset 0 1px 1px rgba(0,0,0,0.075)}.control-group.error input:focus,.control-group.error select:focus,.control-group.error textarea:focus{border-color:#953b39;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #d59392;-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #d59392;box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #d59392}.control-group.error .input-prepend .add-on,.control-group.error .input-append .add-on{color:#b94a48;background-color:#f2dede;border-color:#b94a48}.control-group.success>label,.control-group.success .help-block,.control-group.success .help-inline{color:#468847}.control-group.success .checkbox,.control-group.success .radio,.control-group.success input,.control-group.success select,.control-group.success textarea{color:#468847}.control-group.success input,.control-group.success select,.control-group.success textarea{border-color:#468847;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);box-shadow:inset 0 1px 1px rgba(0,0,0,0.075)}.control-group.success input:focus,.control-group.success select:focus,.control-group.success textarea:focus{border-color:#356635;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #7aba7b;-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #7aba7b;box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #7aba7b}.control-group.success .input-prepend .add-on,.control-group.success .input-append .add-on{color:#468847;background-color:#dff0d8;border-color:#468847}.control-group.info>label,.control-group.info .help-block,.control-group.info .help-inline{color:#3a87ad}.control-group.info .checkbox,.control-group.info .radio,.control-group.info input,.control-group.info select,.control-group.info textarea{color:#3a87ad}.control-group.info input,.control-group.info select,.control-group.info textarea{border-color:#3a87ad;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);box-shadow:inset 0 1px 1px rgba(0,0,0,0.075)}.control-group.info input:focus,.control-group.info select:focus,.control-group.info textarea:focus{border-color:#2d6987;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #7ab5d3;-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #7ab5d3;box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #7ab5d3}.control-group.info .input-prepend .add-on,.control-group.info .input-append .add-on{color:#3a87ad;background-color:#d9edf7;border-color:#3a87ad}input:focus:required:invalid,textarea:focus:required:invalid,select:focus:required:invalid{color:#b94a48;border-color:#ee5f5b}input:focus:required:invalid:focus,textarea:focus:required:invalid:focus,select:focus:required:invalid:focus{border-color:#e9322d;-webkit-box-shadow:0 0 6px #f8b9b7;-moz-box-shadow:0 0 6px #f8b9b7;box-shadow:0 0 6px #f8b9b7}.form-actions{padding:19px 20px 20px;margin-top:20px;margin-bottom:20px;background-color:#f5f5f5;border-top:1px solid #e5e5e5;*zoom:1}.form-actions:before,.form-actions:after{display:table;line-height:0;content:""}.form-actions:after{clear:both}.help-block,.help-inline{color:#595959}.help-block{display:block;margin-bottom:10px}.help-inline{display:inline-block;*display:inline;padding-left:5px;vertical-align:middle;*zoom:1}.input-append,.input-prepend{margin-bottom:5px;font-size:0;white-space:nowrap}.input-append input,.input-prepend input,.input-append select,.input-prepend select,.input-append .uneditable-input,.input-prepend .uneditable-input{position:relative;margin-bottom:0;*margin-left:0;font-size:14px;vertical-align:top;-webkit-border-radius:0 3px 3px 0;-moz-border-radius:0 3px 3px 0;border-radius:0 3px 3px 0}.input-append input:focus,.input-prepend input:focus,.input-append select:focus,.input-prepend select:focus,.input-append .uneditable-input:focus,.input-prepend .uneditable-input:focus{z-index:2}.input-append .add-on,.input-prepend .add-on{display:inline-block;width:auto;height:20px;min-width:16px;padding:4px 5px;font-size:14px;font-weight:normal;line-height:20px;text-align:center;text-shadow:0 1px 0 #fff;background-color:#eee;border:1px solid #ccc}.input-append .add-on,.input-prepend .add-on,.input-append .btn,.input-prepend .btn{vertical-align:top;-webkit-border-radius:0;-moz-border-radius:0;border-radius:0}.input-append .active,.input-prepend .active{background-color:#a9dba9;border-color:#46a546}.input-prepend .add-on,.input-prepend .btn{margin-right:-1px}.input-prepend .add-on:first-child,.input-prepend .btn:first-child{-webkit-border-radius:3px 0 0 3px;-moz-border-radius:3px 0 0 3px;border-radius:3px 0 0 3px}.input-append input,.input-append select,.input-append .uneditable-input{-webkit-border-radius:3px 0 0 3px;-moz-border-radius:3px 0 0 3px;border-radius:3px 0 0 3px}.input-append .add-on,.input-append .btn{margin-left:-1px}.input-append .add-on:last-child,.input-append .btn:last-child{-webkit-border-radius:0 3px 3px 0;-moz-border-radius:0 3px 3px 0;border-radius:0 3px 3px 0}.input-prepend.input-append input,.input-prepend.input-append select,.input-prepend.input-append .uneditable-input{-webkit-border-radius:0;-moz-border-radius:0;border-radius:0}.input-prepend.input-append .add-on:first-child,.input-prepend.input-append .btn:first-child{margin-right:-1px;-webkit-border-radius:3px 0 0 3px;-moz-border-radius:3px 0 0 3px;border-radius:3px 0 0 3px}.input-prepend.input-append .add-on:last-child,.input-prepend.input-append .btn:last-child{margin-left:-1px;-webkit-border-radius:0 3px 3px 0;-moz-border-radius:0 3px 3px 0;border-radius:0 3px 3px 0}input.search-query{padding-right:14px;padding-right:4px \9;padding-left:14px;padding-left:4px \9;margin-bottom:0;-webkit-border-radius:15px;-moz-border-radius:15px;border-radius:15px}.form-search .input-append .search-query,.form-search .input-prepend .search-query{-webkit-border-radius:0;-moz-border-radius:0;border-radius:0}.form-search .input-append .search-query{-webkit-border-radius:14px 0 0 14px;-moz-border-radius:14px 0 0 14px;border-radius:14px 0 0 14px}.form-search .input-append .btn{-webkit-border-radius:0 14px 14px 0;-moz-border-radius:0 14px 14px 0;border-radius:0 14px 14px 0}.form-search .input-prepend .search-query{-webkit-border-radius:0 14px 14px 0;-moz-border-radius:0 14px 14px 0;border-radius:0 14px 14px 0}.form-search .input-prepend .btn{-webkit-border-radius:14px 0 0 14px;-moz-border-radius:14px 0 0 14px;border-radius:14px 0 0 14px}.form-search input,.form-inline input,.form-horizontal input,.form-search textarea,.form-inline textarea,.form-horizontal textarea,.form-search select,.form-inline select,.form-horizontal select,.form-search .help-inline,.form-inline .help-inline,.form-horizontal .help-inline,.form-search .uneditable-input,.form-inline .uneditable-input,.form-horizontal .uneditable-input,.form-search .input-prepend,.form-inline .input-prepend,.form-horizontal .input-prepend,.form-search .input-append,.form-inline .input-append,.form-horizontal .input-append{display:inline-block;*display:inline;margin-bottom:0;vertical-align:middle;*zoom:1}.form-search .hide,.form-inline .hide,.form-horizontal .hide{display:none}.form-search label,.form-inline label,.form-search .btn-group,.form-inline .btn-group{display:inline-block}.form-search .input-append,.form-inline .input-append,.form-search .input-prepend,.form-inline .input-prepend{margin-bottom:0}.form-search .radio,.form-search .checkbox,.form-inline .radio,.form-inline .checkbox{padding-left:0;margin-bottom:0;vertical-align:middle}.form-search .radio input[type="radio"],.form-search .checkbox input[type="checkbox"],.form-inline .radio input[type="radio"],.form-inline .checkbox input[type="checkbox"]{float:left;margin-right:3px;margin-left:0}.control-group{margin-bottom:10px}legend+.control-group{margin-top:20px;-webkit-margin-top-collapse:separate}.form-horizontal .control-group{margin-bottom:20px;*zoom:1}.form-horizontal .control-group:before,.form-horizontal .control-group:after{display:table;line-height:0;content:""}.form-horizontal .control-group:after{clear:both}.form-horizontal .control-label{float:left;width:160px;padding-top:5px;text-align:right}.form-horizontal .controls{*display:inline-block;*padding-left:20px;margin-left:180px;*margin-left:0}.form-horizontal .controls:first-child{*padding-left:180px}.form-horizontal .help-block{margin-bottom:0}.form-horizontal input+.help-block,.form-horizontal select+.help-block,.form-horizontal textarea+.help-block{margin-top:10px}.form-horizontal .form-actions{padding-left:180px}table{max-width:100%;background-color:transparent;border-collapse:collapse;border-spacing:0}.table{width:100%;margin-bottom:20px}.table th,.table td{padding:8px;line-height:20px;text-align:left;vertical-align:top;border-top:1px solid #ddd}.table th{font-weight:bold}.table thead th{vertical-align:bottom}.table caption+thead tr:first-child th,.table caption+thead tr:first-child td,.table colgroup+thead tr:first-child th,.table colgroup+thead tr:first-child td,.table thead:first-child tr:first-child th,.table thead:first-child tr:first-child td{border-top:0}.table tbody+tbody{border-top:2px solid #ddd}.table-condensed th,.table-condensed td{padding:4px 5px}.table-bordered{border:1px solid #ddd;border-collapse:separate;*border-collapse:collapse;border-left:0;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px}.table-bordered th,.table-bordered td{border-left:1px solid #ddd}.table-bordered caption+thead tr:first-child th,.table-bordered caption+tbody tr:first-child th,.table-bordered caption+tbody tr:first-child td,.table-bordered colgroup+thead tr:first-child th,.table-bordered colgroup+tbody tr:first-child th,.table-bordered colgroup+tbody tr:first-child td,.table-bordered thead:first-child tr:first-child th,.table-bordered tbody:first-child tr:first-child th,.table-bordered tbody:first-child tr:first-child td{border-top:0}.table-bordered thead:first-child tr:first-child th:first-child,.table-bordered tbody:first-child tr:first-child td:first-child{-webkit-border-top-left-radius:4px;border-top-left-radius:4px;-moz-border-radius-topleft:4px}.table-bordered thead:first-child tr:first-child th:last-child,.table-bordered tbody:first-child tr:first-child td:last-child{-webkit-border-top-right-radius:4px;border-top-right-radius:4px;-moz-border-radius-topright:4px}.table-bordered thead:last-child tr:last-child th:first-child,.table-bordered tbody:last-child tr:last-child td:first-child,.table-bordered tfoot:last-child tr:last-child td:first-child{-webkit-border-radius:0 0 0 4px;-moz-border-radius:0 0 0 4px;border-radius:0 0 0 4px;-webkit-border-bottom-left-radius:4px;border-bottom-left-radius:4px;-moz-border-radius-bottomleft:4px}.table-bordered thead:last-child tr:last-child th:last-child,.table-bordered tbody:last-child tr:last-child td:last-child,.table-bordered tfoot:last-child tr:last-child td:last-child{-webkit-border-bottom-right-radius:4px;border-bottom-right-radius:4px;-moz-border-radius-bottomright:4px}.table-bordered caption+thead tr:first-child th:first-child,.table-bordered caption+tbody tr:first-child td:first-child,.table-bordered colgroup+thead tr:first-child th:first-child,.table-bordered colgroup+tbody tr:first-child td:first-child{-webkit-border-top-left-radius:4px;border-top-left-radius:4px;-moz-border-radius-topleft:4px}.table-bordered caption+thead tr:first-child th:last-child,.table-bordered caption+tbody tr:first-child td:last-child,.table-bordered colgroup+thead tr:first-child th:last-child,.table-bordered colgroup+tbody tr:first-child td:last-child{-webkit-border-top-right-radius:4px;border-top-right-radius:4px;-moz-border-radius-topleft:4px}.table-striped tbody tr:nth-child(odd) td,.table-striped tbody tr:nth-child(odd) th{background-color:#f9f9f9}.table-hover tbody tr:hover td,.table-hover tbody tr:hover th{background-color:#f5f5f5}table [class*=span],.row-fluid table [class*=span]{display:table-cell;float:none;margin-left:0}.table .span1{float:none;width:44px;margin-left:0}.table .span2{float:none;width:124px;margin-left:0}.table .span3{float:none;width:204px;margin-left:0}.table .span4{float:none;width:284px;margin-left:0}.table .span5{float:none;width:364px;margin-left:0}.table .span6{float:none;width:444px;margin-left:0}.table .span7{float:none;width:524px;margin-left:0}.table .span8{float:none;width:604px;margin-left:0}.table .span9{float:none;width:684px;margin-left:0}.table .span10{float:none;width:764px;margin-left:0}.table .span11{float:none;width:844px;margin-left:0}.table .span12{float:none;width:924px;margin-left:0}.table .span13{float:none;width:1004px;margin-left:0}.table .span14{float:none;width:1084px;margin-left:0}.table .span15{float:none;width:1164px;margin-left:0}.table .span16{float:none;width:1244px;margin-left:0}.table .span17{float:none;width:1324px;margin-left:0}.table .span18{float:none;width:1404px;margin-left:0}.table .span19{float:none;width:1484px;margin-left:0}.table .span20{float:none;width:1564px;margin-left:0}.table .span21{float:none;width:1644px;margin-left:0}.table .span22{float:none;width:1724px;margin-left:0}.table .span23{float:none;width:1804px;margin-left:0}.table .span24{float:none;width:1884px;margin-left:0}.table tbody tr.success td{background-color:#dff0d8}.table tbody tr.error td{background-color:#f2dede}.table tbody tr.warning td{background-color:#fcf8e3}.table tbody tr.info td{background-color:#d9edf7}.table-hover tbody tr.success:hover td{background-color:#d0e9c6}.table-hover tbody tr.error:hover td{background-color:#ebcccc}.table-hover tbody tr.warning:hover td{background-color:#faf2cc}.table-hover tbody tr.info:hover td{background-color:#c4e3f3}[class^="icon-"],[class*=" icon-"]{display:inline-block;width:14px;height:14px;margin-top:1px;*margin-right:.3em;line-height:14px;vertical-align:text-top;background-image:url("../img/glyphicons-halflings.png");background-position:14px 14px;background-repeat:no-repeat}.icon-white,.nav-tabs>.active>a>[class^="icon-"],.nav-tabs>.active>a>[class*=" icon-"],.nav-pills>.active>a>[class^="icon-"],.nav-pills>.active>a>[class*=" icon-"],.nav-list>.active>a>[class^="icon-"],.nav-list>.active>a>[class*=" icon-"],.navbar-inverse .nav>.active>a>[class^="icon-"],.navbar-inverse .nav>.active>a>[class*=" icon-"],.dropdown-menu>li>a:hover>[class^="icon-"],.dropdown-menu>li>a:hover>[class*=" icon-"],.dropdown-menu>.active>a>[class^="icon-"],.dropdown-menu>.active>a>[class*=" icon-"]{background-image:url("../img/glyphicons-halflings-white.png")}.icon-glass{background-position:0 0}.icon-music{background-position:-24px 0}.icon-search{background-position:-48px 0}.icon-envelope{background-position:-72px 0}.icon-heart{background-position:-96px 0}.icon-star{background-position:-120px 0}.icon-star-empty{background-position:-144px 0}.icon-user{background-position:-168px 0}.icon-film{background-position:-192px 0}.icon-th-large{background-position:-216px 0}.icon-th{background-position:-240px 0}.icon-th-list{background-position:-264px 0}.icon-ok{background-position:-288px 0}.icon-remove{background-position:-312px 0}.icon-zoom-in{background-position:-336px 0}.icon-zoom-out{background-position:-360px 0}.icon-off{background-position:-384px 0}.icon-signal{background-position:-408px 0}.icon-cog{background-position:-432px 0}.icon-trash{background-position:-456px 0}.icon-home{background-position:0 -24px}.icon-file{background-position:-24px -24px}.icon-time{background-position:-48px -24px}.icon-road{background-position:-72px -24px}.icon-download-alt{background-position:-96px -24px}.icon-download{background-position:-120px -24px}.icon-upload{background-position:-144px -24px}.icon-inbox{background-position:-168px -24px}.icon-play-circle{background-position:-192px -24px}.icon-repeat{background-position:-216px -24px}.icon-refresh{background-position:-240px -24px}.icon-list-alt{background-position:-264px -24px}.icon-lock{background-position:-287px -24px}.icon-flag{background-position:-312px -24px}.icon-headphones{background-position:-336px -24px}.icon-volume-off{background-position:-360px -24px}.icon-volume-down{background-position:-384px -24px}.icon-volume-up{background-position:-408px -24px}.icon-qrcode{background-position:-432px -24px}.icon-barcode{background-position:-456px -24px}.icon-tag{background-position:0 -48px}.icon-tags{background-position:-25px -48px}.icon-book{background-position:-48px -48px}.icon-bookmark{background-position:-72px -48px}.icon-print{background-position:-96px -48px}.icon-camera{background-position:-120px -48px}.icon-font{background-position:-144px -48px}.icon-bold{background-position:-167px -48px}.icon-italic{background-position:-192px -48px}.icon-text-height{background-position:-216px -48px}.icon-text-width{background-position:-240px -48px}.icon-align-left{background-position:-264px -48px}.icon-align-center{background-position:-288px -48px}.icon-align-right{background-position:-312px -48px}.icon-align-justify{background-position:-336px -48px}.icon-list{background-position:-360px -48px}.icon-indent-left{background-position:-384px -48px}.icon-indent-right{background-position:-408px -48px}.icon-facetime-video{background-position:-432px -48px}.icon-picture{background-position:-456px -48px}.icon-pencil{background-position:0 -72px}.icon-map-marker{background-position:-24px -72px}.icon-adjust{background-position:-48px -72px}.icon-tint{background-position:-72px -72px}.icon-edit{background-position:-96px -72px}.icon-share{background-position:-120px -72px}.icon-check{background-position:-144px -72px}.icon-move{background-position:-168px -72px}.icon-step-backward{background-position:-192px -72px}.icon-fast-backward{background-position:-216px -72px}.icon-backward{background-position:-240px -72px}.icon-play{background-position:-264px -72px}.icon-pause{background-position:-288px -72px}.icon-stop{background-position:-312px -72px}.icon-forward{background-position:-336px -72px}.icon-fast-forward{background-position:-360px -72px}.icon-step-forward{background-position:-384px -72px}.icon-eject{background-position:-408px -72px}.icon-chevron-left{background-position:-432px -72px}.icon-chevron-right{background-position:-456px -72px}.icon-plus-sign{background-position:0 -96px}.icon-minus-sign{background-position:-24px -96px}.icon-remove-sign{background-position:-48px -96px}.icon-ok-sign{background-position:-72px -96px}.icon-question-sign{background-position:-96px -96px}.icon-info-sign{background-position:-120px -96px}.icon-screenshot{background-position:-144px -96px}.icon-remove-circle{background-position:-168px -96px}.icon-ok-circle{background-position:-192px -96px}.icon-ban-circle{background-position:-216px -96px}.icon-arrow-left{background-position:-240px -96px}.icon-arrow-right{background-position:-264px -96px}.icon-arrow-up{background-position:-289px -96px}.icon-arrow-down{background-position:-312px -96px}.icon-share-alt{background-position:-336px -96px}.icon-resize-full{background-position:-360px -96px}.icon-resize-small{background-position:-384px -96px}.icon-plus{background-position:-408px -96px}.icon-minus{background-position:-433px -96px}.icon-asterisk{background-position:-456px -96px}.icon-exclamation-sign{background-position:0 -120px}.icon-gift{background-position:-24px -120px}.icon-leaf{background-position:-48px -120px}.icon-fire{background-position:-72px -120px}.icon-eye-open{background-position:-96px -120px}.icon-eye-close{background-position:-120px -120px}.icon-warning-sign{background-position:-144px -120px}.icon-plane{background-position:-168px -120px}.icon-calendar{background-position:-192px -120px}.icon-random{width:16px;background-position:-216px -120px}.icon-comment{background-position:-240px -120px}.icon-magnet{background-position:-264px -120px}.icon-chevron-up{background-position:-288px -120px}.icon-chevron-down{background-position:-313px -119px}.icon-retweet{background-position:-336px -120px}.icon-shopping-cart{background-position:-360px -120px}.icon-folder-close{background-position:-384px -120px}.icon-folder-open{width:16px;background-position:-408px -120px}.icon-resize-vertical{background-position:-432px -119px}.icon-resize-horizontal{background-position:-456px -118px}.icon-hdd{background-position:0 -144px}.icon-bullhorn{background-position:-24px -144px}.icon-bell{background-position:-48px -144px}.icon-certificate{background-position:-72px -144px}.icon-thumbs-up{background-position:-96px -144px}.icon-thumbs-down{background-position:-120px -144px}.icon-hand-right{background-position:-144px -144px}.icon-hand-left{background-position:-168px -144px}.icon-hand-up{background-position:-192px -144px}.icon-hand-down{background-position:-216px -144px}.icon-circle-arrow-right{background-position:-240px -144px}.icon-circle-arrow-left{background-position:-264px -144px}.icon-circle-arrow-up{background-position:-288px -144px}.icon-circle-arrow-down{background-position:-312px -144px}.icon-globe{background-position:-336px -144px}.icon-wrench{background-position:-360px -144px}.icon-tasks{background-position:-384px -144px}.icon-filter{background-position:-408px -144px}.icon-briefcase{background-position:-432px -144px}.icon-fullscreen{background-position:-456px -144px}.dropup,.dropdown{position:relative}.dropdown-toggle{*margin-bottom:-3px}.dropdown-toggle:active,.open .dropdown-toggle{outline:0}.caret{display:inline-block;width:0;height:0;vertical-align:top;border-top:4px solid #000;border-right:4px solid transparent;border-left:4px solid transparent;content:""}.dropdown .caret{margin-top:8px;margin-left:2px}.dropdown-menu{position:absolute;top:100%;left:0;z-index:1000;display:none;float:left;min-width:160px;padding:5px 0;margin:2px 0 0;list-style:none;background-color:#fff;border:1px solid #ccc;border:1px solid rgba(0,0,0,0.2);*border-right-width:2px;*border-bottom-width:2px;-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px;-webkit-box-shadow:0 5px 10px rgba(0,0,0,0.2);-moz-box-shadow:0 5px 10px rgba(0,0,0,0.2);box-shadow:0 5px 10px rgba(0,0,0,0.2);-webkit-background-clip:padding-box;-moz-background-clip:padding;background-clip:padding-box}.dropdown-menu.pull-right{right:0;left:auto}.dropdown-menu .divider{*width:100%;height:1px;margin:9px 1px;*margin:-5px 0 5px;overflow:hidden;background-color:#e5e5e5;border-bottom:1px solid #fff}.dropdown-menu a{display:block;padding:3px 20px;clear:both;font-weight:normal;line-height:20px;color:#333;white-space:nowrap}.dropdown-menu li>a:hover,.dropdown-menu li>a:focus,.dropdown-submenu:hover>a{color:#fff;text-decoration:none;background-color:#08c;background-color:#0081c2;background-image:-moz-linear-gradient(top,#08c,#0077b3);background-image:-webkit-gradient(linear,0 0,0 100%,from(#08c),to(#0077b3));background-image:-webkit-linear-gradient(top,#08c,#0077b3);background-image:-o-linear-gradient(top,#08c,#0077b3);background-image:linear-gradient(to bottom,#08c,#0077b3);background-repeat:repeat-x;filter:progid:dximagetransform.microsoft.gradient(startColorstr='#ff0088cc',endColorstr='#ff0077b3',GradientType=0)}.dropdown-menu .active>a,.dropdown-menu .active>a:hover{color:#fff;text-decoration:none;background-color:#08c;background-color:#0081c2;background-image:linear-gradient(to bottom,#08c,#0077b3);background-image:-moz-linear-gradient(top,#08c,#0077b3);background-image:-webkit-gradient(linear,0 0,0 100%,from(#08c),to(#0077b3));background-image:-webkit-linear-gradient(top,#08c,#0077b3);background-image:-o-linear-gradient(top,#08c,#0077b3);background-repeat:repeat-x;outline:0;filter:progid:dximagetransform.microsoft.gradient(startColorstr='#ff0088cc',endColorstr='#ff0077b3',GradientType=0)}.dropdown-menu .disabled>a,.dropdown-menu .disabled>a:hover{color:#999}.dropdown-menu .disabled>a:hover{text-decoration:none;cursor:default;background-color:transparent}.open{*z-index:1000}.open>.dropdown-menu{display:block}.pull-right>.dropdown-menu{right:0;left:auto}.dropup .caret,.navbar-fixed-bottom .dropdown .caret{border-top:0;border-bottom:4px solid #000;content:""}.dropup .dropdown-menu,.navbar-fixed-bottom .dropdown .dropdown-menu{top:auto;bottom:100%;margin-bottom:1px}.dropdown-submenu{position:relative}.dropdown-submenu>.dropdown-menu{top:0;left:100%;margin-top:-6px;margin-left:-1px;-webkit-border-radius:0 6px 6px 6px;-moz-border-radius:0 6px 6px 6px;border-radius:0 6px 6px 6px}.dropdown-submenu:hover>.dropdown-menu{display:block}.dropdown-submenu>a:after{display:block;float:right;width:0;height:0;margin-top:5px;margin-right:-10px;border-color:transparent;border-left-color:#ccc;border-style:solid;border-width:5px 0 5px 5px;content:" "}.dropdown-submenu:hover>a:after{border-left-color:#fff}.dropdown .dropdown-menu .nav-header{padding-right:20px;padding-left:20px}.typeahead{margin-top:2px;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px}.well{min-height:20px;padding:19px;margin-bottom:20px;background-color:#f5f5f5;border:1px solid #e3e3e3;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.05);-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.05);box-shadow:inset 0 1px 1px rgba(0,0,0,0.05)}.well blockquote{border-color:#ddd;border-color:rgba(0,0,0,0.15)}.well-large{padding:24px;-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px}.well-small{padding:9px;-webkit-border-radius:3px;-moz-border-radius:3px;border-radius:3px}.fade{opacity:0;-webkit-transition:opacity .15s linear;-moz-transition:opacity .15s linear;-o-transition:opacity .15s linear;transition:opacity .15s linear}.fade.in{opacity:1}.collapse{position:relative;height:0;overflow:hidden;-webkit-transition:height .35s ease;-moz-transition:height .35s ease;-o-transition:height .35s ease;transition:height .35s ease}.collapse.in{height:auto}.close{float:right;font-size:20px;font-weight:bold;line-height:20px;color:#000;text-shadow:0 1px 0 #fff;opacity:.2;filter:alpha(opacity=20)}.close:hover{color:#000;text-decoration:none;cursor:pointer;opacity:.4;filter:alpha(opacity=40)}button.close{padding:0;cursor:pointer;background:transparent;border:0;-webkit-appearance:none}.btn{display:inline-block;*display:inline;padding:4px 14px;margin-bottom:0;*margin-left:.3em;font-size:14px;line-height:20px;*line-height:20px;color:#333;text-align:center;text-shadow:0 1px 1px rgba(255,255,255,0.75);vertical-align:middle;cursor:pointer;background-color:#f5f5f5;*background-color:#e6e6e6;background-image:-webkit-gradient(linear,0 0,0 100%,from(#fff),to(#e6e6e6));background-image:-webkit-linear-gradient(top,#fff,#e6e6e6);background-image:-o-linear-gradient(top,#fff,#e6e6e6);background-image:linear-gradient(to bottom,#fff,#e6e6e6);background-image:-moz-linear-gradient(top,#fff,#e6e6e6);background-repeat:repeat-x;border:1px solid #bbb;*border:0;border-color:rgba(0,0,0,0.1) rgba(0,0,0,0.1) rgba(0,0,0,0.25);border-color:#e6e6e6 #e6e6e6 #bfbfbf;border-bottom-color:#a2a2a2;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;filter:progid:dximagetransform.microsoft.gradient(startColorstr='#ffffffff',endColorstr='#ffe6e6e6',GradientType=0);filter:progid:dximagetransform.microsoft.gradient(enabled=false);*zoom:1;-webkit-box-shadow:inset 0 1px 0 rgba(255,255,255,0.2),0 1px 2px rgba(0,0,0,0.05);-moz-box-shadow:inset 0 1px 0 rgba(255,255,255,0.2),0 1px 2px rgba(0,0,0,0.05);box-shadow:inset 0 1px 0 rgba(255,255,255,0.2),0 1px 2px rgba(0,0,0,0.05)}.btn:hover,.btn:active,.btn.active,.btn.disabled,.btn[disabled]{color:#333;background-color:#e6e6e6;*background-color:#d9d9d9}.btn:active,.btn.active{background-color:#ccc \9}.btn:first-child{*margin-left:0}.btn:hover{color:#333;text-decoration:none;background-color:#e6e6e6;*background-color:#d9d9d9;background-position:0 -15px;-webkit-transition:background-position .1s linear;-moz-transition:background-position .1s linear;-o-transition:background-position .1s linear;transition:background-position .1s linear}.btn:focus{outline:thin dotted #333;outline:5px auto -webkit-focus-ring-color;outline-offset:-2px}.btn.active,.btn:active{background-color:#e6e6e6;background-color:#d9d9d9 \9;background-image:none;outline:0;-webkit-box-shadow:inset 0 2px 4px rgba(0,0,0,0.15),0 1px 2px rgba(0,0,0,0.05);-moz-box-shadow:inset 0 2px 4px rgba(0,0,0,0.15),0 1px 2px rgba(0,0,0,0.05);box-shadow:inset 0 2px 4px rgba(0,0,0,0.15),0 1px 2px rgba(0,0,0,0.05)}.btn.disabled,.btn[disabled]{cursor:default;background-color:#e6e6e6;background-image:none;opacity:.65;filter:alpha(opacity=65);-webkit-box-shadow:none;-moz-box-shadow:none;box-shadow:none}.btn-large{padding:9px 14px;font-size:16px;line-height:normal;-webkit-border-radius:5px;-moz-border-radius:5px;border-radius:5px}.btn-large [class^="icon-"]{margin-top:2px}.btn-small{padding:3px 9px;font-size:12px;line-height:18px}.btn-small [class^="icon-"]{margin-top:0}.btn-mini{padding:2px 6px;font-size:11px;line-height:17px}.btn-block{display:block;width:100%;padding-right:0;padding-left:0;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}.btn-block+.btn-block{margin-top:5px}input[type="submit"].btn-block,input[type="reset"].btn-block,input[type="button"].btn-block{width:100%}.btn-primary.active,.btn-warning.active,.btn-danger.active,.btn-success.active,.btn-info.active,.btn-inverse.active{color:rgba(255,255,255,0.75)}.btn{border-color:#c5c5c5;border-color:rgba(0,0,0,0.15) rgba(0,0,0,0.15) rgba(0,0,0,0.25)}.btn-primary{color:#fff;text-shadow:0 -1px 0 rgba(0,0,0,0.25);background-color:#006dcc;*background-color:#04c;background-image:-webkit-gradient(linear,0 0,0 100%,from(#08c),to(#04c));background-image:-webkit-linear-gradient(top,#08c,#04c);background-image:-o-linear-gradient(top,#08c,#04c);background-image:linear-gradient(to bottom,#08c,#04c);background-image:-moz-linear-gradient(top,#08c,#04c);background-repeat:repeat-x;border-color:#04c #04c #002a80;border-color:rgba(0,0,0,0.1) rgba(0,0,0,0.1) rgba(0,0,0,0.25);filter:progid:dximagetransform.microsoft.gradient(startColorstr='#ff0088cc',endColorstr='#ff0044cc',GradientType=0);filter:progid:dximagetransform.microsoft.gradient(enabled=false)}.btn-primary:hover,.btn-primary:active,.btn-primary.active,.btn-primary.disabled,.btn-primary[disabled]{color:#fff;background-color:#04c;*background-color:#003bb3}.btn-primary:active,.btn-primary.active{background-color:#039 \9}.btn-warning{color:#fff;text-shadow:0 -1px 0 rgba(0,0,0,0.25);background-color:#faa732;*background-color:#f89406;background-image:-webkit-gradient(linear,0 0,0 100%,from(#fbb450),to(#f89406));background-image:-webkit-linear-gradient(top,#fbb450,#f89406);background-image:-o-linear-gradient(top,#fbb450,#f89406);background-image:linear-gradient(to bottom,#fbb450,#f89406);background-image:-moz-linear-gradient(top,#fbb450,#f89406);background-repeat:repeat-x;border-color:#f89406 #f89406 #ad6704;border-color:rgba(0,0,0,0.1) rgba(0,0,0,0.1) rgba(0,0,0,0.25);filter:progid:dximagetransform.microsoft.gradient(startColorstr='#fffbb450',endColorstr='#fff89406',GradientType=0);filter:progid:dximagetransform.microsoft.gradient(enabled=false)}.btn-warning:hover,.btn-warning:active,.btn-warning.active,.btn-warning.disabled,.btn-warning[disabled]{color:#fff;background-color:#f89406;*background-color:#df8505}.btn-warning:active,.btn-warning.active{background-color:#c67605 \9}.btn-danger{color:#fff;text-shadow:0 -1px 0 rgba(0,0,0,0.25);background-color:#da4f49;*background-color:#bd362f;background-image:-webkit-gradient(linear,0 0,0 100%,from(#ee5f5b),to(#bd362f));background-image:-webkit-linear-gradient(top,#ee5f5b,#bd362f);background-image:-o-linear-gradient(top,#ee5f5b,#bd362f);background-image:linear-gradient(to bottom,#ee5f5b,#bd362f);background-image:-moz-linear-gradient(top,#ee5f5b,#bd362f);background-repeat:repeat-x;border-color:#bd362f #bd362f #802420;border-color:rgba(0,0,0,0.1) rgba(0,0,0,0.1) rgba(0,0,0,0.25);filter:progid:dximagetransform.microsoft.gradient(startColorstr='#ffee5f5b',endColorstr='#ffbd362f',GradientType=0);filter:progid:dximagetransform.microsoft.gradient(enabled=false)}.btn-danger:hover,.btn-danger:active,.btn-danger.active,.btn-danger.disabled,.btn-danger[disabled]{color:#fff;background-color:#bd362f;*background-color:#a9302a}.btn-danger:active,.btn-danger.active{background-color:#942a25 \9}.btn-success{color:#fff;text-shadow:0 -1px 0 rgba(0,0,0,0.25);background-color:#5bb75b;*background-color:#51a351;background-image:-webkit-gradient(linear,0 0,0 100%,from(#62c462),to(#51a351));background-image:-webkit-linear-gradient(top,#62c462,#51a351);background-image:-o-linear-gradient(top,#62c462,#51a351);background-image:linear-gradient(to bottom,#62c462,#51a351);background-image:-moz-linear-gradient(top,#62c462,#51a351);background-repeat:repeat-x;border-color:#51a351 #51a351 #387038;border-color:rgba(0,0,0,0.1) rgba(0,0,0,0.1) rgba(0,0,0,0.25);filter:progid:dximagetransform.microsoft.gradient(startColorstr='#ff62c462',endColorstr='#ff51a351',GradientType=0);filter:progid:dximagetransform.microsoft.gradient(enabled=false)}.btn-success:hover,.btn-success:active,.btn-success.active,.btn-success.disabled,.btn-success[disabled]{color:#fff;background-color:#51a351;*background-color:#499249}.btn-success:active,.btn-success.active{background-color:#408140 \9}.btn-info{color:#fff;text-shadow:0 -1px 0 rgba(0,0,0,0.25);background-color:#49afcd;*background-color:#2f96b4;background-image:-webkit-gradient(linear,0 0,0 100%,from(#5bc0de),to(#2f96b4));background-image:-webkit-linear-gradient(top,#5bc0de,#2f96b4);background-image:-o-linear-gradient(top,#5bc0de,#2f96b4);background-image:linear-gradient(to bottom,#5bc0de,#2f96b4);background-image:-moz-linear-gradient(top,#5bc0de,#2f96b4);background-repeat:repeat-x;border-color:#2f96b4 #2f96b4 #1f6377;border-color:rgba(0,0,0,0.1) rgba(0,0,0,0.1) rgba(0,0,0,0.25);filter:progid:dximagetransform.microsoft.gradient(startColorstr='#ff5bc0de',endColorstr='#ff2f96b4',GradientType=0);filter:progid:dximagetransform.microsoft.gradient(enabled=false)}.btn-info:hover,.btn-info:active,.btn-info.active,.btn-info.disabled,.btn-info[disabled]{color:#fff;background-color:#2f96b4;*background-color:#2a85a0}.btn-info:active,.btn-info.active{background-color:#24748c \9}.btn-inverse{color:#fff;text-shadow:0 -1px 0 rgba(0,0,0,0.25);background-color:#363636;*background-color:#222;background-image:-webkit-gradient(linear,0 0,0 100%,from(#444),to(#222));background-image:-webkit-linear-gradient(top,#444,#222);background-image:-o-linear-gradient(top,#444,#222);background-image:linear-gradient(to bottom,#444,#222);background-image:-moz-linear-gradient(top,#444,#222);background-repeat:repeat-x;border-color:#222 #222 #000;border-color:rgba(0,0,0,0.1) rgba(0,0,0,0.1) rgba(0,0,0,0.25);filter:progid:dximagetransform.microsoft.gradient(startColorstr='#ff444444',endColorstr='#ff222222',GradientType=0);filter:progid:dximagetransform.microsoft.gradient(enabled=false)}.btn-inverse:hover,.btn-inverse:active,.btn-inverse.active,.btn-inverse.disabled,.btn-inverse[disabled]{color:#fff;background-color:#222;*background-color:#151515}.btn-inverse:active,.btn-inverse.active{background-color:#080808 \9}button.btn,input[type="submit"].btn{*padding-top:3px;*padding-bottom:3px}button.btn::-moz-focus-inner,input[type="submit"].btn::-moz-focus-inner{padding:0;border:0}button.btn.btn-large,input[type="submit"].btn.btn-large{*padding-top:7px;*padding-bottom:7px}button.btn.btn-small,input[type="submit"].btn.btn-small{*padding-top:3px;*padding-bottom:3px}button.btn.btn-mini,input[type="submit"].btn.btn-mini{*padding-top:1px;*padding-bottom:1px}.btn-link,.btn-link:active,.btn-link[disabled]{background-color:transparent;background-image:none;-webkit-box-shadow:none;-moz-box-shadow:none;box-shadow:none}.btn-link{color:#08c;cursor:pointer;border-color:transparent;-webkit-border-radius:0;-moz-border-radius:0;border-radius:0}.btn-link:hover{color:#005580;text-decoration:underline;background-color:transparent}.btn-link[disabled]:hover{color:#333;text-decoration:none}.btn-group{position:relative;*margin-left:.3em;font-size:0;white-space:nowrap;vertical-align:middle}.btn-group:first-child{*margin-left:0}.btn-group+.btn-group{margin-left:5px}.btn-toolbar{margin-top:10px;margin-bottom:10px;font-size:0}.btn-toolbar .btn-group{display:inline-block;*display:inline;*zoom:1}.btn-toolbar .btn+.btn,.btn-toolbar .btn-group+.btn,.btn-toolbar .btn+.btn-group{margin-left:5px}.btn-group>.btn{position:relative;-webkit-border-radius:0;-moz-border-radius:0;border-radius:0}.btn-group>.btn+.btn{margin-left:-1px}.btn-group>.btn,.btn-group>.dropdown-menu{font-size:14px}.btn-group>.btn-mini{font-size:11px}.btn-group>.btn-small{font-size:12px}.btn-group>.btn-large{font-size:16px}.btn-group>.btn:first-child{margin-left:0;-webkit-border-bottom-left-radius:4px;border-bottom-left-radius:4px;-webkit-border-top-left-radius:4px;border-top-left-radius:4px;-moz-border-radius-bottomleft:4px;-moz-border-radius-topleft:4px}.btn-group>.btn:last-child,.btn-group>.dropdown-toggle{-webkit-border-top-right-radius:4px;border-top-right-radius:4px;-webkit-border-bottom-right-radius:4px;border-bottom-right-radius:4px;-moz-border-radius-topright:4px;-moz-border-radius-bottomright:4px}.btn-group>.btn.large:first-child{margin-left:0;-webkit-border-bottom-left-radius:6px;border-bottom-left-radius:6px;-webkit-border-top-left-radius:6px;border-top-left-radius:6px;-moz-border-radius-bottomleft:6px;-moz-border-radius-topleft:6px}.btn-group>.btn.large:last-child,.btn-group>.large.dropdown-toggle{-webkit-border-top-right-radius:6px;border-top-right-radius:6px;-webkit-border-bottom-right-radius:6px;border-bottom-right-radius:6px;-moz-border-radius-topright:6px;-moz-border-radius-bottomright:6px}.btn-group>.btn:hover,.btn-group>.btn:focus,.btn-group>.btn:active,.btn-group>.btn.active{z-index:2}.btn-group .dropdown-toggle:active,.btn-group.open .dropdown-toggle{outline:0}.btn-group>.btn+.dropdown-toggle{*padding-top:5px;padding-right:8px;*padding-bottom:5px;padding-left:8px;-webkit-box-shadow:inset 1px 0 0 rgba(255,255,255,0.125),inset 0 1px 0 rgba(255,255,255,0.2),0 1px 2px rgba(0,0,0,0.05);-moz-box-shadow:inset 1px 0 0 rgba(255,255,255,0.125),inset 0 1px 0 rgba(255,255,255,0.2),0 1px 2px rgba(0,0,0,0.05);box-shadow:inset 1px 0 0 rgba(255,255,255,0.125),inset 0 1px 0 rgba(255,255,255,0.2),0 1px 2px rgba(0,0,0,0.05)}.btn-group>.btn-mini+.dropdown-toggle{*padding-top:2px;padding-right:5px;*padding-bottom:2px;padding-left:5px}.btn-group>.btn-small+.dropdown-toggle{*padding-top:5px;*padding-bottom:4px}.btn-group>.btn-large+.dropdown-toggle{*padding-top:7px;padding-right:12px;*padding-bottom:7px;padding-left:12px}.btn-group.open .dropdown-toggle{background-image:none;-webkit-box-shadow:inset 0 2px 4px rgba(0,0,0,0.15),0 1px 2px rgba(0,0,0,0.05);-moz-box-shadow:inset 0 2px 4px rgba(0,0,0,0.15),0 1px 2px rgba(0,0,0,0.05);box-shadow:inset 0 2px 4px rgba(0,0,0,0.15),0 1px 2px rgba(0,0,0,0.05)}.btn-group.open .btn.dropdown-toggle{background-color:#e6e6e6}.btn-group.open .btn-primary.dropdown-toggle{background-color:#04c}.btn-group.open .btn-warning.dropdown-toggle{background-color:#f89406}.btn-group.open .btn-danger.dropdown-toggle{background-color:#bd362f}.btn-group.open .btn-success.dropdown-toggle{background-color:#51a351}.btn-group.open .btn-info.dropdown-toggle{background-color:#2f96b4}.btn-group.open .btn-inverse.dropdown-toggle{background-color:#222}.btn .caret{margin-top:8px;margin-left:0}.btn-mini .caret,.btn-small .caret,.btn-large .caret{margin-top:6px}.btn-large .caret{border-top-width:5px;border-right-width:5px;border-left-width:5px}.dropup .btn-large .caret{border-top:0;border-bottom:5px solid #000}.btn-primary .caret,.btn-warning .caret,.btn-danger .caret,.btn-info .caret,.btn-success .caret,.btn-inverse .caret{border-top-color:#fff;border-bottom-color:#fff}.btn-group-vertical{display:inline-block;*display:inline;*zoom:1}.btn-group-vertical .btn{display:block;float:none;width:100%;-webkit-border-radius:0;-moz-border-radius:0;border-radius:0}.btn-group-vertical .btn+.btn{margin-top:-1px;margin-left:0}.btn-group-vertical .btn:first-child{-webkit-border-radius:4px 4px 0 0;-moz-border-radius:4px 4px 0 0;border-radius:4px 4px 0 0}.btn-group-vertical .btn:last-child{-webkit-border-radius:0 0 4px 4px;-moz-border-radius:0 0 4px 4px;border-radius:0 0 4px 4px}.btn-group-vertical .btn-large:first-child{-webkit-border-radius:6px 6px 0 0;-moz-border-radius:6px 6px 0 0;border-radius:6px 6px 0 0}.btn-group-vertical .btn-large:last-child{-webkit-border-radius:0 0 6px 6px;-moz-border-radius:0 0 6px 6px;border-radius:0 0 6px 6px}.alert{padding:8px 35px 8px 14px;margin-bottom:20px;color:#c09853;text-shadow:0 1px 0 rgba(255,255,255,0.5);background-color:#fcf8e3;border:1px solid #fbeed5;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px}.alert h4{margin:0}.alert .close{position:relative;top:-2px;right:-21px;line-height:20px}.alert-success{color:#468847;background-color:#dff0d8;border-color:#d6e9c6}.alert-danger,.alert-error{color:#b94a48;background-color:#f2dede;border-color:#eed3d7}.alert-info{color:#3a87ad;background-color:#d9edf7;border-color:#bce8f1}.alert-block{padding-top:14px;padding-bottom:14px}.alert-block>p,.alert-block>ul{margin-bottom:0}.alert-block p+p{margin-top:5px}.nav{margin-bottom:20px;margin-left:0;list-style:none}.nav>li>a{display:block}.nav>li>a:hover{text-decoration:none;background-color:#eee}.nav>.pull-right{float:right}.nav-header{display:block;padding:3px 15px;font-size:11px;font-weight:bold;line-height:20px;color:#999;text-shadow:0 1px 0 rgba(255,255,255,0.5);text-transform:uppercase}.nav li+.nav-header{margin-top:9px}.nav-list{padding-right:15px;padding-left:15px;margin-bottom:0}.nav-list>li>a,.nav-list .nav-header{margin-right:-15px;margin-left:-15px;text-shadow:0 1px 0 rgba(255,255,255,0.5)}.nav-list>li>a{padding:3px 15px}.nav-list>.active>a,.nav-list>.active>a:hover{color:#fff;text-shadow:0 -1px 0 rgba(0,0,0,0.2);background-color:#08c}.nav-list [class^="icon-"]{margin-right:2px}.nav-list .divider{*width:100%;height:1px;margin:9px 1px;*margin:-5px 0 5px;overflow:hidden;background-color:#e5e5e5;border-bottom:1px solid #fff}.nav-tabs,.nav-pills{*zoom:1}.nav-tabs:before,.nav-pills:before,.nav-tabs:after,.nav-pills:after{display:table;line-height:0;content:""}.nav-tabs:after,.nav-pills:after{clear:both}.nav-tabs>li,.nav-pills>li{float:left}.nav-tabs>li>a,.nav-pills>li>a{padding-right:12px;padding-left:12px;margin-right:2px;line-height:14px}.nav-tabs{border-bottom:1px solid #ddd}.nav-tabs>li{margin-bottom:-1px}.nav-tabs>li>a{padding-top:8px;padding-bottom:8px;line-height:20px;border:1px solid transparent;-webkit-border-radius:4px 4px 0 0;-moz-border-radius:4px 4px 0 0;border-radius:4px 4px 0 0}.nav-tabs>li>a:hover{border-color:#eee #eee #ddd}.nav-tabs>.active>a,.nav-tabs>.active>a:hover{color:#555;cursor:default;background-color:#fff;border:1px solid #ddd;border-bottom-color:transparent}.nav-pills>li>a{padding-top:8px;padding-bottom:8px;margin-top:2px;margin-bottom:2px;-webkit-border-radius:5px;-moz-border-radius:5px;border-radius:5px}.nav-pills>.active>a,.nav-pills>.active>a:hover{color:#fff;background-color:#08c}.nav-stacked>li{float:none}.nav-stacked>li>a{margin-right:0}.nav-tabs.nav-stacked{border-bottom:0}.nav-tabs.nav-stacked>li>a{border:1px solid #ddd;-webkit-border-radius:0;-moz-border-radius:0;border-radius:0}.nav-tabs.nav-stacked>li:first-child>a{-webkit-border-top-right-radius:4px;border-top-right-radius:4px;-webkit-border-top-left-radius:4px;border-top-left-radius:4px;-moz-border-radius-topright:4px;-moz-border-radius-topleft:4px}.nav-tabs.nav-stacked>li:last-child>a{-webkit-border-bottom-right-radius:4px;border-bottom-right-radius:4px;-webkit-border-bottom-left-radius:4px;border-bottom-left-radius:4px;-moz-border-radius-bottomright:4px;-moz-border-radius-bottomleft:4px}.nav-tabs.nav-stacked>li>a:hover{z-index:2;border-color:#ddd}.nav-pills.nav-stacked>li>a{margin-bottom:3px}.nav-pills.nav-stacked>li:last-child>a{margin-bottom:1px}.nav-tabs .dropdown-menu{-webkit-border-radius:0 0 6px 6px;-moz-border-radius:0 0 6px 6px;border-radius:0 0 6px 6px}.nav-pills .dropdown-menu{-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px}.nav .dropdown-toggle .caret{margin-top:6px;border-top-color:#08c;border-bottom-color:#08c}.nav .dropdown-toggle:hover .caret{border-top-color:#005580;border-bottom-color:#005580}.nav-tabs .dropdown-toggle .caret{margin-top:8px}.nav .active .dropdown-toggle .caret{border-top-color:#fff;border-bottom-color:#fff}.nav-tabs .active .dropdown-toggle .caret{border-top-color:#555;border-bottom-color:#555}.nav>.dropdown.active>a:hover{cursor:pointer}.nav-tabs .open .dropdown-toggle,.nav-pills .open .dropdown-toggle,.nav>li.dropdown.open.active>a:hover{color:#fff;background-color:#999;border-color:#999}.nav li.dropdown.open .caret,.nav li.dropdown.open.active .caret,.nav li.dropdown.open a:hover .caret{border-top-color:#fff;border-bottom-color:#fff;opacity:1;filter:alpha(opacity=100)}.tabs-stacked .open>a:hover{border-color:#999}.tabbable{*zoom:1}.tabbable:before,.tabbable:after{display:table;line-height:0;content:""}.tabbable:after{clear:both}.tab-content{overflow:auto}.tabs-below>.nav-tabs,.tabs-right>.nav-tabs,.tabs-left>.nav-tabs{border-bottom:0}.tab-content>.tab-pane,.pill-content>.pill-pane{display:none}.tab-content>.active,.pill-content>.active{display:block}.tabs-below>.nav-tabs{border-top:1px solid #ddd}.tabs-below>.nav-tabs>li{margin-top:-1px;margin-bottom:0}.tabs-below>.nav-tabs>li>a{-webkit-border-radius:0 0 4px 4px;-moz-border-radius:0 0 4px 4px;border-radius:0 0 4px 4px}.tabs-below>.nav-tabs>li>a:hover{border-top-color:#ddd;border-bottom-color:transparent}.tabs-below>.nav-tabs>.active>a,.tabs-below>.nav-tabs>.active>a:hover{border-color:transparent #ddd #ddd #ddd}.tabs-left>.nav-tabs>li,.tabs-right>.nav-tabs>li{float:none}.tabs-left>.nav-tabs>li>a,.tabs-right>.nav-tabs>li>a{min-width:74px;margin-right:0;margin-bottom:3px}.tabs-left>.nav-tabs{float:left;margin-right:19px;border-right:1px solid #ddd}.tabs-left>.nav-tabs>li>a{margin-right:-1px;-webkit-border-radius:4px 0 0 4px;-moz-border-radius:4px 0 0 4px;border-radius:4px 0 0 4px}.tabs-left>.nav-tabs>li>a:hover{border-color:#eee #ddd #eee #eee}.tabs-left>.nav-tabs .active>a,.tabs-left>.nav-tabs .active>a:hover{border-color:#ddd transparent #ddd #ddd;*border-right-color:#fff}.tabs-right>.nav-tabs{float:right;margin-left:19px;border-left:1px solid #ddd}.tabs-right>.nav-tabs>li>a{margin-left:-1px;-webkit-border-radius:0 4px 4px 0;-moz-border-radius:0 4px 4px 0;border-radius:0 4px 4px 0}.tabs-right>.nav-tabs>li>a:hover{border-color:#eee #eee #eee #ddd}.tabs-right>.nav-tabs .active>a,.tabs-right>.nav-tabs .active>a:hover{border-color:#ddd #ddd #ddd transparent;*border-left-color:#fff}.nav>.disabled>a{color:#999}.nav>.disabled>a:hover{text-decoration:none;cursor:default;background-color:transparent}.navbar{*position:relative;*z-index:2;margin-bottom:20px;overflow:visible;color:#777}.navbar-inner{min-height:40px;padding-right:20px;padding-left:20px;background-color:#fafafa;background-image:-moz-linear-gradient(top,#fff,#f2f2f2);background-image:-webkit-gradient(linear,0 0,0 100%,from(#fff),to(#f2f2f2));background-image:-webkit-linear-gradient(top,#fff,#f2f2f2);background-image:-o-linear-gradient(top,#fff,#f2f2f2);background-image:linear-gradient(to bottom,#fff,#f2f2f2);background-repeat:repeat-x;border:1px solid #d4d4d4;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;filter:progid:dximagetransform.microsoft.gradient(startColorstr='#ffffffff',endColorstr='#fff2f2f2',GradientType=0);*zoom:1;-webkit-box-shadow:0 1px 4px rgba(0,0,0,0.065);-moz-box-shadow:0 1px 4px rgba(0,0,0,0.065);box-shadow:0 1px 4px rgba(0,0,0,0.065)}.navbar-inner:before,.navbar-inner:after{display:table;line-height:0;content:""}.navbar-inner:after{clear:both}.navbar .container{width:auto}.nav-collapse.collapse{height:auto}.navbar .brand{display:block;float:left;padding:10px 20px 10px;margin-left:-20px;font-size:20px;font-weight:200;color:#777;text-shadow:0 1px 0 #fff}.navbar .brand:hover{text-decoration:none}.navbar-text{margin-bottom:0;line-height:40px}.navbar-link{color:#777}.navbar-link:hover{color:#333}.navbar .divider-vertical{height:40px;margin:0 9px;border-right:1px solid #fff;border-left:1px solid #f2f2f2}.navbar .btn,.navbar .btn-group{margin-top:5px}.navbar .btn-group .btn,.navbar .input-prepend .btn,.navbar .input-append .btn{margin-top:0}.navbar-form{margin-bottom:0;*zoom:1}.navbar-form:before,.navbar-form:after{display:table;line-height:0;content:""}.navbar-form:after{clear:both}.navbar-form input,.navbar-form select,.navbar-form .radio,.navbar-form .checkbox{margin-top:5px}.navbar-form input,.navbar-form select,.navbar-form .btn{display:inline-block;margin-bottom:0}.navbar-form input[type="image"],.navbar-form input[type="checkbox"],.navbar-form input[type="radio"]{margin-top:3px}.navbar-form .input-append,.navbar-form .input-prepend{margin-top:6px;white-space:nowrap}.navbar-form .input-append input,.navbar-form .input-prepend input{margin-top:0}.navbar-search{position:relative;float:left;margin-top:5px;margin-bottom:0}.navbar-search .search-query{padding:4px 14px;margin-bottom:0;font-family:"Helvetica Neue",Helvetica,Arial,sans-serif;font-size:13px;font-weight:normal;line-height:1;-webkit-border-radius:15px;-moz-border-radius:15px;border-radius:15px}.navbar-static-top{position:static;width:100%;margin-bottom:0}.navbar-static-top .navbar-inner{-webkit-border-radius:0;-moz-border-radius:0;border-radius:0}.navbar-fixed-top,.navbar-fixed-bottom{position:fixed;right:0;left:0;z-index:1030;margin-bottom:0}.navbar-fixed-top .navbar-inner,.navbar-static-top .navbar-inner{border-width:0 0 1px}.navbar-fixed-bottom .navbar-inner{border-width:1px 0 0}.navbar-fixed-top .navbar-inner,.navbar-fixed-bottom .navbar-inner{padding-right:0;padding-left:0;-webkit-border-radius:0;-moz-border-radius:0;border-radius:0}.navbar-static-top .container,.navbar-fixed-top .container,.navbar-fixed-bottom .container{width:940px}.navbar-fixed-top{top:0}.navbar-fixed-top .navbar-inner,.navbar-static-top .navbar-inner{-webkit-box-shadow:inset 0 -1px 0 rgba(0,0,0,0.1),0 1px 10px rgba(0,0,0,0.1);-moz-box-shadow:inset 0 -1px 0 rgba(0,0,0,0.1),0 1px 10px rgba(0,0,0,0.1);box-shadow:inset 0 -1px 0 rgba(0,0,0,0.1),0 1px 10px rgba(0,0,0,0.1)}.navbar-fixed-bottom{bottom:0}.navbar-fixed-bottom .navbar-inner{-webkit-box-shadow:inset 0 1px 0 rgba(0,0,0,0.1),0 -1px 10px rgba(0,0,0,0.1);-moz-box-shadow:inset 0 1px 0 rgba(0,0,0,0.1),0 -1px 10px rgba(0,0,0,0.1);box-shadow:inset 0 1px 0 rgba(0,0,0,0.1),0 -1px 10px rgba(0,0,0,0.1)}.navbar .nav{position:relative;left:0;display:block;float:left;margin:0 10px 0 0}.navbar .nav.pull-right{float:right;margin-right:0}.navbar .nav>li{float:left}.navbar .nav>li>a{float:none;padding:10px 15px 10px;color:#777;text-decoration:none;text-shadow:0 1px 0 #fff}.navbar .nav .dropdown-toggle .caret{margin-top:8px}.navbar .nav>li>a:focus,.navbar .nav>li>a:hover{color:#333;text-decoration:none;background-color:transparent}.navbar .nav>.active>a,.navbar .nav>.active>a:hover,.navbar .nav>.active>a:focus{color:#555;text-decoration:none;background-color:#e5e5e5;-webkit-box-shadow:inset 0 3px 8px rgba(0,0,0,0.125);-moz-box-shadow:inset 0 3px 8px rgba(0,0,0,0.125);box-shadow:inset 0 3px 8px rgba(0,0,0,0.125)}.navbar .btn-navbar{display:none;float:right;padding:7px 10px;margin-right:5px;margin-left:5px;color:#fff;text-shadow:0 -1px 0 rgba(0,0,0,0.25);background-color:#ededed;*background-color:#e5e5e5;background-image:-webkit-gradient(linear,0 0,0 100%,from(#f2f2f2),to(#e5e5e5));background-image:-webkit-linear-gradient(top,#f2f2f2,#e5e5e5);background-image:-o-linear-gradient(top,#f2f2f2,#e5e5e5);background-image:linear-gradient(to bottom,#f2f2f2,#e5e5e5);background-image:-moz-linear-gradient(top,#f2f2f2,#e5e5e5);background-repeat:repeat-x;border-color:#e5e5e5 #e5e5e5 #bfbfbf;border-color:rgba(0,0,0,0.1) rgba(0,0,0,0.1) rgba(0,0,0,0.25);filter:progid:dximagetransform.microsoft.gradient(startColorstr='#fff2f2f2',endColorstr='#ffe5e5e5',GradientType=0);filter:progid:dximagetransform.microsoft.gradient(enabled=false);-webkit-box-shadow:inset 0 1px 0 rgba(255,255,255,0.1),0 1px 0 rgba(255,255,255,0.075);-moz-box-shadow:inset 0 1px 0 rgba(255,255,255,0.1),0 1px 0 rgba(255,255,255,0.075);box-shadow:inset 0 1px 0 rgba(255,255,255,0.1),0 1px 0 rgba(255,255,255,0.075)}.navbar .btn-navbar:hover,.navbar .btn-navbar:active,.navbar .btn-navbar.active,.navbar .btn-navbar.disabled,.navbar .btn-navbar[disabled]{color:#fff;background-color:#e5e5e5;*background-color:#d9d9d9}.navbar .btn-navbar:active,.navbar .btn-navbar.active{background-color:#ccc \9}.navbar .btn-navbar .icon-bar{display:block;width:18px;height:2px;background-color:#f5f5f5;-webkit-border-radius:1px;-moz-border-radius:1px;border-radius:1px;-webkit-box-shadow:0 1px 0 rgba(0,0,0,0.25);-moz-box-shadow:0 1px 0 rgba(0,0,0,0.25);box-shadow:0 1px 0 rgba(0,0,0,0.25)}.btn-navbar .icon-bar+.icon-bar{margin-top:3px}.navbar .nav>li>.dropdown-menu:before{position:absolute;top:-7px;left:9px;display:inline-block;border-right:7px solid transparent;border-bottom:7px solid #ccc;border-left:7px solid transparent;border-bottom-color:rgba(0,0,0,0.2);content:''}.navbar .nav>li>.dropdown-menu:after{position:absolute;top:-6px;left:10px;display:inline-block;border-right:6px solid transparent;border-bottom:6px solid #fff;border-left:6px solid transparent;content:''}.navbar-fixed-bottom .nav>li>.dropdown-menu:before{top:auto;bottom:-7px;border-top:7px solid #ccc;border-bottom:0;border-top-color:rgba(0,0,0,0.2)}.navbar-fixed-bottom .nav>li>.dropdown-menu:after{top:auto;bottom:-6px;border-top:6px solid #fff;border-bottom:0}.navbar .nav li.dropdown.open>.dropdown-toggle,.navbar .nav li.dropdown.active>.dropdown-toggle,.navbar .nav li.dropdown.open.active>.dropdown-toggle{color:#555;background-color:#e5e5e5}.navbar .nav li.dropdown>.dropdown-toggle .caret{border-top-color:#777;border-bottom-color:#777}.navbar .nav li.dropdown.open>.dropdown-toggle .caret,.navbar .nav li.dropdown.active>.dropdown-toggle .caret,.navbar .nav li.dropdown.open.active>.dropdown-toggle .caret{border-top-color:#555;border-bottom-color:#555}.navbar .pull-right>li>.dropdown-menu,.navbar .nav>li>.dropdown-menu.pull-right{right:0;left:auto}.navbar .pull-right>li>.dropdown-menu:before,.navbar .nav>li>.dropdown-menu.pull-right:before{right:12px;left:auto}.navbar .pull-right>li>.dropdown-menu:after,.navbar .nav>li>.dropdown-menu.pull-right:after{right:13px;left:auto}.navbar .pull-right>li>.dropdown-menu .dropdown-menu,.navbar .nav>li>.dropdown-menu.pull-right .dropdown-menu{right:100%;left:auto;margin-right:-1px;margin-left:0;-webkit-border-radius:6px 0 6px 6px;-moz-border-radius:6px 0 6px 6px;border-radius:6px 0 6px 6px}.navbar-inverse{color:#999}.navbar-inverse .navbar-inner{background-color:#1b1b1b;background-image:-moz-linear-gradient(top,#222,#111);background-image:-webkit-gradient(linear,0 0,0 100%,from(#222),to(#111));background-image:-webkit-linear-gradient(top,#222,#111);background-image:-o-linear-gradient(top,#222,#111);background-image:linear-gradient(to bottom,#222,#111);background-repeat:repeat-x;border-color:#252525;filter:progid:dximagetransform.microsoft.gradient(startColorstr='#ff222222',endColorstr='#ff111111',GradientType=0)}.navbar-inverse .brand,.navbar-inverse .nav>li>a{color:#999;text-shadow:0 -1px 0 rgba(0,0,0,0.25)}.navbar-inverse .brand:hover,.navbar-inverse .nav>li>a:hover{color:#fff}.navbar-inverse .nav>li>a:focus,.navbar-inverse .nav>li>a:hover{color:#fff;background-color:transparent}.navbar-inverse .nav .active>a,.navbar-inverse .nav .active>a:hover,.navbar-inverse .nav .active>a:focus{color:#fff;background-color:#111}.navbar-inverse .navbar-link{color:#999}.navbar-inverse .navbar-link:hover{color:#fff}.navbar-inverse .divider-vertical{border-right-color:#222;border-left-color:#111}.navbar-inverse .nav li.dropdown.open>.dropdown-toggle,.navbar-inverse .nav li.dropdown.active>.dropdown-toggle,.navbar-inverse .nav li.dropdown.open.active>.dropdown-toggle{color:#fff;background-color:#111}.navbar-inverse .nav li.dropdown>.dropdown-toggle .caret{border-top-color:#999;border-bottom-color:#999}.navbar-inverse .nav li.dropdown.open>.dropdown-toggle .caret,.navbar-inverse .nav li.dropdown.active>.dropdown-toggle .caret,.navbar-inverse .nav li.dropdown.open.active>.dropdown-toggle .caret{border-top-color:#fff;border-bottom-color:#fff}.navbar-inverse .navbar-search .search-query{color:#fff;background-color:#515151;border-color:#111;-webkit-box-shadow:inset 0 1px 2px rgba(0,0,0,0.1),0 1px 0 rgba(255,255,255,0.15);-moz-box-shadow:inset 0 1px 2px rgba(0,0,0,0.1),0 1px 0 rgba(255,255,255,0.15);box-shadow:inset 0 1px 2px rgba(0,0,0,0.1),0 1px 0 rgba(255,255,255,0.15);-webkit-transition:none;-moz-transition:none;-o-transition:none;transition:none}.navbar-inverse .navbar-search .search-query:-moz-placeholder{color:#ccc}.navbar-inverse .navbar-search .search-query:-ms-input-placeholder{color:#ccc}.navbar-inverse .navbar-search .search-query::-webkit-input-placeholder{color:#ccc}.navbar-inverse .navbar-search .search-query:focus,.navbar-inverse .navbar-search .search-query.focused{padding:5px 15px;color:#333;text-shadow:0 1px 0 #fff;background-color:#fff;border:0;outline:0;-webkit-box-shadow:0 0 3px rgba(0,0,0,0.15);-moz-box-shadow:0 0 3px rgba(0,0,0,0.15);box-shadow:0 0 3px rgba(0,0,0,0.15)}.navbar-inverse .btn-navbar{color:#fff;text-shadow:0 -1px 0 rgba(0,0,0,0.25);background-color:#0e0e0e;*background-color:#040404;background-image:-webkit-gradient(linear,0 0,0 100%,from(#151515),to(#040404));background-image:-webkit-linear-gradient(top,#151515,#040404);background-image:-o-linear-gradient(top,#151515,#040404);background-image:linear-gradient(to bottom,#151515,#040404);background-image:-moz-linear-gradient(top,#151515,#040404);background-repeat:repeat-x;border-color:#040404 #040404 #000;border-color:rgba(0,0,0,0.1) rgba(0,0,0,0.1) rgba(0,0,0,0.25);filter:progid:dximagetransform.microsoft.gradient(startColorstr='#ff151515',endColorstr='#ff040404',GradientType=0);filter:progid:dximagetransform.microsoft.gradient(enabled=false)}.navbar-inverse .btn-navbar:hover,.navbar-inverse .btn-navbar:active,.navbar-inverse .btn-navbar.active,.navbar-inverse .btn-navbar.disabled,.navbar-inverse .btn-navbar[disabled]{color:#fff;background-color:#040404;*background-color:#000}.navbar-inverse .btn-navbar:active,.navbar-inverse .btn-navbar.active{background-color:#000 \9}.breadcrumb{padding:8px 15px;margin:0 0 20px;list-style:none;background-color:#f5f5f5;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px}.breadcrumb li{display:inline-block;*display:inline;text-shadow:0 1px 0 #fff;*zoom:1}.breadcrumb .divider{padding:0 5px;color:#ccc}.breadcrumb .active{color:#999}.pagination{height:40px;margin:20px 0}.pagination ul{display:inline-block;*display:inline;margin-bottom:0;margin-left:0;-webkit-border-radius:3px;-moz-border-radius:3px;border-radius:3px;*zoom:1;-webkit-box-shadow:0 1px 2px rgba(0,0,0,0.05);-moz-box-shadow:0 1px 2px rgba(0,0,0,0.05);box-shadow:0 1px 2px rgba(0,0,0,0.05)}.pagination ul>li{display:inline}.pagination ul>li>a,.pagination ul>li>span{float:left;padding:0 14px;line-height:38px;text-decoration:none;background-color:#fff;border:1px solid #ddd;border-left-width:0}.pagination ul>li>a:hover,.pagination ul>.active>a,.pagination ul>.active>span{background-color:#f5f5f5}.pagination ul>.active>a,.pagination ul>.active>span{color:#999;cursor:default}.pagination ul>.disabled>span,.pagination ul>.disabled>a,.pagination ul>.disabled>a:hover{color:#999;cursor:default;background-color:transparent}.pagination ul>li:first-child>a,.pagination ul>li:first-child>span{border-left-width:1px;-webkit-border-radius:3px 0 0 3px;-moz-border-radius:3px 0 0 3px;border-radius:3px 0 0 3px}.pagination ul>li:last-child>a,.pagination ul>li:last-child>span{-webkit-border-radius:0 3px 3px 0;-moz-border-radius:0 3px 3px 0;border-radius:0 3px 3px 0}.pagination-centered{text-align:center}.pagination-right{text-align:right}.pager{margin:20px 0;text-align:center;list-style:none;*zoom:1}.pager:before,.pager:after{display:table;line-height:0;content:""}.pager:after{clear:both}.pager li{display:inline}.pager a,.pager span{display:inline-block;padding:5px 14px;background-color:#fff;border:1px solid #ddd;-webkit-border-radius:15px;-moz-border-radius:15px;border-radius:15px}.pager a:hover{text-decoration:none;background-color:#f5f5f5}.pager .next a,.pager .next span{float:right}.pager .previous a{float:left}.pager .disabled a,.pager .disabled a:hover,.pager .disabled span{color:#999;cursor:default;background-color:#fff}.modal-open .modal .dropdown-menu{z-index:2050}.modal-open .modal .dropdown.open{*z-index:2050}.modal-open .modal .popover{z-index:2060}.modal-open .modal .tooltip{z-index:2080}.modal-backdrop{position:fixed;top:0;right:0;bottom:0;left:0;z-index:1040;background-color:#000}.modal-backdrop.fade{opacity:0}.modal-backdrop,.modal-backdrop.fade.in{opacity:.8;filter:alpha(opacity=80)}.modal{position:fixed;top:50%;left:50%;z-index:1050;width:560px;margin:-250px 0 0 -280px;overflow:auto;background-color:#fff;border:1px solid #999;border:1px solid rgba(0,0,0,0.3);*border:1px solid #999;-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px;-webkit-box-shadow:0 3px 7px rgba(0,0,0,0.3);-moz-box-shadow:0 3px 7px rgba(0,0,0,0.3);box-shadow:0 3px 7px rgba(0,0,0,0.3);-webkit-background-clip:padding-box;-moz-background-clip:padding-box;background-clip:padding-box}.modal.fade{top:-25%;-webkit-transition:opacity .3s linear,top .3s ease-out;-moz-transition:opacity .3s linear,top .3s ease-out;-o-transition:opacity .3s linear,top .3s ease-out;transition:opacity .3s linear,top .3s ease-out}.modal.fade.in{top:50%}.modal-header{padding:9px 15px;border-bottom:1px solid #eee}.modal-header .close{margin-top:2px}.modal-header h3{margin:0;line-height:30px}.modal-body{max-height:400px;padding:15px;overflow-y:auto}.modal-form{margin-bottom:0}.modal-footer{padding:14px 15px 15px;margin-bottom:0;text-align:right;background-color:#f5f5f5;border-top:1px solid #ddd;-webkit-border-radius:0 0 6px 6px;-moz-border-radius:0 0 6px 6px;border-radius:0 0 6px 6px;*zoom:1;-webkit-box-shadow:inset 0 1px 0 #fff;-moz-box-shadow:inset 0 1px 0 #fff;box-shadow:inset 0 1px 0 #fff}.modal-footer:before,.modal-footer:after{display:table;line-height:0;content:""}.modal-footer:after{clear:both}.modal-footer .btn+.btn{margin-bottom:0;margin-left:5px}.modal-footer .btn-group .btn+.btn{margin-left:-1px}.tooltip{position:absolute;z-index:1030;display:block;padding:5px;font-size:11px;opacity:0;filter:alpha(opacity=0);visibility:visible}.tooltip.in{opacity:.8;filter:alpha(opacity=80)}.tooltip.top{margin-top:-3px}.tooltip.right{margin-left:3px}.tooltip.bottom{margin-top:3px}.tooltip.left{margin-left:-3px}.tooltip-inner{max-width:200px;padding:3px 8px;color:#fff;text-align:center;text-decoration:none;background-color:#000;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px}.tooltip-arrow{position:absolute;width:0;height:0;border-color:transparent;border-style:solid}.tooltip.top .tooltip-arrow{bottom:0;left:50%;margin-left:-5px;border-top-color:#000;border-width:5px 5px 0}.tooltip.right .tooltip-arrow{top:50%;left:0;margin-top:-5px;border-right-color:#000;border-width:5px 5px 5px 0}.tooltip.left .tooltip-arrow{top:50%;right:0;margin-top:-5px;border-left-color:#000;border-width:5px 0 5px 5px}.tooltip.bottom .tooltip-arrow{top:0;left:50%;margin-left:-5px;border-bottom-color:#000;border-width:0 5px 5px}.popover{position:absolute;top:0;left:0;z-index:1010;display:none;width:236px;padding:1px;background-color:#fff;border:1px solid #ccc;border:1px solid rgba(0,0,0,0.2);-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px;-webkit-box-shadow:0 5px 10px rgba(0,0,0,0.2);-moz-box-shadow:0 5px 10px rgba(0,0,0,0.2);box-shadow:0 5px 10px rgba(0,0,0,0.2);-webkit-background-clip:padding-box;-moz-background-clip:padding;background-clip:padding-box}.popover.top{margin-bottom:10px}.popover.right{margin-left:10px}.popover.bottom{margin-top:10px}.popover.left{margin-right:10px}.popover-title{padding:8px 14px;margin:0;font-size:14px;font-weight:normal;line-height:18px;background-color:#f7f7f7;border-bottom:1px solid #ebebeb;-webkit-border-radius:5px 5px 0 0;-moz-border-radius:5px 5px 0 0;border-radius:5px 5px 0 0}.popover-content{padding:9px 14px}.popover-content p,.popover-content ul,.popover-content ol{margin-bottom:0}.popover .arrow,.popover .arrow:after{position:absolute;display:inline-block;width:0;height:0;border-color:transparent;border-style:solid}.popover .arrow:after{z-index:-1;content:""}.popover.top .arrow{bottom:-10px;left:50%;margin-left:-10px;border-top-color:#fff;border-width:10px 10px 0}.popover.top .arrow:after{bottom:-1px;left:-11px;border-top-color:rgba(0,0,0,0.25);border-width:11px 11px 0}.popover.right .arrow{top:50%;left:-10px;margin-top:-10px;border-right-color:#fff;border-width:10px 10px 10px 0}.popover.right .arrow:after{bottom:-11px;left:-1px;border-right-color:rgba(0,0,0,0.25);border-width:11px 11px 11px 0}.popover.bottom .arrow{top:-10px;left:50%;margin-left:-10px;border-bottom-color:#fff;border-width:0 10px 10px}.popover.bottom .arrow:after{top:-1px;left:-11px;border-bottom-color:rgba(0,0,0,0.25);border-width:0 11px 11px}.popover.left .arrow{top:50%;right:-10px;margin-top:-10px;border-left-color:#fff;border-width:10px 0 10px 10px}.popover.left .arrow:after{right:-1px;bottom:-11px;border-left-color:rgba(0,0,0,0.25);border-width:11px 0 11px 11px}.thumbnails{margin-left:-20px;list-style:none;*zoom:1}.thumbnails:before,.thumbnails:after{display:table;line-height:0;content:""}.thumbnails:after{clear:both}.row-fluid .thumbnails{margin-left:0}.thumbnails>li{float:left;margin-bottom:20px;margin-left:20px}.thumbnail{display:block;padding:4px;line-height:20px;border:1px solid #ddd;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;-webkit-box-shadow:0 1px 3px rgba(0,0,0,0.055);-moz-box-shadow:0 1px 3px rgba(0,0,0,0.055);box-shadow:0 1px 3px rgba(0,0,0,0.055);-webkit-transition:all .2s ease-in-out;-moz-transition:all .2s ease-in-out;-o-transition:all .2s ease-in-out;transition:all .2s ease-in-out}a.thumbnail:hover{border-color:#08c;-webkit-box-shadow:0 1px 4px rgba(0,105,214,0.25);-moz-box-shadow:0 1px 4px rgba(0,105,214,0.25);box-shadow:0 1px 4px rgba(0,105,214,0.25)}.thumbnail>img{display:block;max-width:100%;margin-right:auto;margin-left:auto}.thumbnail .caption{padding:9px;color:#555}.label,.badge{font-size:11.844px;font-weight:bold;line-height:14px;color:#fff;text-shadow:0 -1px 0 rgba(0,0,0,0.25);white-space:nowrap;vertical-align:baseline;background-color:#999}.label{padding:1px 4px 2px;-webkit-border-radius:3px;-moz-border-radius:3px;border-radius:3px}.badge{padding:1px 9px 2px;-webkit-border-radius:9px;-moz-border-radius:9px;border-radius:9px}a.label:hover,a.badge:hover{color:#fff;text-decoration:none;cursor:pointer}.label-important,.badge-important{background-color:#b94a48}.label-important[href],.badge-important[href]{background-color:#953b39}.label-warning,.badge-warning{background-color:#f89406}.label-warning[href],.badge-warning[href]{background-color:#c67605}.label-success,.badge-success{background-color:#468847}.label-success[href],.badge-success[href]{background-color:#356635}.label-info,.badge-info{background-color:#3a87ad}.label-info[href],.badge-info[href]{background-color:#2d6987}.label-inverse,.badge-inverse{background-color:#333}.label-inverse[href],.badge-inverse[href]{background-color:#1a1a1a}.btn .label,.btn .badge{position:relative;top:-1px}.btn-mini .label,.btn-mini .badge{top:0}@-webkit-keyframes progress-bar-stripes{from{background-position:40px 0}to{background-position:0 0}}@-moz-keyframes progress-bar-stripes{from{background-position:40px 0}to{background-position:0 0}}@-ms-keyframes progress-bar-stripes{from{background-position:40px 0}to{background-position:0 0}}@-o-keyframes progress-bar-stripes{from{background-position:0 0}to{background-position:40px 0}}@keyframes progress-bar-stripes{from{background-position:40px 0}to{background-position:0 0}}.progress{height:20px;margin-bottom:20px;overflow:hidden;background-color:#f7f7f7;background-image:-moz-linear-gradient(top,#f5f5f5,#f9f9f9);background-image:-webkit-gradient(linear,0 0,0 100%,from(#f5f5f5),to(#f9f9f9));background-image:-webkit-linear-gradient(top,#f5f5f5,#f9f9f9);background-image:-o-linear-gradient(top,#f5f5f5,#f9f9f9);background-image:linear-gradient(to bottom,#f5f5f5,#f9f9f9);background-repeat:repeat-x;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;filter:progid:dximagetransform.microsoft.gradient(startColorstr='#fff5f5f5',endColorstr='#fff9f9f9',GradientType=0);-webkit-box-shadow:inset 0 1px 2px rgba(0,0,0,0.1);-moz-box-shadow:inset 0 1px 2px rgba(0,0,0,0.1);box-shadow:inset 0 1px 2px rgba(0,0,0,0.1)}.progress .bar{float:left;width:0;height:100%;font-size:12px;color:#fff;text-align:center;text-shadow:0 -1px 0 rgba(0,0,0,0.25);background-color:#0e90d2;background-image:-moz-linear-gradient(top,#149bdf,#0480be);background-image:-webkit-gradient(linear,0 0,0 100%,from(#149bdf),to(#0480be));background-image:-webkit-linear-gradient(top,#149bdf,#0480be);background-image:-o-linear-gradient(top,#149bdf,#0480be);background-image:linear-gradient(to bottom,#149bdf,#0480be);background-repeat:repeat-x;filter:progid:dximagetransform.microsoft.gradient(startColorstr='#ff149bdf',endColorstr='#ff0480be',GradientType=0);-webkit-box-shadow:inset 0 -1px 0 rgba(0,0,0,0.15);-moz-box-shadow:inset 0 -1px 0 rgba(0,0,0,0.15);box-shadow:inset 0 -1px 0 rgba(0,0,0,0.15);-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;-webkit-transition:width .6s ease;-moz-transition:width .6s ease;-o-transition:width .6s ease;transition:width .6s ease}.progress .bar+.bar{-webkit-box-shadow:inset 1px 0 0 rgba(0,0,0,0.15),inset 0 -1px 0 rgba(0,0,0,0.15);-moz-box-shadow:inset 1px 0 0 rgba(0,0,0,0.15),inset 0 -1px 0 rgba(0,0,0,0.15);box-shadow:inset 1px 0 0 rgba(0,0,0,0.15),inset 0 -1px 0 rgba(0,0,0,0.15)}.progress-striped .bar{background-color:#149bdf;background-image:-webkit-gradient(linear,0 100%,100% 0,color-stop(0.25,rgba(255,255,255,0.15)),color-stop(0.25,transparent),color-stop(0.5,transparent),color-stop(0.5,rgba(255,255,255,0.15)),color-stop(0.75,rgba(255,255,255,0.15)),color-stop(0.75,transparent),to(transparent));background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:-moz-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);-webkit-background-size:40px 40px;-moz-background-size:40px 40px;-o-background-size:40px 40px;background-size:40px 40px}.progress.active .bar{-webkit-animation:progress-bar-stripes 2s linear infinite;-moz-animation:progress-bar-stripes 2s linear infinite;-ms-animation:progress-bar-stripes 2s linear infinite;-o-animation:progress-bar-stripes 2s linear infinite;animation:progress-bar-stripes 2s linear infinite}.progress-danger .bar,.progress .bar-danger{background-color:#dd514c;background-image:-moz-linear-gradient(top,#ee5f5b,#c43c35);background-image:-webkit-gradient(linear,0 0,0 100%,from(#ee5f5b),to(#c43c35));background-image:-webkit-linear-gradient(top,#ee5f5b,#c43c35);background-image:-o-linear-gradient(top,#ee5f5b,#c43c35);background-image:linear-gradient(to bottom,#ee5f5b,#c43c35);background-repeat:repeat-x;filter:progid:dximagetransform.microsoft.gradient(startColorstr='#ffee5f5b',endColorstr='#ffc43c35',GradientType=0)}.progress-danger.progress-striped .bar,.progress-striped .bar-danger{background-color:#ee5f5b;background-image:-webkit-gradient(linear,0 100%,100% 0,color-stop(0.25,rgba(255,255,255,0.15)),color-stop(0.25,transparent),color-stop(0.5,transparent),color-stop(0.5,rgba(255,255,255,0.15)),color-stop(0.75,rgba(255,255,255,0.15)),color-stop(0.75,transparent),to(transparent));background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:-moz-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent)}.progress-success .bar,.progress .bar-success{background-color:#5eb95e;background-image:-moz-linear-gradient(top,#62c462,#57a957);background-image:-webkit-gradient(linear,0 0,0 100%,from(#62c462),to(#57a957));background-image:-webkit-linear-gradient(top,#62c462,#57a957);background-image:-o-linear-gradient(top,#62c462,#57a957);background-image:linear-gradient(to bottom,#62c462,#57a957);background-repeat:repeat-x;filter:progid:dximagetransform.microsoft.gradient(startColorstr='#ff62c462',endColorstr='#ff57a957',GradientType=0)}.progress-success.progress-striped .bar,.progress-striped .bar-success{background-color:#62c462;background-image:-webkit-gradient(linear,0 100%,100% 0,color-stop(0.25,rgba(255,255,255,0.15)),color-stop(0.25,transparent),color-stop(0.5,transparent),color-stop(0.5,rgba(255,255,255,0.15)),color-stop(0.75,rgba(255,255,255,0.15)),color-stop(0.75,transparent),to(transparent));background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:-moz-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent)}.progress-info .bar,.progress .bar-info{background-color:#4bb1cf;background-image:-moz-linear-gradient(top,#5bc0de,#339bb9);background-image:-webkit-gradient(linear,0 0,0 100%,from(#5bc0de),to(#339bb9));background-image:-webkit-linear-gradient(top,#5bc0de,#339bb9);background-image:-o-linear-gradient(top,#5bc0de,#339bb9);background-image:linear-gradient(to bottom,#5bc0de,#339bb9);background-repeat:repeat-x;filter:progid:dximagetransform.microsoft.gradient(startColorstr='#ff5bc0de',endColorstr='#ff339bb9',GradientType=0)}.progress-info.progress-striped .bar,.progress-striped .bar-info{background-color:#5bc0de;background-image:-webkit-gradient(linear,0 100%,100% 0,color-stop(0.25,rgba(255,255,255,0.15)),color-stop(0.25,transparent),color-stop(0.5,transparent),color-stop(0.5,rgba(255,255,255,0.15)),color-stop(0.75,rgba(255,255,255,0.15)),color-stop(0.75,transparent),to(transparent));background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:-moz-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent)}.progress-warning .bar,.progress .bar-warning{background-color:#faa732;background-image:-moz-linear-gradient(top,#fbb450,#f89406);background-image:-webkit-gradient(linear,0 0,0 100%,from(#fbb450),to(#f89406));background-image:-webkit-linear-gradient(top,#fbb450,#f89406);background-image:-o-linear-gradient(top,#fbb450,#f89406);background-image:linear-gradient(to bottom,#fbb450,#f89406);background-repeat:repeat-x;filter:progid:dximagetransform.microsoft.gradient(startColorstr='#fffbb450',endColorstr='#fff89406',GradientType=0)}.progress-warning.progress-striped .bar,.progress-striped .bar-warning{background-color:#fbb450;background-image:-webkit-gradient(linear,0 100%,100% 0,color-stop(0.25,rgba(255,255,255,0.15)),color-stop(0.25,transparent),color-stop(0.5,transparent),color-stop(0.5,rgba(255,255,255,0.15)),color-stop(0.75,rgba(255,255,255,0.15)),color-stop(0.75,transparent),to(transparent));background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:-moz-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent)}.accordion{margin-bottom:20px}.accordion-group{margin-bottom:2px;border:1px solid #e5e5e5;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px}.accordion-heading{border-bottom:0}.accordion-heading .accordion-toggle{display:block;padding:8px 15px}.accordion-toggle{cursor:pointer}.accordion-inner{padding:9px 15px;border-top:1px solid #e5e5e5}.carousel{position:relative;margin-bottom:20px;line-height:1}.carousel-inner{position:relative;width:100%;overflow:hidden}.carousel .item{position:relative;display:none;-webkit-transition:.6s ease-in-out left;-moz-transition:.6s ease-in-out left;-o-transition:.6s ease-in-out left;transition:.6s ease-in-out left}.carousel .item>img{display:block;line-height:1}.carousel .active,.carousel .next,.carousel .prev{display:block}.carousel .active{left:0}.carousel .next,.carousel .prev{position:absolute;top:0;width:100%}.carousel .next{left:100%}.carousel .prev{left:-100%}.carousel .next.left,.carousel .prev.right{left:0}.carousel .active.left{left:-100%}.carousel .active.right{left:100%}.carousel-control{position:absolute;top:40%;left:15px;width:40px;height:40px;margin-top:-20px;font-size:60px;font-weight:100;line-height:30px;color:#fff;text-align:center;background:#222;border:3px solid #fff;-webkit-border-radius:23px;-moz-border-radius:23px;border-radius:23px;opacity:.5;filter:alpha(opacity=50)}.carousel-control.right{right:15px;left:auto}.carousel-control:hover{color:#fff;text-decoration:none;opacity:.9;filter:alpha(opacity=90)}.carousel-caption{position:absolute;right:0;bottom:0;left:0;padding:15px;background:#333;background:rgba(0,0,0,0.75)}.carousel-caption h4,.carousel-caption p{line-height:20px;color:#fff}.carousel-caption h4{margin:0 0 5px}.carousel-caption p{margin-bottom:0}.hero-unit{padding:60px;margin-bottom:30px;background-color:#eee;-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px}.hero-unit h1{margin-bottom:0;font-size:60px;line-height:1;letter-spacing:-1px;color:inherit}.hero-unit p{font-size:18px;font-weight:200;line-height:30px;color:inherit}.pull-right{float:right}.pull-left{float:left}.hide{display:none}.show{display:block}.invisible{visibility:hidden}.affix{position:fixed}
diff --git a/docs/public/bootstrap/img/glyphicons-halflings-white.png b/docs/public/bootstrap/img/glyphicons-halflings-white.png
new file mode 100644
index 0000000000000000000000000000000000000000..3bf6484a29d8da269f9bc874b25493a45fae3bae
GIT binary patch
literal 8777
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
B7G?kd

literal 0
HcmV?d00001

diff --git a/docs/public/bootstrap/img/glyphicons-halflings.png b/docs/public/bootstrap/img/glyphicons-halflings.png
new file mode 100644
index 0000000000000000000000000000000000000000..a9969993201f9cee63cf9f49217646347297b643
GIT binary patch
literal 12799
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

literal 0
HcmV?d00001

diff --git a/docs/public/bootstrap/js/bootstrap.js b/docs/public/bootstrap/js/bootstrap.js
new file mode 100644
index 00000000..f73fcb8e
--- /dev/null
+++ b/docs/public/bootstrap/js/bootstrap.js
@@ -0,0 +1,2027 @@
+/* ===================================================
+ * bootstrap-transition.js v2.1.1
+ * http://twitter.github.com/bootstrap/javascript.html#transitions
+ * ===================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ========================================================== */
+
+
+!function ($) {
+
+  $(function () {
+
+    "use strict"; // jshint ;_;
+
+
+    /* CSS TRANSITION SUPPORT (http://www.modernizr.com/)
+     * ======================================================= */
+
+    $.support.transition = (function () {
+
+      var transitionEnd = (function () {
+
+        var el = document.createElement('bootstrap')
+          , transEndEventNames = {
+               'WebkitTransition' : 'webkitTransitionEnd'
+            ,  'MozTransition'    : 'transitionend'
+            ,  'OTransition'      : 'oTransitionEnd otransitionend'
+            ,  'transition'       : 'transitionend'
+            }
+          , name
+
+        for (name in transEndEventNames){
+          if (el.style[name] !== undefined) {
+            return transEndEventNames[name]
+          }
+        }
+
+      }())
+
+      return transitionEnd && {
+        end: transitionEnd
+      }
+
+    })()
+
+  })
+
+}(window.jQuery);/* ==========================================================
+ * bootstrap-alert.js v2.1.1
+ * http://twitter.github.com/bootstrap/javascript.html#alerts
+ * ==========================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ========================================================== */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* ALERT CLASS DEFINITION
+  * ====================== */
+
+  var dismiss = '[data-dismiss="alert"]'
+    , Alert = function (el) {
+        $(el).on('click', dismiss, this.close)
+      }
+
+  Alert.prototype.close = function (e) {
+    var $this = $(this)
+      , selector = $this.attr('data-target')
+      , $parent
+
+    if (!selector) {
+      selector = $this.attr('href')
+      selector = selector && selector.replace(/.*(?=#[^\s]*$)/, '') //strip for ie7
+    }
+
+    $parent = $(selector)
+
+    e && e.preventDefault()
+
+    $parent.length || ($parent = $this.hasClass('alert') ? $this : $this.parent())
+
+    $parent.trigger(e = $.Event('close'))
+
+    if (e.isDefaultPrevented()) return
+
+    $parent.removeClass('in')
+
+    function removeElement() {
+      $parent
+        .trigger('closed')
+        .remove()
+    }
+
+    $.support.transition && $parent.hasClass('fade') ?
+      $parent.on($.support.transition.end, removeElement) :
+      removeElement()
+  }
+
+
+ /* ALERT PLUGIN DEFINITION
+  * ======================= */
+
+  $.fn.alert = function (option) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('alert')
+      if (!data) $this.data('alert', (data = new Alert(this)))
+      if (typeof option == 'string') data[option].call($this)
+    })
+  }
+
+  $.fn.alert.Constructor = Alert
+
+
+ /* ALERT DATA-API
+  * ============== */
+
+  $(function () {
+    $('body').on('click.alert.data-api', dismiss, Alert.prototype.close)
+  })
+
+}(window.jQuery);/* ============================================================
+ * bootstrap-button.js v2.1.1
+ * http://twitter.github.com/bootstrap/javascript.html#buttons
+ * ============================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============================================================ */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* BUTTON PUBLIC CLASS DEFINITION
+  * ============================== */
+
+  var Button = function (element, options) {
+    this.$element = $(element)
+    this.options = $.extend({}, $.fn.button.defaults, options)
+  }
+
+  Button.prototype.setState = function (state) {
+    var d = 'disabled'
+      , $el = this.$element
+      , data = $el.data()
+      , val = $el.is('input') ? 'val' : 'html'
+
+    state = state + 'Text'
+    data.resetText || $el.data('resetText', $el[val]())
+
+    $el[val](data[state] || this.options[state])
+
+    // push to event loop to allow forms to submit
+    setTimeout(function () {
+      state == 'loadingText' ?
+        $el.addClass(d).attr(d, d) :
+        $el.removeClass(d).removeAttr(d)
+    }, 0)
+  }
+
+  Button.prototype.toggle = function () {
+    var $parent = this.$element.closest('[data-toggle="buttons-radio"]')
+
+    $parent && $parent
+      .find('.active')
+      .removeClass('active')
+
+    this.$element.toggleClass('active')
+  }
+
+
+ /* BUTTON PLUGIN DEFINITION
+  * ======================== */
+
+  $.fn.button = function (option) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('button')
+        , options = typeof option == 'object' && option
+      if (!data) $this.data('button', (data = new Button(this, options)))
+      if (option == 'toggle') data.toggle()
+      else if (option) data.setState(option)
+    })
+  }
+
+  $.fn.button.defaults = {
+    loadingText: 'loading...'
+  }
+
+  $.fn.button.Constructor = Button
+
+
+ /* BUTTON DATA-API
+  * =============== */
+
+  $(function () {
+    $('body').on('click.button.data-api', '[data-toggle^=button]', function ( e ) {
+      var $btn = $(e.target)
+      if (!$btn.hasClass('btn')) $btn = $btn.closest('.btn')
+      $btn.button('toggle')
+    })
+  })
+
+}(window.jQuery);/* ==========================================================
+ * bootstrap-carousel.js v2.1.1
+ * http://twitter.github.com/bootstrap/javascript.html#carousel
+ * ==========================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ========================================================== */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* CAROUSEL CLASS DEFINITION
+  * ========================= */
+
+  var Carousel = function (element, options) {
+    this.$element = $(element)
+    this.options = options
+    this.options.slide && this.slide(this.options.slide)
+    this.options.pause == 'hover' && this.$element
+      .on('mouseenter', $.proxy(this.pause, this))
+      .on('mouseleave', $.proxy(this.cycle, this))
+  }
+
+  Carousel.prototype = {
+
+    cycle: function (e) {
+      if (!e) this.paused = false
+      this.options.interval
+        && !this.paused
+        && (this.interval = setInterval($.proxy(this.next, this), this.options.interval))
+      return this
+    }
+
+  , to: function (pos) {
+      var $active = this.$element.find('.item.active')
+        , children = $active.parent().children()
+        , activePos = children.index($active)
+        , that = this
+
+      if (pos > (children.length - 1) || pos < 0) return
+
+      if (this.sliding) {
+        return this.$element.one('slid', function () {
+          that.to(pos)
+        })
+      }
+
+      if (activePos == pos) {
+        return this.pause().cycle()
+      }
+
+      return this.slide(pos > activePos ? 'next' : 'prev', $(children[pos]))
+    }
+
+  , pause: function (e) {
+      if (!e) this.paused = true
+      if (this.$element.find('.next, .prev').length && $.support.transition.end) {
+        this.$element.trigger($.support.transition.end)
+        this.cycle()
+      }
+      clearInterval(this.interval)
+      this.interval = null
+      return this
+    }
+
+  , next: function () {
+      if (this.sliding) return
+      return this.slide('next')
+    }
+
+  , prev: function () {
+      if (this.sliding) return
+      return this.slide('prev')
+    }
+
+  , slide: function (type, next) {
+      var $active = this.$element.find('.item.active')
+        , $next = next || $active[type]()
+        , isCycling = this.interval
+        , direction = type == 'next' ? 'left' : 'right'
+        , fallback  = type == 'next' ? 'first' : 'last'
+        , that = this
+        , e = $.Event('slide', {
+            relatedTarget: $next[0]
+          })
+
+      this.sliding = true
+
+      isCycling && this.pause()
+
+      $next = $next.length ? $next : this.$element.find('.item')[fallback]()
+
+      if ($next.hasClass('active')) return
+
+      if ($.support.transition && this.$element.hasClass('slide')) {
+        this.$element.trigger(e)
+        if (e.isDefaultPrevented()) return
+        $next.addClass(type)
+        $next[0].offsetWidth // force reflow
+        $active.addClass(direction)
+        $next.addClass(direction)
+        this.$element.one($.support.transition.end, function () {
+          $next.removeClass([type, direction].join(' ')).addClass('active')
+          $active.removeClass(['active', direction].join(' '))
+          that.sliding = false
+          setTimeout(function () { that.$element.trigger('slid') }, 0)
+        })
+      } else {
+        this.$element.trigger(e)
+        if (e.isDefaultPrevented()) return
+        $active.removeClass('active')
+        $next.addClass('active')
+        this.sliding = false
+        this.$element.trigger('slid')
+      }
+
+      isCycling && this.cycle()
+
+      return this
+    }
+
+  }
+
+
+ /* CAROUSEL PLUGIN DEFINITION
+  * ========================== */
+
+  $.fn.carousel = function (option) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('carousel')
+        , options = $.extend({}, $.fn.carousel.defaults, typeof option == 'object' && option)
+        , action = typeof option == 'string' ? option : options.slide
+      if (!data) $this.data('carousel', (data = new Carousel(this, options)))
+      if (typeof option == 'number') data.to(option)
+      else if (action) data[action]()
+      else if (options.interval) data.cycle()
+    })
+  }
+
+  $.fn.carousel.defaults = {
+    interval: 5000
+  , pause: 'hover'
+  }
+
+  $.fn.carousel.Constructor = Carousel
+
+
+ /* CAROUSEL DATA-API
+  * ================= */
+
+  $(function () {
+    $('body').on('click.carousel.data-api', '[data-slide]', function ( e ) {
+      var $this = $(this), href
+        , $target = $($this.attr('data-target') || (href = $this.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '')) //strip for ie7
+        , options = !$target.data('modal') && $.extend({}, $target.data(), $this.data())
+      $target.carousel(options)
+      e.preventDefault()
+    })
+  })
+
+}(window.jQuery);/* =============================================================
+ * bootstrap-collapse.js v2.1.1
+ * http://twitter.github.com/bootstrap/javascript.html#collapse
+ * =============================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============================================================ */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* COLLAPSE PUBLIC CLASS DEFINITION
+  * ================================ */
+
+  var Collapse = function (element, options) {
+    this.$element = $(element)
+    this.options = $.extend({}, $.fn.collapse.defaults, options)
+
+    if (this.options.parent) {
+      this.$parent = $(this.options.parent)
+    }
+
+    this.options.toggle && this.toggle()
+  }
+
+  Collapse.prototype = {
+
+    constructor: Collapse
+
+  , dimension: function () {
+      var hasWidth = this.$element.hasClass('width')
+      return hasWidth ? 'width' : 'height'
+    }
+
+  , show: function () {
+      var dimension
+        , scroll
+        , actives
+        , hasData
+
+      if (this.transitioning) return
+
+      dimension = this.dimension()
+      scroll = $.camelCase(['scroll', dimension].join('-'))
+      actives = this.$parent && this.$parent.find('> .accordion-group > .in')
+
+      if (actives && actives.length) {
+        hasData = actives.data('collapse')
+        if (hasData && hasData.transitioning) return
+        actives.collapse('hide')
+        hasData || actives.data('collapse', null)
+      }
+
+      this.$element[dimension](0)
+      this.transition('addClass', $.Event('show'), 'shown')
+      $.support.transition && this.$element[dimension](this.$element[0][scroll])
+    }
+
+  , hide: function () {
+      var dimension
+      if (this.transitioning) return
+      dimension = this.dimension()
+      this.reset(this.$element[dimension]())
+      this.transition('removeClass', $.Event('hide'), 'hidden')
+      this.$element[dimension](0)
+    }
+
+  , reset: function (size) {
+      var dimension = this.dimension()
+
+      this.$element
+        .removeClass('collapse')
+        [dimension](size || 'auto')
+        [0].offsetWidth
+
+      this.$element[size !== null ? 'addClass' : 'removeClass']('collapse')
+
+      return this
+    }
+
+  , transition: function (method, startEvent, completeEvent) {
+      var that = this
+        , complete = function () {
+            if (startEvent.type == 'show') that.reset()
+            that.transitioning = 0
+            that.$element.trigger(completeEvent)
+          }
+
+      this.$element.trigger(startEvent)
+
+      if (startEvent.isDefaultPrevented()) return
+
+      this.transitioning = 1
+
+      this.$element[method]('in')
+
+      $.support.transition && this.$element.hasClass('collapse') ?
+        this.$element.one($.support.transition.end, complete) :
+        complete()
+    }
+
+  , toggle: function () {
+      this[this.$element.hasClass('in') ? 'hide' : 'show']()
+    }
+
+  }
+
+
+ /* COLLAPSIBLE PLUGIN DEFINITION
+  * ============================== */
+
+  $.fn.collapse = function (option) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('collapse')
+        , options = typeof option == 'object' && option
+      if (!data) $this.data('collapse', (data = new Collapse(this, options)))
+      if (typeof option == 'string') data[option]()
+    })
+  }
+
+  $.fn.collapse.defaults = {
+    toggle: true
+  }
+
+  $.fn.collapse.Constructor = Collapse
+
+
+ /* COLLAPSIBLE DATA-API
+  * ==================== */
+
+  $(function () {
+    $('body').on('click.collapse.data-api', '[data-toggle=collapse]', function (e) {
+      var $this = $(this), href
+        , target = $this.attr('data-target')
+          || e.preventDefault()
+          || (href = $this.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '') //strip for ie7
+        , option = $(target).data('collapse') ? 'toggle' : $this.data()
+      $this[$(target).hasClass('in') ? 'addClass' : 'removeClass']('collapsed')
+      $(target).collapse(option)
+    })
+  })
+
+}(window.jQuery);/* ============================================================
+ * bootstrap-dropdown.js v2.1.1
+ * http://twitter.github.com/bootstrap/javascript.html#dropdowns
+ * ============================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============================================================ */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* DROPDOWN CLASS DEFINITION
+  * ========================= */
+
+  var toggle = '[data-toggle=dropdown]'
+    , Dropdown = function (element) {
+        var $el = $(element).on('click.dropdown.data-api', this.toggle)
+        $('html').on('click.dropdown.data-api', function () {
+          $el.parent().removeClass('open')
+        })
+      }
+
+  Dropdown.prototype = {
+
+    constructor: Dropdown
+
+  , toggle: function (e) {
+      var $this = $(this)
+        , $parent
+        , isActive
+
+      if ($this.is('.disabled, :disabled')) return
+
+      $parent = getParent($this)
+
+      isActive = $parent.hasClass('open')
+
+      clearMenus()
+
+      if (!isActive) {
+        $parent.toggleClass('open')
+        $this.focus()
+      }
+
+      return false
+    }
+
+  , keydown: function (e) {
+      var $this
+        , $items
+        , $active
+        , $parent
+        , isActive
+        , index
+
+      if (!/(38|40|27)/.test(e.keyCode)) return
+
+      $this = $(this)
+
+      e.preventDefault()
+      e.stopPropagation()
+
+      if ($this.is('.disabled, :disabled')) return
+
+      $parent = getParent($this)
+
+      isActive = $parent.hasClass('open')
+
+      if (!isActive || (isActive && e.keyCode == 27)) return $this.click()
+
+      $items = $('[role=menu] li:not(.divider) a', $parent)
+
+      if (!$items.length) return
+
+      index = $items.index($items.filter(':focus'))
+
+      if (e.keyCode == 38 && index > 0) index--                                        // up
+      if (e.keyCode == 40 && index < $items.length - 1) index++                        // down
+      if (!~index) index = 0
+
+      $items
+        .eq(index)
+        .focus()
+    }
+
+  }
+
+  function clearMenus() {
+    getParent($(toggle))
+      .removeClass('open')
+  }
+
+  function getParent($this) {
+    var selector = $this.attr('data-target')
+      , $parent
+
+    if (!selector) {
+      selector = $this.attr('href')
+      selector = selector && /#/.test(selector) && selector.replace(/.*(?=#[^\s]*$)/, '') //strip for ie7
+    }
+
+    $parent = $(selector)
+    $parent.length || ($parent = $this.parent())
+
+    return $parent
+  }
+
+
+  /* DROPDOWN PLUGIN DEFINITION
+   * ========================== */
+
+  $.fn.dropdown = function (option) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('dropdown')
+      if (!data) $this.data('dropdown', (data = new Dropdown(this)))
+      if (typeof option == 'string') data[option].call($this)
+    })
+  }
+
+  $.fn.dropdown.Constructor = Dropdown
+
+
+  /* APPLY TO STANDARD DROPDOWN ELEMENTS
+   * =================================== */
+
+  $(function () {
+    $('html')
+      .on('click.dropdown.data-api touchstart.dropdown.data-api', clearMenus)
+    $('body')
+      .on('click.dropdown touchstart.dropdown.data-api', '.dropdown form', function (e) { e.stopPropagation() })
+      .on('click.dropdown.data-api touchstart.dropdown.data-api'  , toggle, Dropdown.prototype.toggle)
+      .on('keydown.dropdown.data-api touchstart.dropdown.data-api', toggle + ', [role=menu]' , Dropdown.prototype.keydown)
+  })
+
+}(window.jQuery);/* =========================================================
+ * bootstrap-modal.js v2.1.1
+ * http://twitter.github.com/bootstrap/javascript.html#modals
+ * =========================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ========================================================= */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* MODAL CLASS DEFINITION
+  * ====================== */
+
+  var Modal = function (element, options) {
+    this.options = options
+    this.$element = $(element)
+      .delegate('[data-dismiss="modal"]', 'click.dismiss.modal', $.proxy(this.hide, this))
+    this.options.remote && this.$element.find('.modal-body').load(this.options.remote)
+  }
+
+  Modal.prototype = {
+
+      constructor: Modal
+
+    , toggle: function () {
+        return this[!this.isShown ? 'show' : 'hide']()
+      }
+
+    , show: function () {
+        var that = this
+          , e = $.Event('show')
+
+        this.$element.trigger(e)
+
+        if (this.isShown || e.isDefaultPrevented()) return
+
+        $('body').addClass('modal-open')
+
+        this.isShown = true
+
+        this.escape()
+
+        this.backdrop(function () {
+          var transition = $.support.transition && that.$element.hasClass('fade')
+
+          if (!that.$element.parent().length) {
+            that.$element.appendTo(document.body) //don't move modals dom position
+          }
+
+          that.$element
+            .show()
+
+          if (transition) {
+            that.$element[0].offsetWidth // force reflow
+          }
+
+          that.$element
+            .addClass('in')
+            .attr('aria-hidden', false)
+            .focus()
+
+          that.enforceFocus()
+
+          transition ?
+            that.$element.one($.support.transition.end, function () { that.$element.trigger('shown') }) :
+            that.$element.trigger('shown')
+
+        })
+      }
+
+    , hide: function (e) {
+        e && e.preventDefault()
+
+        var that = this
+
+        e = $.Event('hide')
+
+        this.$element.trigger(e)
+
+        if (!this.isShown || e.isDefaultPrevented()) return
+
+        this.isShown = false
+
+        $('body').removeClass('modal-open')
+
+        this.escape()
+
+        $(document).off('focusin.modal')
+
+        this.$element
+          .removeClass('in')
+          .attr('aria-hidden', true)
+
+        $.support.transition && this.$element.hasClass('fade') ?
+          this.hideWithTransition() :
+          this.hideModal()
+      }
+
+    , enforceFocus: function () {
+        var that = this
+        $(document).on('focusin.modal', function (e) {
+          if (that.$element[0] !== e.target && !that.$element.has(e.target).length) {
+            that.$element.focus()
+          }
+        })
+      }
+
+    , escape: function () {
+        var that = this
+        if (this.isShown && this.options.keyboard) {
+          this.$element.on('keyup.dismiss.modal', function ( e ) {
+            e.which == 27 && that.hide()
+          })
+        } else if (!this.isShown) {
+          this.$element.off('keyup.dismiss.modal')
+        }
+      }
+
+    , hideWithTransition: function () {
+        var that = this
+          , timeout = setTimeout(function () {
+              that.$element.off($.support.transition.end)
+              that.hideModal()
+            }, 500)
+
+        this.$element.one($.support.transition.end, function () {
+          clearTimeout(timeout)
+          that.hideModal()
+        })
+      }
+
+    , hideModal: function (that) {
+        this.$element
+          .hide()
+          .trigger('hidden')
+
+        this.backdrop()
+      }
+
+    , removeBackdrop: function () {
+        this.$backdrop.remove()
+        this.$backdrop = null
+      }
+
+    , backdrop: function (callback) {
+        var that = this
+          , animate = this.$element.hasClass('fade') ? 'fade' : ''
+
+        if (this.isShown && this.options.backdrop) {
+          var doAnimate = $.support.transition && animate
+
+          this.$backdrop = $('<div class="modal-backdrop ' + animate + '" />')
+            .appendTo(document.body)
+
+          if (this.options.backdrop != 'static') {
+            this.$backdrop.click($.proxy(this.hide, this))
+          }
+
+          if (doAnimate) this.$backdrop[0].offsetWidth // force reflow
+
+          this.$backdrop.addClass('in')
+
+          doAnimate ?
+            this.$backdrop.one($.support.transition.end, callback) :
+            callback()
+
+        } else if (!this.isShown && this.$backdrop) {
+          this.$backdrop.removeClass('in')
+
+          $.support.transition && this.$element.hasClass('fade')?
+            this.$backdrop.one($.support.transition.end, $.proxy(this.removeBackdrop, this)) :
+            this.removeBackdrop()
+
+        } else if (callback) {
+          callback()
+        }
+      }
+  }
+
+
+ /* MODAL PLUGIN DEFINITION
+  * ======================= */
+
+  $.fn.modal = function (option) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('modal')
+        , options = $.extend({}, $.fn.modal.defaults, $this.data(), typeof option == 'object' && option)
+      if (!data) $this.data('modal', (data = new Modal(this, options)))
+      if (typeof option == 'string') data[option]()
+      else if (options.show) data.show()
+    })
+  }
+
+  $.fn.modal.defaults = {
+      backdrop: true
+    , keyboard: true
+    , show: true
+  }
+
+  $.fn.modal.Constructor = Modal
+
+
+ /* MODAL DATA-API
+  * ============== */
+
+  $(function () {
+    $('body').on('click.modal.data-api', '[data-toggle="modal"]', function ( e ) {
+      var $this = $(this)
+        , href = $this.attr('href')
+        , $target = $($this.attr('data-target') || (href && href.replace(/.*(?=#[^\s]+$)/, ''))) //strip for ie7
+        , option = $target.data('modal') ? 'toggle' : $.extend({ remote: !/#/.test(href) && href }, $target.data(), $this.data())
+
+      e.preventDefault()
+
+      $target
+        .modal(option)
+        .one('hide', function () {
+          $this.focus()
+        })
+    })
+  })
+
+}(window.jQuery);/* ===========================================================
+ * bootstrap-tooltip.js v2.1.1
+ * http://twitter.github.com/bootstrap/javascript.html#tooltips
+ * Inspired by the original jQuery.tipsy by Jason Frame
+ * ===========================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ========================================================== */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* TOOLTIP PUBLIC CLASS DEFINITION
+  * =============================== */
+
+  var Tooltip = function (element, options) {
+    this.init('tooltip', element, options)
+  }
+
+  Tooltip.prototype = {
+
+    constructor: Tooltip
+
+  , init: function (type, element, options) {
+      var eventIn
+        , eventOut
+
+      this.type = type
+      this.$element = $(element)
+      this.options = this.getOptions(options)
+      this.enabled = true
+
+      if (this.options.trigger == 'click') {
+        this.$element.on('click.' + this.type, this.options.selector, $.proxy(this.toggle, this))
+      } else if (this.options.trigger != 'manual') {
+        eventIn = this.options.trigger == 'hover' ? 'mouseenter' : 'focus'
+        eventOut = this.options.trigger == 'hover' ? 'mouseleave' : 'blur'
+        this.$element.on(eventIn + '.' + this.type, this.options.selector, $.proxy(this.enter, this))
+        this.$element.on(eventOut + '.' + this.type, this.options.selector, $.proxy(this.leave, this))
+      }
+
+      this.options.selector ?
+        (this._options = $.extend({}, this.options, { trigger: 'manual', selector: '' })) :
+        this.fixTitle()
+    }
+
+  , getOptions: function (options) {
+      options = $.extend({}, $.fn[this.type].defaults, options, this.$element.data())
+
+      if (options.delay && typeof options.delay == 'number') {
+        options.delay = {
+          show: options.delay
+        , hide: options.delay
+        }
+      }
+
+      return options
+    }
+
+  , enter: function (e) {
+      var self = $(e.currentTarget)[this.type](this._options).data(this.type)
+
+      if (!self.options.delay || !self.options.delay.show) return self.show()
+
+      clearTimeout(this.timeout)
+      self.hoverState = 'in'
+      this.timeout = setTimeout(function() {
+        if (self.hoverState == 'in') self.show()
+      }, self.options.delay.show)
+    }
+
+  , leave: function (e) {
+      var self = $(e.currentTarget)[this.type](this._options).data(this.type)
+
+      if (this.timeout) clearTimeout(this.timeout)
+      if (!self.options.delay || !self.options.delay.hide) return self.hide()
+
+      self.hoverState = 'out'
+      this.timeout = setTimeout(function() {
+        if (self.hoverState == 'out') self.hide()
+      }, self.options.delay.hide)
+    }
+
+  , show: function () {
+      var $tip
+        , inside
+        , pos
+        , actualWidth
+        , actualHeight
+        , placement
+        , tp
+
+      if (this.hasContent() && this.enabled) {
+        $tip = this.tip()
+        this.setContent()
+
+        if (this.options.animation) {
+          $tip.addClass('fade')
+        }
+
+        placement = typeof this.options.placement == 'function' ?
+          this.options.placement.call(this, $tip[0], this.$element[0]) :
+          this.options.placement
+
+        inside = /in/.test(placement)
+
+        $tip
+          .remove()
+          .css({ top: 0, left: 0, display: 'block' })
+          .appendTo(inside ? this.$element : document.body)
+
+        pos = this.getPosition(inside)
+
+        actualWidth = $tip[0].offsetWidth
+        actualHeight = $tip[0].offsetHeight
+
+        switch (inside ? placement.split(' ')[1] : placement) {
+          case 'bottom':
+            tp = {top: pos.top + pos.height, left: pos.left + pos.width / 2 - actualWidth / 2}
+            break
+          case 'top':
+            tp = {top: pos.top - actualHeight, left: pos.left + pos.width / 2 - actualWidth / 2}
+            break
+          case 'left':
+            tp = {top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left - actualWidth}
+            break
+          case 'right':
+            tp = {top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left + pos.width}
+            break
+        }
+
+        $tip
+          .css(tp)
+          .addClass(placement)
+          .addClass('in')
+      }
+    }
+
+  , setContent: function () {
+      var $tip = this.tip()
+        , title = this.getTitle()
+
+      $tip.find('.tooltip-inner')[this.options.html ? 'html' : 'text'](title)
+      $tip.removeClass('fade in top bottom left right')
+    }
+
+  , hide: function () {
+      var that = this
+        , $tip = this.tip()
+
+      $tip.removeClass('in')
+
+      function removeWithAnimation() {
+        var timeout = setTimeout(function () {
+          $tip.off($.support.transition.end).remove()
+        }, 500)
+
+        $tip.one($.support.transition.end, function () {
+          clearTimeout(timeout)
+          $tip.remove()
+        })
+      }
+
+      $.support.transition && this.$tip.hasClass('fade') ?
+        removeWithAnimation() :
+        $tip.remove()
+
+      return this
+    }
+
+  , fixTitle: function () {
+      var $e = this.$element
+      if ($e.attr('title') || typeof($e.attr('data-original-title')) != 'string') {
+        $e.attr('data-original-title', $e.attr('title') || '').removeAttr('title')
+      }
+    }
+
+  , hasContent: function () {
+      return this.getTitle()
+    }
+
+  , getPosition: function (inside) {
+      return $.extend({}, (inside ? {top: 0, left: 0} : this.$element.offset()), {
+        width: this.$element[0].offsetWidth
+      , height: this.$element[0].offsetHeight
+      })
+    }
+
+  , getTitle: function () {
+      var title
+        , $e = this.$element
+        , o = this.options
+
+      title = $e.attr('data-original-title')
+        || (typeof o.title == 'function' ? o.title.call($e[0]) :  o.title)
+
+      return title
+    }
+
+  , tip: function () {
+      return this.$tip = this.$tip || $(this.options.template)
+    }
+
+  , validate: function () {
+      if (!this.$element[0].parentNode) {
+        this.hide()
+        this.$element = null
+        this.options = null
+      }
+    }
+
+  , enable: function () {
+      this.enabled = true
+    }
+
+  , disable: function () {
+      this.enabled = false
+    }
+
+  , toggleEnabled: function () {
+      this.enabled = !this.enabled
+    }
+
+  , toggle: function () {
+      this[this.tip().hasClass('in') ? 'hide' : 'show']()
+    }
+
+  , destroy: function () {
+      this.hide().$element.off('.' + this.type).removeData(this.type)
+    }
+
+  }
+
+
+ /* TOOLTIP PLUGIN DEFINITION
+  * ========================= */
+
+  $.fn.tooltip = function ( option ) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('tooltip')
+        , options = typeof option == 'object' && option
+      if (!data) $this.data('tooltip', (data = new Tooltip(this, options)))
+      if (typeof option == 'string') data[option]()
+    })
+  }
+
+  $.fn.tooltip.Constructor = Tooltip
+
+  $.fn.tooltip.defaults = {
+    animation: true
+  , placement: 'top'
+  , selector: false
+  , template: '<div class="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>'
+  , trigger: 'hover'
+  , title: ''
+  , delay: 0
+  , html: true
+  }
+
+}(window.jQuery);
+/* ===========================================================
+ * bootstrap-popover.js v2.1.1
+ * http://twitter.github.com/bootstrap/javascript.html#popovers
+ * ===========================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =========================================================== */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* POPOVER PUBLIC CLASS DEFINITION
+  * =============================== */
+
+  var Popover = function (element, options) {
+    this.init('popover', element, options)
+  }
+
+
+  /* NOTE: POPOVER EXTENDS BOOTSTRAP-TOOLTIP.js
+     ========================================== */
+
+  Popover.prototype = $.extend({}, $.fn.tooltip.Constructor.prototype, {
+
+    constructor: Popover
+
+  , setContent: function () {
+      var $tip = this.tip()
+        , title = this.getTitle()
+        , content = this.getContent()
+
+      $tip.find('.popover-title')[this.options.html ? 'html' : 'text'](title)
+      $tip.find('.popover-content > *')[this.options.html ? 'html' : 'text'](content)
+
+      $tip.removeClass('fade top bottom left right in')
+    }
+
+  , hasContent: function () {
+      return this.getTitle() || this.getContent()
+    }
+
+  , getContent: function () {
+      var content
+        , $e = this.$element
+        , o = this.options
+
+      content = $e.attr('data-content')
+        || (typeof o.content == 'function' ? o.content.call($e[0]) :  o.content)
+
+      return content
+    }
+
+  , tip: function () {
+      if (!this.$tip) {
+        this.$tip = $(this.options.template)
+      }
+      return this.$tip
+    }
+
+  , destroy: function () {
+      this.hide().$element.off('.' + this.type).removeData(this.type)
+    }
+
+  })
+
+
+ /* POPOVER PLUGIN DEFINITION
+  * ======================= */
+
+  $.fn.popover = function (option) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('popover')
+        , options = typeof option == 'object' && option
+      if (!data) $this.data('popover', (data = new Popover(this, options)))
+      if (typeof option == 'string') data[option]()
+    })
+  }
+
+  $.fn.popover.Constructor = Popover
+
+  $.fn.popover.defaults = $.extend({} , $.fn.tooltip.defaults, {
+    placement: 'right'
+  , trigger: 'click'
+  , content: ''
+  , template: '<div class="popover"><div class="arrow"></div><div class="popover-inner"><h3 class="popover-title"></h3><div class="popover-content"><p></p></div></div></div>'
+  })
+
+}(window.jQuery);/* =============================================================
+ * bootstrap-scrollspy.js v2.1.1
+ * http://twitter.github.com/bootstrap/javascript.html#scrollspy
+ * =============================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============================================================== */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* SCROLLSPY CLASS DEFINITION
+  * ========================== */
+
+  function ScrollSpy(element, options) {
+    var process = $.proxy(this.process, this)
+      , $element = $(element).is('body') ? $(window) : $(element)
+      , href
+    this.options = $.extend({}, $.fn.scrollspy.defaults, options)
+    this.$scrollElement = $element.on('scroll.scroll-spy.data-api', process)
+    this.selector = (this.options.target
+      || ((href = $(element).attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '')) //strip for ie7
+      || '') + ' .nav li > a'
+    this.$body = $('body')
+    this.refresh()
+    this.process()
+  }
+
+  ScrollSpy.prototype = {
+
+      constructor: ScrollSpy
+
+    , refresh: function () {
+        var self = this
+          , $targets
+
+        this.offsets = $([])
+        this.targets = $([])
+
+        $targets = this.$body
+          .find(this.selector)
+          .map(function () {
+            var $el = $(this)
+              , href = $el.data('target') || $el.attr('href')
+              , $href = /^#\w/.test(href) && $(href)
+            return ( $href
+              && $href.length
+              && [[ $href.position().top, href ]] ) || null
+          })
+          .sort(function (a, b) { return a[0] - b[0] })
+          .each(function () {
+            self.offsets.push(this[0])
+            self.targets.push(this[1])
+          })
+      }
+
+    , process: function () {
+        var scrollTop = this.$scrollElement.scrollTop() + this.options.offset
+          , scrollHeight = this.$scrollElement[0].scrollHeight || this.$body[0].scrollHeight
+          , maxScroll = scrollHeight - this.$scrollElement.height()
+          , offsets = this.offsets
+          , targets = this.targets
+          , activeTarget = this.activeTarget
+          , i
+
+        if (scrollTop >= maxScroll) {
+          return activeTarget != (i = targets.last()[0])
+            && this.activate ( i )
+        }
+
+        for (i = offsets.length; i--;) {
+          activeTarget != targets[i]
+            && scrollTop >= offsets[i]
+            && (!offsets[i + 1] || scrollTop <= offsets[i + 1])
+            && this.activate( targets[i] )
+        }
+      }
+
+    , activate: function (target) {
+        var active
+          , selector
+
+        this.activeTarget = target
+
+        $(this.selector)
+          .parent('.active')
+          .removeClass('active')
+
+        selector = this.selector
+          + '[data-target="' + target + '"],'
+          + this.selector + '[href="' + target + '"]'
+
+        active = $(selector)
+          .parent('li')
+          .addClass('active')
+
+        if (active.parent('.dropdown-menu').length)  {
+          active = active.closest('li.dropdown').addClass('active')
+        }
+
+        active.trigger('activate')
+      }
+
+  }
+
+
+ /* SCROLLSPY PLUGIN DEFINITION
+  * =========================== */
+
+  $.fn.scrollspy = function (option) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('scrollspy')
+        , options = typeof option == 'object' && option
+      if (!data) $this.data('scrollspy', (data = new ScrollSpy(this, options)))
+      if (typeof option == 'string') data[option]()
+    })
+  }
+
+  $.fn.scrollspy.Constructor = ScrollSpy
+
+  $.fn.scrollspy.defaults = {
+    offset: 10
+  }
+
+
+ /* SCROLLSPY DATA-API
+  * ================== */
+
+  $(window).on('load', function () {
+    $('[data-spy="scroll"]').each(function () {
+      var $spy = $(this)
+      $spy.scrollspy($spy.data())
+    })
+  })
+
+}(window.jQuery);/* ========================================================
+ * bootstrap-tab.js v2.1.1
+ * http://twitter.github.com/bootstrap/javascript.html#tabs
+ * ========================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ======================================================== */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* TAB CLASS DEFINITION
+  * ==================== */
+
+  var Tab = function (element) {
+    this.element = $(element)
+  }
+
+  Tab.prototype = {
+
+    constructor: Tab
+
+  , show: function () {
+      var $this = this.element
+        , $ul = $this.closest('ul:not(.dropdown-menu)')
+        , selector = $this.attr('data-target')
+        , previous
+        , $target
+        , e
+
+      if (!selector) {
+        selector = $this.attr('href')
+        selector = selector && selector.replace(/.*(?=#[^\s]*$)/, '') //strip for ie7
+      }
+
+      if ( $this.parent('li').hasClass('active') ) return
+
+      previous = $ul.find('.active a').last()[0]
+
+      e = $.Event('show', {
+        relatedTarget: previous
+      })
+
+      $this.trigger(e)
+
+      if (e.isDefaultPrevented()) return
+
+      $target = $(selector)
+
+      this.activate($this.parent('li'), $ul)
+      this.activate($target, $target.parent(), function () {
+        $this.trigger({
+          type: 'shown'
+        , relatedTarget: previous
+        })
+      })
+    }
+
+  , activate: function ( element, container, callback) {
+      var $active = container.find('> .active')
+        , transition = callback
+            && $.support.transition
+            && $active.hasClass('fade')
+
+      function next() {
+        $active
+          .removeClass('active')
+          .find('> .dropdown-menu > .active')
+          .removeClass('active')
+
+        element.addClass('active')
+
+        if (transition) {
+          element[0].offsetWidth // reflow for transition
+          element.addClass('in')
+        } else {
+          element.removeClass('fade')
+        }
+
+        if ( element.parent('.dropdown-menu') ) {
+          element.closest('li.dropdown').addClass('active')
+        }
+
+        callback && callback()
+      }
+
+      transition ?
+        $active.one($.support.transition.end, next) :
+        next()
+
+      $active.removeClass('in')
+    }
+  }
+
+
+ /* TAB PLUGIN DEFINITION
+  * ===================== */
+
+  $.fn.tab = function ( option ) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('tab')
+      if (!data) $this.data('tab', (data = new Tab(this)))
+      if (typeof option == 'string') data[option]()
+    })
+  }
+
+  $.fn.tab.Constructor = Tab
+
+
+ /* TAB DATA-API
+  * ============ */
+
+  $(function () {
+    $('body').on('click.tab.data-api', '[data-toggle="tab"], [data-toggle="pill"]', function (e) {
+      e.preventDefault()
+      $(this).tab('show')
+    })
+  })
+
+}(window.jQuery);/* =============================================================
+ * bootstrap-typeahead.js v2.1.1
+ * http://twitter.github.com/bootstrap/javascript.html#typeahead
+ * =============================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============================================================ */
+
+
+!function($){
+
+  "use strict"; // jshint ;_;
+
+
+ /* TYPEAHEAD PUBLIC CLASS DEFINITION
+  * ================================= */
+
+  var Typeahead = function (element, options) {
+    this.$element = $(element)
+    this.options = $.extend({}, $.fn.typeahead.defaults, options)
+    this.matcher = this.options.matcher || this.matcher
+    this.sorter = this.options.sorter || this.sorter
+    this.highlighter = this.options.highlighter || this.highlighter
+    this.updater = this.options.updater || this.updater
+    this.$menu = $(this.options.menu).appendTo('body')
+    this.source = this.options.source
+    this.shown = false
+    this.listen()
+  }
+
+  Typeahead.prototype = {
+
+    constructor: Typeahead
+
+  , select: function () {
+      var val = this.$menu.find('.active').attr('data-value')
+      this.$element
+        .val(this.updater(val))
+        .change()
+      return this.hide()
+    }
+
+  , updater: function (item) {
+      return item
+    }
+
+  , show: function () {
+      var pos = $.extend({}, this.$element.offset(), {
+        height: this.$element[0].offsetHeight
+      })
+
+      this.$menu.css({
+        top: pos.top + pos.height
+      , left: pos.left
+      })
+
+      this.$menu.show()
+      this.shown = true
+      return this
+    }
+
+  , hide: function () {
+      this.$menu.hide()
+      this.shown = false
+      return this
+    }
+
+  , lookup: function (event) {
+      var items
+
+      this.query = this.$element.val()
+
+      if (!this.query || this.query.length < this.options.minLength) {
+        return this.shown ? this.hide() : this
+      }
+
+      items = $.isFunction(this.source) ? this.source(this.query, $.proxy(this.process, this)) : this.source
+
+      return items ? this.process(items) : this
+    }
+
+  , process: function (items) {
+      var that = this
+
+      items = $.grep(items, function (item) {
+        return that.matcher(item)
+      })
+
+      items = this.sorter(items)
+
+      if (!items.length) {
+        return this.shown ? this.hide() : this
+      }
+
+      return this.render(items.slice(0, this.options.items)).show()
+    }
+
+  , matcher: function (item) {
+      return ~item.toLowerCase().indexOf(this.query.toLowerCase())
+    }
+
+  , sorter: function (items) {
+      var beginswith = []
+        , caseSensitive = []
+        , caseInsensitive = []
+        , item
+
+      while (item = items.shift()) {
+        if (!item.toLowerCase().indexOf(this.query.toLowerCase())) beginswith.push(item)
+        else if (~item.indexOf(this.query)) caseSensitive.push(item)
+        else caseInsensitive.push(item)
+      }
+
+      return beginswith.concat(caseSensitive, caseInsensitive)
+    }
+
+  , highlighter: function (item) {
+      var query = this.query.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, '\\$&')
+      return item.replace(new RegExp('(' + query + ')', 'ig'), function ($1, match) {
+        return '<strong>' + match + '</strong>'
+      })
+    }
+
+  , render: function (items) {
+      var that = this
+
+      items = $(items).map(function (i, item) {
+        i = $(that.options.item).attr('data-value', item)
+        i.find('a').html(that.highlighter(item))
+        return i[0]
+      })
+
+      items.first().addClass('active')
+      this.$menu.html(items)
+      return this
+    }
+
+  , next: function (event) {
+      var active = this.$menu.find('.active').removeClass('active')
+        , next = active.next()
+
+      if (!next.length) {
+        next = $(this.$menu.find('li')[0])
+      }
+
+      next.addClass('active')
+    }
+
+  , prev: function (event) {
+      var active = this.$menu.find('.active').removeClass('active')
+        , prev = active.prev()
+
+      if (!prev.length) {
+        prev = this.$menu.find('li').last()
+      }
+
+      prev.addClass('active')
+    }
+
+  , listen: function () {
+      this.$element
+        .on('blur',     $.proxy(this.blur, this))
+        .on('keypress', $.proxy(this.keypress, this))
+        .on('keyup',    $.proxy(this.keyup, this))
+
+      if ($.browser.chrome || $.browser.webkit || $.browser.msie) {
+        this.$element.on('keydown', $.proxy(this.keydown, this))
+      }
+
+      this.$menu
+        .on('click', $.proxy(this.click, this))
+        .on('mouseenter', 'li', $.proxy(this.mouseenter, this))
+    }
+
+  , move: function (e) {
+      if (!this.shown) return
+
+      switch(e.keyCode) {
+        case 9: // tab
+        case 13: // enter
+        case 27: // escape
+          e.preventDefault()
+          break
+
+        case 38: // up arrow
+          e.preventDefault()
+          this.prev()
+          break
+
+        case 40: // down arrow
+          e.preventDefault()
+          this.next()
+          break
+      }
+
+      e.stopPropagation()
+    }
+
+  , keydown: function (e) {
+      this.suppressKeyPressRepeat = !~$.inArray(e.keyCode, [40,38,9,13,27])
+      this.move(e)
+    }
+
+  , keypress: function (e) {
+      if (this.suppressKeyPressRepeat) return
+      this.move(e)
+    }
+
+  , keyup: function (e) {
+      switch(e.keyCode) {
+        case 40: // down arrow
+        case 38: // up arrow
+          break
+
+        case 9: // tab
+        case 13: // enter
+          if (!this.shown) return
+          this.select()
+          break
+
+        case 27: // escape
+          if (!this.shown) return
+          this.hide()
+          break
+
+        default:
+          this.lookup()
+      }
+
+      e.stopPropagation()
+      e.preventDefault()
+  }
+
+  , blur: function (e) {
+      var that = this
+      setTimeout(function () { that.hide() }, 150)
+    }
+
+  , click: function (e) {
+      e.stopPropagation()
+      e.preventDefault()
+      this.select()
+    }
+
+  , mouseenter: function (e) {
+      this.$menu.find('.active').removeClass('active')
+      $(e.currentTarget).addClass('active')
+    }
+
+  }
+
+
+  /* TYPEAHEAD PLUGIN DEFINITION
+   * =========================== */
+
+  $.fn.typeahead = function (option) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('typeahead')
+        , options = typeof option == 'object' && option
+      if (!data) $this.data('typeahead', (data = new Typeahead(this, options)))
+      if (typeof option == 'string') data[option]()
+    })
+  }
+
+  $.fn.typeahead.defaults = {
+    source: []
+  , items: 8
+  , menu: '<ul class="typeahead dropdown-menu"></ul>'
+  , item: '<li><a href="#"></a></li>'
+  , minLength: 1
+  }
+
+  $.fn.typeahead.Constructor = Typeahead
+
+
+ /*   TYPEAHEAD DATA-API
+  * ================== */
+
+  $(function () {
+    $('body').on('focus.typeahead.data-api', '[data-provide="typeahead"]', function (e) {
+      var $this = $(this)
+      if ($this.data('typeahead')) return
+      e.preventDefault()
+      $this.typeahead($this.data())
+    })
+  })
+
+}(window.jQuery);
+/* ==========================================================
+ * bootstrap-affix.js v2.1.1
+ * http://twitter.github.com/bootstrap/javascript.html#affix
+ * ==========================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ========================================================== */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* AFFIX CLASS DEFINITION
+  * ====================== */
+
+  var Affix = function (element, options) {
+    this.options = $.extend({}, $.fn.affix.defaults, options)
+    this.$window = $(window).on('scroll.affix.data-api', $.proxy(this.checkPosition, this))
+    this.$element = $(element)
+    this.checkPosition()
+  }
+
+  Affix.prototype.checkPosition = function () {
+    if (!this.$element.is(':visible')) return
+
+    var scrollHeight = $(document).height()
+      , scrollTop = this.$window.scrollTop()
+      , position = this.$element.offset()
+      , offset = this.options.offset
+      , offsetBottom = offset.bottom
+      , offsetTop = offset.top
+      , reset = 'affix affix-top affix-bottom'
+      , affix
+
+    if (typeof offset != 'object') offsetBottom = offsetTop = offset
+    if (typeof offsetTop == 'function') offsetTop = offset.top()
+    if (typeof offsetBottom == 'function') offsetBottom = offset.bottom()
+
+    affix = this.unpin != null && (scrollTop + this.unpin <= position.top) ?
+      false    : offsetBottom != null && (position.top + this.$element.height() >= scrollHeight - offsetBottom) ?
+      'bottom' : offsetTop != null && scrollTop <= offsetTop ?
+      'top'    : false
+
+    if (this.affixed === affix) return
+
+    this.affixed = affix
+    this.unpin = affix == 'bottom' ? position.top - scrollTop : null
+
+    this.$element.removeClass(reset).addClass('affix' + (affix ? '-' + affix : ''))
+  }
+
+
+ /* AFFIX PLUGIN DEFINITION
+  * ======================= */
+
+  $.fn.affix = function (option) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('affix')
+        , options = typeof option == 'object' && option
+      if (!data) $this.data('affix', (data = new Affix(this, options)))
+      if (typeof option == 'string') data[option]()
+    })
+  }
+
+  $.fn.affix.Constructor = Affix
+
+  $.fn.affix.defaults = {
+    offset: 0
+  }
+
+
+ /* AFFIX DATA-API
+  * ============== */
+
+  $(window).on('load', function () {
+    $('[data-spy="affix"]').each(function () {
+      var $spy = $(this)
+        , data = $spy.data()
+
+      data.offset = data.offset || {}
+
+      data.offsetBottom && (data.offset.bottom = data.offsetBottom)
+      data.offsetTop && (data.offset.top = data.offsetTop)
+
+      $spy.affix(data)
+    })
+  })
+
+
+}(window.jQuery);
\ No newline at end of file
diff --git a/docs/public/bootstrap/js/bootstrap.min.js b/docs/public/bootstrap/js/bootstrap.min.js
new file mode 100644
index 00000000..0e33fb16
--- /dev/null
+++ b/docs/public/bootstrap/js/bootstrap.min.js
@@ -0,0 +1,6 @@
+/*!
+* Bootstrap.js by @fat & @mdo
+* Copyright 2012 Twitter, Inc.
+* http://www.apache.org/licenses/LICENSE-2.0.txt
+*/
+!function(e){e(function(){"use strict";e.support.transition=function(){var e=function(){var e=document.createElement("bootstrap"),t={WebkitTransition:"webkitTransitionEnd",MozTransition:"transitionend",OTransition:"oTransitionEnd otransitionend",transition:"transitionend"},n;for(n in t)if(e.style[n]!==undefined)return t[n]}();return e&&{end:e}}()})}(window.jQuery),!function(e){"use strict";var t='[data-dismiss="alert"]',n=function(n){e(n).on("click",t,this.close)};n.prototype.close=function(t){function s(){i.trigger("closed").remove()}var n=e(this),r=n.attr("data-target"),i;r||(r=n.attr("href"),r=r&&r.replace(/.*(?=#[^\s]*$)/,"")),i=e(r),t&&t.preventDefault(),i.length||(i=n.hasClass("alert")?n:n.parent()),i.trigger(t=e.Event("close"));if(t.isDefaultPrevented())return;i.removeClass("in"),e.support.transition&&i.hasClass("fade")?i.on(e.support.transition.end,s):s()},e.fn.alert=function(t){return this.each(function(){var r=e(this),i=r.data("alert");i||r.data("alert",i=new n(this)),typeof t=="string"&&i[t].call(r)})},e.fn.alert.Constructor=n,e(function(){e("body").on("click.alert.data-api",t,n.prototype.close)})}(window.jQuery),!function(e){"use strict";var t=function(t,n){this.$element=e(t),this.options=e.extend({},e.fn.button.defaults,n)};t.prototype.setState=function(e){var t="disabled",n=this.$element,r=n.data(),i=n.is("input")?"val":"html";e+="Text",r.resetText||n.data("resetText",n[i]()),n[i](r[e]||this.options[e]),setTimeout(function(){e=="loadingText"?n.addClass(t).attr(t,t):n.removeClass(t).removeAttr(t)},0)},t.prototype.toggle=function(){var e=this.$element.closest('[data-toggle="buttons-radio"]');e&&e.find(".active").removeClass("active"),this.$element.toggleClass("active")},e.fn.button=function(n){return this.each(function(){var r=e(this),i=r.data("button"),s=typeof n=="object"&&n;i||r.data("button",i=new t(this,s)),n=="toggle"?i.toggle():n&&i.setState(n)})},e.fn.button.defaults={loadingText:"loading..."},e.fn.button.Constructor=t,e(function(){e("body").on("click.button.data-api","[data-toggle^=button]",function(t){var n=e(t.target);n.hasClass("btn")||(n=n.closest(".btn")),n.button("toggle")})})}(window.jQuery),!function(e){"use strict";var t=function(t,n){this.$element=e(t),this.options=n,this.options.slide&&this.slide(this.options.slide),this.options.pause=="hover"&&this.$element.on("mouseenter",e.proxy(this.pause,this)).on("mouseleave",e.proxy(this.cycle,this))};t.prototype={cycle:function(t){return t||(this.paused=!1),this.options.interval&&!this.paused&&(this.interval=setInterval(e.proxy(this.next,this),this.options.interval)),this},to:function(t){var n=this.$element.find(".item.active"),r=n.parent().children(),i=r.index(n),s=this;if(t>r.length-1||t<0)return;return this.sliding?this.$element.one("slid",function(){s.to(t)}):i==t?this.pause().cycle():this.slide(t>i?"next":"prev",e(r[t]))},pause:function(t){return t||(this.paused=!0),this.$element.find(".next, .prev").length&&e.support.transition.end&&(this.$element.trigger(e.support.transition.end),this.cycle()),clearInterval(this.interval),this.interval=null,this},next:function(){if(this.sliding)return;return this.slide("next")},prev:function(){if(this.sliding)return;return this.slide("prev")},slide:function(t,n){var r=this.$element.find(".item.active"),i=n||r[t](),s=this.interval,o=t=="next"?"left":"right",u=t=="next"?"first":"last",a=this,f=e.Event("slide",{relatedTarget:i[0]});this.sliding=!0,s&&this.pause(),i=i.length?i:this.$element.find(".item")[u]();if(i.hasClass("active"))return;if(e.support.transition&&this.$element.hasClass("slide")){this.$element.trigger(f);if(f.isDefaultPrevented())return;i.addClass(t),i[0].offsetWidth,r.addClass(o),i.addClass(o),this.$element.one(e.support.transition.end,function(){i.removeClass([t,o].join(" ")).addClass("active"),r.removeClass(["active",o].join(" ")),a.sliding=!1,setTimeout(function(){a.$element.trigger("slid")},0)})}else{this.$element.trigger(f);if(f.isDefaultPrevented())return;r.removeClass("active"),i.addClass("active"),this.sliding=!1,this.$element.trigger("slid")}return s&&this.cycle(),this}},e.fn.carousel=function(n){return this.each(function(){var r=e(this),i=r.data("carousel"),s=e.extend({},e.fn.carousel.defaults,typeof n=="object"&&n),o=typeof n=="string"?n:s.slide;i||r.data("carousel",i=new t(this,s)),typeof n=="number"?i.to(n):o?i[o]():s.interval&&i.cycle()})},e.fn.carousel.defaults={interval:5e3,pause:"hover"},e.fn.carousel.Constructor=t,e(function(){e("body").on("click.carousel.data-api","[data-slide]",function(t){var n=e(this),r,i=e(n.attr("data-target")||(r=n.attr("href"))&&r.replace(/.*(?=#[^\s]+$)/,"")),s=!i.data("modal")&&e.extend({},i.data(),n.data());i.carousel(s),t.preventDefault()})})}(window.jQuery),!function(e){"use strict";var t=function(t,n){this.$element=e(t),this.options=e.extend({},e.fn.collapse.defaults,n),this.options.parent&&(this.$parent=e(this.options.parent)),this.options.toggle&&this.toggle()};t.prototype={constructor:t,dimension:function(){var e=this.$element.hasClass("width");return e?"width":"height"},show:function(){var t,n,r,i;if(this.transitioning)return;t=this.dimension(),n=e.camelCase(["scroll",t].join("-")),r=this.$parent&&this.$parent.find("> .accordion-group > .in");if(r&&r.length){i=r.data("collapse");if(i&&i.transitioning)return;r.collapse("hide"),i||r.data("collapse",null)}this.$element[t](0),this.transition("addClass",e.Event("show"),"shown"),e.support.transition&&this.$element[t](this.$element[0][n])},hide:function(){var t;if(this.transitioning)return;t=this.dimension(),this.reset(this.$element[t]()),this.transition("removeClass",e.Event("hide"),"hidden"),this.$element[t](0)},reset:function(e){var t=this.dimension();return this.$element.removeClass("collapse")[t](e||"auto")[0].offsetWidth,this.$element[e!==null?"addClass":"removeClass"]("collapse"),this},transition:function(t,n,r){var i=this,s=function(){n.type=="show"&&i.reset(),i.transitioning=0,i.$element.trigger(r)};this.$element.trigger(n);if(n.isDefaultPrevented())return;this.transitioning=1,this.$element[t]("in"),e.support.transition&&this.$element.hasClass("collapse")?this.$element.one(e.support.transition.end,s):s()},toggle:function(){this[this.$element.hasClass("in")?"hide":"show"]()}},e.fn.collapse=function(n){return this.each(function(){var r=e(this),i=r.data("collapse"),s=typeof n=="object"&&n;i||r.data("collapse",i=new t(this,s)),typeof n=="string"&&i[n]()})},e.fn.collapse.defaults={toggle:!0},e.fn.collapse.Constructor=t,e(function(){e("body").on("click.collapse.data-api","[data-toggle=collapse]",function(t){var n=e(this),r,i=n.attr("data-target")||t.preventDefault()||(r=n.attr("href"))&&r.replace(/.*(?=#[^\s]+$)/,""),s=e(i).data("collapse")?"toggle":n.data();n[e(i).hasClass("in")?"addClass":"removeClass"]("collapsed"),e(i).collapse(s)})})}(window.jQuery),!function(e){"use strict";function r(){i(e(t)).removeClass("open")}function i(t){var n=t.attr("data-target"),r;return n||(n=t.attr("href"),n=n&&/#/.test(n)&&n.replace(/.*(?=#[^\s]*$)/,"")),r=e(n),r.length||(r=t.parent()),r}var t="[data-toggle=dropdown]",n=function(t){var n=e(t).on("click.dropdown.data-api",this.toggle);e("html").on("click.dropdown.data-api",function(){n.parent().removeClass("open")})};n.prototype={constructor:n,toggle:function(t){var n=e(this),s,o;if(n.is(".disabled, :disabled"))return;return s=i(n),o=s.hasClass("open"),r(),o||(s.toggleClass("open"),n.focus()),!1},keydown:function(t){var n,r,s,o,u,a;if(!/(38|40|27)/.test(t.keyCode))return;n=e(this),t.preventDefault(),t.stopPropagation();if(n.is(".disabled, :disabled"))return;o=i(n),u=o.hasClass("open");if(!u||u&&t.keyCode==27)return n.click();r=e("[role=menu] li:not(.divider) a",o);if(!r.length)return;a=r.index(r.filter(":focus")),t.keyCode==38&&a>0&&a--,t.keyCode==40&&a<r.length-1&&a++,~a||(a=0),r.eq(a).focus()}},e.fn.dropdown=function(t){return this.each(function(){var r=e(this),i=r.data("dropdown");i||r.data("dropdown",i=new n(this)),typeof t=="string"&&i[t].call(r)})},e.fn.dropdown.Constructor=n,e(function(){e("html").on("click.dropdown.data-api touchstart.dropdown.data-api",r),e("body").on("click.dropdown touchstart.dropdown.data-api",".dropdown form",function(e){e.stopPropagation()}).on("click.dropdown.data-api touchstart.dropdown.data-api",t,n.prototype.toggle).on("keydown.dropdown.data-api touchstart.dropdown.data-api",t+", [role=menu]",n.prototype.keydown)})}(window.jQuery),!function(e){"use strict";var t=function(t,n){this.options=n,this.$element=e(t).delegate('[data-dismiss="modal"]',"click.dismiss.modal",e.proxy(this.hide,this)),this.options.remote&&this.$element.find(".modal-body").load(this.options.remote)};t.prototype={constructor:t,toggle:function(){return this[this.isShown?"hide":"show"]()},show:function(){var t=this,n=e.Event("show");this.$element.trigger(n);if(this.isShown||n.isDefaultPrevented())return;e("body").addClass("modal-open"),this.isShown=!0,this.escape(),this.backdrop(function(){var n=e.support.transition&&t.$element.hasClass("fade");t.$element.parent().length||t.$element.appendTo(document.body),t.$element.show(),n&&t.$element[0].offsetWidth,t.$element.addClass("in").attr("aria-hidden",!1).focus(),t.enforceFocus(),n?t.$element.one(e.support.transition.end,function(){t.$element.trigger("shown")}):t.$element.trigger("shown")})},hide:function(t){t&&t.preventDefault();var n=this;t=e.Event("hide"),this.$element.trigger(t);if(!this.isShown||t.isDefaultPrevented())return;this.isShown=!1,e("body").removeClass("modal-open"),this.escape(),e(document).off("focusin.modal"),this.$element.removeClass("in").attr("aria-hidden",!0),e.support.transition&&this.$element.hasClass("fade")?this.hideWithTransition():this.hideModal()},enforceFocus:function(){var t=this;e(document).on("focusin.modal",function(e){t.$element[0]!==e.target&&!t.$element.has(e.target).length&&t.$element.focus()})},escape:function(){var e=this;this.isShown&&this.options.keyboard?this.$element.on("keyup.dismiss.modal",function(t){t.which==27&&e.hide()}):this.isShown||this.$element.off("keyup.dismiss.modal")},hideWithTransition:function(){var t=this,n=setTimeout(function(){t.$element.off(e.support.transition.end),t.hideModal()},500);this.$element.one(e.support.transition.end,function(){clearTimeout(n),t.hideModal()})},hideModal:function(e){this.$element.hide().trigger("hidden"),this.backdrop()},removeBackdrop:function(){this.$backdrop.remove(),this.$backdrop=null},backdrop:function(t){var n=this,r=this.$element.hasClass("fade")?"fade":"";if(this.isShown&&this.options.backdrop){var i=e.support.transition&&r;this.$backdrop=e('<div class="modal-backdrop '+r+'" />').appendTo(document.body),this.options.backdrop!="static"&&this.$backdrop.click(e.proxy(this.hide,this)),i&&this.$backdrop[0].offsetWidth,this.$backdrop.addClass("in"),i?this.$backdrop.one(e.support.transition.end,t):t()}else!this.isShown&&this.$backdrop?(this.$backdrop.removeClass("in"),e.support.transition&&this.$element.hasClass("fade")?this.$backdrop.one(e.support.transition.end,e.proxy(this.removeBackdrop,this)):this.removeBackdrop()):t&&t()}},e.fn.modal=function(n){return this.each(function(){var r=e(this),i=r.data("modal"),s=e.extend({},e.fn.modal.defaults,r.data(),typeof n=="object"&&n);i||r.data("modal",i=new t(this,s)),typeof n=="string"?i[n]():s.show&&i.show()})},e.fn.modal.defaults={backdrop:!0,keyboard:!0,show:!0},e.fn.modal.Constructor=t,e(function(){e("body").on("click.modal.data-api",'[data-toggle="modal"]',function(t){var n=e(this),r=n.attr("href"),i=e(n.attr("data-target")||r&&r.replace(/.*(?=#[^\s]+$)/,"")),s=i.data("modal")?"toggle":e.extend({remote:!/#/.test(r)&&r},i.data(),n.data());t.preventDefault(),i.modal(s).one("hide",function(){n.focus()})})})}(window.jQuery),!function(e){"use strict";var t=function(e,t){this.init("tooltip",e,t)};t.prototype={constructor:t,init:function(t,n,r){var i,s;this.type=t,this.$element=e(n),this.options=this.getOptions(r),this.enabled=!0,this.options.trigger=="click"?this.$element.on("click."+this.type,this.options.selector,e.proxy(this.toggle,this)):this.options.trigger!="manual"&&(i=this.options.trigger=="hover"?"mouseenter":"focus",s=this.options.trigger=="hover"?"mouseleave":"blur",this.$element.on(i+"."+this.type,this.options.selector,e.proxy(this.enter,this)),this.$element.on(s+"."+this.type,this.options.selector,e.proxy(this.leave,this))),this.options.selector?this._options=e.extend({},this.options,{trigger:"manual",selector:""}):this.fixTitle()},getOptions:function(t){return t=e.extend({},e.fn[this.type].defaults,t,this.$element.data()),t.delay&&typeof t.delay=="number"&&(t.delay={show:t.delay,hide:t.delay}),t},enter:function(t){var n=e(t.currentTarget)[this.type](this._options).data(this.type);if(!n.options.delay||!n.options.delay.show)return n.show();clearTimeout(this.timeout),n.hoverState="in",this.timeout=setTimeout(function(){n.hoverState=="in"&&n.show()},n.options.delay.show)},leave:function(t){var n=e(t.currentTarget)[this.type](this._options).data(this.type);this.timeout&&clearTimeout(this.timeout);if(!n.options.delay||!n.options.delay.hide)return n.hide();n.hoverState="out",this.timeout=setTimeout(function(){n.hoverState=="out"&&n.hide()},n.options.delay.hide)},show:function(){var e,t,n,r,i,s,o;if(this.hasContent()&&this.enabled){e=this.tip(),this.setContent(),this.options.animation&&e.addClass("fade"),s=typeof this.options.placement=="function"?this.options.placement.call(this,e[0],this.$element[0]):this.options.placement,t=/in/.test(s),e.remove().css({top:0,left:0,display:"block"}).appendTo(t?this.$element:document.body),n=this.getPosition(t),r=e[0].offsetWidth,i=e[0].offsetHeight;switch(t?s.split(" ")[1]:s){case"bottom":o={top:n.top+n.height,left:n.left+n.width/2-r/2};break;case"top":o={top:n.top-i,left:n.left+n.width/2-r/2};break;case"left":o={top:n.top+n.height/2-i/2,left:n.left-r};break;case"right":o={top:n.top+n.height/2-i/2,left:n.left+n.width}}e.css(o).addClass(s).addClass("in")}},setContent:function(){var e=this.tip(),t=this.getTitle();e.find(".tooltip-inner")[this.options.html?"html":"text"](t),e.removeClass("fade in top bottom left right")},hide:function(){function r(){var t=setTimeout(function(){n.off(e.support.transition.end).remove()},500);n.one(e.support.transition.end,function(){clearTimeout(t),n.remove()})}var t=this,n=this.tip();return n.removeClass("in"),e.support.transition&&this.$tip.hasClass("fade")?r():n.remove(),this},fixTitle:function(){var e=this.$element;(e.attr("title")||typeof e.attr("data-original-title")!="string")&&e.attr("data-original-title",e.attr("title")||"").removeAttr("title")},hasContent:function(){return this.getTitle()},getPosition:function(t){return e.extend({},t?{top:0,left:0}:this.$element.offset(),{width:this.$element[0].offsetWidth,height:this.$element[0].offsetHeight})},getTitle:function(){var e,t=this.$element,n=this.options;return e=t.attr("data-original-title")||(typeof n.title=="function"?n.title.call(t[0]):n.title),e},tip:function(){return this.$tip=this.$tip||e(this.options.template)},validate:function(){this.$element[0].parentNode||(this.hide(),this.$element=null,this.options=null)},enable:function(){this.enabled=!0},disable:function(){this.enabled=!1},toggleEnabled:function(){this.enabled=!this.enabled},toggle:function(){this[this.tip().hasClass("in")?"hide":"show"]()},destroy:function(){this.hide().$element.off("."+this.type).removeData(this.type)}},e.fn.tooltip=function(n){return this.each(function(){var r=e(this),i=r.data("tooltip"),s=typeof n=="object"&&n;i||r.data("tooltip",i=new t(this,s)),typeof n=="string"&&i[n]()})},e.fn.tooltip.Constructor=t,e.fn.tooltip.defaults={animation:!0,placement:"top",selector:!1,template:'<div class="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',trigger:"hover",title:"",delay:0,html:!0}}(window.jQuery),!function(e){"use strict";var t=function(e,t){this.init("popover",e,t)};t.prototype=e.extend({},e.fn.tooltip.Constructor.prototype,{constructor:t,setContent:function(){var e=this.tip(),t=this.getTitle(),n=this.getContent();e.find(".popover-title")[this.options.html?"html":"text"](t),e.find(".popover-content > *")[this.options.html?"html":"text"](n),e.removeClass("fade top bottom left right in")},hasContent:function(){return this.getTitle()||this.getContent()},getContent:function(){var e,t=this.$element,n=this.options;return e=t.attr("data-content")||(typeof n.content=="function"?n.content.call(t[0]):n.content),e},tip:function(){return this.$tip||(this.$tip=e(this.options.template)),this.$tip},destroy:function(){this.hide().$element.off("."+this.type).removeData(this.type)}}),e.fn.popover=function(n){return this.each(function(){var r=e(this),i=r.data("popover"),s=typeof n=="object"&&n;i||r.data("popover",i=new t(this,s)),typeof n=="string"&&i[n]()})},e.fn.popover.Constructor=t,e.fn.popover.defaults=e.extend({},e.fn.tooltip.defaults,{placement:"right",trigger:"click",content:"",template:'<div class="popover"><div class="arrow"></div><div class="popover-inner"><h3 class="popover-title"></h3><div class="popover-content"><p></p></div></div></div>'})}(window.jQuery),!function(e){"use strict";function t(t,n){var r=e.proxy(this.process,this),i=e(t).is("body")?e(window):e(t),s;this.options=e.extend({},e.fn.scrollspy.defaults,n),this.$scrollElement=i.on("scroll.scroll-spy.data-api",r),this.selector=(this.options.target||(s=e(t).attr("href"))&&s.replace(/.*(?=#[^\s]+$)/,"")||"")+" .nav li > a",this.$body=e("body"),this.refresh(),this.process()}t.prototype={constructor:t,refresh:function(){var t=this,n;this.offsets=e([]),this.targets=e([]),n=this.$body.find(this.selector).map(function(){var t=e(this),n=t.data("target")||t.attr("href"),r=/^#\w/.test(n)&&e(n);return r&&r.length&&[[r.position().top,n]]||null}).sort(function(e,t){return e[0]-t[0]}).each(function(){t.offsets.push(this[0]),t.targets.push(this[1])})},process:function(){var e=this.$scrollElement.scrollTop()+this.options.offset,t=this.$scrollElement[0].scrollHeight||this.$body[0].scrollHeight,n=t-this.$scrollElement.height(),r=this.offsets,i=this.targets,s=this.activeTarget,o;if(e>=n)return s!=(o=i.last()[0])&&this.activate(o);for(o=r.length;o--;)s!=i[o]&&e>=r[o]&&(!r[o+1]||e<=r[o+1])&&this.activate(i[o])},activate:function(t){var n,r;this.activeTarget=t,e(this.selector).parent(".active").removeClass("active"),r=this.selector+'[data-target="'+t+'"],'+this.selector+'[href="'+t+'"]',n=e(r).parent("li").addClass("active"),n.parent(".dropdown-menu").length&&(n=n.closest("li.dropdown").addClass("active")),n.trigger("activate")}},e.fn.scrollspy=function(n){return this.each(function(){var r=e(this),i=r.data("scrollspy"),s=typeof n=="object"&&n;i||r.data("scrollspy",i=new t(this,s)),typeof n=="string"&&i[n]()})},e.fn.scrollspy.Constructor=t,e.fn.scrollspy.defaults={offset:10},e(window).on("load",function(){e('[data-spy="scroll"]').each(function(){var t=e(this);t.scrollspy(t.data())})})}(window.jQuery),!function(e){"use strict";var t=function(t){this.element=e(t)};t.prototype={constructor:t,show:function(){var t=this.element,n=t.closest("ul:not(.dropdown-menu)"),r=t.attr("data-target"),i,s,o;r||(r=t.attr("href"),r=r&&r.replace(/.*(?=#[^\s]*$)/,""));if(t.parent("li").hasClass("active"))return;i=n.find(".active a").last()[0],o=e.Event("show",{relatedTarget:i}),t.trigger(o);if(o.isDefaultPrevented())return;s=e(r),this.activate(t.parent("li"),n),this.activate(s,s.parent(),function(){t.trigger({type:"shown",relatedTarget:i})})},activate:function(t,n,r){function o(){i.removeClass("active").find("> .dropdown-menu > .active").removeClass("active"),t.addClass("active"),s?(t[0].offsetWidth,t.addClass("in")):t.removeClass("fade"),t.parent(".dropdown-menu")&&t.closest("li.dropdown").addClass("active"),r&&r()}var i=n.find("> .active"),s=r&&e.support.transition&&i.hasClass("fade");s?i.one(e.support.transition.end,o):o(),i.removeClass("in")}},e.fn.tab=function(n){return this.each(function(){var r=e(this),i=r.data("tab");i||r.data("tab",i=new t(this)),typeof n=="string"&&i[n]()})},e.fn.tab.Constructor=t,e(function(){e("body").on("click.tab.data-api",'[data-toggle="tab"], [data-toggle="pill"]',function(t){t.preventDefault(),e(this).tab("show")})})}(window.jQuery),!function(e){"use strict";var t=function(t,n){this.$element=e(t),this.options=e.extend({},e.fn.typeahead.defaults,n),this.matcher=this.options.matcher||this.matcher,this.sorter=this.options.sorter||this.sorter,this.highlighter=this.options.highlighter||this.highlighter,this.updater=this.options.updater||this.updater,this.$menu=e(this.options.menu).appendTo("body"),this.source=this.options.source,this.shown=!1,this.listen()};t.prototype={constructor:t,select:function(){var e=this.$menu.find(".active").attr("data-value");return this.$element.val(this.updater(e)).change(),this.hide()},updater:function(e){return e},show:function(){var t=e.extend({},this.$element.offset(),{height:this.$element[0].offsetHeight});return this.$menu.css({top:t.top+t.height,left:t.left}),this.$menu.show(),this.shown=!0,this},hide:function(){return this.$menu.hide(),this.shown=!1,this},lookup:function(t){var n;return this.query=this.$element.val(),!this.query||this.query.length<this.options.minLength?this.shown?this.hide():this:(n=e.isFunction(this.source)?this.source(this.query,e.proxy(this.process,this)):this.source,n?this.process(n):this)},process:function(t){var n=this;return t=e.grep(t,function(e){return n.matcher(e)}),t=this.sorter(t),t.length?this.render(t.slice(0,this.options.items)).show():this.shown?this.hide():this},matcher:function(e){return~e.toLowerCase().indexOf(this.query.toLowerCase())},sorter:function(e){var t=[],n=[],r=[],i;while(i=e.shift())i.toLowerCase().indexOf(this.query.toLowerCase())?~i.indexOf(this.query)?n.push(i):r.push(i):t.push(i);return t.concat(n,r)},highlighter:function(e){var t=this.query.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g,"\\$&");return e.replace(new RegExp("("+t+")","ig"),function(e,t){return"<strong>"+t+"</strong>"})},render:function(t){var n=this;return t=e(t).map(function(t,r){return t=e(n.options.item).attr("data-value",r),t.find("a").html(n.highlighter(r)),t[0]}),t.first().addClass("active"),this.$menu.html(t),this},next:function(t){var n=this.$menu.find(".active").removeClass("active"),r=n.next();r.length||(r=e(this.$menu.find("li")[0])),r.addClass("active")},prev:function(e){var t=this.$menu.find(".active").removeClass("active"),n=t.prev();n.length||(n=this.$menu.find("li").last()),n.addClass("active")},listen:function(){this.$element.on("blur",e.proxy(this.blur,this)).on("keypress",e.proxy(this.keypress,this)).on("keyup",e.proxy(this.keyup,this)),(e.browser.chrome||e.browser.webkit||e.browser.msie)&&this.$element.on("keydown",e.proxy(this.keydown,this)),this.$menu.on("click",e.proxy(this.click,this)).on("mouseenter","li",e.proxy(this.mouseenter,this))},move:function(e){if(!this.shown)return;switch(e.keyCode){case 9:case 13:case 27:e.preventDefault();break;case 38:e.preventDefault(),this.prev();break;case 40:e.preventDefault(),this.next()}e.stopPropagation()},keydown:function(t){this.suppressKeyPressRepeat=!~e.inArray(t.keyCode,[40,38,9,13,27]),this.move(t)},keypress:function(e){if(this.suppressKeyPressRepeat)return;this.move(e)},keyup:function(e){switch(e.keyCode){case 40:case 38:break;case 9:case 13:if(!this.shown)return;this.select();break;case 27:if(!this.shown)return;this.hide();break;default:this.lookup()}e.stopPropagation(),e.preventDefault()},blur:function(e){var t=this;setTimeout(function(){t.hide()},150)},click:function(e){e.stopPropagation(),e.preventDefault(),this.select()},mouseenter:function(t){this.$menu.find(".active").removeClass("active"),e(t.currentTarget).addClass("active")}},e.fn.typeahead=function(n){return this.each(function(){var r=e(this),i=r.data("typeahead"),s=typeof n=="object"&&n;i||r.data("typeahead",i=new t(this,s)),typeof n=="string"&&i[n]()})},e.fn.typeahead.defaults={source:[],items:8,menu:'<ul class="typeahead dropdown-menu"></ul>',item:'<li><a href="#"></a></li>',minLength:1},e.fn.typeahead.Constructor=t,e(function(){e("body").on("focus.typeahead.data-api",'[data-provide="typeahead"]',function(t){var n=e(this);if(n.data("typeahead"))return;t.preventDefault(),n.typeahead(n.data())})})}(window.jQuery),!function(e){"use strict";var t=function(t,n){this.options=e.extend({},e.fn.affix.defaults,n),this.$window=e(window).on("scroll.affix.data-api",e.proxy(this.checkPosition,this)),this.$element=e(t),this.checkPosition()};t.prototype.checkPosition=function(){if(!this.$element.is(":visible"))return;var t=e(document).height(),n=this.$window.scrollTop(),r=this.$element.offset(),i=this.options.offset,s=i.bottom,o=i.top,u="affix affix-top affix-bottom",a;typeof i!="object"&&(s=o=i),typeof o=="function"&&(o=i.top()),typeof s=="function"&&(s=i.bottom()),a=this.unpin!=null&&n+this.unpin<=r.top?!1:s!=null&&r.top+this.$element.height()>=t-s?"bottom":o!=null&&n<=o?"top":!1;if(this.affixed===a)return;this.affixed=a,this.unpin=a=="bottom"?r.top-n:null,this.$element.removeClass(u).addClass("affix"+(a?"-"+a:""))},e.fn.affix=function(n){return this.each(function(){var r=e(this),i=r.data("affix"),s=typeof n=="object"&&n;i||r.data("affix",i=new t(this,s)),typeof n=="string"&&i[n]()})},e.fn.affix.Constructor=t,e.fn.affix.defaults={offset:0},e(window).on("load",function(){e('[data-spy="affix"]').each(function(){var t=e(this),n=t.data();n.offset=n.offset||{},n.offsetBottom&&(n.offset.bottom=n.offsetBottom),n.offsetTop&&(n.offset.top=n.offsetTop),t.affix(n)})})}(window.jQuery);
\ No newline at end of file
diff --git a/docs/public/css/base.scss b/docs/public/css/base.scss
new file mode 100644
index 00000000..6ac3a055
--- /dev/null
+++ b/docs/public/css/base.scss
@@ -0,0 +1,72 @@
+@charset "utf-8";
+body {
+    padding-top: 60px;
+}
+
+footer {
+    background-color: #F5F5F5;
+    padding: 40px 0;
+    height: 100px;
+    margin-top: 40px;
+    color: #999999;
+}
+
+section {
+    padding-top: 30px;
+}
+
+.manual-example {
+    border-top: 1px solid #E5E5E5;
+}
+
+.manual-example td {
+    white-space: pre-wrap;
+    font-family: Monaco, Menlo, Consolas, "Courier New", monospace;
+}
+
+.manual-example td.jqprogram {
+    font-weight: bold;
+}
+
+.manual-example th {
+    text-align: right;
+    padding-right: 10px;
+}
+
+.tutorial-example {
+    position: relative;
+    margin-bottom: 10px;
+}
+
+.tutorial-example pre {
+    margin-bottom: 0px;
+}
+
+.tutorial-example a {
+    position: absolute;
+    top: 0px;
+    right: 0px;
+    padding: 15px 8px;
+    color: #777777;
+    font-weight: bold;
+    line-height: 10px;
+    font-size: 12px;
+    border-left: 1px solid #DDDDDD;
+    bottom: 0;
+    display: block;
+}
+
+
+
+#blurb {
+    padding-top: 20px;
+}
+
+#blurb p {
+    font-size: 20pt;
+}
+
+h3 code {
+    border: 0;
+    font-size: 20px;
+}
\ No newline at end of file
diff --git a/docs/public/jq.png b/docs/public/jq.png
new file mode 100644
index 0000000000000000000000000000000000000000..41d6d391dbf86ed4d36559d19f2cd3885b077096
GIT binary patch
literal 8195
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

literal 0
HcmV?d00001

diff --git a/docs/public/robots.txt b/docs/public/robots.txt
new file mode 100644
index 00000000..14267e90
--- /dev/null
+++ b/docs/public/robots.txt
@@ -0,0 +1,2 @@
+User-agent: *
+Allow: /
\ No newline at end of file
diff --git a/docs/site.yml b/docs/site.yml
new file mode 100644
index 00000000..4c752db0
--- /dev/null
+++ b/docs/site.yml
@@ -0,0 +1,11 @@
+# The key value pairs found below are available within the templates.
+
+
+jq_version: 1.0
+footer: |
+  
+  This website is made with [Bonsai](http://www.tinytree.info) and
+  [Twitter Boostrap](http://twitter.github.com/bootstrap/). jq is
+  licensed under the MIT license (code) and the
+  [CC-BY-3.0](http://creativecommons.org/licenses/by/3.0/) license
+  (docs).
\ No newline at end of file
diff --git a/docs/templates/default.liquid b/docs/templates/default.liquid
new file mode 100644
index 00000000..eb2ebbb8
--- /dev/null
+++ b/docs/templates/default.liquid
@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html lang="en">
+  {% include "shared/head" %}
+  <body id="{{slug}}">
+    {% include "shared/header" %}	
+    
+    <div class="container">
+        
+      <div class="row">
+        <h1>{{headline}}</h1>
+        {% for item in body %}
+          {% if item.text %}
+            {{ item.text | markdownify }}
+          {% endif %}
+        
+          {% if item.command %}
+
+        
+            {% capture resultID %}{{ "result" | unique}}{% endcapture %}
+            <div class="tutorial-example">
+              <div class="accordion-heading">
+                <pre>{{item.command}}</pre>
+                <a data-toggle="collapse" href="#{{resultID}}">Show result</a>
+              </div>
+              <div id="{{resultID}}" class="accordion-body collapse"><pre>{{item.result}}</pre></div>
+            </div>
+          {% endif %}
+        {% endfor %}
+      </div>
+    </div>
+    {% include "shared/footer" %}
+    
+  </body>
+</html>
diff --git a/docs/templates/index.liquid b/docs/templates/index.liquid
new file mode 100644
index 00000000..f9fc945c
--- /dev/null
+++ b/docs/templates/index.liquid
@@ -0,0 +1,38 @@
+<!DOCTYPE html>
+<html lang="en">
+  {% include "shared/head" %}
+  <body id="{{slug}}">
+    {% include "shared/header" %}	
+    
+    <div class="container">
+      <div class="row">
+        <div class="hero-unit">
+          <img src="/jq.png" style="width: 400px; height: 220px; float: left; margin-right: 60px">
+          <div id="blurb">
+            {{blurb | markdownify}}
+            <div class="btn-group" style="float:right">
+              <a class="btn btn-primary dropdown-toggle" data-toggle="dropdown" href="#">
+                Download jq-{{jq_version}}
+                <span class="caret"></span>
+              </a>
+              <ul class="dropdown-menu">
+                <li><a href="/download/linux/x68_64/jq">Linux (x86_64)</a></li>
+                <li><a href="/download/osx/64/jq">OS X (64-bit)</a></li>
+                <li><a href="/download">Other platforms and source</a></li>
+              </ul>
+            </div>
+
+          </div>
+          <div style="clear:both;"></div>
+        </div>
+      </div>
+        
+      <div class="row">
+
+
+	{{body | markdownify}}
+      </div>
+    </div>
+    {% include "shared/footer" %}    
+  </body>
+</html>
diff --git a/docs/templates/manual.liquid b/docs/templates/manual.liquid
new file mode 100644
index 00000000..b3eb2e2f
--- /dev/null
+++ b/docs/templates/manual.liquid
@@ -0,0 +1,109 @@
+<!DOCTYPE html>
+<html lang="en">
+  {% include "shared/head" %}
+  <body id="{{slug}}" data-spy="scroll" data-target="#navcolumn" data-offset="100">
+    {% include "shared/header" %}	
+    <div class="container">
+      <div class="row">
+        <div class="span3" id="navcolumn">
+          <div class="affix">
+          <h4>Contents</h4>
+          <ul class="nav nav-pills nav-stacked">
+            {% for section in sections %}
+              <li {% if forloop.first %} class="active" {% endif %}>
+                <a href="#{{section.title | sanitize}}">{{section.title}}</a>
+              </li>
+            {% endfor %}
+          </ul>
+          <form class="form-search">
+            <script type="text/javascript">
+              var section_map = {
+                {% for section in sections %}
+                  {% for entry in section.entries %}
+                    {{entry.title | json}} : {{entry.title | sanitize | json}},
+                  {% endfor %}
+                  {{section.title | json}} : {{section.title | sanitize | json}}
+                  {% unless forloop.last %},{% endunless %}
+                {% endfor %}
+              };
+              var section_names = $.map(section_map, function(v,k){return k});
+              $(function(){
+                $('#searchbox').typeahead({source: section_names})
+                $('#searchbox').change(function() {
+                  if ($(this).val() in section_map) {
+                    location.hash = '#' + section_map[$(this).val()];
+                  }
+                });
+              });
+            </script>
+            <input type="text"
+                   class="input-medium search-query"
+                   placeholder="Search"
+                   autocomplete="off"
+                   id="searchbox">
+          </form>
+          </div>
+        </div>
+        <div class="span9">
+          <h1>{{headline}}</h1>
+          {% for section in sections %}
+            <section id="{{section.title | sanitize}}">
+              <h2>{{section.title}}</h2>
+              {{section.body | markdownify}}
+              {% for entry in section.entries %}
+                <section id="{{entry.title | sanitize}}">
+                <h3>
+                  {{entry.title | markdownify}}
+                  {% if entry.subtitle %}<small>{{entry.subtitle}}</small>{% endif %}
+                </h3>
+                {{entry.body | markdownify}}
+
+                {% if entry.examples %}
+                  <div>
+                    {% capture exampleID %}{{ "" | unique }}{% endcapture %}
+                    <a data-toggle="collapse" href="#example{{exampleID}}">
+                      <i class="icon-chevron-right"></i>
+                      {% if entry.examples[1] %}Examples{%else%}Example{%endif%}
+                    </a>
+                    <div id="example{{exampleID}}" class="collapse">
+                      
+                    {% for example in entry.examples %}
+                      <table class="manual-example">
+                        <tr><th></th><td class="jqprogram">jq '{{example.program}}'</td></tr>
+                        <tr><th>Input</th><td>{{example.input}}</td></tr>
+                        {% unless example.output[0] %}
+                          <tr>
+                            <th>Output</th>
+                            <td><i>none</i></td>
+                          </tr>
+                        {% endunless %}
+                        {% for output in example.output %}
+                          <tr>
+                            {% if forloop.index == 1 %}
+                              <th>Output</th>
+                            {% else %}
+                              <th></th>
+                            {% endif %}
+                            <td>{{output}}</td>
+                          </tr>
+                        {% endfor %}
+                        
+                      </table>
+                    {% endfor %}
+                    </div>
+                  </div>
+                 {% endif %}
+                 </section>
+              {% endfor %}
+            </section>
+          {% endfor %}
+        </div>
+      </div>
+      
+
+    </div>
+      {% include "shared/footer" %}    
+  </body>
+
+
+</html>
diff --git a/docs/templates/shared/_footer.liquid b/docs/templates/shared/_footer.liquid
new file mode 100644
index 00000000..0e50c133
--- /dev/null
+++ b/docs/templates/shared/_footer.liquid
@@ -0,0 +1,5 @@
+<footer>
+  <div class="container">
+    {{ footer | markdownify }}
+  </div>
+</footer>
diff --git a/docs/templates/shared/_head.liquid b/docs/templates/shared/_head.liquid
new file mode 100644
index 00000000..acc6dfe2
--- /dev/null
+++ b/docs/templates/shared/_head.liquid
@@ -0,0 +1,12 @@
+<head>
+  <meta charset=UTF-8>
+  <title>{{headline}} | jq</title>
+  <link rel="stylesheet" href="/bootstrap/css/bootstrap.css" type="text/css">
+  <link rel="stylesheet" href="/css/base.css" type="text/css">
+  <!--[if IE]>
+    <script src="http://html5shiv.googlecode.com/svn/trunk/html5.js"></script>
+  <![endif]-->
+  <script src="//ajax.googleapis.com/ajax/libs/jquery/1.8.1/jquery.min.js"></script>
+  <script src="/bootstrap/js/bootstrap.js"></script>
+
+</head>
\ No newline at end of file
diff --git a/docs/templates/shared/_header.liquid b/docs/templates/shared/_header.liquid
new file mode 100644
index 00000000..82f778d7
--- /dev/null
+++ b/docs/templates/shared/_header.liquid
@@ -0,0 +1,24 @@
+
+<div class="navbar navbar-inverse navbar-fixed-top">
+  <div class="navbar-inner">
+    <div class="container">
+      <button type="button" class="btn btn-navbar" data-toggle="collapse" data-target=".nav-collapse">
+        <span class="icon-bar"></span>
+        <span class="icon-bar"></span>
+        <span class="icon-bar"></span>
+      </button>
+      <a class="brand" href="/">jq</a>
+      <div class="nav-collapse collapse">
+        <ul class="nav">
+          {% for item in navigation %}
+            <li {% if item.permalink == permalink %} class="active" {% endif %}>
+              <a href="{{item.permalink}}">{{item.name}}</a>
+            </li>
+          {% endfor %}
+          <li><a href="https://github.com/stedolan/jq/issues">Issues</a></li>
+          <li><a href="https://github.com/stedolan/jq">Source</a></li>
+        </ul>
+      </div>
+    </div>
+  </div>
+</div>

From 46af5238ce3e9327e0268d18373d07f67eed58b8 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 18 Sep 2012 17:59:09 +0100
Subject: [PATCH 089/284] Add a COPYING file with too many words in it.

---
 COPYING | 70 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 70 insertions(+)
 create mode 100644 COPYING

diff --git a/COPYING b/COPYING
new file mode 100644
index 00000000..03b0f56f
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,70 @@
+jq is copyright (C) 2012 Stephen Dolan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+
+jq's documentation (everything found under the docs/ subdirectory in
+the source tree) is licensed under the Creative Commons CC BY 3.0
+license, which can be found at:
+
+         http://creativecommons.org/licenses/by/3.0/
+
+The documentation website includes a copy of Twitter's Boostrap and
+relies on Bonsai, Liquid templates and various other projects, look
+them up for detailed licensing conditions.
+         
+
+         
+jq incorporates David M. Gay's dtoa.c and g_fmt.c, which bear the
+following notices:
+
+dtoa.c:
+The author of this software is David M. Gay.
+
+Copyright (c) 1991, 2000, 2001 by Lucent Technologies.
+
+Permission to use, copy, modify, and distribute this software for any
+purpose without fee is hereby granted, provided that this entire notice
+is included in all copies of any software which is or includes a copy
+or modification of this software and in all copies of the supporting
+documentation for such software.
+
+THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+WARRANTY.  IN PARTICULAR, NEITHER THE AUTHOR NOR LUCENT MAKES ANY
+REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+
+g_fmt.c:
+The author of this software is David M. Gay.
+
+Copyright (c) 1991, 1996 by Lucent Technologies.
+
+Permission to use, copy, modify, and distribute this software for any
+purpose without fee is hereby granted, provided that this entire notice
+is included in all copies of any software which is or includes a copy
+or modification of this software and in all copies of the supporting
+documentation for such software.
+
+THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+WARRANTY.  IN PARTICULAR, NEITHER THE AUTHOR NOR LUCENT MAKES ANY
+REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+

From 20e45f363c91ef4a305eff5709212f1b2fb43523 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 18 Sep 2012 22:17:13 +0100
Subject: [PATCH 090/284] Separate the tests and the main program.

---
 Makefile               |  21 ++++-----
 execute.c              |  25 ++++++++++-
 execute.h              |  13 ++++++
 jv_test.c => jq_test.c | 100 ++++++++++++++++++++++++++++++++++++++---
 main.c                 |  99 +---------------------------------------
 5 files changed, 141 insertions(+), 117 deletions(-)
 create mode 100644 execute.h
 rename jv_test.c => jq_test.c (65%)

diff --git a/Makefile b/Makefile
index db63b777..7348b292 100644
--- a/Makefile
+++ b/Makefile
@@ -8,8 +8,6 @@ clean:
 	sed 's/.*`\(.*\)'\''.*/\1/' | grep -v '^all$$' | \
 	xargs rm
 
-jv_utf8_tables.gen.h: gen_utf8_tables.py
-	python $^ > $@
 
 lexer.gen.c: lexer.l
 	flex -o lexer.gen.c --header-file=lexer.gen.h lexer.l
@@ -19,21 +17,20 @@ parser.gen.c: parser.y lexer.gen.h
 	bison -W -d parser.y -v --report-file=parser.gen.info -o $@
 parser.gen.h: parser.gen.c
 
+jv_utf8_tables.gen.h: gen_utf8_tables.py
+	python $^ > $@
 jv_unicode.c: jv_utf8_tables.gen.h
 
-parsertest: parser.gen.c lexer.gen.c main.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c
+JQ_SRC=parser.gen.c lexer.gen.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c
+
+
+jq_test: $(JQ_SRC) jq_test.c
 	$(CC) -DJQ_DEBUG=1 -o $@ $^
 
-jq: parser.gen.c lexer.gen.c main.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c
+jq: $(JQ_SRC) main.c
 	$(CC) -DJQ_DEBUG=0 -o $@ $^
 
-jv_test: jv_test.c jv.c jv_print.c jv_dtoa.c jv_unicode.c
-	$(CC) -DNO_JANSSON -o $@ $^
 
-jv_parse: jv_parse.c jv.c jv_print.c jv_dtoa.c
-	$(CC) -DNO_JANSSON -o $@ $^ -DJV_PARSE_MAIN
-
-
-test: jv_test
-	valgrind --error-exitcode=1 -q --leak-check=full ./jv_test
+test: jq_test
+	valgrind --error-exitcode=1 -q --leak-check=full ./jq_test >/dev/null
 
diff --git a/execute.c b/execute.c
index 6b0948c5..93aefc0e 100644
--- a/execute.c
+++ b/execute.c
@@ -3,6 +3,8 @@
 #include <stdlib.h>
 #include <stdint.h>
 
+#include "execute.h"
+
 #include "opcode.h"
 #include "bytecode.h"
 #include "compile.h"
@@ -10,8 +12,10 @@
 #include "forkable_stack.h"
 #include "frame_layout.h"
 
+#include "locfile.h"
 #include "jv.h"
-
+#include "parser.h"
+#include "builtin.h"
 
 typedef struct {
   jv value;
@@ -500,3 +504,22 @@ void jq_teardown() {
   pathbuf = 0;
   pathsize = 0;
 }
+
+struct bytecode* jq_compile(const char* str) {
+  struct locfile locations;
+  locfile_init(&locations, str, strlen(str));
+  block program;
+  struct bytecode* bc = 0;
+  int nerrors = jq_parse(&locations, &program);
+  if (nerrors == 0) {
+    block_append(&program, block_join(gen_op_simple(YIELD), gen_op_simple(BACKTRACK)));
+    program = builtins_bind(program);
+    nerrors = block_compile(program, &locations, &bc);
+    block_free(program);
+  }
+  if (nerrors) {
+    fprintf(stderr, "%d compile %s\n", nerrors, nerrors > 1 ? "errors" : "error");
+  }
+  locfile_free(&locations);
+  return bc;
+}
diff --git a/execute.h b/execute.h
new file mode 100644
index 00000000..bf31e5e8
--- /dev/null
+++ b/execute.h
@@ -0,0 +1,13 @@
+#ifndef EXECUTE_H
+#define EXECUTE_H
+#include "bytecode.h"
+
+
+struct bytecode* jq_compile(const char* str);
+
+void jq_init(struct bytecode* bc, jv value);
+jv jq_next();
+void jq_teardown();
+
+
+#endif
diff --git a/jv_test.c b/jq_test.c
similarity index 65%
rename from jv_test.c
rename to jq_test.c
index 725e5aba..b4674c81 100644
--- a/jv_test.c
+++ b/jq_test.c
@@ -1,9 +1,97 @@
 #include <assert.h>
 #include <stdio.h>
 #include <string.h>
+#include <stdlib.h>
 #include "jv.h"
+#include "execute.h"
 
-int main(){
+static void jv_test();
+static void run_jq_tests();
+
+int main() {
+  jv_test();
+  run_jq_tests();
+}
+
+
+
+
+static int skipline(const char* buf) {
+  int p = 0;
+  while (buf[p] == ' ' || buf[p] == '\t') p++;
+  if (buf[p] == '#' || buf[p] == '\n' || buf[p] == 0) return 1;
+  return 0;
+}
+
+static void run_jq_tests() {
+  FILE* testdata = fopen("testdata","r");
+  char buf[4096];
+  int tests = 0, passed = 0;
+
+  while (1) {
+    if (!fgets(buf, sizeof(buf), testdata)) break;
+    if (skipline(buf)) continue;
+    printf("Testing %s\n", buf);
+    int pass = 1;
+    struct bytecode* bc = jq_compile(buf);
+    assert(bc);
+    printf("Disassembly:\n");
+    dump_disassembly(2, bc);
+    printf("\n");
+    fgets(buf, sizeof(buf), testdata);
+    jv input = jv_parse(buf);
+    assert(jv_is_valid(input));
+    jq_init(bc, input);
+
+    while (fgets(buf, sizeof(buf), testdata)) {
+      if (skipline(buf)) break;
+      jv expected = jv_parse(buf);
+      assert(jv_is_valid(expected));
+      jv actual = jq_next();
+      if (!jv_is_valid(actual)) {
+        jv_free(actual);
+        printf("Insufficient results\n");
+        pass = 0;
+        break;
+      } else if (!jv_equal(jv_copy(expected), jv_copy(actual))) {
+        printf("Expected ");
+        jv_dump(jv_copy(expected), 0);
+        printf(", but got ");
+        jv_dump(jv_copy(actual), 0);
+        printf("\n");
+        pass = 0;
+      }
+      jv as_string = jv_dump_string(jv_copy(expected), rand());
+      jv reparsed = jv_parse_sized(jv_string_value(as_string), jv_string_length(jv_copy(as_string)));
+      assert(jv_equal(jv_copy(expected), jv_copy(reparsed)));
+      jv_free(as_string);
+      jv_free(reparsed);
+      jv_free(expected);
+      jv_free(actual);
+    }
+    if (pass) {
+      jv extra = jq_next();
+      if (jv_is_valid(extra)) {
+        printf("Superfluous result: ");
+        jv_dump(extra, 0);
+        printf("\n");
+        pass = 0;
+      } else {
+        jv_free(extra);
+      }
+    }
+    jq_teardown();
+    bytecode_free(bc);
+    tests++;
+    passed+=pass;
+  }
+  fclose(testdata);
+  printf("%d of %d tests passed\n", passed,tests);
+  if (passed != tests) exit(1);
+}
+
+
+static void jv_test() {
   /// Arrays and numbers
   {
     jv a = jv_array();
@@ -82,7 +170,7 @@ int main(){
     assert(jv_array_length(jv_array_get(jv_copy(a), 1)) == 1);
 
 
-    jv_dump(jv_copy(a)); printf("\n");
+    jv_dump(jv_copy(a), 0); printf("\n");
     jv_free(a);
   }
 
@@ -92,8 +180,8 @@ int main(){
     assert(jv_equal(jv_string("foo"), jv_string_sized("foo", 3)));
     char nasty[] = "foo\0";
     jv shortstr = jv_string(nasty), longstr = jv_string_sized(nasty, sizeof(nasty));
-    assert(jv_string_length(shortstr) == strlen(nasty));
-    assert(jv_string_length(longstr) == sizeof(nasty));
+    assert(jv_string_length(shortstr) == (int)strlen(nasty));
+    assert(jv_string_length(longstr) == (int)sizeof(nasty));
 
   
     char a1s[] = "hello", a2s[] = "hello", bs[] = "goodbye";
@@ -111,7 +199,7 @@ int main(){
 
     assert(jv_equal(jv_string("hello42!"), jv_string_fmt("hello%d%s", 42, "!")));
     char big[20000];
-    for (int i=0; i<sizeof(big); i++) big[i] = 'a';
+    for (int i=0; i<(int)sizeof(big); i++) big[i] = 'a';
     big[sizeof(big)-1] = 0;
     jv str = jv_string_fmt("%s", big);
     assert(jv_string_length(jv_copy(str)) == sizeof(big) - 1);
@@ -135,7 +223,7 @@ int main(){
     jv_free(o1);
     assert(jv_number_value(jv_object_get(jv_copy(o2), jv_string("bar"))) == 240);
 
-    jv_dump(jv_copy(o2)); printf("\n");
+    jv_dump(jv_copy(o2), 0); printf("\n");
 
     jv_free(o2);
   }
diff --git a/main.c b/main.c
index 0a9eefe8..776c9575 100644
--- a/main.c
+++ b/main.c
@@ -6,106 +6,9 @@
 #include "jv_parse.h"
 #include "locfile.h"
 #include "parser.h"
-
-
-void jq_init(struct bytecode* bc, jv value);
-jv jq_next();
-void jq_teardown();
-
-struct bytecode* jq_compile(const char* str) {
-  struct locfile locations;
-  locfile_init(&locations, str, strlen(str));
-  block program;
-  struct bytecode* bc = 0;
-  int nerrors = jq_parse(&locations, &program);
-  if (nerrors == 0) {
-    block_append(&program, block_join(gen_op_simple(YIELD), gen_op_simple(BACKTRACK)));
-    program = builtins_bind(program);
-    nerrors = block_compile(program, &locations, &bc);
-    block_free(program);
-  }
-  if (nerrors) {
-    fprintf(stderr, "%d compile %s\n", nerrors, nerrors > 1 ? "errors" : "error");
-  }
-  locfile_free(&locations);
-  return bc;
-}
-
-int skipline(const char* buf) {
-  int p = 0;
-  while (buf[p] == ' ' || buf[p] == '\t') p++;
-  if (buf[p] == '#' || buf[p] == '\n' || buf[p] == 0) return 1;
-  return 0;
-}
-
-void run_tests() {
-  FILE* testdata = fopen("testdata","r");
-  char buf[4096];
-  int tests = 0, passed = 0;
-
-  while (1) {
-    if (!fgets(buf, sizeof(buf), testdata)) break;
-    if (skipline(buf)) continue;
-    printf("Testing %s\n", buf);
-    int pass = 1;
-    struct bytecode* bc = jq_compile(buf);
-    assert(bc);
-    printf("Disassembly:\n");
-    dump_disassembly(2, bc);
-    printf("\n");
-    fgets(buf, sizeof(buf), testdata);
-    jv input = jv_parse(buf);
-    assert(jv_is_valid(input));
-    jq_init(bc, input);
-
-    while (fgets(buf, sizeof(buf), testdata)) {
-      if (skipline(buf)) break;
-      jv expected = jv_parse(buf);
-      assert(jv_is_valid(expected));
-      jv actual = jq_next();
-      if (!jv_is_valid(actual)) {
-        jv_free(actual);
-        printf("Insufficient results\n");
-        pass = 0;
-        break;
-      } else if (!jv_equal(jv_copy(expected), jv_copy(actual))) {
-        printf("Expected ");
-        jv_dump(jv_copy(expected), 0);
-        printf(", but got ");
-        jv_dump(jv_copy(actual), 0);
-        printf("\n");
-        pass = 0;
-      }
-      jv as_string = jv_dump_string(jv_copy(expected), rand());
-      jv reparsed = jv_parse_sized(jv_string_value(as_string), jv_string_length(jv_copy(as_string)));
-      assert(jv_equal(jv_copy(expected), jv_copy(reparsed)));
-      jv_free(as_string);
-      jv_free(reparsed);
-      jv_free(expected);
-      jv_free(actual);
-    }
-    if (pass) {
-      jv extra = jq_next();
-      if (jv_is_valid(extra)) {
-        printf("Superfluous result: ");
-        jv_dump(extra, 0);
-        printf("\n");
-        pass = 0;
-      } else {
-        jv_free(extra);
-      }
-    }
-    jq_teardown();
-    bytecode_free(bc);
-    tests++;
-    passed+=pass;
-  }
-  fclose(testdata);
-  printf("%d of %d tests passed\n", passed,tests);
-}
+#include "execute.h"
 
 int main(int argc, char* argv[]) {
-  if (argc == 1) { run_tests(); return 0; }
   struct bytecode* bc = jq_compile(argv[1]);
   if (!bc) return 1;
 

From 04e85e11de6e13cb4dbb3ec30637d762412806e9 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 18 Sep 2012 22:47:19 +0100
Subject: [PATCH 091/284] Print Unicode characters unescaped by default.

---
 jv_print.c | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/jv_print.c b/jv_print.c
index 64bf178a..9e0a8812 100644
--- a/jv_print.c
+++ b/jv_print.c
@@ -32,9 +32,10 @@ static void jvp_dump_string(jv str, int ascii_only, FILE* F, jv* S) {
   assert(jv_get_kind(str) == JV_KIND_STRING);
   const char* i = jv_string_value(str);
   const char* end = i + jv_string_length(jv_copy(str));
+  const char* cstart;
   int c = 0;
   char buf[32];
-  while ((i = jvp_utf8_next(i, end, &c))) {
+  while ((i = jvp_utf8_next((cstart = i), end, &c))) {
     assert(c != -1);
     int unicode_escape = 0;
     if (0x20 <= c && c <= 0x7E) {
@@ -71,7 +72,11 @@ static void jvp_dump_string(jv str, int ascii_only, FILE* F, jv* S) {
         break;
       }
     } else {
-      unicode_escape = 1;
+      if (ascii_only) {
+        unicode_escape = 1;
+      } else {
+        put_buf(cstart, i - cstart, F, S);
+      }
     }
     if (unicode_escape) {
       if (c <= 0xffff) {
@@ -120,7 +125,7 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
   }
   case JV_KIND_STRING:
     put_char('"', F, S);
-    jvp_dump_string(x, 0, F, S);
+    jvp_dump_string(x, flags & JV_PRINT_ASCII, F, S);
     put_char('"', F, S);
     break;
   case JV_KIND_ARRAY: {

From fbf7bc835bfa96800411dc9e7014544779060225 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 18 Sep 2012 23:17:27 +0100
Subject: [PATCH 092/284] More docs + docs cleanup

---
 docs/content/1.tutorial/default.yml |  4 +-
 docs/content/3.manual/manual.yml    | 69 ++++++++++++++++++++---------
 docs/content/index/index.yml        | 19 +++++++-
 docs/public/css/base.scss           | 18 +++++++-
 docs/templates/index.liquid         | 11 +++--
 docs/templates/manual.liquid        |  3 +-
 6 files changed, 94 insertions(+), 30 deletions(-)

diff --git a/docs/content/1.tutorial/default.yml b/docs/content/1.tutorial/default.yml
index 5ba2df15..61ff97ed 100644
--- a/docs/content/1.tutorial/default.yml
+++ b/docs/content/1.tutorial/default.yml
@@ -236,4 +236,6 @@ body:
 
       - - -
 
-      asdf
\ No newline at end of file
+      Here endeth the tutorial! There's lots more to play with, go
+      read [the manual](/manual) if you're interested, and [download
+      jq](/download) if you haven't already.
\ No newline at end of file
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 20793976..417432b4 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -1,13 +1,40 @@
 headline: jq Manual
+body: |
+
+  A jq program is a "filter": it takes an input, and produces an
+  output. There are a lot of builtin filters for extracting a
+  particular field of an object, or converting a number to a string,
+  or various other standard tasks.
+
+  Filters can be combined in various ways - you can pipe the output of
+  one filter into another filter, or collect the output of a filter
+  into an array.
+  
+  Some filters produce multiple results, for instance there's one that
+  produces all the elements of its input array. Piping that filter
+  into a second runs the second filter for each element of the
+  array. Generally, things that would be done with loops and iteration
+  in other languages are just done by gluing filters together in jq.
+
+  It's important to remember that every filter has an input and an
+  output. Even literals like "hello" or 42 are filters - they take an
+  input but always produce the same literal as output. Operations that
+  combine two filters, like addition, generally feed the same input to
+  both and combine the results. So, you can implement an averaging
+  filter as `add / length` - feeding the input array both to the `add`
+  filter and the `length` filter and dividing the results.
+
+  But that's getting ahead of ourselves. :) Let's start with something
+  simpler:
+  
 sections:
   - title: Basics
-    body: "{ some *intro* text \n\n\n}\n"
     entries:
       - title: "`.`"
         body: |
           
-          The absolute simplest (and least interesting) jq expression
-          is `.`. This is a jq expression that takes its input and
+          The absolute simplest (and least interesting) filter
+          is `.`. This is a filter that takes its input and
           produces it unchanged as output.
 
           Since jq by default pretty-prints all output, this trivial
@@ -22,7 +49,7 @@ sections:
       - title: "`.foo`"
         body: |
           
-          The simplest *useful* jq expression is .foo. When given a
+          The simplest *useful* filter is .foo. When given a
           JSON object (aka dictionary or hash) as input, it produces
           the value at the key "foo", or null if there\'s none present.
 
@@ -75,11 +102,11 @@ sections:
       - title: "`,`"
         body: |
           
-          If two jq expressions are separated by a comma, then the
+          If two filters are separated by a comma, then the
           input will be fed into both and there will be multiple
           outputs: first, all of the outputs produced by the left
           expression, and then all of the outputs produced by the
-          right. For instance, jq expression `.foo, .bar`, produces
+          right. For instance, filter `.foo, .bar`, produces
           both the "foo" fields and "bar" fields as separate outputs.
 
         examples:
@@ -97,7 +124,7 @@ sections:
           
       - title: "`|`"
         body: |
-          The | operator combines two jq expressions by feeding the output(s) of
+          The | operator combines two filters by feeding the output(s) of
           the one on the left into the input of the one on the right. It\'s
           pretty much the same as the Unix shell\'s pipe, if you\'re used to
           that. 
@@ -135,7 +162,7 @@ sections:
           expressions are collected into one big array. You can use it
           to construct an array out of a known quantity of values (as
           in `[.foo, .bar, .baz]`) or to "collect" all the results of a
-          jq expression into an array (as in `[.items[].name]`)
+          filter into an array (as in `[.items[].name]`)
         
           Once you understand the "," operator, you can look at jq\'s array
           syntax in a different light: the expression [1,2,3] is not using a
@@ -143,7 +170,7 @@ sections:
           the `[]` operator (collect results) to the expression 1,2,3 (which
           produces three different results).
 
-          If you have a jq expression `X` that produces four results,
+          If you have a filter `X` that produces four results,
           then the expression `[X]` will produce a single result, an
           array of four elements.
 
@@ -161,7 +188,7 @@ sections:
           the quotes can be left off. The value can be any expression
           (although you may need to wrap it in parentheses if it\'s a
           complicated one), which gets applied to the {} expression\'s
-          input (remember, all jq expressions have an input and an
+          input (remember, all filters have an input and an
           output).
           
               {foo: .bar}
@@ -222,7 +249,7 @@ sections:
       - title: Addition - `+`
         body: |
 
-          The operator `+` takes two jq expressions, applies them both
+          The operator `+` takes two filters, applies them both
           to the same input, and adds the results together. What
           "adding" means depends on the types involved:
 
@@ -435,7 +462,7 @@ sections:
       - title: Alternative operator - `//`
         body: |
 
-          A jq expression of the form `a // b` produces the same
+          A filter of the form `a // b` produces the same
           results as `a`, if `a` produces results other than `false`
           and `null`. Otherwise, `a // b` produces the same results as `b`.
 
@@ -474,7 +501,7 @@ sections:
       - title: Variables
         body: |
           
-          In jq, all jq expressions have an input and an output, so manual
+          In jq, all filters have an input and an output, so manual
           plumbing is not necessary to pass a value from one part of a program
           to the next. Many expressions, for instance `a + b`, pass their input
           to two distinct subexpressions (here `a` and `b` are both passed the
@@ -520,9 +547,9 @@ sections:
           
               .realnames as $names | .posts[] | {title, author: $names[.author]}
           
-          The expression "asdf as $x" runs asdf, puts the result in $x, and
-          returns the original input. Apart from the side-effect of binding the
-          variable, it has the same effect as ".".
+          The expression "foo as $x" runs foo, puts the result in $x,
+          and returns the original input. Apart from the side-effect
+          of binding the variable, it has the same effect as ".".
           
           Variables are scoped over the rest of the expression that defines
           them, so 
@@ -543,7 +570,7 @@ sections:
       - title: 'Defining Functions'
         body: |
           
-          You can give a jq expression a name using "def" syntax:
+          You can give a filter a name using "def" syntax:
 
               def increment: . + 1;
           
@@ -553,7 +580,7 @@ sections:
 
               def map(f): [.[] | f];
 
-          Arguments are passed as jq expressions, not as values. The
+          Arguments are passed as filters, not as values. The
           same argument may be referenced multiple times with
           different inputs (here `f` is run for each element of the
           input array). Arguments to a function work more like
@@ -597,7 +624,7 @@ sections:
       - title: "`=`"
         body: |
           
-          The jq expression `.foo = 1` will take as input an object
+          The filter `.foo = 1` will take as input an object
           and produce as output an object with the "foo" field set to
           1. There is no notion of "modifying" or "changing" something
           in jq - all jq values are immutable. For instance,
@@ -621,7 +648,7 @@ sections:
       - title: "`|=`"
         body: |
           As well as the assignment operator '=', jq provides the "update"
-          operator '|=', which takes a jq expression on the right-hand side and
+          operator '|=', which takes a filter on the right-hand side and
           works out the new value for the property being assigned to by running
           the old value through this expression. For instance, .foo |= .+1 will
           build an object with the "foo" field set to the input's "foo" plus 1.
@@ -670,7 +697,7 @@ sections:
           When jq encounters an assignment like 'a = b', it records the "path"
           taken to select a part of the input document while executing a. This
           path is then used to find which part of the input to change while
-          executing the assignment. Any jq expression may be used on the
+          executing the assignment. Any filter may be used on the
           left-hand side of an equals - whichever paths it selects from the
           input will be where the assignment is performed.
           
diff --git a/docs/content/index/index.yml b/docs/content/index/index.yml
index f0e7196e..03331f0a 100644
--- a/docs/content/index/index.yml
+++ b/docs/content/index/index.yml
@@ -2,11 +2,26 @@ headline: jq
 
 blurb: |
   
-  jq is a command-line JSON processor.
+  jq is a lightweight and flexible command-line JSON processor.
   
-body: |
+body1: |
 
+  jq is like `sed` for JSON data - you can use it to slice and filter
+  and map and transform structured data with the same ease that `sed`,
+  `awk`, `grep` and friends let you play with text.
 
+body2: |
+
+  jq is written in portable C, and it has zero runtime
+  dependencies. You can download a single binary, `scp` it to a far away
+  machine, and expect it to work.
+
+body3: |
+
+  jq can mangle the data format that you have into the one that you
+  want with very little effort, and the program to do so is often
+  shorter and simpler than you'd expect.
   
+tail: |
   Go read the [tutorial](/tutorial) for more, or the [manual](/manual)
   for *way* more.
\ No newline at end of file
diff --git a/docs/public/css/base.scss b/docs/public/css/base.scss
index 6ac3a055..eafd7d02 100644
--- a/docs/public/css/base.scss
+++ b/docs/public/css/base.scss
@@ -59,13 +59,29 @@ section {
 
 
 #blurb {
-    padding-top: 20px;
+    padding-top: 40px;
+    padding-right: 50px;
 }
 
 #blurb p {
     font-size: 20pt;
 }
 
+#blurb .btn-group {
+    margin-top: 20px;
+}
+
+#multiblurb {
+    line-height: 1.7;
+    text-align: center;
+    font-size: 12pt;
+}
+
+#multiblurb code {
+    border: 0;
+    font-size: 12pt;
+}
+
 h3 code {
     border: 0;
     font-size: 20px;
diff --git a/docs/templates/index.liquid b/docs/templates/index.liquid
index f9fc945c..39ee0c5a 100644
--- a/docs/templates/index.liquid
+++ b/docs/templates/index.liquid
@@ -27,10 +27,13 @@
         </div>
       </div>
         
-      <div class="row">
-
-
-	{{body | markdownify}}
+      <div class="row" id="multiblurb">
+	<div class="span4">{{body1 | markdownify}}</div>
+        <div class="span4">{{body2 | markdownify}}</div>
+	<div class="span4">{{body3 | markdownify}}</div>        
+      </div>
+      <div class="row" style="text-align:center; margin-top: 30px">
+        {{tail | markdownify}}
       </div>
     </div>
     {% include "shared/footer" %}    
diff --git a/docs/templates/manual.liquid b/docs/templates/manual.liquid
index b3eb2e2f..af22fcad 100644
--- a/docs/templates/manual.liquid
+++ b/docs/templates/manual.liquid
@@ -2,7 +2,7 @@
 <html lang="en">
   {% include "shared/head" %}
   <body id="{{slug}}" data-spy="scroll" data-target="#navcolumn" data-offset="100">
-    {% include "shared/header" %}	
+    {% include "shared/header" %}
     <div class="container">
       <div class="row">
         <div class="span3" id="navcolumn">
@@ -46,6 +46,7 @@
         </div>
         <div class="span9">
           <h1>{{headline}}</h1>
+          {{ body | markdownify }}
           {% for section in sections %}
             <section id="{{section.title | sanitize}}">
               <h2>{{section.title}}</h2>

From 5863160112ac8b50f8b7b7da60044a78f8f261de Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 18 Sep 2012 23:32:24 +0100
Subject: [PATCH 093/284] Implement the 'add' builtin promised by the docs'
 examples.

---
 builtin.c                        | 20 +++++++++++++++++
 docs/content/3.manual/manual.yml | 37 ++++++++++++++++++++++++++++++++
 testdata                         |  4 ++++
 3 files changed, 61 insertions(+)

diff --git a/builtin.c b/builtin.c
index f291a95e..1eee5bb5 100644
--- a/builtin.c
+++ b/builtin.c
@@ -90,6 +90,25 @@ static void f_divide(jv input[], jv output[]) {
   }  
 }
 
+static void f_add(jv input[], jv output[]) {
+  jv array = input[0];
+  if (jv_get_kind(array) != JV_KIND_ARRAY) {
+    output[0] = jv_invalid_with_msg(jv_string_fmt("Cannot add elements of an %s",
+                                                  jv_kind_name(jv_get_kind(array))));
+  } else if (jv_array_length(jv_copy(array)) == 0) {
+    output[0] = jv_null();
+  } else {
+    jv sum = jv_array_get(jv_copy(array), 0);
+    for (int i = 1; i < jv_array_length(jv_copy(array)); i++) {
+      jv x = jv_array_get(jv_copy(array), i);
+      jv add_args[] = {jv_null(), x, sum};
+      f_plus(add_args, &sum);
+    }
+    output[0] = sum;
+  }
+  jv_free(array);
+}
+
 static void f_equal(jv input[], jv output[]) {
   jv_free(input[0]);
   output[0] = jv_bool(jv_equal(input[2], input[1]));
@@ -185,6 +204,7 @@ static struct cfunction function_list[] = {
   {f_equal, "_equal", CALL_BUILTIN_3_1},
   {f_length, "length", CALL_BUILTIN_1_1},
   {f_type, "type", CALL_BUILTIN_1_1},
+  {f_add, "add", CALL_BUILTIN_1_1},
 };
 
 static struct symbol_table cbuiltins = {function_list, sizeof(function_list)/sizeof(function_list[0])};
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 417432b4..10998dce 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -321,6 +321,43 @@ sections:
             input: '[[1,2], "string", {"a":2}, null]'
             output: [2, 6, 1, 0]
 
+      - title: `map(x)`
+        body: |
+
+          For any filter `x`, `map(x)` will run that filter for each
+          element of the input array, and produce the outputs a new
+          array. `map(.+1)` will increment each element of an array of numbers.
+
+          `map(x)` is equivalent to `[.[] | x]`. In fact, this is how
+          it's defined.
+
+        examples:
+          - program: 'map(.+1)'
+            input: '[1,2,3]'
+            output: ['[2,3,4]']
+
+      - title: `add`
+        body: |
+
+          The filter `add` takes as input an array, and produces as
+          output the elements of the array added together. This might
+          mean summed, concatenated or merged depending on the types
+          of the elements of the input array - the rules are the same
+          as those for the `+` operator (described above).
+
+          If the input is an empty array, `add` returns `null`.
+
+        examples:
+          - program: add
+            input: '["a","b","c"]'
+            output: ["abc"]
+          - program: add
+            input: '[1, 2, 3]'
+            output: [6]
+          - program: add
+            input: '[]'
+            output: ["null"]
+            
       - title: `tonumber`
         body: |
 
diff --git a/testdata b/testdata
index 7357ccb2..8a289973 100644
--- a/testdata
+++ b/testdata
@@ -211,6 +211,10 @@ null
 null
 [1,2,3,4]
 
+map(add)
+[[], [1,2,3], ["a","b","c"], [[3],[4,5],[6]], [{"a":1}, {"b":2}, {"a":3}]]
+[null, 6, "abc", [3,4,5,6], {"a":3, "b": 2}]
+
 #
 # User-defined functions
 # Oh god.

From 305059ff9f630b7fb140ef61fab5613483a75ff0 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 18 Sep 2012 23:37:46 +0100
Subject: [PATCH 094/284] Usage messages if jq is run with no arguments.

Beats segfaulting.
---
 main.c | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/main.c b/main.c
index 776c9575..92a7c652 100644
--- a/main.c
+++ b/main.c
@@ -8,7 +8,20 @@
 #include "parser.h"
 #include "execute.h"
 
+static const char* progname;
+
+static void usage() {
+  fprintf(stderr, "\njq - commandline JSON processor\n");
+  fprintf(stderr, "Usage: %s <jq filter>\n\n", progname);
+  fprintf(stderr, "For a description of how to write jq filters and\n");
+  fprintf(stderr, "why you might want to, see the jq documentation at\n");
+  fprintf(stderr, "http://stedolan.github.com/jq\n\n");
+  exit(1);
+}
+
 int main(int argc, char* argv[]) {
+  if (argc) progname = argv[0];
+  if (argc != 2 || !strcmp(argv[1], "--help") || !strcmp(argv[1], "--version")) usage();
   struct bytecode* bc = jq_compile(argv[1]);
   if (!bc) return 1;
 

From 3898f744dc624782ce21ef287b452183425154eb Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 18 Sep 2012 23:40:19 +0100
Subject: [PATCH 095/284] Add a README

---
 README.md | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 README.md

diff --git a/README.md b/README.md
new file mode 100644
index 00000000..8f7b240d
--- /dev/null
+++ b/README.md
@@ -0,0 +1,14 @@
+jq
+==
+
+jq is a command-line JSON processor.
+
+If you want to learn to use jq, read the documentation at
+[https://stedolan.github.com/jq](https://stedolan.github.com/jq). This
+documentation is generated from the docs/ folder of this repository.
+
+If you want to hack on jq, feel free, but be warned that its internals
+are not well-documented at the moment. Bring a hard hat and a shovel.
+
+You can find some basic build instructions at
+[https://stedolan.github.com/jq/download](https://stedolan.github.com/jq/download)

From 134b062be7cf2b62d0e69772836e6312fd9e60d5 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 18 Sep 2012 23:45:30 +0100
Subject: [PATCH 096/284] Fix a parsing bug for \uXXXX escapes (some invalid
 escapes were accepted).

Found by gcc -O -Wall identifying a use of uninitialised variables.
---
 jv_parse.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/jv_parse.c b/jv_parse.c
index e4565ef7..63cdf935 100644
--- a/jv_parse.c
+++ b/jv_parse.c
@@ -155,6 +155,7 @@ static int unhex4(char* hex) {
     if ('0' <= c && c <= '9') n = c - '0';
     else if ('a' <= c && c <= 'f') n = c - 'a' + 10;
     else if ('A' <= c && c <= 'F') n = c - 'A' + 10;
+    else return -1;
     r <<= 4;
     r |= n;
   }
@@ -186,7 +187,10 @@ static pfunc found_string(struct jv_parser* p) {
         /* ahh, the complicated case */
         if (in + 4 > end)
           return "Invalid \\uXXXX escape";
-        unsigned long codepoint = unhex4(in);
+        int hexvalue = unhex4(in);
+        if (hexvalue < 0)
+          return "Invalid characters in \\uXXXX escape";
+        unsigned long codepoint = (unsigned long)hexvalue;
         in += 4;
         if (0xD800 <= codepoint && codepoint <= 0xDBFF) {
           /* who thought UTF-16 surrogate pairs were a good idea? */

From 71ab537ee924e0490cde43da6e678963618deea0 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 18 Sep 2012 23:46:23 +0100
Subject: [PATCH 097/284] Initialise some variables to keep gcc happy.

---
 compile.c | 2 +-
 jv_dtoa.c | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/compile.c b/compile.c
index 719a2706..fe50c70a 100644
--- a/compile.c
+++ b/compile.c
@@ -527,7 +527,7 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
       int nargs = curr->imm.intval;
       assert(nargs > 0);
       code[pos++] = (uint16_t)nargs;
-      int desired_params;
+      int desired_params = 0;
       for (int i=0; i<nargs; i++) {
         curr = curr->next;
         assert(curr && opcode_describe(curr->op)->flags & OP_IS_CALL_PSEUDO);
diff --git a/jv_dtoa.c b/jv_dtoa.c
index 2c27c880..b200c462 100644
--- a/jv_dtoa.c
+++ b/jv_dtoa.c
@@ -2120,7 +2120,7 @@ bigcomp
  (struct dtoa_context* C, U *rv, const char *s0, BCinfo *bc)
 {
 	Bigint *b, *d;
-	int b2, bbits, d2, dd, dig, dsign, i, j, nd, nd0, p2, p5, speccase;
+	int b2, bbits, d2, dd=0, dig, dsign, i, j, nd, nd0, p2, p5, speccase;
 
 	dsign = bc->dsign;
 	nd = bc->nd;

From c463877e17fee6b5a82a235c98adbccbebbda96e Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 19 Sep 2012 00:08:02 +0100
Subject: [PATCH 098/284] Add binaries and update download docs.

---
 docs/content/1.tutorial/default.yml     |   2 +-
 docs/content/2.download/default.yml     |  11 ++++++++---
 docs/content/2.download/linux_x86_64/jq | Bin 0 -> 447776 bytes
 docs/content/2.download/osx_64/jq       | Bin 0 -> 185432 bytes
 docs/templates/index.liquid             |   4 ++--
 5 files changed, 11 insertions(+), 6 deletions(-)
 create mode 100755 docs/content/2.download/linux_x86_64/jq
 create mode 100755 docs/content/2.download/osx_64/jq

diff --git a/docs/content/1.tutorial/default.yml b/docs/content/1.tutorial/default.yml
index 61ff97ed..f41e5aae 100644
--- a/docs/content/1.tutorial/default.yml
+++ b/docs/content/1.tutorial/default.yml
@@ -1,7 +1,7 @@
 headline: Tutorial
 body:
   - text: |
-    
+
       Twitter have a JSON API, so let's play with that. This URL gets
       us the last 5 tweets about JSON:
       
diff --git a/docs/content/2.download/default.yml b/docs/content/2.download/default.yml
index 03c9cb7f..9d69780a 100644
--- a/docs/content/2.download/default.yml
+++ b/docs/content/2.download/default.yml
@@ -7,13 +7,18 @@ body:
       possible to build it for nearly any platform. Prebuilt binaries are
       available for Linux (64-bit x86) and OS X.
     
-       * [Download binary for 64-bit Linux](/download/linux/x68_64/jq)
-       * [Download binary for OS X](/download/osx/64/jq)
+       * [Download binary for 64-bit Linux](/download/linux_x86_64/jq)
+       * [Download binary for OS X](/download/osx_64/jq)
        * [Download source](/download/source/jq.tgz)
 
+      The binaries should just run, but you may need to make them
+      executable first using:
+
+          chmod +x jq
+       
       jq is licensed under the MIT license. For all of the gory
       details, read the file `COPYING` in the source distribution.
-       
+
       Hacking on jq
       =============
 
diff --git a/docs/content/2.download/linux_x86_64/jq b/docs/content/2.download/linux_x86_64/jq
new file mode 100755
index 0000000000000000000000000000000000000000..5a36b20225b33a60951fd05781a166fce908e17a
GIT binary patch
literal 447776
zcmd443wTu3^*20|1c?}&K~ds;)UgHyjf$EG=nR>_i3W`VnyN@JN}(X8Fi})4!AUB|
zF-lvtv|3BG?Vn!$ma65dBoIjOR)d!owMuGH_YhD7g%pbUe!sQ%naqTlkiOshe9sqU
z&e{8{wf4I0wXbKN1;wSKGu&>M^Oxbe(#2G3PC&Bsugg_2?<h(0C*Ue@W#jiduCrat
z?IU@7!e@b`Yoj6UT(jk=%aw_17Vk4mMn*v2nCq!J<#MhLhrF`9uD^h})z^VLHKcQO
zxqR}Rxgx=C{oJ*CvgAA0d|}4r+H9^49@!&auEEPSc+R!WkaMn%d?dqvryBWA%?KdH
zbbuFENPfGnPO)X5hVS70)YY2s)YU<Obgl!B)`-s4!Mh%KT^2ILd$>4!UN~dg?UxO^
zaK;@&XH1(}J!j~gg3E?pHtd4gcVBR^@b3i;ax&)H2|~@$$H_>s?1A`4Tk`p~SKiuj
zVx{$;<p)n+{kQv$v5xWGcJ=@~I}`s1&p#jj9m5;^4Z^=%{5uZ+PQpL_orZsX@sDNF
z_9x)q@%WeSk7e`kbbWzecKuNwXW*aXVtjHe{^jrnfAk~rN0s)&Kg#OCKgx6>{_*b=
zeGysv<DTWQEb=G%cKcj4Zf^$jSQh^VpZ3V9QzlII7Ve2U?yDap{IbeX?(Tp2$Vinx
zB~AWUY4XRX$zPu)|DiPb2h!w^PLsbRP5!xQ^0%eQzc)>OMVkC)(&TSVlmG8D`M0FW
zr@ejn*ZprkGE&*=#WeZ9Nt6Fpn*4$^`7LSkJJRISH&gM+dYLMJO`7~4A%6gBbN<(p
zap#KHw*c;$U(hZ8k0w9RE#Eb1()aGVd*-Cs;mNbYlP0+khAJ6#E_2;EXIj`byK2_7
znc*pbnjM~XM|G8}sybXbb@D9NtUD*qm~nTdYj*gKX*2P7^6c4ng20r?(`LA)&7K?%
z-{+cg=iO6WQ@(d+cs8EjIcwI;yC(r-a(LR^GhKJxc~|9KRj$ezcTS##N3MHj&om{0
z;N8_>*Ax~cU{&|I?uwU1*eTOy+&S}Z*OYr_O$*=YngUMlAmCkh-*cyHQpt6bP$K!7
z#R4WxqCiHvyC#FxDIjq-3Y=of1OA<^F{LG=iY8rr!NnI`3O!}?;=i7tKmu{eEpd#o
zjDOW9PeXXia2-Vl#$U%*+HQ<piE-7jCu1UGne*q^lle}3<1@#e%=a<F{N?V^^qm;)
z<ogox6XS7SLcSBriIbm@@3e8uFG$E|+0I`eAz$LMd0-{vlPBk|EFnL!%_vXEH%+ae
zR3zlHt#JOPCgeNq8lP1q<U8#R^XDYwvpsSCY7+9<Mmc|r67tzLIe&{2@*P|A*^-2O
zwr$Se(uDlP`o1h7pY5LWw>%-AZLssVDk0x#Bl)Z`A)oEK^S3!6KiA2`wKXB%Y5Vzj
zYeK%$XJCF?LcY@`GhZd-CpNab6Y|-oaQ>{w&TN$l540j1vzuJ5&Py{sKhxEDP8NPW
zX9RG^^i+b!+B)%f&VkR6X6=c!N_r2|bm3T|q<1h)*NrWg^e0TyWn)Vv{Q=W-)!1T5
zzs)pVG*%<&*O;bj#;PQ}foZyAtU}Ujn5HYn$|U^)({#aDK+?Zwnyweim-Mqt)8%45
zN&lQ_x?0RD=^ryq7mK+h{V>yXt=R5wk#Ww0Ow*-eZIZs9X}VIZRnoJVrVGUyCH;M-
z8A@WyC4D>7bfwr*N#D#gT`0C#(l;<o*NN3g`f8@>GO;R2k7Amx604B(6-?7bVr7!P
zm}$C3EFkIgn5Ij_@{zu1SBbslHp~9RifrFqHol~#(fhri%W7HglS|8El|h$k0pQn*
z7t<H4XrHgPpXsvd8p9c#t>P4m6aQ9Sj)rT3HI(tuigX-n*`MB<F|lbC$`hooCpPd=
zXPf7Y8s@EH%7I_skqLOq-e9fYah2t6wd`hV%eU3QXY&gDx5EzpCkDS}<ewprt9rl$
zV5<2r$i(J8&mhaaw~78~MMjo?0)X%-aTW$lXz*fG0{G6>iLnQO61xXKT8hGZa~GUO
zL02!H8FZ}~hGN%kgen^TiXZjpq0UY#dXv|x+!qbKkad363r)eBf;R>y1jkPpXD!^h
z72qZIe@g8AmR;&ED78cWKq>C5+Q#tZp1~o1nP+gRzrr(kyuZpb_-TI);5~zX?O!a{
zKl+!-^(FsuxxVag#MQF@HrD>OWc?SumXJT2hQ>7~pHJ#*{a!aALVmARAM*QnmuuCJ
z_rp#jfAr~@F7*%L_|iJuH?R_@5C7BI8H{vxR{N}I|Cz{MLtk76GOmVgl<@;##10@?
zJbbP{d)}au=y<<(Ez&O0U}*ULS@ZMSPg-3?{R~02*3Vwz&IIvDliR9n3Jst8VAg`Y
z!NObpxeE;Ng>hg}W)Q%k=#U3XDtDD+4)NO`m)f7Jxo|bhj@cX5Wln`3Mn}HB{Y+i3
z`Vryn1EIk?Rxeo<bgesD1N=S?P$d9|iVMG8a7z1mR`k-x@TlQ7l&U^G2*x(KLxtbW
z8=wn19tDNms!%QX8zAo_r08cYAgzTPX~|nA25${c4Bi%;)C7;ni+qt4`SudeL+yBE
z@9Xq`v-JDqFvGI5{8n^SHkA*(kMfE=)Wh$giZuW>J;?V6@^p_NA%L{cwW3#8(OKE*
z=_;gVI;lsQs&G;@Ox@t5W-%3VQg<+QnUlJasXQlTF?F(&x`L@3Cp82q)bTvZKgY7?
z(!;|3Jj;el(8F^Z7?{<wH_{2A1>}nw0=%=V=v;tB!~R@#Evx`X?gD~S1*|A)hGn;?
zOK;)REnQC$0f6fxZk`&%r;&|w3=>Y#>cGTqrRKBLf`n4HCPOq^^>h9CYTV6mbp~{`
zV?q)I^ZXJ#x1u3`z6B-=q-56Z#k5lj6$B$4L&G=ocfqmvJuiF`e$TJYYrhKD3&Y0+
z7k2bP?W!Kse(c&);j-<QtR2Y9khT4JIcN22b5W7%L4DmN$Y>aWA9c>ZJ3H47<?}vk
zzk`cZJ+%^})C47wMMq+ztIuvtf-n+I{w^ho8)JP+pb-SJKW;dInpsqyOs9bjm|7zs
zaXTC8nL<6TuZ0__sau-H!Dp&Mb`x3D&O+^h<FLP=f#F6?PZr0JdkIC?eHgw{i@b3h
z8R>GIpuLr5fm^}*=sS}oV8nT1Bt(I^bR7WkPK<sV1%e7-RFtn`laP#Tth%MC=E}3G
zZ?^2Oq&Uxt>)ka6&JCB~XF=bZ17}qaXuqW9z>si3&4F7zXN1s>9A!n;yW9I)_19<A
z+?R1{_33ony3X)Xo)rTY4eV=08r|)ym@%?BtFH^vcOX%Hs%7t&640`ut?AtJytRLe
zRUhmGz-G^i6Bi+VTW%}T?5=&gdZ#tGV{c-^64@EB>=CG5VSjds{jUAGRk_}Z4%yTO
z&#~+;7-U@P5|AyiTOtR)_0+zNj1o^nmOtcK`D<4rB6ZNyu+g$-_`Q*iHJ;k%pntn*
z|A%#r(y)3;K6vE;bkPQHiX0lcYABFB*QvsGPyGXcL*o;Ch4w1;G;AMLKk#g;a)YO#
z*5&#^&{ep#dUT}29S&NRZ%>K5e4Oi^plfsZl3?UeA5ZO-K(dxt(P6@8N#!Q+ztI~+
z7}g9w2+NhYn>`O63qZ6Qg&!?g8nSm0`QCmZTXp(31!e?Y$dcBleRzr8{0jJRwP!M~
zn6=|v-rc~v)7G}l$K}Me-UYaL)>^z|^YL=zTlTiY)L&9R{@Bh{?3tDp?(saR<1id)
zxc8pHR(;lSR^f(wkF}x$q4$hcQ~={Jp0`LpQ0IJ~E|y&yJu9d=8#dyc>b#l<+_S6C
z3Ks5~cN(RR8mZa5u>(=!-e^UdGTO6CA{$}yCbwrrW^hrKzqYY@y)fB6P`GOE57mq2
zV<*A3aMwU`i-b_SIg;TnwO?H`6DqKxm!m=m1vO>AAY><c(ZZdZAw-FNsKox7btJFE
z{_9w~rPO}YvUil)pOxBQs&CJyV~oszxYZYyP+GgzUjww@>NzN)#8##Dzf0{s5}B>~
zm*tsaN4$N_$U(pgA2Tuw7f;<o_$`SRL-U$INpx&>Npu2gCyAD_oj^5KHO;8)jh?#l
zICz#HXwr%Rz8LV*xp~>Y6kMp2-()qem4r~j{W3f-ZEvmgoD9lbe}#JM6T*l56&g6?
zpK2gO{we`eotxl%9et`TEiJleJ;VR<RqAkkcTLRom#JxR==O8tbb_lNPN6aavLoJe
zDPtk0)?O-gs0*kD#x-s2k01l-<(Jq{IBp7XgRTgApSbZNWG>uD+b6hBQn$4OGZ<aL
znT9E+i7Kr6TGIus^|K_aMJu>Q?m?YIOW_3-uwE&mdsS)uOa7%8oRuO}m6g{2(O+>g
zBgjs4S!V#&CA9>Jsn9@YDdLf@J*y<LDPu~|z6+eAQ&3VL8vkuc;U>?6*9%cqI=Ic+
z(!sb&gXLKZ4|vXngFW<{Q^<6y<!-b_dXck+KbB{7EBO!b$@;cFP*T|i>Zg04Z?r^k
zwAz`17V^(2MQe~Z)(tKW!1>vfcmY<5<{>cFy|1MH#z7^o{NeZd57bKbe~M8_76QW!
z_=m6^Vh0DcsMLMHTK`EVYeX5Ty!I8SWP-}o^;zF=oCeGi`@NF&yRxpS4{0eakk~*H
za5j)|@Zpjz>S5v!zr*hfXES0vwOjj2o)uAUt9~H#J>+=HjSdnzPo?$4wvYl;JwkE<
z7zSJ;>WjPx%~KUs^aD!@E3y9(Idqn%_Sbw=xyjS;w6qP8gJ=@itBuTsVXB9gf^<bG
zu*z9T0Sm~tVA$PM9jwiT2K5~J$q-;Faa{9HlZdqt_b0<@_nu-^;*n=XP21gw!u`cd
zX?41QyJ_LU`w?~TooiLT<7s&OIB7^WRNrM)eh7|EVH;BS;e!5=gPT3I|HQy||A+0B
zC}oB_GTuJ}^`=%BD6vPQk+1b<gBjfWc<<Hs=-So_vnBSJ?6LI=@b8{n`y<EgVo{EX
zApVLat_N6_r}lmngF%aD#j>Ty33yh#C*gf?E84I6Ecj$rvlT^5dc+@qcvjSsdrR&E
zUJD_v4EGqGo($Yg*8Z)*Xs9Kd?i!5Vlm#PL?I+2T^=+95pw{5^(O?!I<DV5dc$Md&
z5_G%lt!VP9(BzdwkJ3uFGfJYPQP!yJSRMc*zm$C_x6Th{$GphbQQ&7+gEg=sEZUFz
z$zJR$%q)~dPb`UEi)cDul|=8^t(vb(0l4{az~HJH*h_tSeG2fO0bKXuev_hD6tk!#
zdgEex3)xZIt|c3+n~Z0px6&QK(C9Yac-7S#SwwR~AC^~G$^^Q6y5X=O$|B@5?Sp}t
z&ZD8VRKZo8J7UEdY51&>bQe;-K`M|ddYOi&YkKDCwHB!F1q_ZM2=sRCZs>0n1Zx}{
zJ!&k}sVXZpQ%U+>2n5ueJTS{{FscsueH^#J)r-(2VYRAYwL;yJ!Ah8Q>tz8}c^&8-
zL`N&fin!m+d$HuXpsY21Nr^7F22>NZqem!@`<EcUBzhV6&W@A5Z7i_a*HPbCsj&k_
zO;(qhNKpBK39(y2Zfl&JCr<9SX~>lsa^>B~y+`XtwZK;NC1F<GJYMsZq{_=M=IC-=
zlz-1w^~S9!0Q;u^thqS_;C4*Qb*K2kgcN{l0jMigXbc~xbjAuJ;Z$4=Rl4D1A&9~3
z;qF^yFy;uxd=V)q<zUWBy)La(xB7e0;Vf$m^>ixmjKjgz->*p_;rre=)9`Dp+{;tN
zh2@6>23Mh%=u)4vWrCDRMq8K`d?(tq!@zGy1wNG2?NrpyP7D5MD(YWjnzoz0gR9OX
z_489v-;@?SKNa;SQ-NPd>TiCTLe%f21%EpgGX<%@Igz05PDTA_0Z$V;c4D@JZHF-y
z!V20H6INRBtO20~Q-v7b$}G&`j$30Kcae5nX-4R>b9)tuMz1nqztIW%n|0V9w+<yn
zAD7@~MIVt^z-EB6-Kt4yUb1_E^K`UM*?@4J85hQrUYNy3m?hnW`BR!mw$#8c6Zp|f
zjWEj`VU}xQeu%y;nMcFuQdat~vD}bbg{y91sRAhkDqtauB2}hUtpT<4G5&{D92iQQ
z`olSLtDDst&C=eNd(dy?Xj1O3-y=}`OCvogtqz{V<JkNhOl5I~maRo2<WZx94~!*5
zxGc<;*7`Tgz08=_`ddxHt7is&JnC@PV&{UaII;8~;J{i`uZXJgZWg?hp|?#+c-*gW
zbvi;ij?s@#-I=1ot~f?yRaDYan89g{m*IZh&oQ*qQ)Ls2HM2FyPPA0345}XYZ<TAa
zo<W-<N>9mQqk-QnSM=ufke6*FOH|(UsBH#S$rXKHBW#BjR(dU6!d}>(LfBXPQNYw4
zo%?S}VU8t&kS5?fAP=2hr*2)!jGmI3iyH(mb!55>&vYZ)a8(Kh205td{o(2W@ltA=
z8>eWkY+RiNke+aSEQNCZh~>m1xZXCyVs|g_nsRb+)xzw#k|n3?QTPmS9<K-rf{dU*
zWCn$MR0`%i!d$ZDRB0;6PqPu~@z15c5*|`2Cg1Q-fNP>+epEyrlEX#pC!lr&#WYJ%
z-SBP^yfn^pr93oam8Vm*0<lv8!Qc`Ak6NkaE2uG)BHZf;W68aVFl8oTB20cNt~T}6
zWGmui!>ct}<}l2%h^dKWtCGpSKay}M+D`$)kVLL6Fuxj+qB@|9i>CF)-69*C`ei{_
zjBDlUsx*`r8_G-M+BLYrl&>rH^-(>TN4-a#p~2$#No_O=>F&Qv4gF=fa>l`0|4&~O
z6DQWuZvj{B8LkCRtkh{8LfyLtOik*MseoY$qgt2B2&7i$a>LXrEwm1;r$ORWx^FbV
zn^Q}W|6fV)7dS-h7kwPJ`;I~GuC-QE=2l#F=W2mKrmS&o23X<hG))XeXNdGEQFa@Y
z4!Lev_Z(Xz={4;iNiC#|F5IUiArIHCj)$;{7(-SWWA>*}qt{^P;@U$utmY+>Y1U2S
zs4LSl<1^&)cx9-QD?***x2Uty#M69(S0Go@sye{QUbp})ce5%hBoE2)rw9JuT?qrf
zj4G$&N^uJ8*e~Lbzmw|md_2}A=u&atNDgEaKRJ%Oqu_AHVx!`ZUr+V;Y$2Vxx$G;?
zlH1&Wh&Ln)ANv^708&Te?4dJd*xMk_(#_N8Ue?#bSxOfR80%QLCJc#-K1tDT-Nd5m
zuf>#5secZ1gqxIeL$^II6ZGLrN}^+SlhMU4PNw`GF5ly1%7>q!P|UH+NxS~8#W^Rv
zIAunh@?>$s|4bpyBDc|M`tHcu%eBS3M~ezm%v4-gK{%KC>t%#Ysp2XFJcn0Q96?6?
zB{J*p4Q-ma?uFDCyhXUCjnFc`0|52Hi=+-+3zly9mdL$nPnVj6X;0hIGrU|NANQ}~
z6$}d_V3>@M;qMrR6Dx1~$gW|#^j?)K6%_WSq^t{=YTaekj~|LoLe_a$2FNTK++1q!
zE*bouwf<8~z#gy$@8Fy;$DF!YOYT`iE!*-jpA)*c&nvCJKN}5So_%#TrtUBmo5OkP
z6_GYf6i3w1pl9V+OdYp+*1h1vYOJSWi+j()12VsTvQ@cf%J4@n<NS7Ye^0|7FXPm9
ztpDdQ&=SwOW#<Dv)(J1g#B?6lLuC3rd=`_a8?N|lI<^~i&8B16lgHU`EV1Q-MY2|E
z@8I-2U55r-P7hiKAGMq68mliTg)n@SuCj1eUp@aXZ2DP%2ohY)byckCdg`7fJ&Zy$
zU9%EY*b?re`fg>_G9_K{zIHePLxEV^NWW^N$@j?0*<@vN52F1Gu3$IyO02&l@I($~
zc<O!)g~n!+=+m+?Kn-SAPou_N3v%RAJu~(cpg1>Mp%*9-Jg^Qn(9iXd0`iQR+DFVP
z$m6mIfi<7JhGr;CefXi+QP#D%ntBJ!61{`7yfge2?f%2F1{{`U*44RMk45^hA1huX
z9Y@-X)%Bz4Nbc$!EWRHtizJN;t}h)v!=LA={Q#y4M$f=1yl2G=0ofHW1IyC3KY@3>
zaNDqz+zth|C6O<3OCq~6N+MroV|Ty=mu!V2({L!R@s>oIQ7c{&K`nch+-J+kau#aH
zOS0O6{JfF~mO8$hjjH`MT*<yZ$KC`No&jfa#eCbb+idmcJ;Z8pzYF25Yw7dtr;&j<
zYhfu@`+&9hb+z{so+OKg`Zj#SI)cWl2P&jgkL6r!`mfB_&_QMRKIrTmTevfPgMBOd
zwb5IR(XfA_*yUNVJg!d5KJ{>Qo;VE@K1LNtR41raH-b<es{&U*OA0sY)x0;~)itMk
zow`81h$rpm8uvWRH)7kcW+f_!9g9dIE4m#BpouHG+=3X{>9g!Zmc7@i$F?ioz&(Tx
zezZE9Z6Rzp&!x6-#At7XkvLannw(qm8SfD3v08=xK&EAn1Bz_2L39cG2Vx6_YG%s^
zr_bfeWIzJ?T<q@RPIs7QAl3n`=x{4KJ6r83aR_G!VWEdAG!WYueB>G{sJHsjL!05>
z&Dw$m-krJFI%(P8sEa8fW7iO}Yk~JQHQ-bAL;H!`6W1)qLJBtR<&JS<q4{%l-`_er
zUvzV0(5V=q(edF!UKEtuv^YAZv^4q{(MzK@1;!R`@kDGSf}Ryeuc4FGz8XHpv*K0H
zih=dMT2QT&n&w*+#8!s0?J-kJ?dz(rJ8lVgytE-V(sA>AAfTQNe4^171kcJxj;?ta
z8&y0F>pd&>gxt;89_nd$>9UF_cE~hWZvgnH`m79+2-IVB4;zTc$b<Jn&b>|8PYSb)
zfv*f~MOP&n@Y!RAvCk3>U~X$nz_K4A`&RTg{%_xu?OEYkG$y~vY8jJ<d@Rb3$u(D>
zxdwP`8Dr@S7F?LZ5(_Woya1=dTrrfEw3k=9CH5?FpRavj-4jny%_B?JIy*2u?{s$R
zMWo;0E;?pBmZa@5<Lesl8=!H%ZK$Y0eOL>@xbx?xifGn@^&uC4O0oLh86MLz#>XNc
zZ+5e}paEtQqIz4#453Y0#*ENFqw~1W7;@j3YYiXK3Lm!jt2fY8LTm6ItRl|vx6ykP
zw-UgQ!s17HmVHq6xV)$4Z9&bnH-)14*e68~=1$*I`|OsY0+wV&i=~KuR&)Z4kk#7W
zM^s=HZVeyXQp5(<)lxK!+(`b|y6xdXbh%64hKshSD?uKc3Vzw>S<z@0<rUl2Aercd
zrEtew?kVuW9rK!^ePM2x8d43=cF$^MqF*$SulGos-*iyJx<h4?ptmVHrT{nMC{6a2
z+JaH7zW$;<$cBQd`!&?iKqo_o_MCk11bo@mof38#VZT7+vF8lau=ac)*z;N7+$MYe
zTo$?*+Ck<zeT_b}#H95V)YTxUN$_Qp^fElxG0Of-T}M}``>^^1_4Zq6LFGL{S$mJ6
z+mC?sS;JCX)n5pPpac<4P|E}o)4?tcSu2n&>j=5b9qvcZs-NQytoUVMUrR<fXG#kv
zb|NhqkuNfklNIjI49UvEre6E2^|4I*RWa~h>kol_%~|1oT@XlTgpZEXK++w~Z0-v~
zUxE!&k3o}&d9w2vyKE@iEfcZ#(LTs+e<!H_{54ss=K!#dg=@J!BD$9AIMph!ak<*>
zNB8*ubD@UI&W>B8g0-=Np>Ey5x-~=BEyU=c{f%Y6hw({60D`EKL<a7zsqW9+h^_RR
zRoEUPTmFi$0do%aNPnTe;<gLBC_5SOF#xs{`K30p+53#O^mOdxwiwWFMO%a_<Yh!h
zJ;Ht=sYmo#^-rkF@hXW}2d(G=)UD3yk=Vx?SedOB=n`4q$lAvZu7zOjG?a)<eEhRo
zihNRXOHnS<F*<=2E%I6QWt~>xxLnVJzeP@@G25zCR{gMD1hVW8)C1y=McpVj9RTI%
zIAEi;*)3}VfQCaJZ5;B2tGfH+j>G+NN0z-M$shM^NOH%08xp;7-v;B1_H=3{8@?yK
z07S||(1fS<L1B0=1Lu3<s={;lCa{@nMMku`!ljTG1Ez8L*n`T<C?FUuqT|r?lqKaw
z#|^W~d;)=>b$l0%Y%8(>+p~y`fA$bazfGNuJ<Kgd97mz@bz==36mV3Oz|kaKI0`OQ
zU=Q^3|9i#^`-XvMv7N#&(B8+Y+g1Is;e(AwD&I!u!-{<C_WZC0Jj2mz=3f4-t9l+T
zow#5VSKQ~%p%2N9vg-b&@c9Bd)<%?Pp+{}mQ_(@H$i_c!OTZ6Wa5Vn9?5Vz%KpyW}
z0=lUS6zG(+c%THg5ks{fuRFgv`qD=(Jyi+w4vJKSL-t;56AsnS%otm_3p{gY=WO~W
zw0aC?FuB2cfv5cp)V7AH<h&m^4|!IE`ny7lvS7^h?!wm>e1U;(b12vCYR<|<KkF02
zT?38A3PtQC#C`*tO(AEOp@VpBLfVxQ?0&ZQuu?$->rrQ%jn6+oBiy1a)*@+xU=Wqu
z7c|{i(}*1-jTrs48k=0VsiPSnjJKB7`{At*z~w(!=L#So1!0^Lc4gtp(gmj6h$Hll
z5pc~97>(9)hb$<~+eb=?Z8kW{HMK~ZspviBg|o-cy*AQ(l0CZ|eLGa|zlccD2PznD
z1|YQ1ZeBP%0$fGAN6Khc6U0l3Dy+x@6_^5G1Zt$ho<f<?qVZPcZYz3CMRZ(gWQW`S
z`}!}>a39!mz#jN#jQs4P@%5phxRe^79cLemblwua4nG*McIH)|Bm2?YFOPIS5I$yM
zC+vi`pcc3HmGy%5Au_Fxw+jY5hPMlz0=w(}gI;q(7K3xkX7uA|uJ%6Cor8<0V_*w=
z>n(?G7`E(pEPD+bcgucZ2`-WQE!2jVQJgJ7qSRI0w`EkRw*CXzu4>q-Pyauk32?;v
z$OB%Tvv;}VAfD(51Sr@;EIOEWxLn6h9e?T(K@u%`w`jH)B)6$IzQ&NU!Q}%#(dh_W
zMfr=0UD2Y_5__j-#RQDla-PsV`Bv^ocY5+gQ!RUXs-8T${yFu!C*SH>`S@|{$$J_O
zcvgJn{x-QEzY*hv`m92y8*gDFJ0^anEPPpT*1D=|^e}-%qJBWq=~Y%`(NrQZuhf37
z1{y1|Q6+bj4*tX*S3rgrjmvMAwV>$%yglN1XbgJdb|ZEIHa-YWw0I;HEt=Z?j1~O@
zO+Y;?{{{wwN}>_wM7^2g3hc5hCpjkz-lo0+%q!e968izDCLqu51@cQo?n~rh$;g-W
z0{LDdXA^lpcBUkh{BM}=NNit0<fDnaCK>tVULYR=%q#tfJTDn}K`)RSiF^!^1Ifsv
zdVw4vat@I*lac%M0(mr%`6fiH8Jk!V6t;Qqkrj3{kv&AVlaZsnKz;)-uk<H!X)^M)
zy+D49$VU;`lZ-r|7sxjd*-PZN`zOi#F7~z^$w^Ki@&F<~k&MjU-bX^-3Yb@pBXW5%
z^3A<Keu~J)6Zw>6<kNbAd>fGm68U5F^b_pdhCOCSV*5-YpFreaB_luA3*_y9L3m&c
z@~q2?O-iOPxfc|k1q>oBNBtYt?>NKVYBz8BHcqmD9pedz)b^%WMl$iNUJx%%U~h%j
z6tjMP><stjEgg}L3{UM?Y{<dQf_|8uuD&pKu_QCYeIp%N)xLJmEAt@PD*nWV;?XN7
zK~Jj&GkH3atFze<a_&brg#FkMu0x-MvGgKrsf%3;s04eIVOQRf?C~S++>8E!jbn6N
zffaqR26tBdTz^1SyiRH%zKOsfjim$JpcBG9|9B_k6}}}C`w)9r5{mo?Y#gb`)1}C#
zSmZh{WZ;ZHOI05|Nm|a{1NMGu&A#an2T^+6Og2kt2KzrAXE4+7hxS_YS7i7bp3L9K
zUhp>`Fzo1HjohVHpriB3iInuKqmv}v`^AwZ9R^B=dz<}11G_qECrHE5ewIx4sb0|i
z2Vh>wAXB#{Bj45w<X-}Y9@B{(W3TXChuENGA}95N$ju~TYT}B3dl9yTH;4R_VLq`d
zr&}wuk+PrY(MWvbD)uC%@DiM8$*v=-_I<!u(J1`}e!I>ueuVd>Rv`m#xl5s%75GDi
zWz(B5$4>7N7pXFSq_?Q4+Mkkx-n^Bi24OsH<DIx3$f^<WOe|^P<$tM3CvNUZ2R)PO
zgTB!#qNS?7Nm`l(`yHvOy~tgGscZM1AIEu0S-YjkLq{bQ*@=C3M=CNvw-VoMOh(?&
z3*^i$ev?8`(-D}>q!*PXmv=)i%KHgmV)vr!k>GtN_X6)0z-S>qM3hKC{%FUMHFP?V
z8DGwa&#D`+Td&ks*7?$^v0V!JN5uQgW;TG6F;Q>i{t>R~v!gfo>~WY~N2yreu+c|1
zK$!7p35<Xu@T4e!VHu|~^6>KNYZ!TA_UD0NR(;MDR^evPLs%NeIspo@GNo9Ia}eaW
zsULA+7ef*b3gRP=zP28DaEUlRx_Au(Y^(BBPs1Ze%NoJv@KAfb$!Nn!!K&QS1-u6@
z1t$(fzN&uD)9`lv4Q{?W#r1^9ftx+GS7VW<H2Pc(c&mHcQ#%WtBN?FB(*t&E>|f|N
znEH-7b%on1?6^mUqq{jA&B12D$ov9V^>NnV%{a6JYrj9n>Rl{=ALMAY7SuJ)A0+X?
zvtpP#uxMBYU&$-PyM~x3h--0REA*UEeY}}8ZyDtSL$25kC>B+|0OrZx-<mlp7nA0X
zajw)E4PpX*9On0iwYDD>l<84ygv!PY)ZhbHj>-#0=KEb?><Jj1ix=SP-d^Cv{wTbS
zmx(h%O7I?7dtbZ-$Qx{+!<e!eGcX^ht#B0N$#ml&ylmSt8gUXO!gum8vQj6~T$OzL
zjt7m<=8h{2Yz41zJ|8W|$atj7$3>&-TDbh)1)0?vnUm)V-)B`~8J>&Ad768x5-*wa
zb?tns?o}KGa9x)}4TMA8kX`D=E3|l%Yf)A|EVH^x3$c)lw~jI9RR>nX8XcIrTZUE6
zNJqcwrr3SBBi~oi=WoM~fsj3WSS$i*)YGddWpfKfgWrG*i_N2df&qxpes(Z&C8oUN
z_@@Iu*n-+l?W4S#Q6AVsTzBMWec_w(nRAc{1+8PXP`9HbyJ(n9r4sLAq>=blBA%Wg
z)H;YfFw9kb5taqvSXk`f{LIJdc(i=M74G(v60uP6AfPKK%eo*zPk~LMvrz}HfwptL
z64hdDj%$y3*6?d{?+I=>01!@~h(W+9O#Uf1?~-F|(@2&lG6xeAqJwhU{^U>5wLmGE
zMZ+Lcl5v*MJk41dP>!Pytjkpr3i%<#=B@`+Q~)JQ7zkqKFpSsRzs(5WR9v?&d_nA1
zbYL+5s5KoA6-iwh^lTf?iDj`*2Ui^7xFVuS5w<}vnwUx*^RZvmouy2OX`;{Z-QcTC
zKWq`@JrB$9uaJ-S8Lte+MY_f9{a%^Kd;Sz`@YL?*Ad+oQ`xvLt^A9VOZl(PfIuhTF
z-OX8cdW3I<tcKOzhKyJ#eh`@#c7O3$rtX{n0u*QBZ#O6YWc^pKnuIZZ|BYoP{szj#
zA4B-?g6h6z8a46&!T}B`p-+9Ge$QD%y}I{H-o_UVWFk+NV$7P`clDYZ<^Zu4SxSGL
zD+tEWEm^Hl1?-D83z;!Q<b!(Qg?h>ghok^fCe1O!w@r=0?h-S<%;PSw<YUSyN-XCx
zmNPI_IUsSH<ZJR+s3Rl7UG;0g;+*1}oNa9>%F~Qtz7fP$>%0od1Cc#kl_&T%^$Z?K
zkiMm9@#0mkpP+T<9CU9EreXOqbRXB^pldIlbo~XL!;2z2E4ciA{^dAv$^NFn2UOh~
zeE6l#&iaXHg5Kks?Vgn*%G7h<8mp>Sv?{xyda46B8Gymayn$}dqx$84oSabkAx@we
zc60s2j3D0S-?z~nexTU1av$o4=h55YYNP9CRO202^e^!)@X8@&_2W>`+dwJ92?<m7
zH@m#yK?^_Y{1WSB--&b7@glZL90xKD7sd0oBX3IGt}wE{X&4dDeiPZD!uIN?V_!pC
z%d!`TPsWa|eeRDN0&$q%0VehyA7hMJhiiimKk8y+mmo;wS~j=znbVc<(kcTEBCD6Z
zQ=eM&2pfi#`xuCP1l17<0Ej@`GUR{;)Gg1@xnxMF!7M%$urdLY$!fI$Bgb}YSyuQW
z?lgn;8b-%?J@f*^WOT`6nF)e!$Ak9cCG(m%^jpY8C8%(Ai8LiH66}r4&vwnP3fhMx
zGOXbnJ0UD(@K_~n`Ncplt^9PXdpp)TOWm?E_Xeu9J}BupKFvHEMUL>RA0c~RV1PTE
zgLKHBfkpp}_Wt@=HJ(KS1Kpbnr)Mu%qNlTEg`kU@pltkzUhA!Ub^eLMiT!QEb#XcR
zQV#oz5EkCAfa^u(1zhv5logTU`WgNV`+dXwXAKo`oOk{VoXU5w!jFJ8tTluskVlA%
zb4Dfx7QB(bhOW6+sf&n#Iy4y9Tl4||41LIoUZqatqiC_X0<N&L*sWMQg8F3?Ej5`s
zO)t|p#g1r|g=<r$vLf>^bAB{7wdAXZq~gyjP-~a7)GyVGykd_4R`9xNC(c~MW<|RL
ztFheLfT-2aD*V>-cq8^3n4JK!+y}<Y@i2tB0-;E38hyZv>aW4wo77G$N5DuKVGly5
zh4!^ftpgiwROC~*29Mnjf`+h-B@i&ubr{<2pJDQZ`ydhyLt99WlMh3ay#(Ok1Vrs}
z9@my5o@5pNz50~);?-F{2bI;R_UrD3of_`Lj~WgtJli3<z#{K`t-=G<U*dQ%fo0D_
z!!9PQN9zcun&<=9a3~i<4IvWY><KS*1Vtd~@OTmRDncRpCnv2AkoSY+T}u65Qrh$<
z_~Zj#^*&Y|g7(hP*%jU(wtyMn|HOfpJ`Ug|0LDT_z~vA-6o0;n#OC06iTx3pi2}A8
zr*rp+q4aGWQjyZNq-5U$kHmr#4mrAwJWK!&(W%~$-FBu57H-5@L6Ha0XF8!IS{;C)
z0%{SkAW2rKJ-uN6CKvij;nTPt??r<FGhS0xY-1P9m$ETS{gaJ@w&%0jpLAXO|Lrk#
zJDxn#r7opnqL+S*dmUYdJ<rC(98=eV?C!_ZT>^~W98=dy>kpwB<QP9Wrmp3GB@i5b
zOq~E<7zdVP>V6L3!;Y!@L^dcS98>29i#lrVApGIS)Mds2UKN0ZW9rlskoq>1s;(qs
zNypUPhl09}sar=#%*nabKtLXTOkMJ+E`Vdj2$=JJ3i$Fzjbvi?HLfkA1Ng<o%L}Tj
zr?wsy4hw#|2d~dG!de@jMuubfY!yB&m~ih6)ayI(`uPDX!rgz=wJL(O)llZtfgyW(
zMX6m`PA|V3dGK=hFGi~2bG48A;Jxti+4*Z?z~`tVpp`flZALKC;tuTFl*J8Ts988`
z>gXvUyDB$`0h6f)m!JmV$p;QU+vEIXu)1yg1E{dUonnv5MUV+1YzMF+Ik37rqDn^m
ztwHoAAbNo~sCu&D#VK)TGU8o8EaAW|dVO~NEVumwwC+_HmU1{%`5LAWO7H?zrj>~Z
ze5GX<S{UV8_I&`l2jS}nD6R}WKn7z^-NUHJ?Kz1y5K$0d=JHgM5u0ch^)d^DSOu1h
zv^=#tWJ={$e*u+#01Ign@kcap7@{5pv}fftV2Ec=*jcafCLh~8^08L|p+tuh&b-kS
z>VIhkcZ&%p&&O^6?GkJoEnv~bh(OsTm4_^Mr@BnI*d&YY_4;fFZO6v>0K`6&y6v#K
z!{VpBM=!kqq&T?l)b7@f4JC(VQi@@aA~I*73+@TblFGl~<gN*DQ=F|49fu%@*V3lg
z1A_H8x{*~7E%WZ%P~+IAKcc0M`}t46Bi{TS6w>VW)V>V6c~%zXdRA^mYjJDct2m@m
zT-qB)IEgOwG!Qs6E5HdwArvac311bgpPA)Z*%+)3jn07f$2&^FH9+OGV|n`&oNL4&
ze_W`(`di8|0|Tsm0dEbO5h?0~cv0o#?IIL4wsPNf^<nNJoQ=~%KUaU~Kz}c2A5}jV
z;c;964wsB{oESbk(lIDJKhiNUJYG}EjZ<1eN}n$y)316~j>@fh!%NP`x`Or>+C%DC
z^~H;$R=H;-9WIClDXSIxO<6zMrxOq8$#`N<PcZ-lXmocV?MbMpo|OS?`N|6Ly$dT7
z`&nTjSZa!$A?3^V6Hjp|=-^)j&g8}(_VJ#&*WvG|tG8m%g;}M5r*<iX(&C*T7w>G^
zBpc#k8<eM(^Y1d#QBpsH)3DAO2Yc7G<}?B6s5w*9(rY*GExc7jHPo6D!!!zoG<`eg
z9R{GNn}6bRO~KSHA`iCZVnApU9J|Dz3e;T;-*AKRz{`FPAXT-Y%mkl6!?pgcCgEeE
z%_Q=eSS*R2dFEMW*MSQTA1W;K5)>0tnOH&!NK`Sg6p7d!&<r<@S&8b=E>(_&6AD8Y
zpsi4EGI)HS_%|fXgkKLw#q?Z@A8=nD8zjWC!;F2o(Le=eryLi)G;WzybiA3r?d;@~
z;9TS3m&G5q@$q$dES1T#5^q%O-{RgJFEu0fXYjpmgU?f2E7D*>4uzvn*ce7n2m`5T
zSvIQoc+CEt9$O9&?HX6aOSp=zvFkS|A)4n@L+%}CD6>=uMWYXOqUeLg2T*jWHfehy
z+%SNn_%`LDpz-v+>P_v}A>_E{8$pWW#biH;Vt$BXLYRv}z0tv%JAGom09Q^(i_xm_
z1gGjWzeRCErQ~-c2qgwm@{f`A;eqtt`*a|!-HP6#L%02cMBG0MF8nAd0$&M42j1~E
zHW=cRbQ~tcDVLf=9+XfXY0O}2nG?d)!NQFlc;pNsc^a<0o1N{g48d&{Mx&=-msjNe
z{Lbork^6^rR%7qU{rTLjUiWsjV(o9!gOxQP!>z)%`hjoeeC$IFQ<1Co{u-9Uj=GjW
zHlgAh=CFgVf^7sI6zB(m0I#d~qaZS{iY)9sEW>_n0%Gc!m!!RN9M8ysq(1wg`V@1J
zv@M#5nkDGOuz1}>1ZdmeV|D|hz#D}|i+W%WXz`teIR0;dk1(ErI`Am*XU6fT694-e
z|3u=O))l&z_Lh4m<!rh#M2r^Yi<6c?Tmg5Ry+g%%sn}dKLKl>cf}UbQ)$xLsupl=I
z;;_v;y(j+k271=No`o1@f3jVUkkz7=e<h+6$OdJ+DFR(^ArP{#h~+F|UYv*&@eGM<
zQ&)3L(GtkTLj<%I^*v1pIuXVp%t4E%NFF{23jtCFVXdUjYM?cJ8(9p1I@`tZT}%iV
z1AqqGOgT>i7<X@;v|66l#h;3t2Y-d9_H@k4$=F#lM1H<e|G|0~gv$bE8;gH9j_LX-
z=&lDQgu4r!96BD9^_I|L<k_YoyOEth)9go#TL=4BxoxfzU?QN4{ox<QOOR3KB+`q{
z4uJF>;!fr0rfsyGO}crS%?X-KFW4MFB1_^#^2z4On$2bzaR{4v32gr3%VahSgeLt5
zPK392)c$r+0y`Z(QvYR~dIhP!yi}C1MW6=Irv++h9BMJ4p43pI3=aqpppIIH8+cYx
z8I|{Az~Ek#H(GN=Ps5aer6!B?c%K!~39Mx^wEK9MhZoV=8?<p6B4+vV-Z#|_vQks>
zs4e4TT33U+q^Y1Ze~R-d(tPntk>=;J?^1O2ALKY(Ek}Log-I6!OiWtC5>~`Z5R*Pa
zdMQl`L7|IbMnD9`iI@)N>Ju8_NP!E{=9i@Rew^M9SO-Rs9%tg5=O4tM-_Pf#^0}RF
zVIiwM)3Pt8ZlFF8W=KPs<*asi&c=vu3}cXiw3^vTJ~{s=p(nDjylc{A4g-x7W$><;
zdM8F78Q_NXe?lHP3#2PxBdx#W8EExO6++8{*T!_<9fAa{2y>%z$FAxPsKrSJ22+T7
zq~(gO!;hxDF;2UJU4jvy&FVI=JGOR@Xc0QRCxlODulGVtfJ<GPITtFmI`|6;$`@=P
zC|;tX@IOGjYKM0w=3@GlQ7oRPPbm0WDu04k!j<K%PjeXcxxm4Iywq-IPyR+LdOT;f
zZnauQNh?(vJ>P1{1VgU&Yc+Ro$GMBpd=tSPIvRKhi0r`_a-Jr}R%FCdBgp9akwca9
zKQP}jXkVpAe2j}DurAB-f~W2Sz{OrB|2PL-H^jPHz~juspZ(s#H#xLsEXF*Vj|2{4
zi4*<rGjYm2dOmtm=<`+R&Ebf5ed#0Cq%S!^soYGbLH}V+bUT40gcB)jIF;0l-_c73
zfRHvs9t|<;>CR5W0)}xu>T5VHdj+bjcxHl@wQB@1(Fm<zd?2qGwy1Lu2@RW=lZ-z>
z2M*Q+H!6qbf-md1GPSG4(N6hO+0&g+j&>q_YT}{fhhku#8qJUf+F*jON6M7`#mLjI
zxxJba=QzPhh*48n5$BMb?po7)b)w6iR5i4h>6x4#V2GFWFd$W`0o#gPYJB&HT61P^
zOqqI!kuL7jWWP+!HhJ(dR85^XN%C+|EOlMZE-`!&Awvyk0ZH<gsf!N-Htu??0Gm^5
z%jt_vI2eB_{GclcX^H!b#7>ZBps1i!Q?)5(b$cqds8DMdQ_y*>f#jOZLiDZJX=RS+
z2=|NR-VE#X*a^*%Oj4=urY1ZYgf+oxOeJ(RJ{&G_D8Y#_K4143>a5<m_L5j0@zjyQ
zoHL5IoCU+YRL>@B6Wt*W$GfB;QlUQK?sfFR11JI=+mPSljaJ3?x-n$-JpG9%FbnL3
zaHNmusTP(Te&XAsY5}Uf^_0}KDhYs%sxEZ^6A+1<n!-jU7luh5jImP}Hi)#aw-YA@
zq^7mc_>*=%?Zl_2;;TZvZb0FQ>>a~*E7Zy)be;E{$xGD5wA6;4BcOCPkerHv3w@J5
zs=#vhXfbUswUH1l0=nWcKB~8p9~w>Ng1&a7A<54j|6cdgxChM=sk{0-jsuM+ccmP-
z<E&?CMH5&^s@?&$3|7$Pz09#fBC|d+o2Q-VtYl_{S)ZCt6DCz{pSsE9X`MHCDC%j#
zXq*XyJrt1I(i@YDHqZMTN<OMOPaFEu6nq5Kzi2D)p&@D0fO^a189vZ%xzrQlQOSG+
z)Ncfm9SxLY!K5@LP09w0CWY0|lu{c|9-3FJ5|1$5Rau-FpvUDfJw_Q;W3AhHQ$Y!l
zMTY_~fO|e+Rmo<e(IiZi*~{TiLWPG$%tpu#s8Z9+=?3G>`QQXX5L?H=zYa9lh|W?5
znl=`TK%<?vMcqp8PAJ!zI?^ZpN<c7tRDlnzhrWmLQA4T-c#DMkOXl!RO+yEo9AT+T
zcOoCrR4(aC_5Tz5=?T2Z<P#6u!P!s85Oi?2g1d;kLp#GCs%X(UPQX`uw?m(GHm)1(
zF4QFkRl7|bbs<rOt=w*?PQBF1IKW{^64NG9!+w0%Tbpj|6zvYoaT=Whxi{_*FbU%h
z+q+Q(yKIJcQj0hyW3lMj=vQLv9}iaz5!M<6YMKY-&_KG2z<uF~e47#;76k4UX0+2)
z@P)%cjZfTapaZ%hIWAjlvdfrVu5EW$S|WpzpyPh;O5!A*9b+Yg3KAuXKYT+TntBOw
zmr?A68(FP&-xj`v7cO5<->q8KeazrQPrOC>f!5q}9P)LAO;MarT`xsD5lPE@Ukb>4
zb#4+Q4V$lyH+f!aOuCHus*@&79B!eP&LCATu97ZDeP0CVs%Vb4vUWITVypNoP}fzX
z;4lp1!N71T1%2sm@&j(Gv`ar#Ntcp3%J3FqJvGiOwn4%;^Pp}8bc->@Ycy5AP<0}!
zj+<gdhqex=aoTIyz2_J;E-}omtA}&;Z;Ntsl+y*FH-VR_XIQaOdK<h%m)>$aWpd)G
zE?v=woYHrjgpq8dlpZe{T|bu?2WNods@40xGggU%fkOd97$z7S?S~}BY)NDir?o=s
zG+Vg}$dEElKnqZzqz*&#6;fH@=yZ)EyT};fsEb-U7vXCcT80x2!$|ESrL5##E;46w
zZ(ZbT?9xsYz9$!P3)SAc$P%G_1Q+?3<CDW(<N?;;Bo~QP{C6&L@?nx4?jkENS8|vW
zcXyFHB$y<L5g&WOgX9E)?gC)^!@8HsMd<KdBP@1xeC+Dv@%w^aeqS(Gw{Is4Z>S1@
z$fkw@ypxHLuHX=mnHudYG0ZR|jm;6!5Z26a{27S_3FInBZmLFoJ_V|esCld-m4XTd
zIM^Tz&o|xP(~`Tr5|sl=!UMz)=mrW+0mN>SFDv2$SaLQH$LU}pH?knx<$07d!Ls41
zVG!=rueqTcdx0vOaFk9!HWkV_48@pxnS&FFqI_Hom3*mw`$0Fk<Hm3f#!S@1_T;7k
zI@e4zx%qj+>;*M68q~(tAfi9ggt^D`=hNWpJnxopzT8aR=(Tyx9~VF@NaJeoQl^iD
z=^|JUum~^NDhI4{>t#{CSt%*S_6dB=1Umw-<obE0`aMueY<xguATY2I3OhqNJ@?O#
zu+DC8Bx2#zY|J*k#5tS^@#Uy;&fz@&FqWh0w$H~oL)+AWtsvA=OlDm8N{>Ae+XLIU
zL=RChp~WLPd_0l^2c5C;iEJ#;?RG(8i!GB;cUYJw<4&f(Vg`v5Q@6h-6OI|!mhS9C
zTaURVJ{lvBycyv$xY{TVbl6I(y5J60h;3><=vkbb+g1HE89<|(xOooun1U@FlVf(w
z;iMcUo|f%%R{a>C?Ale3)6C&N3zf(&x8r_}{`n02sHezsQFdXG7dmqh;8N&godBFo
zfcwb<PJr372v<EBh|^Pe4nyQB?ig!a3Y;_JI9C#9G>MMMu4}}u19^T{{CP2-e}~U+
z%Bg#MPF7*-JOguf947l|z+?!FHyOqshsh_*$K)x(Lw=Ih++@85XSnQF^T@oNX;06#
zr{~zy;n>?$K&FnJlUIO_dFB-8Dwh^3%85>J+2eAspgg?DJ1^5N5*q(uD-Kt|@QM4>
z($aVraG(Kf%=FsDS-6jr=?UH5Tet7NlUC>d3cAgw%;TW8hTEyT9oSll#Ts?0u;3bA
zo`cnB0lX*<IF-s-4?xV0)`v1Pu%U+gqurQ~OyZeaL)B_D=$OUFA`&e*KCa>EEN!lo
zwoM(w(khE`tjtWk7hL^Y`T^V2DyqrlF3K^hWvGyte&4I!=W~1@&3=FI`Z;~06S51p
zfKe|cniwx*F&WJzqr>Zmc?$Qy7X*U4#k3EuBE-HQV%>eu{A00e!>a7G-2b-Ro1LSq
zV18$Amqn{QnwRTc&5VT8n1Xbp8MR|Fv55e_O?@o4+`EBIFNLkM`dgJ_vk_OXW+J%y
zYpUXkxIWv+#1Fs(QJ*7fWR90h8Un|&O|*e(sj?D*+e*LG^SIf18$1}8Dy7PCF;az8
zu`t`Bt`nM#^d#*5<Vkl_;{KrhZr$7Si=`1z=K}_>W8gidzWCN$;byGeS5ceK#C7#6
z7XMmZXXjwNZM9wwmvgsZcW$WgU)7D+W*a}3Zg<!6w05-RBy?U}j&&ro5QM1E7iGE>
zj^>5^1n~SgV8Jf{SPsDYqO?xN%B7MHKS2aNh<)?7XLwc~r;ZgBY?>0>zY)9P?+Py5
z&h79t*A=?p(C~@?H(Zd#2upq)+%;6N<d18)rD!|eQYpAPI<W2h^WkWSWt#xrO7Ne>
zRr4Mt`V+v}w0Q?BG>EzFr(pv(J{8!al+-0@_TUkG<pqzW)ssdKmBz=4E=OMKmLO%s
z_zdknc5K1v3pc<z0kTjZXJIip9s(AIPsnnfJ{o_zoKKI%QyU?tILpMD$JvueuCrZx
zgYl_Dl_j-slYH9{bC>Y+>*)5KxR1=qbyWxPE?_8Hk;7K+Qt>0cNb#kr7u`Z)wxVSa
zm^~_NEfe*q=TSqA-?WnSG2)(FfYwLf^w9X{algb-I7KWI)nh5E(eSv8TPfpt*!2qg
z2ko!b3UC>n?k$|2<GFTvPN?wH`$mOuxMETLOT)O-<KAb_#;b{V^<cPqSFkce(dpU6
zgTLV(IquBEN%PI>RXhs0f$yH~4Y_yOJ3@m$iC&Xa_!_)G7`P_Rz*qEw-#rKhDtB0!
z=MUauk7aOYtv(ODSX{6<6$-)5KRIKu+wpdB)x&}J%8mexv7xy<Y;Vk*orB#|>p$xQ
zhSi7gCoCn>wW>QvHy3`CXH(BpvEd^Z47nl?<hbS+V_&tg3Oh0Tg$Zo;{#=g%pPaxB
zKKq!(xJsvY0?fqDn?1n`3k3@&<}7F`MZZOQ2feV4UT1!jeg*FSj#<vqXdXNyJA{p#
z>jGem+Ta0td=2BI)r;xG7zmpP=f;_d>U#@`jS$<So+JS~FNEWujBFV8fyCAx6^ZUc
z9;;Wr?*D|iwi}`YN|zp;O=XSaS(u(D*p-27dAjRW&XyfORSw=9gIDXXkz$G3AE=Rz
zzMeWRMRNqbNFG6pxR>F$E~{$?9rnrJK%73Fy5A(>NEGNoLJ;Ue5&?Q*gnHb4Ct1kU
z?Be(VT{8O+<n$Y88A8^bk=YZ}nKx6R+q6f#4Mt;MqE~xFH5?@(9p$O}XOc)gs^RVH
zsfH|1-T(F;XEfBk$1`O2kr<*n3cufzpr1)c#8byDs_B(>+;<by(FBHLZE(3Gm9F-e
zQ8c{zyP@}@H3?21p48SWFZzkVXI0;RL~h2GljU9!J&T}@`QJeavE99wzzulR($4Eh
z1EZ=VRGqg02k=$_k73u!x?G--%4tFEe&f(RB$c!kmsX}4j#$(+HxZ~;8t@Sm5k)VI
zOYdmm&gC>Zn-TPos>hL1tK?|^-YWMJQZR#N5?=MU8+D;da&RmNz9l5LJQ<|c-=Xil
zu_b*-94~1eW!WS++Nrstb<O2846UHPF9EtYWfR2<`s#9nB348gKtBT|)1*lFm~aUj
zA<Q%&K^)CQtv}a15N3TQA^URkk<c&u)Q|ULmZ(~&YB5a_T2NDjmedqMWT%LN#3BNT
zMU=6K1=3MMV<c)RcGObbrIsp!X*YSqn52|TA^1>~P?HZ9I5sh18&l{+vutNI;U)hZ
zlU^de{*u4Oq?ejBxgq>=lP))Dx+$mRD@?kPX*;KD%E+sBl}aQCcpl#r;6eIO@?wF~
zt|KMtIPJ{qF;=e>EVK|YDd7ke$rk9o;iEBfKQ_iaR&~4d_tiZKbCTa6da-yB0!2!k
z5ebke;FCsSOy-OnE{!=IHpOF>8n7d`NvO(YY8*o-YH=A|4z|I5Sl-RyT?ID{)PP>>
z9tp!vu{|p1=jdWdyRnmufJ&8R6Cve9yqY1<M~QNdj;#g?UTjU&%lF4>z4XE?o1tjk
z`gEyLeBV){=%<lvLBd|@=e>&F=;ubdSloJAKTfGqL!DB+>i(-GuFk=wH(~f14PGMP
z5{7-xFbw0(6O_p^T<X<pb?MB}%0|~j?oHHNY7$-h_79TYk&N@A@yTB3eo>P9_Nah~
z2DBBd8>j1fWdMHXEOR&kK|Dx~Z9)%E2j?0=W!H(H`(6&|WH{^0pN4p@ezecilg@PE
zB}0s_YB=^d14w$jn9q*u^Y_U7A7)nMsW1LCz^9Ax6u6$cI^-AC5A<Wuv<fqEE>H0W
zyU!?4=8H+gFb(+`SQ}Z03^n3jc7^*4#eHb_Ij7??@9L2KFTR;uKja2}j>F0v>LDs>
zo==;uu|(U!=XC4y(3^+H$O^x7>kChN_qH=#3s#p@ZnWx8MS=f9fqgb3&x#Jr)q}S2
zxrn|pY76D+@T>N--H!HIDsYecYrr~SQ5~F*1rrAeZQJp=UcBGq$9n;0PS+f-FFovh
zrvewyT)>L=%zrF}NbnE?A#~6{5;=;zxFQV}*<51-HD(<s7+4*|D;T{=Bn8AxI1fD+
zEMk@Dh{J)`u>dPO^B$&EM*&G&wS;!t8t&{|mxsKDs;?*G01;WM6lG$-g+d_$&-v9m
z)1eJ68StE64l5{g0R0G!x>GjjahQg8wKy2&Hv;emk<Hhz0<c$6t_J)uR#L#vNGo06
zUd*kokwC^a7iVBYHF=J%pxz>{CiN#NGu;s3Z7jx$;O|jz)Olz6gMx3HP3NPg1DKRs
zH;^h=P8HlDOL$l(sLIlXOyZ(h{p_5E#e94{Qb5qK9ejkrTpadGt`fyz|A~}-Hz3e{
zQGydUNl!pTW6c-YjH5s}wwTi(ye|Ewm<VyQPTi<eFShs7-0%<%eRrXLa;#2Wpi>`c
zHu>Q~dA|bMD9~9~cIW(ivO?xa`CX(mU?~9CAYi!cR;?=--6GFrmaUmDk9&EAX8vY4
zkxYu-6raSAX{URr_wUVuhI&HR*1vdiyq>2~(d{9&n|-Q>lNy{P4cIYQF=1!?VHA$Q
zv*c#yUEJFYBk57MqpgL^R`R*G1vnmus~F{4(<?tW!d6n)pU0idLaU?h|AAwktEum3
zp2n%h3YfmTPq00;yHS}}3k8{x6m<!O0#NX*oQM}Cw}+38H01_gMhULc`nxiwL=K*L
zZ$Hn<CVm+HmqCNx7-!&T)b_ut1RduwZOYOmE~AG^y_DH2NH1|Pfa(RuV>{V~zKeQO
z;w+jLc4S1iwSFb{rit8b5?;)S5een0CvO38ygi~pfP@FeK`>x239q^gjw^Ljgx-jJ
z9h6=o*G1r(L|qu$>#+YLnR0VlI@&vdbRH89Y3T<N(cwB<?hV&olR!wqkiaCcPvd33
z4+(XdOc~Zn!okl=#LrK}FL3bHy}*l2V66tFMhK(1{!qw0A~}}*h`$X_*oJK872B*t
zH(*4!>_!H3z_-ftm(0i}u>&4g^-#JsP#XnQt6Gyal4_bXDWEh#^nTTwoFzj}TLPZ2
zp<AjhJqlijKoRc=;Fa3DVpW_oO%ie+DI$jywb<KD8I6M7d)_YkKjiJ-m?k7|?{cOU
zobYTi&B@J%B6A#jT5@l+RAv%hwSNq%6^J}$h*ZRhoM4DBhaG$o3o4vy(xP^xt4vxn
z4>oGz6yD)HCU%K1C(#cUNxI7q78?rU%kTrOz%YloFBzwijY%&Vj|sC;Oz9q1$ta~)
zW(KEAQLcJaHf>_qCQN9nEt7krtK}vkp0Ua#a@7Mei@7UyBdaKgk!h{{e~=<`0IPFe
zGi5Nx87t8nH=Fb#;4<B6(u<h}g|;|_MTP=%NMWhLP$s?1q<5S2a)$!0nupPb!csml
zkxj6i8Xzdr3gc)uHZhpVl_<3f7&=N-F}VL?I<49p9jg^WsINoli#VYrBsAU-su7ON
zP*zj{E(%zL=mCiU6H5&kyrNd`jKdQj6AtGR5ZeT-ry$Ihwn9B9BOCd!nG>P7KRO<s
zWH{l(g(PP~i5(6vDva%)<e@R4*v;lCI)YA+J1iiL03PcdcaLLT>n^NoP0T`bb(C(d
zD*lCWg=Zx;`!(x~Q?|23!wN!+>hlSUL{Bqm9fn^<GA$VwLR4mv_8}h<+5<v{RX!%H
z=q}qNM0Z}3$S31ObQ~qmJP?WUO+qR}fk{YX5<o)5WaDG4p9u%wGEjnFW)gy5ZW6ib
zJnUGFWg}#yP{;KUIY}Kk(2r5azBZ_XozcWtTrRs})Af)us2hmbCWb;c+i9=$uyMC!
z7kOj%o0_~78Cr)f(oL%EUr^knvj2gcQ1p-5NkF<$$o147s2_|<WT+?SRign44OMq@
z7=A7e8p8G><1jmrVKnsaHqj90)4)myA9}3ZbxnQgUC=?F|0&}*bJ%9;V5u-_CX1Zd
z(7lGG(J56>1AMhuI$CB>ZsLqnsm1(GrS_`9pGhAwk7W~AMm)~+t~P}RhAF-@&a2_H
zhSHF|L2QINu1)q%A$2QbO&L(3j_bi^6$ezYCrLQTqNj2*D{?B}nwmsE=Aa>C4jVFI
z0_vP9X=mR!nnFoCaVsfkP(666W?ZE$%|yHsE;0$x#A1_>O4#TkSWmt~<<YDpmaEQ0
z{}Oc}u25r4M^j=<#{g1VFA4zbOHqLOUxc78H_<#fUINRSw}8;E_NwauilNXXDvh{_
zt-nU;YW<hXa~)~zr&D$QAWeq=QNm1&QyDlvHep7SKa88MR>7-+FkkG7K0Mu|IK#rZ
z7+JBUz(&NC0YY-^)rW~Yu|d;SrgTW@v<L{b>hG7Kom6ft5#5{ZS@|I-PlTuS29;1<
zBIUzqv17r}9*?(A^8u)fDyO#`TYv;$nQ+`-neh){X1Pho2&R!J>o}kV3KI^>=0ud%
zI0~S)nnbSpgA9ZbLy@xz^5Q%tuqEOMjM0RF*P1X1ud2SBQ>p_vItJ^Fz}6(TILsg?
z&Wzl5@2;zdFJ-3#Ymc0^k8zWO*d@-*4-F~u=a5pVx%nJ+*%RXWViGf<-ZOIuJKltu
z+xp=sLmaN;oWU!aJ)$ry*9Cu5^RbbEC`>p^XUn~j-)j<Hbu=bwf`!eVdRI2M4|>kS
z7ElvXvmsCK3-+<#KBizMoPzTb3(j{64%zs4kE!8rVrD$Hysy@tylK~~*6XcHs4c9X
zp9|Are4bt1%h;v9Kx_`$&6p*k#~x9yA#Be(L!<N_VLR#&R?KUcaRQ^4#fVC3z>liD
z;=jaNO03;rGWI<bsC&>;pcmbPZsIuqmI_lv0qPiMv)mt6E5aAcD!?pUIGgh}XLDe!
z0Ia8L*f+*EnB&mGp{BSuw8|Vq6R!dZbuP?BMKIx@Oie_oa!^!X%-F>4Mp73x81s&p
zy}(Ibm<LirKqqz&yhZm=C%sRp%v8_AA4+`1f!U~Z8u>9!1>rDFnNEy;<YfPj*_ft@
z^#^2EfbQgOX>i;aFTBolESSR~P#ZM{F*cjD1ZkvOO?o$;^E+fx-YF=Lz#2(jXUDNc
zPPcDVLSP@|jXev)O^M9Q;BhE20{TVVelgnbsoOMfB&KDHVWu%o9=z=aLKk_&dXpwk
z<edi=YR0@<iCLBp$&a$Sj)=1A@sVL7K?Nk%iO%vPW|h|&t~_pDzvya8y~JSgQcPn1
zL%s43X_13awFpbz9pk5N-pGH4K(X0<1bf?K-<Nsk-ZXIPO;{_|j9HT;Mg9p4>WUzW
zykTN@MJ`1#l({W#_D7jR%NesSB}=rNNiQ?$-6k#F2~cpsh}t-%LIK)i06_1pQ81uA
zNt<aYQ1nXLjMy;q&_+0{7i(j_WTx~mJw+|!xz;l51Y<J2)WBz(v~UJ|y*I_IJ0s1L
z$;gLKu8+%?&1toKq_tBVeDD7or&#vE|2wC+7ajQ61XC}yx_ay|t)dhC851TlfGMrN
zD+@!G=92nb>x|&j-eu>G-?`9=_?n79B&$HL68&}zN@*jk#>hZDPYm{c9C|V8Qi<In
zF78lx`W;Q7jAtwdBVXX$icU3f3-ycDw<>S7{+b{*t}QsF{bpU=Uypm~X3kUm@n-a?
z@xnl-`Wo!<kY{j+{rzQ{$Ff8oOJvs_&LG1LcDrxNk_~qsFKE!PXMq4>Wb91D3!O7q
z=jg=vzd=8JOe|>>chdUYEcb`C4p*R?66<=Ce<;kss&QmYLTxoPbJcS6*1LKfs7LC_
zp;U9NzeXyR=3$ZC8y*&$g!DU?BB4e*qk{yLWr--u<0v4!$|Q2tCB$>WbolR1v+(0j
zwJb}8ODAwU6F(+!gOF5rC*+Z1fj5&Ii%cSqvMe@<UiM9rRrD%G(<nvaA!xM;t)6_H
z=v~qCT1;1P&@ve79$ePY%NemDND{Cyfm|9>Pe0G}v3`#^iP%rg8{p+w*5<;D-eeoR
z4F{2NbrNe-2iLjgIcsUhy@kb2SDq7HGUG{E`1|^=WJ1Qr6iCj`6D!LMm`o}070)R$
z>(tXWE}&X^6gmm8t05D@+{bIMSKIjdZt?X?w6EK&Hj#~GdZEy#L-l6p2_1|*dJS&e
zo02+d^=DjT+7+*ru3w^7o_G_;R&i-^ND|l=aWEgjzP!;Xy-yO@mvOKF!8Q|2)N$wy
zhwfh9N$(+syU57dSDoo{%@4@lTX~}@%N*#~=XN|vJ0qta&xh%7#`bBK0Biwv)Q!9t
zH|o6!P(Vwcvq%+xEq%P^4qDO2h%MZy9r%za$4dNKXe8$5Yrr%7`Fy{h=Vw43SKX_g
zN5i-gcv-!yncK(J&+|Aw!v3oJHTgP8(}H#cQ>*@doGRamx1%!DBaoeT3-A~rgS?vL
z1iAWHtMcCrcL6(V9Y4~-Pn<L@z;*?$iNodr`_#oe!6TQ*Ry}9xx%p2msNqxu_p1I6
z9_V+`ANezjf}6?e8_I;I@)c`zB5_o%JWPH;u8i+%VWqW2`Bx;Nn%9<p{uks%u}y*;
z=BZmxqt7LfKoLF`fm4w924B4_@wccSysD>3;)plC23PwqJUDVNW0iUqtBR#K^4;=`
z-HZ>Y?qR1pI&#8DX9@KbS`LK<)PV84gY4}mH)K<W03UVfGWItvjxF3sJIae#auyqE
z2@hklqJ2ddJQ52i=$4JqbGT~$ccj-p7Z)^cdS!S30sxDGIK^_4ha2EXjl^cUbh`@F
z2^Rn{(sjhz)FYMdLa`Y9R^uzkX(s#Bt(e8y<2kQUvo`hI9$Aas4`)hG>qqBEWb3K8
z2x?GQasQ@T(rY4iOpnE#CB^mWskk3v%-2=i!$&CYY1lTsbT9hFlz+yB12`Xii%JXV
zcz5|=ElNN;f(f8vRn!a<dwr@JJog}R`qEDt0>sG1sm|L@s7XD0o;sf;aWf8_8aMDZ
zX-oBau6fAG*R107Y3;K`;GL6Ue+WWQ@zs2_kkT5@lp6qRUj;CHRqx8}U0s-UHr=C7
zH9n66Z=~yE_ExBIUstiWy(q2tJYh|=?Ngsk(;Pvbl(i>bKNjxXOr#^I>7%pAR2I&q
zPt8>9F7)No@}-^;bZiWLrbkyD(^dZi%8mEis8eVV@e?<eF@OY7TEGHTG@e(cFSnnG
zA+&-J0}X8#cw4bIwo=&Xsf_Jsir}8w-}dPB^>kRc`v`G&J&mP3zF2Bgt-nUJOi7#x
zf2U_D58|$WKZK&RK8NKzhh;coPhszLRIS)&B$hUc9n6cXG^IM0^@#nxPipqxaiOT!
z8&Q`6NsD^3)LLg*MT;sVb;WV|u5nQxgKqziM7@M^EZn#mCF_cglYnr4Bq#olgzamf
zN7-$SQ{&N4&O!YOaHLg33jE#_juJvEJR1hUQ4Y9)0eHSj(gM7C1G^?=H?Q=^VJ|q8
zcGL2>n*xV!`YQ*tPD+qorUsp3KppQO^eIq^%q%1J^h9;9k8obRYrn^H+vX{ry!E;l
z@&@vWNpF!GNSP3dV*HqM&y>G9UF`fNE?i~=tt!jNmWtsG8oW`!F*e<>?k?jQ9Dr!g
z2q31>@tLD(b-g2m;P1GM@r-;`4VAIrG(sGar{kp3^`ySt^i_Slz<=XHtBDr<zvDtS
z`flPvzou3oZF(2FO@mg?JEG+OfEjw@J}(K}cey1|I<HUAeCajb3%6Nws<_Q6Tzca+
zQ4MYjxVTO3bL=W4emUT12@t(^n=9EHPA|j}mG_~zX-|e&O^CSLnAdFDSf!58fYu0U
zI*v0R$MECK#pwvtDt^ESWaic+2)(5Den=d0=G2mAI)kSeKVm%Ws!Tn_U)A5idEDSM
z@@i`wq2t7CVM^lILYPWitDu*KlnDYtRKXt4t?>{QP=jf6m?_|dsBW$D1%0#}z2K?%
zWXg_3v>}<jmVJPO)4@Iq_r~ZTl?%4aJcXN2dNofWbGOi)s`Y7<HY6NHD!Di9{BD!L
zM}9sdRt?gs6zd!^zLsy3^-ixucERP;0G}?B38%<xxi>}X>2X9=y?4_`qz^9ANG#q#
zS|s;}_eZeqLX_W0G_Lg%pDh;p$+iAGlkhQ-ZxU#;Y6Zuk%u#y0kt;I^d<X`MIOw^}
z#4JJYWv&3aI?eFHgj2}W#6qg#g)D=lg-xDEev2V#j9(#OQAZYAy@w)#k&VJxqiCk5
zYC&r(C1(+dplHexI9ry;+44AN$AUAyMDfTHtQU~0BNwBtGJ-En;AolL8@nwx39lL`
zpfbUwy8u(2E&v*G^m_kFMo?-mNPT*u1oeO6B0;@ZtS;9`&kK@-_5u^y8&R^ZY!@H^
ziR7XbqhPr=;<TCsCR{o3P>JJxtn@LXmr6V!4MeXbe+!^7-7@#aYotblWi?lV8&C}Y
zQdt(6gpYhKHVNtARcI$pJqa05lP-*lO?yHCh?NA!9l8tXn#I0DA6mGv4OHc2AB-}4
zH>TSqoa!d2hR(z9D4|J`Xka?UizQ!oic!4o6r*(ADTX^GwL~lNc7^n4o)@$prdZV@
z4roL`d!u6If<rkCP*1eCo<O*A?x_^tS&eiLz7v~i+Kw8sVrySa9TL@h$5TQKWS=;q
zgumCI)iYT%%q(%!*xAQCXph~mUIisB$meF>DUhb&{7vtJT#j&uhV#gR{PQ?zWB+do
zGE|mZ()R%V!79=##i%0T4tp_<EJ&^f{l6*5AnDen7vy*mq$g*M43G%B5Em0+d*O!H
zYNS#@k_h|ov%2%V6n?2A>>J|sy@_?&x!llB54EJ1=2()eslee`kq(b*>K;NQ58m}V
znV28OCw1{cv{Ws;0*6?%Rqi=W?5sg01ss00j@`f7rv=X0e5|Xm;G&9Ull3+NAmLTV
z0SD9TUR*d>{f$xFZUC&pKbQImLK9J#qowFt*%DeV6Tqcu@~O?F1WA2Pt;}<p+k9zm
zziVn`YXZI0ys;7Sg1EYzO($4j!eJrTlqxLv92V4uJn2fEM<e>w-#tC^@+R>>xOcqd
z16uvT_z@EhF9oJ};U!=a-gQ);cBU{Q)mr4cVjnQC*Cmz#M-`e9nQ%%hH-$)v6(%A5
zTJ+yl9|lI#r`AUN>#;0WDxR5Y(7tHu0}=?oW_1;b029lFRcT_);m>$d#wU$@f|Z_t
zQ;2#J`?gK*wRgI#qGXedYcb(SHYZWC8b>m<15+66y*6?|MRS;H&aQW=Rc@+u;l?E(
zkLeC{5a@snXalf){Yeynn&H#SM!17AxYPxQD$~lms=rnybfGJCIT2tA)3BM-Rks~R
z2|7+V-dPhnUWoOk!EXS2E@cZ<EOEtI#CC`(E|bmSGTD3oL-xBp4)8I0N-gT+pYw6@
zL9OdHJd4AzP{my8jU{-za3i%rtt`P+Yvr9Mj;NLCIla=#t3oL)gCkQh*c@l@e9a&k
zOJ?xmBQv<@m|iiM*E54p|15<DUyn2R@J~g9hco!2$B(GN?A|f>kWfmi!Gly$cN4e9
z85IA9>x%{>I}7x}?B1UkBsesD6phV>b$^TF{DnRj!C{t3A5+zRLgxcl!Izg|R1<7i
zg5Q#sX0H0{&$g6Ahk)jnrS?}LTkUz?+P}q0zj{3rHF6bLGi%R%@D)1CS#sVPI~z~`
zi$&?Kwdm(=myJ$1iw@kaiGlvQe^9#5@T1<i46LrIK_+(=VI`F-#nJfE@V~|2alLR-
z78(+Wfbs&j1P5D=E&PwC?l{OS%&RkhOm!yUAXH$Tdu=0%e?{R(z&ejlfRUxMGWDvc
zx+&Yj7ur8a#TDk_F%PdQleubc@a>)KQlI<|AI}*B-YtA6)>+^GBY0%EIBb1Cwj9A!
zuUjulhKaqHxNglO!enoWK1h`7))AK*Q{lMgVO{{20+%^YwD4QI!!x#-51XQ6a?T%v
zgEsZ;7S&{T*k8TVnCL}N9gd_6MHl1*_qDjg*;osY9fBp)>+~PHxxPFTI|xd)u0NPj
zpY;noz<CNK^`Snn0lq+QZ!C#y%-a89_=;DGmYi3FO&P&yBWkZ7`pg^a(D1wD>*mus
zesbwUr(E>qI>cGLnGCY^f2_G<`uNY#Tvfk`&wCRyWbcl&WkxzO!h<3mnc=?J(qBEA
zXZ@|1>(5yKxwpNK1Ye|a_`&+N?2B4Vjujo~_pBI|by3T-&aQF?qLgWkQtqbEMc?2%
zqrvrGcyTvv*Ywxg>uj}N^}lG-v`v>j|H1})!}=ZGi&}$`x7@|{yqq9cCn7usGOl&4
zzijNg*wWFIe25^={G3z76Bif5V1-Td@CDs3RSoVlCuR>X&&F|fAN>zJ{uRi+j(*p$
z3qR_EOW+Zecwu4SEmnP~)r(Ib0l?)PkC}XUVD}Ou-*$$JP%MtXJ0#z5D{MkByO*Ju
z`_Q%1#q9nyikZz~z|U}~!zph4Cs`=c3yn&V=?*HSSE#<?0~=*RkP^7sPvAa0b3$ii
zPPRMp|FHKa;89iC+VH6i5Fl_O1_;PdU?B-(KvaSeQ&54577zgy6=g_*K|_e7ia{X(
zD^X6zQoGxG^>+8YZTIcL9_-d0XrO6Kf)LbJ1GI{^-QawRQc-ASaLE6@YwuI3AVIv}
z_k92NJpW(yRPD2;wbx#I?X}lldpQ4~)`7b!*S#xmXxC(ui!vK7wY@AD#1yI>;C7iq
z0jtzw^G)F&1+a{DLavdpJ}a_5DZ-oUz5~L6sT#`DEZmoW&~`CD)_ic3WpD#Fs$-D%
zHgvI)z1CQwF%hN)93jFx$RRHeoc;E?uUu%EMH6|+3fzu5POi?AyZ;W_=d<ILwE80{
zxC!J?3V1yw!=GnkCvqz(TotEq?oUDC^Clp5hwBGXU3E9D-QoI7mWFp;+d-+(u7;b^
zcz0km4*d?r$vNMDLi8nGVyK{?V>jR(*o~n<AXD1b3?eWH&7hjN8=LsS@uV>BNP9?K
zAdG5$#DYm!mWdmCKW*kq)G~g7%x^+|tIQWL^IT@OK53Yh{%KP@&0Fy_xlA*TY4VN-
z#|gVMtV+vUofaCA_iX4w`!Q@JwVH8pRi;03SEgNvl#msI2)GMiP^k`A*Xm1BL5GG3
z_Hf#XRNGz%1CG$+3Qz~tg;<sgFE_`Ng#LjB7IRX^-oQ4*TNUqPqX8AgHP9dA{@5<q
zDwTC+KA($>_V!aUC_$7RwD}5C>SvAPcy)#%UcLvrs?x~!aG_kGK4`NhLT4k(_K9rk
zv--B0u8|dO^<RKTe#Iu58RwBT<dF{m(qGbo&b~`vG#%>V&jEw2$*{kZi>MYuNM$w4
zj=jhoZPv;Ryv!|&iCd<+B~Qu6I3u_Um)M~526Ns1mg#~Q+zg3tnXZ#(6PD}}YtGGk
zHT0xaj@vkKuT3VnnLR&{k>UD#<gPaBg`C~>f3L~h#_TOA-$tcSt7cc;{@Ram$wU_V
zCiYgS+rx2%=+3#;XBHB)^tb=X>L{G8`5C+|W`U=bEO&ri8~wY2{X5A1y-wH=dM_F&
zh^}kBVppAH563mXE%q`zdbyeRpxqk{jXpll+b})Do40EfuCOE_?}@YGqa@@{#$w}g
zj_u8BSv?Y}Oi^TA7rf5>6vyK<`#nS!y1qcTcek%grcvnnpwOyJkKHySQhEh$2Fmw@
z+lFj$qqgSs6ZRNZ*V;8LlH#!n(+jN+{E_vUMUhpR*!*n&0HCgltQ*q~{96QWy*+ie
zZ+Iq{;Gn%-ICE6XG{qj%6nB8zp_Wwe3i483Jd53dyoY>J0180?c*ZYeJOSB)iCg|I
zHl6(dKx=Zg6bLkHKCWfPR3>d_xUK8zF;-if=Zi%cM7GREf8446mqKycx#gda^Z$AY
z|2dyUPCUvHXCi>Bu6{GSaXD(drBD)5nMbRg@V9hD8oc~#hUTRi!b>e(VSYS&0`T|Q
z6Oaj61a2c8+(|LpSW0YQXR$28%8<LzpK{~bz7-X4x{7FtyqQ%PR9_T?`C@Ta3!$Qg
zrlqw^Q?;3fDK0|}=nHYkj5JM%II}M!AAr`#3}q1y+3}fVE}uj;tQKa`SN5P*EnQOp
z5|&@;R$qG!(gesR7@;8?o?yGwA**VaJ>==uQF7{#w&Ac`ZG?Vy+<pn{)soyr5bvZa
z*kCODgME|WWYkVys#S~%;+|f-rUtdCa;mjPSIe2^((v>jC<MkTAXdQ6Ha*_iJ|be5
z0Wojh`?!>=n6YhfwC^B0^+znpxW<0y6AS`}lOOW1VwV?F<B<%mIJg>Sut$>6n0({D
z{$z!PFXtWCF3>m|5@R%6$`HOiViMeZVn2zdjtv0I83C%&L+*CMfX~4`jGfC+(M0?l
zVpa&9QVJb4_MsiARN$&f2%Rf2P__4Vc6D^-fb}L$C)vLRVya)aB&V`0C=*}do%V5z
zJsYnXKp&5{7w-HPX6mp%IC2e2Jg6@bN9%k&pLB;Vpe}vbK!Tg`K_ug6px<LTir|y%
zvH!wTxG}T6e6&NB9pV56qJcQcbTRm=Q`TT@p_tz1EyB1Hgpn=R;TRAfB8ZR*;vM1s
zct^ngXzz9UYUPdZw}Ng()|Z@OAwSmF*^C8z35dV0F?gAo1GANxgR36Q9GFVXoF8~L
zAcvXr6WM@c=KR|8sQA@(0y9UQU}f`dH_+9JO5UdyTSgLCJ2@tk^EoEx!u3bmZ{LIk
zRQfWjkNw8bDR7iUG)aFp*mM^bIcs6lJ!ro=0z*lpbc_-EG1Uerwa4w>iA+Ce{{?XY
zyiI)L)2x>>4^X0rlG09wtxc$lE5=%qDMY0MhTFbWcOS<!15G_8SuhN0f))!w?fz&n
zoZ3YHbN><zz7nEK35H2*@IL{I@MmB0<;RSzj>rCh-RVCN%l_xLOOCN(P{Q+K>!F>i
zz-JJM>+bOe-*;oFe}({RlODr?{OcKUBgSQgR|ZR79xqw&8p4v##wbsrv^M)BH8Lg9
zlp@MJ=#+{U;1W#>VKdzSEM;~H_F@m{#?n)u2X<#|a&38Uoysn(joga0k=YRjSqbco
zOq1;0ICFlM`=-DHFiD^pDM`T1&Yf~BalUP-%y?7szEIZI0+3<pwvEZEbyk&w{{1hK
zH{QD`F~ErAL%JMvA+4P81pPsJkW@E=eD|R!s?JdIwPVMp$JrEJLg_?nl8rsIMr;W;
z<LZD*AbexjfLu<%lT1+n(&eihuO1P_YAkV@1ahSLExEJ=$Ovu)5EC2=?jS9orA)G)
z^5}+B>Mg{D{g4834J+_dJVTU{w`wNI#8A{rOqL>nU8uSjklDsw0gT#vA%9qci4w@A
zH>cI&Ei*^#>vcI`Nj-A8@j4wl8}J1z>TqT32KAnpQ@C<K?%-U57HJE5>;;s84TUI!
zWfe*hD60?*#<KpKL+(zTG<(nXAuHy`f8z5*0n=i?exX#+E#pUAjD_E?f(*0oMbq=l
zL>S{2r2?-zfU;_`L;!~{q%9gxi}+MdGB2`U6RO}&_v7}9c*NTXz@d8Y&UQ2jw%9Ok
zf*`O{Hrz0qyjYx9JSVHAnvNT*u@Mv%L?vYxI4aq|P2h#lD{oJmiQ89~aI7l^*Ud)>
z<h})TiBPfq>Ialz%Rv*uAd%Egat0_OF`e7Kg||+DH$XuaBwdsxsjZILUT!;)8h-vE
z$gop3iHt)_vNpev+TbNWtjZ7QDWOH<AA$v?Zi_t!lx9+1O;4bU<Rw5@ge$_k!x_>4
zV^SMJZV{)aZ^XyE-%-f@VHk3SpRP&}!QuBE<dh(p#Fjv%oKebt8ttTn*C9f@rlas$
zLWsb3l6^j!No^)Y=j;U50uaZM5AoLsWWzAR@`{~o^W!LhBglQ;I0}yvg`$oq92}}h
zQSRigisxUW^1CEIZ-0{fSH<%$;<)fb=0_E(<jvGHTEH{kz666;fE&5!SugCkt07l;
z{|shOGi|f3i7cXL+hkR+dfm4X){xBYxsto5B;Q3QhPb_pU5>8|VqN|--as#~fzAgm
zb}L(6PlP&WH`{~`7GIE?Z;xOhIXnGLpQZS>{py$MLuqXOwiy;UObjec`DHkpZ~vyf
z0`*slqyh_dO240KO{my83p!uUf-3eagtf@#z@(T;)W_D&XRm4rhB_0L3?C)!gjt+p
zkivTj`^fD=NDsw+*`(K%@wSt(^Q|GMGyqXubO1HVvj((Bdot|L(J_=ZD1Zv$fP@LY
zM?ev!CfS1yt3$EyKZgAFNKhJ@E#t+%0@M@ZR&!!#6*@F!DyH4%(U#VYJQLoP70pK*
zE8RE_VG56(tF+_DBl=?bU&|<|M1=?s^hPB-3Mi+dJP8<wF%DQrPv1boY>hLL^z>&3
ztNIAO-$s4Vkw#lBt~UE&K~u_*OJSws!IB?d=NXOHt<ij;<gDJsC=i|n1Q{=?z`UQD
zb@e1G@GiDXP!pU`4m5<)U@r>r>J14dgMkvbW0=@A#j)GOE;kz31*}u?)Z=238l6H?
z?~JGZJ3GafgAm(rZ5F4aaNTerv#y2IEf#s|yS&sh+N=+dkDVs^UKAe4%c+uA>e#*(
z3<0B9EV22%M;vH8>CmX(XG2Ln3RsV0am@Cx9;JkC9Zm#OswpKcBY8fF=Q+sQ<T6it
zlW%2bM^A##RO3a*CMN@77}m@UL%NdAg&9h+^?*7<{-<6I01!mZDQG0c^C1<E6(Fax
zK>#^@jVhnh)s)r;b4xkREmfS9tqI`9uMGeYz)b*~#8q3jxy%eNm2#&yLx4MwDEgfa
zsXJjKQY(B{gZWf%HmC{Dk9WcoBxj$2sy2Hhy#l0arU4y@1G*O?-P##VWrsj<U!Oxs
zzG6EY3f?!#QDt8&IfRASOlT|ck0^h7alC+GGU!O3UBg%~sGe!VlTFVP36)af>U8Rm
zd6~-ID)RQ6YIV?l12Ti-u5%eFwb6$(Lx@JI_t-$U%7D80nAXO2ivn>jW!OIht=nr*
zC<IqEP)yb+H6u&fnl)(N#Iy)K^=q!tz7^d|@xwMw(R1VcAksZ`01Ng}J5&lqF-Z%q
z)lHCLkC6Nv*(Lw@czzM;yZR%)h@-3JNWLscPO^JYHlR;m=<oE(K@jTSK&V(xXy~je
z)+H#=P;jn;3;L<XrGQTvb}grfXT|nrrf~G1_-ud}F0y}tbK)X?TI?V55o-XLM<dE_
zzfXKsofR1t#fvUiMW^VZfeHGz5KPVIKrm-MCpKqkl(W|2CCD!|Oy0p3;msdvmL^7%
z>MWv0b?@Yx#J9yx0<vGH_LY%E6Q+ge9A_isoHz=Lhyu6jC!p|AKL>?X8ikc`zYc{r
zG5R|wBrN%d-$!4D+74s-XtMZ&!pfv_XUCW9KcF>~k?(z4A4fw1DeT<v+H-)NjHI|-
z-yrt808z!iP3b>Du;1=^ggo`jH^g)gsXIFP2cit&J%;ORC<i2dCT@%XpDy=uk?7dE
zOCxu=U_~jxN=N3LqDbb;SkuS=92lI{+6G)V{RjqD29LF$2)!7&-34vrQk3Pz9KqTR
zPYyg70)K);GQ~)_2{)GP&WL&_PMy*-kf;Gl0oL8E-8S!}^ja-2v|BArM~1js_O{s@
zaQO)?50TkrtXy9pFf&rR%dif>B>5=8KSJ9)kVW5{ieYFDq=d|uF_NkIG6K+h$W*y<
z*Prl4k%WOu@D^2?p74Zs!$PcL5*kNv1yI6F^j>e?!J3P8=~!Ld1$q={x)fvq2m0M~
z5iE4!`s!z)=dn1Q76-Nv<8Z+GwGh5V;m#~RYr7^B^e0u71-noW%rD6$oL`C*U@xN(
zxRXjBn1@=EbVf(;tHGACM7pHIYcSxt{gzzZ#3uJ!>f)wH)iZ$duJ-xPd<~aj#Ki_r
z+sh<P$ppwqEsly6Ch6}veA)`e+%^O?PvFyEW`YBt(NezL1v-AcJgkQROpu2zxq|3y
z2&@oAlimItMbC}6>_zpgMq-@R5#tl*JN<t3Kfk`e9|g8fe|PQ=A-xu<c9YqTrdO5F
zOEKW1RQHf9*GcvjDL+wWOWgAY{sm(`<k=u?#dd^;dJ<zW<j-Sa<aN2*N0^=4+GHHY
za@|2YC`NP=2v>&u50t5q5D$u8xs)`M<Mfi{hCRI%Cw{$ZWWRyY5rE7(rrj#QE{_8%
zKwH>%oii{+$N5yI&qhZ_9UJq7N+?V#{Tu>W)F-W6eN)}ZgkA$70V6HyBC5*Q6M#5Z
z**~G?j>bY0saBIFhPKh(#2I20;HJ$Z=dM28DztFqz&BQ(I7w@ORIu33AwpF*pPHq5
z`4O!f<aWxiwoFL$=*y+$LtkCnDQ8=u-b$39-qJPN6<86^Zu?g7K4%8*faL))coir?
zfkF$|Veram`(X^lSb>&!iIUJVpx_OE;nFWML~=iK7ZcWeF8wS*A1J3GT{yt)AOi5Z
zj{-cU>m-1W6n`c=A;PDUR%15@v}^3>2xIp^eDOpY90K+u>5HsWXWP5&_c#zjd9KqJ
z&#A;5CE_%o7*eHgLt@#q0|u!76;#deXDOk(nE4z^8V)_lIofhgrTq(aE%>8LPJmBZ
zYL4A=CpzdQC{<91j=~d*7F_dG1w(xqA_yadn;^`(&!IhqKkE`482+rQS@#se{(>KZ
zaKz<3#6_=W{V?XAK&U<NRiOvGglqSNH(p~}7~%<!96)EmY}rY95PsF;@^+c^PXm_5
zB#y|72#fv-f9(1izUwu1xeV3eXi7g_C0Jzl!Z4<C2!byHqqF8HuwR!u!?gGihAL<K
ziP8xkm+9Eq#;rd<Bth#MtyK*vHU-sVw=X~s5c)-b<xn#EBR-*CM)cuCQXY7P6p~B4
zg_e8Z7o*WZy9tldOWw0L<54nWlZIK(mudN|!$sKUsdfNO>q%Ukm$XGM)ddK^AA=Nt
zqH@zFZbT2_PuZyi>r4`h?5(XfOd6+s>g$N4vGT7B?Yt3i_z?;0d*t@A&TZe@JsX&8
zVTVi3M0InNA!!0f4C+ZS^Qhk5*_|2oaM+B|9J#cdhj)qgCzaa{%7JG0rK3p-^WJf2
z6zd}diS<%WS81)7bd_`HrGM7wr;*Si4s{Pxf=G8Rkwp(8sZ4k&ZnW*wc`dy^vN~l8
zf(>(XKki$NT-CbaWH(%?yklSZaBggH<f<QTIGL*b*T;HAu6m08-V%QqHpz8s#SXDh
z)3KdfP`kEsSYjOf4^k=NO|k9s?->xIlxs6Yh(cP=n55*{&j5PceAr>QG6Y>#r{jG%
zB6ih<I2rcOIC+MkML5#n0r`;#4+VIbBpaTTqKaj|4!g<b!vG+32-mueP!Jo-P<m(R
z^aDCpvm~$I7o4FG;&4fXXlWomg=#30RQ7sQnrOHk!~j|$MpP%sFu}n|jW!r0=F6IM
z!wh%B^`5*|?8NBzBorr{z%+L3_%*hYK7&8|fo@=|*3jUH&**N=@Fc$NtTxNOraSx8
zv@9(DTt3Z%y%_>R_67-vw+SKu5PF`5O=5WY*<8q>0Cy5}S9`Iot5BZ+5x*(}(==<^
z>6FU?<r+YP>jQ%4K;jvR<M|~Ec`pt0`UIE`i2MPsiAK*~9gz1#*B02nA_CU5f`)1S
z%cli^r2zO&96*0;ZL)s`0K~H4>Vkqzqt6pOK&lQK49P}S#N~Rd+?sXs*)JMq<BgH7
z{L0`}`N3fK{H11nBLK$+i|VIZ<_HA)Hf%I7w(=Z-mRoT%_ff{CGM1b8qcUJ|{-^SO
z63@$hRnb#Ohu6P@->O;cB%Ek`6+w|Z)yDK#Z*%j!F0!G1awcAE%b~}QX>U|>EID5|
zR%;SqS!fbezh8r3p#ZG^8M4Hx{U!T$r<{kmB197cP|ei^{zz@HKLTyuzG4hRsMmux
z3$|Pg`fZqO;GiM!F1GXj4p1nj*l(%w!1%hnMe*`(Q{{yw$GS@X*!Y%dewHNFj$Npn
zfm^;+?!~rX<@6Hg^0|Jq?gTYXuHChp*7Td>T4uNjre%hQPW-jm3uSNxKDyVY;X!&W
zYLBkeGOd8gH4ZJ)0^$olLI)qe+V~aUxFh@VoJFa~UBz}S@6`(Hd;PfX&Q-ilJNFXI
zF~jTKM$KfUC6r)b#GbvTL+BiZ=p4Z5OlARlB=d2R+g<ydzhQlreMc%uy}rOM=R;(D
zu{}j0qPAjOX#|I3$9>+6^q|_}`_U8VIoE(~RS(|)ac4iytkz|C317<$sh2f7BXJA=
z#`pJ-&+&Hi@DwAMfko_w>FIgX(`pAtuf{I?tx4>SH^gCPu{Yj8nCwhF%+0zlr8fvQ
z$zpZg45MJf7o*L(C^qf$sWun?J%da6U)wWMcs$=_-ur71J~kIY?%+)P4>Rk(hmfTY
zMjunTZZ_+Fp`U8|Ai-p_?mv|OrcibCe)V|Q(g)4DyVdjh(1Pe{JbGmqB-f7u7g7x&
zRuw!#7x{x{0}5eW!6^<RTdoFk2h74lP}!4$Q~AHTdm)y``$Zp3<HZSIB%AgBj;B~Z
zwNO-G?)Ze+FUNc~x*icNQg6`5h*rW2L~jcE_+NVg{y_xph!*tgXCWT-`xt2vaF<!P
zK|QTE>slZo5O%X!pMylvFGS((bdY-WgbaZ751~P+<7_|?_6VqLREg<PT@z}CJWKC{
zy-#~YARIag{QrX8M`sxeSL$LW>0%bKn2V+R*Xh^oQUcU@$`gyJN-SnAi@EOX#q?0c
z)V<yViu5!$8cQBI7WoRkP~8T)Sf|~_e2Fu9oSA+S0M1gK_x{Fom<l{})^u#$W}rlA
zw@688*UKcWXxU0BD0jq56~#+5guRw$DR|^@X|B2v?G@zXIahG3Adazs9mHRPy%>>s
zAPhHWL`I_*l21hYr1Bt|r_yG!J6}wb%Gob!JO3iJoF;}MDjzaGR@#TAKpRjv8wIMt
zzY4Q+YO)3UbyJMQ3mVYoID$|!f%I_1B-^{VRm;f(&RppbtCwL9mfYO>b{>V(d{9LR
zJU@lgc7v!w2@yi2V_d6v7DT!lL<)E?Ch&>~Y%;_HRIC8hI^nWNO0#g7*tyi~%#9a-
zX0XJsrQ;_D<J6%JcRC%zx4YFo7{yJ$2l{8D<p}5!x*zm~C_QI3>AH_Z1)IbmLe9dD
z-~X3l$A|wnbJIp`2m5+%dJ>qPg#xkL&YhJg{t76U_F;-dSwxRtG?O~HRhJD2mag*@
zJ95ds873MI2``*oE`47F>Rf8Scufq{R?VOetIP#okW=P@smLf01Qj$u+~tNTV*S}+
z_dBNAAV8#qQO~L0cv^M8xd`CDald)@Mdpt8o3$PLP2Cq?{-5qQe5--xgLCLNccJoU
z;hN}=<NSP1v^?;FP{XW$^Bc)7GMt+Xw;00?`HCKg;j%T43B%=TPlkOrY!hTSxsSc`
zx#vh3X1)o-B`P#4WHX#uzZ}(xjs_z_pBQEiG0gh+fd~(I)fXTt&`?qkD7oD~)Ai2G
zy!XxUTto(}cg)RbfylM4`~|pu3_(SCFPZo7^+M+6YazVWCq<_IGk>mmZ$E%AH#g$#
zt;N5=dErf&o+8*Ppbtm6W#79y#gpa)&;-GNbSHoo8wPZ90$$Jo-JJm1F_@yK6F?==
zA1Um@UOc}DCXl-Wz{%dE_MUB;0gu1rL?H5%kquREBMwd)#%i33EX46fC&x%6+OWP0
zDwZuzT|;L5Ma&pkpJq?t8rCEJF~;i%xPsZud(T58-WPz|wY&Sfo$yB>wp|dY6`uLA
zRB^CX&h}h`438AKo{shKZo*+!p~6dnybsK~c`lbTIP8P+=Nu)&JPO*_52E{#Vd!xf
z<}rEJ66y)<fh;*FTUj05mG7{0<}U4%mIP(CTG69^BNE2)9Ub*yEc1a07KHkQ|NICD
z=?bMQZ57OcSy#K}8tXQ*{%y0Kdkq_=rC&ZR&Ae|A28k#)4-(@INH2RYmEnrpFB$xx
z1W(V1aw~#tAJq0Uk5f}5h}Tq}otkP7w$mNAulp;C`Vcr_g)whhI)-(bbCiJ^YFK}S
z!}>dz6C$-5LaUhN&tJ*1tYennA&aWH5iH!XADTYfq7h}=ccb&O3iLP_?vZDWVXO8C
zhJSbt#RX6t8|Gzl42*Qs<Zf@g>jWw72^t<f4m?|)H9TdHgZ9E2mlEFRK$c?#P<uzC
z1~!AK<9US|Jr1ZedDfsZv`0YoC#WYGB63Bw6`rBwXe*<bl2l_QsI+5|&)>O9doHcc
zWi#(z(DX+1fuk_b{sjawqIG=SPD@+#B>ejELwT&iEz{Ar<ni06a`Zs^<MZ<POPB+q
z&GNXK3H~IHerBU2z!Z#+Ka$5~Oz`jRj}7ve%>*0d@g^jQtx<VmRo?C5FZXUg1l(ea
zyxV!_b!@(O`)`=8*t@-ve!qA7gLDhDJ4w5_+RffE48X|;c~G9CTQI})Zs#O2*2}y7
zX}VpMzi8v<3^wcELXzla{DtqzfVUqk?$JX0sY4=rK*WR<Z+!=+5)nL{iX%vDwF3JX
zR+zV<XxPl(<f#-1JV9QRn_Pg<2y}OUr;GJJRZ36YUE~$X0tjyVC?S9k+=|tx>?(yx
zOrX@ZD|E(s*1J>imD1(U1}A_NJ5GTl?1YB^%>Lq8mhEiZQ&Y(^cN)@r+#V3FirAkG
zT>_VG)O^m}$lj0TDs<>8I<MV>(!Hg2vgZgyQhScj&F~V+*Mu}@tNd&Li2nX;6eQwq
z)Xwgv5vNBrN}VTLo^}6k*DD4H;-OnQNBk84+tCjrHNh7U{HA9V(dlu(`xC(zYmbaV
z+jb+huv#+Mz4LNr*h<6c!OWd832|721olM`-)wk#930AZu`;qqGlLH^?8~q+NQ=Pl
z&Q3eB@*lBec~;)A{|FZHTTyI#-7!kjWCMy-W6EusFbr{!+LVaYgW4m6`O&VgD{KKP
ziESAhpMDe>*~i5of41{}U#d+KH|=!RR_M|yUEs&-Lh7Fh`uq*hwb)a<n0N?3@W>1Z
zWgYe72%U84i&#t5N6x^kvGZv+=LIuIcK|QUmybg44?kTXrwp?SHm&nOcZx?7WV*cu
z%N0nIwG-!OhO2Y<xN+fc)@M|4@b(`!0sRGu!ZBAU#=0KkIu5RZI3dLCc(~CEy08Fi
zcL1B}1}fNT9gUKY0XNtpz1AnP!NhtlfCX5}3TXr_E9BW3V6`X1ZfjPG{k^>~d$y>m
zJ_<9z){Ni5R<IO^?idd5Q@QxFAN&Y)w{XhupHI>LZu@~t^c7B@RUl3F_QecrZV#lD
z-yY1s#~FBTNcDai?@}|zHr|<z|I|i|TdPOJ`XrY9S7?pVn*b53;5{Ek0<MFvPLK8G
zYegS`KbFR)^>}jBe(DmZraIVihvK~i(zhK~4pz1Yf!^>t*m#9^&k31m_P|yTTRii)
zW`uQpO~7Kml@2>PSEr>1KG8&Sa@(n!6l7B?3RaPVv#>dY%mxl+qxb+z@ul8FoM9KB
zr|``F*%DDQY(V*Ty6`Tv7(qrg^O-xL{X@)_0wpJAx{hNNBOh29(cdE%)-CeGr+DT>
z&>ay+w~*-m5J%`DQxAnt+_HLH_|$@6YWUQ!5PFcXzyhSTk7J}ZcdWx1VhOb0<M4ew
z0EbW2;%womA?5?mAzftZ3EC3xrRWzPI|T5FaDIz?+P{Qwe@Hl{RI9zPZ?z{1GSQt(
zbQn*GkjmN<tz@EWnP}H(i3-{iRWea76Fqubq6^v+u_M?$;E&b7+#Tu*^*xXSxd7q#
z8rkX|h@x1@Mi|KrqqgskxvU*Tfi?%0gN(6DHUd+Z0Zz%c_HKNGbEgf@zrOKJ<8#w!
zI@Nu{3kP=0?3islvZ<O0Ec;ayGLy%S03u+0$#Q=Kc6O#c<H5JsUz#6p%$tF<;yr21
zeeXNqo)SLK2e@ee)N}2VWI9sFepqBVCT8#`Hm=iq8ntYBLLxXE4TDVxE67gAy^%b1
zK8yV^CzOhfZf4+@pd4<K2p@8xJ9vV_bR5i`hW!xY8rFHT!!1cF*yf=leGr8aUc`u=
zTv-2h@G_9VV+7qA!a_oS6zP@Uhxgju3SZ1&;w6mV!1!|#Oe8`hk@^k<6tmFd5Mhrz
zYa+yFMEb1EAw=3Yipk<!RJbDSAFy7<g&RKWLpF3TR+*FLb4C-qX4tWv3Qc+(G}Gi+
zqnV*S8TKmRCPxl8D?S1dha@%wPYo+SX>JdVd!Hho*&kvJAo^SqiaBQt-Ndj+V@QvK
zVRj;hxp53{Yw5sEWo)`#EOs7?RorwJaan@EI5&;%$W7A`*O8m9N65J$ZI8xS>9wBr
za<7yD37s8oOd`WZmm;7LNB1Vl2Jhfdjg4^MFv1t?P_D<evAofd{aojafaawFlxF`4
zxDai69K!kKSvPI5_F$2cyaY+_(ah8Y6f}nA!vFN2Q?qFV77>Ay80nac9tVN)L<Fij
zMWEmt6!@M!pixsDL_bIN^5F#Xt4}E<yHxS>=+pT5iccLP2tQvF_dd0rJT#d8bE1j;
zBNAfc(~qIL33F4~9-;3)v6pjA5YRTT1~T+(bAuZFwY>qJ46o7v8+z`1(QRx)a@iC|
zg}nzc5|#B<LX-9Wgss7!VFwLj@$MwV?s#O28iCyQ?(M1~N-8TIfn{jL!x3R9IuOB}
zOeW2$Ts>?4E)O{g<Re^$1KYd(>MTh%rgNBpsO>+HsMOvc0cf1@iL2yNo#VUlQs1^v
zYSX(JPh`+zw1v8a8`GNJO%vZo^rhg!CGj=Vm(=ub67F3)f8)DIU4RWJ^`D9|W%`<r
z?QH1#X>-@$P=U=Gw{HBjIVsq6?_sO&6Rw?2hm)+nTObl}TMzz>rMOoh71z!^kx{o#
zm3lbs(`Hi@c{t_M=44gg;Ut0rlpu<CS$%hIaU(YhyDGC`dS=d^(4~RMbgYv-gX@GM
z8HmCu{3$pkFmE#Mu#2WN<oUygQyM1V`mVIR<NX`Mdt5t<^7gEJ3lOHK3^$CAYR8}^
z$ylKU{d}GiP*3qMyP~jUcgEY=axrW0M=DY1bZq+b-Ge47PYXn<QoIc}e{TKL{vlXf
zsFKs{#U_dHiSD)Ix1y1ZoF?m^`#;<Wi}6QS;vy@zG-x32lWOF=_Qd|f5r3ckZ*|-6
z?{+M<JRX-eGZH$%cx!j~!yduHr$!M{3vMxdYa^7nkFK;@t&{uhZb10}YoS=RDDT5n
zDTNKwKetYL_uJNfCiiwjjdljQ?Tnc^=RSYaTW&u}v<7-mak8PanTT6`)h#c)zbPAx
zor`^my<!*makZAY!xcVJP}9Q~DZsMljb3wBBX;m)nL8%)0xd|~*O<z0^^zT3s=;yb
z(|)uVR-yclGz9O-ve&?V6t+{W=A75+|8CB14j&qVD^;#fxQzfZ^3x(~U&C#g!ZMdv
zW||Moq4<j2m=*p2mrLUCC&enbG!QAh8*NaT)eyKl4P`g@?nx689{(7JV2}!zX_$3&
z<PYmroPYL8k5aTM#BQnaMdojh1zaxx@023z<D#ahyCEa|E)HlP4dgTzS*=A)w%bch
z2(ON7OexCyYc;mFV1D5Zulx5bBQ&Nc;`?`Ob;DYkMDMEZ7rygzBXl0|L@i<VuTI4k
zmBAxks}fgi?ZZ)8dlD#6-?*j*s*=lxQ%xyA>?xpV$SLuL9)8zJe|Tq#-+IyCbcFc4
z0eqgNIUcv`Hht(0zZ*yA_3BoT1IXN?k-6ubk%6R0LGxxLNXZU+0<*ZU#(K&AD-`YU
zdMF^{8s?@zLq^wWI-I%XcCuq@ePc~l)1gf0tzd1OgKK&d-6<1HbweUk$@IG;aO+t3
z%dWNPOPE}xw9qD<&Nb{3+<upNFg8@S!C0^Ee<xDNC5}jby&L7(3*P*)&6=NPm8Z89
zWFmkkh3K^NZ@j41&X2Z--}mFf4HzhktXGPx7nCXCW=x9FO?(Z@Q=qL3$3)5?lX*A3
zgNRz6g%?IQeUQoRHQlgJCqp7}-WO@of&46*CDVD;#)r@i5ipEQvegaT(EDHB|E~3M
zkANrLx;o2h+JBf6)L2)fNVl+J29Gs&VEB}){|Dh+N!IO|u?q<ew?w=r%Cbt3)iNy;
zeE^5W+(I1L=rc9)Q1<gs;k{PBZI`etNS?m2A!8;$qxV`}!5R(0Fxc)rI|*nty_1@=
z3l~UIVxYrgo5EQyYzu#RK~2`50oB+7aD0!ft1(iXm3Oq}U;5Mrgx*CEdR7*hUyjDW
zZlc)6dcpoP2xo3Se-k*e+EuqN2!?7BDYAJ=!6wM(-L8VVw$KN$WQK#TVECCFNz-^S
zigU#h8|iNiQ#13XXRgOe+Do`W(bo{lEClMA(;@@MUVd|Wf%(JT*m3x2awyGy7+uRB
z@q@4S2O{$x%nIb~t?uo&o^9a>1mMl+k^5GE9EjYUHM8W?S&`r$vu5)3tTRhKm>sG3
zb=J(hX!X@a)?d91IYkf&z-pr02=J=(PwRt*@wlep6JJA8z_r`&`jTP;Mlp6%Yl4FQ
z!s@?Uld+<fGBfY_)mw1UVE>}XoX@=?6?(zM6zs;4DLmN-9<}CYI-L(v@|fbom(bm;
z`B~s^wl*Z=wfd467^KLvervyd96Bmya&D0q!Y0V1bF`?VbkV;ex4H$nzHu#XeuCDC
zYbAE74Q99mfZ3KIo6joG@HG@-M4OpaRMHxVEciEU&AAH{oQtpp--V|*OA7Kebn`Xz
zo0+q>DCc9Tc(?_U>jf>5eAqGz^7`{WTm5p8wYSK6Hjwvf^;itVImZ>5zI0?4M+>yW
zbF1GhI==7fNag@Pw1lF_yl>-{#;ZOTO7-+|z`#Hr&NG6?d{zN3{Q_g~W?Ec|`e`t`
zVR{<&1Jv}QsSZtGyZ(V`eJ{w0hRhbf)z@!LY=If?=`<MgaJHqhF`ajs@KVl7)RpSQ
zt6JkL**Co*eM7+f?XyKLj2qASn_}+iR{Dk_C?meSUA1rc@yg!0-peaI>Fe^n7%9`h
z&b&;bFM1;_M!4g$sKm$90h#qMX&F2!kYVQoNm?tA@G|s{nbyB3y{!dxS=ce}h1!9>
zddS}}5CbyK>u@a2;ISJF$b7eP7}w-E9Yf)b0lpQt2M7DB;We{9`;V{|qBz6u0{AdS
z;Pzr*x~8aMc>($uSmqA&1eV{xo?`971tA5vT#z4j#OFWV>5`eI#xe*FL3Okb_wN$t
zy`Kd~_#4ny>z@hzRi-YO6(6zvNGqGM6gU8nJ&EeXS-is-pH*Z5@V~s)%hpRxU!>yT
ztQP}Prpu;4wRS?-(4U^Sv!)v;>uSV%pO0f*+un?sE{?L2DeFI|87K-uOUm8EA4155
zrui5{2AHXSAckfSSUTXr^_J`I%kqZb9TF_?icBud`B<|wmZU!R?my(~wp(@JhFqWZ
z%>EB4(EPY<^PkoPq5%yUw`mj}h@IDvrukeaID#(iwQfecp;g=L#h|LXW+lt1H_n1~
za@8a5pUe`(TV}Ymo2}hk?M~8e0bO;b6x@!(`q=Y~Uf}aLKqyWt;2P7rBtKT}5gxK*
zBmE8iFqDq6qp#A)nLmnm*~D;51r(Jp3WB|zpaZekUkE#fDl5s`u8FC46G%fr?BIMG
z&f7l5#Q5NGlX}7qWOZ1CUcNA|kuIiJbT>>Ivl>@dXS8`<TJ$@w0c$6Bro$Y}Cp<u>
zD~7`OkV?G9WrQw>{uQGQ+mfrmjZFMIC$Y3yJLud{j^jxLV{R^R<>v<9u7l?H-~FLg
zu|(dDL0~{;3icSZgink!?|%-l;S+i01I>8AE%Bl`3OSTP%NzbYt+rRh_qc&9ZIOx@
zt+DeEX4dwIq<lw$=FPzM*)Rl&+N<6tXl~Ba1=Ms0@S1H!)}B~0{$^SqW6dCtbKGm4
z!fE9?U;}3ZoSAvMt1m2ytZDOZSksmp8X|)(x<CNa7o1Bu;@WU!ZtzGfUBdO)8$L1C
ztiKgi^GDW#RLT-&?(pLIWFY4myuF15c&$B!Ijuguo(_|oS>FeF!Y6V=BScORaotvs
zSqXp&pz7xa55-a?S!B(N;kGpM-ZW%(NI5eH*XrLV6)1G=VHvtaAFiX!R@v6N!gg+O
zz1MXj+~%su^Ff!%_PU-`HXoNSG8=ZZlWDbSk&4F+*9Wog;kJz0)JW!cT>E@^uY_J_
zx=6YiOTih8Y}6CVayHYS9|=5eL`M6CAW~9n1dKh|8MS?pIg(kN5Yfvz8SCEe@2s{l
zybaJnTMYt{HLc;cZst9d)UiRQ$Hsa{h)Qa;gx@<DZYwnFc`_doBfHz4ZXcO-yb^)8
zvoxY9iXw$^mIfCVy7ET_yX21v^^EoP3VPV@6g$t{(Wrdbv@Ne~K{i-gRZsAmI|`FD
zTKE1EFxifSI;#=e?=3W(n)68W-G@BLAHZS?QJNXK27{LBe1PpmlaH$z3#P5jiR3>O
zS+@pzPgThQbW<m#xr4kht|pb-{mRUoXT4j8%tHObr_yS>Z*1eU&z$w5&wBCr!NU5#
z`^>@@W3bUHDkx;I(Liw@+6?;&jsTZ#ADi``^g)%jE5V{ph=fnfGVAU|G#+YugijQi
z^^e0B%L<=Z26_cE!Y3-#-ePlz58(^96+p~zjj0jID3Py}t!2SG{b7ZGYuohGQVfz5
zA?RhQt}e(k9Mr+*quK<~7QG(WZJUS7AriqK!o~%t`xnIXoam6}LgaC(?ntp{F9a6m
zH2JuLmp$k~6oszoGkst{VdE{F)tIxuM^^Nx-yGS56RAqbhEH^>xiI2C4$B88S<f4P
z@EX=Wrg;`GT1!X=%9`c_WGp}|z^=|mFkzC%nmg(AtsU-%f>MC_zk*C~y9h2`R<sOR
zw!v6pj6%1~o98L0t=xih6~-tahBFi$vcANu=-vf6&A1EUkuyN+rx7^3E*m|h;P?Ti
ziWh#%>4n>PCl0$k=1+T)kscKO3CiXNbNc(6(b25t@S7&?SuWX^0O*DkK_y;`@F8@>
zX;|R7Vj{Ab_wNM&k?}l1R6uZi&;u?s1}DVLhgiY6C+!o56YI`vz_WNuA<;eqGx^a3
zxoDJRRMJo7j;!jD3ydUVo83=)3K-K}dvfXd0^8fLaLvb~-0AidUKiGMB8B_VFOJhe
zhO)<8m{pg6F~BH|XdW18_G0PJRr_w7I<Ztqx$)N;%i`p(P?I_1=^+nT9jjSc0yds9
zj7Qg*_r46xkk1dUTjg|xwzeZqSAYO*i#CG#uoDy~Lzodn^tT8=OIkmNd;Gu|+wzvv
z+7i{IJtu@5;S*TR{2Xu|%Lw++ym1@6ut?-~P6Y${u~4DDvG%=qr66;JwSu>wRy`Ox
zwu+%+Z~Zehv%)8b)Lb4ud8zrpZ&47+d;$(X;gb_<dd3^NDmivxIO^WUTJL{zXsfPo
ztk)I^IW$ydTxwq5h-Gr+F~9XAz%lE;kN<P$xP|AQbmF-u?H1?bM9nT*1l5)!Th0Mg
z=n>%Qvwq_F0c#IYlWpF=8;@JSia2=m`FXY7K}jlz;l|!rtfykou-&r(jxRE!Z7Y*u
z%97W*zDwQ-uQ{{PU-FT6L;j_?p;Ww}C-yef7Ab0v3tiNk_g9}e`wd7-8T%JQRMrgN
z0tkvyk#&zltJ^WLOQfO(m#{Rtc-8S?T(%wSE_IfazP!fu9_y8y7N4sn5_}vRZ<~=P
z1$nAkdH4URP?YdvDf|bfM4k5yQ2>RT(zfN@|JEdH&+)^1Pc@w!lJhK#H8p)i8x>2Z
zs}XaQyyn{Du~Z3U*Hm{&La<on&SV~h=~lC-C~{plYSUR>7#^@{jjN((Mk;!BhjGK)
zG1CY~bD^cXwsEx;yEF;vatu(|oEthsvnMv}LrD3d8R5NP6_a2M<r08vmoE>4M{Q>8
zY6&QcRCMX)-HuHpM(iDu64dtP9D=zt75W~abW#+rv<&3Eql=<AKmM8w8bU?W-wX`=
z6mE+!sji?UG`C?TYzb}lp!eewU!IuF^_O_#lV3lq1mWEo_7yK+E)uy<-2xYR$U_?i
z2UGSV!tenG>*!W0J3`*U&OuD~1O>gwY!;Pz3ZTF+bNw@GdZ0Fbs-JJgy5TS9Ir^dO
zvqPgH_rQUk8cE69b}1iEc_aR|jVF^ZSz14RYcd>PP7@mR<dE7vvXHp{J+yl{Mg;Dt
zFk-&&$%|{pZG8*VdL(R5u>dK!zGlRRIceh|87c(YgH96}o#EQ=I+nM~YBp!Rl=qrB
zdp~NKh10U#b6(2XpVLYo>gYFWrhud%ut@g|GzRCo2y$yycw1AbI6i0`0fpG2#X>mD
zi8HOk@koo?DoIfGne(vw66R+TdNX!TVp<RDR0g+9NZ8F%+HRncWz_UWnHawW4PGP+
zGy>MqINV#gq0ZXnYgh!W`6nK#mD&<3_l^tK&cXE#==zitP#v<@_kzg9@x-@-{iFS1
zL4_R0{(fr%q7i7;-<1wt5D7`stG`~$#rhQp*HT%QZLTnkC%TyTlp;919!Br(;q^F9
zeE%Z&x3N9+$oK&Fh7xIPSP^t~!j6kFA9x38+DGT;Rmg|n`nk~5iANpP%l3G$^-{u+
zK+L$U#Dt_SL}6evvaU$__!x4b)wJ;q>W&*vVr=ZP`h4rz_F+U13VAP^^(g@07e7Zz
zf8Ij^%dC42%dt{Z43;o6tHCm1u)*VfD3qV*eLc=hG!7$igo?gGzS>LMYY2K)C7TaS
z1the2_T{R@%!q+{qNv9JiDZoqWdenaU^j-?^&~AiqR26hQuFfrr0LE3&O<%gi;KPr
z!Pf2teZg=GjNthYXbbAMi)LWf{Q-$!YeDyM_@M4b2qO334fb)J@jU9Gk%v4RfMB8=
znTWec<h8@u@gY9882RoK5+e*U_e}Xd2g@QEVvm{&_8^_gfKj^VYuLVY=b+F9zPt)3
z){!@1flZ`NGO&}O074e@U;{;u@BkdP2d&X8`6zb00w&gWX?=%Pe4b~W?qc<bLT%TK
z@_E)ZT$||~b!}$To2f1?uk^?A3idU@MCy*DWN@V~{8pPEi+Q<teb<|rOU;*kJR`<G
zELG*S%8DjhGA;Zjk~Pa_xMOAw;~}y$q<Z+jWzSMG8`Fi1o@uBVx9gdA{}-?Z*9do+
z^^}~P{*l8SK4r&j4PGLzU8?8k+TN1DAp3Hq7?_cr;Ne8_yq%`D2G-pnZx0E0idk|E
ze6mrn7c|t=auo+jhPc$D;zLsuLr-E;z(^mvjp+&!(t(&+4#uGX^KCm*z6p%UaPnnI
zBNWF55{G>^Ym5+@k@|j>_<)1c>vwL%o`3Y^&kW;Gty%va*16#)LKO6XxH6l_ec#7k
zULXq8z=Mi@C{aB)VB_j@TiXxUts3hHz9Y3oco}`&4xF$9`KTqIu0`)eXGDjJ7aZj>
zfz#E^x_=@IaecIldG9_vvr^+wDUcbJT3LXJ;%Ge7H;Syp^1ao_xuYU52v0J{2`alc
zmq~7?36%1|g}%e?jm;FrIbh8<-Qh!EHY~ZJ(ut&a@KEQZ07|KKE6}U14bAO@jUMkJ
zYBm{CWYB-Yp9p^ZS-@*bQ>H<*auhP_@4>%AtI#?TV|hD6)klRUN6nFqAeZpw0_h!b
zLS#Da(>^c-N0ED8uhf0#-uKZctkFJ%tQy*0pJ)^jOxhGr`aDAX&YUk7qDl|I!{t$i
z+yQvhQp3b!^t;$?64#0LVkE<O4CMm$QX!C<U{)m~XdRaW;rbc%XZ&b$EvFk>z!!t8
z5wVj<#22wk9RhpZsQW}`f<C%V))GfSa&2tlN@Ct#bJpI-jV?$bHI`1W1%t3Z%f+Gy
z-RF8MXMty39Ldo@lI)NTnO)OI&V9%*oG&#)cq|JsYtKi_acCe?Yd7LhF$l+XO4qCZ
zdu<P|^}6@?>rxX!0o}5x!TjtXmdU7HH@jYg9@R^OctnGMUg~qbi3k|Fb&mB;$<(I+
zLyD{e7_6izYo+MiI-*4pS<>oS&qrDeR>iO(fb)$)bH_#A@cX&moTtrt&S3$zI5M>@
z;QELa$5j28j0o7GR+#fIa>ODoNkenP%drZrcVm5h=8h5<L14AtC17~}MPbA<*ej~d
zP&k>c&;aHrrnRw{O8x@#fuEyMqR-+_jA)5yXM7dyAN><8fmeEdn~O+`+F^+ezL;$X
zEv=3YSU)cS`1k)DKG+RVLr*W_hqf2=nh<WaVvs6MhJMUS`mjV*?9KUGyk^<4zF2$3
z+$ys#ZcswKa+=NhjmYPXqzqKmx<FMcQ&7nRAoGEjVV;Se#NSscbS3UIq7EF_<M#cd
zt?hE$V;90oAIL(Lt`Zpqv{_%G9-$FFz&op>KgFM<i{Tw?f0HNOz<<J!8|RH*!h@#u
z8^K{b0|j(N8GIlE?a^Tpj2*>{S$h>ymqVh^a*5s@m-3w`B>#;z5ZRL5L9vKFp}^Hl
zQ{d_zJvVUk1l)WS79Ut*<!D8*%(RMJYqB#(DT5i*?g?8_4{Su>ET^|H<^Drju?o3k
zW4B_!YRhSIB3eV~u>qf|D!E``RW&U`n&^4>(}Gn>f%5oKEv#6W4sd622a^V`!TTMw
za7W+<2Y>>p&C5uz8{!004>X5ilMECiWrAh5n}q9D<D^CWe3;9=L_HAJ^KSx0lO3ft
zMc+mY7FaN9l9l<v;|99;oM~xC%w8f^qEABYYnRxu$qCP66P|}9Jj0&t82A#6ePk#%
z#nTNSDLt4&wb=pfDWK;{?GaPn1bUPt8iB`XE6ivLGW)974<QXP&(>g*bY=nj2}VE0
z2v}Qt1nl4GQD9r~h&ziP1QjghVCu{P6>`2D^J5N-nD8zD;c3f3pDxDRp)SXHj}F$U
zCM>&}b#fyLS722iTKb@Uhb~rRaw$A$C_nl|3ntdl1NhUuttc^FetWv#!l)E&Yfm>c
zF<oYRx^luBfW+9;cmQ}NF0Nt&K*Oxhtyw9WfqB9={9%gy66Cc%j90KGEIe;~e-m<J
z@f^*UOCt>JFU5RcSAl4SRZwGt*f7!C+afB*a4>u=h!Tu-MF>Ak(9Zjz8)fd@VwfW!
zDH5iyxP~M&WGmEOh#y!{c1**f0~g5;yiR$xJ9-#)^sNw1Iy#`Ex9aHU5Ura4knS8E
z!g?--mzE@UWa-Tc><_=Ez;4v}zKeVu=GUo-2R0p4vDDaWEVTt7g4WATA7*ZRx2>yT
z1TQA?RkCjj>Kya{=r<dmMW4ntMMtOG_#qERV3>EKWFxi$47V;h=vfoFhpIvNguCW~
z$o;+XhzVTP{v%s^p`~&@wp#Ze>UJX5bL)ptM{+)9G5ZfGU9(XLjjqm#kkTY0P^&Yr
zJ;W(9{2}!UH|xrw6w?)K&cy$M)P^z<AKIO--H|Uqr1ZR3;<yGfy3tDUfPBwzcCiW>
zM?#;&#hgjOl<;T|VJ{-=aK5MS>QVlZ6xjqRYad7kR9E$Kl1ZJ@n1N5$N5@++@~y+`
z)MShRqd-4-8u|(6LWF0m$xI&YX~^_|w@Q&Mo8hrOzEK`eLy8AhZUiB?RFY!}pqqJb
zuqSfjF|{T=49y@#WD*v61w)3fUIbF*;wV__?_~vDR6ATsrj<My$3+JN6qs&iqLs5y
z{CxcKt(RkEOvv&8B`X<k{lv;U_LT0%9^RS)bc6iZGzS#i`C#}qu}Uy|jL6O>CUEoV
zih>7E7Co_U%&&F6Blfee3U33A{9fk0eZdph;91uTE*cOos~~-9sz8VEArm2L!3SPg
z^?7G0E&2Trg^B6&n4tE2s)QLaBdK~4Z{iLP5s8f@4U=ouB}dWZDWAkwH9}a@fbL$!
znXSsCR%T;23uqsT@g6@AoE@+lRS~<G-&yZMoBOOrSzQQ@_}X$X>#V}MI8jDj7a756
z!k{QSqvtP|s2Ra39zMv&HEM7$a^0VVPSh~b1I|XdsqZ6|k~iG5infaNM<gEdV;Rmv
zSN-6?9?1ni)NOvx%_=wVDO8=P$=?)pN1!`3evXSD)MV@gHd;?%mw7N=meZGz5q#cc
z-W$Pu3gG+H3)0s=%T8k6I|8B6IZ0AE$nrYA4=i#OE=>ahn8z$;o?Fso<<WttdZ!}1
zLdv`G#02Cs@819_HKco*qC@JQ39f=AqEA<p7O<MaZwM0z9Mr5C&ED#bY%;)qO(#=u
zV04)5xx@RJgFOQ!Ek~!ay`;TcTzgN3-edZsX7jVD2}mq8=QS-guSG?!OGL&Y;b;Vs
zj0+$m*ofh#T<@k{MUh+3D3CCagi6?eKqSjQ7qO}fT0xd)&3kDfR0N8^u!9u<^ZqfU
z%+xQj+o%gwl|FrhHW|Zzij1-IRpK&Qf%5j7bsSGnPp-x_Q$zuk1Ax9$qtckWDVg&C
zg$XM6IwB7M#&fGSM_)nS@L_QMvkr>bO$I;{_4+R`=!^CFV~~0Kko8Rf8MH~TXSH-`
zsJv5gfNj3BJN{v8n84aNr32GYVH^dB)%iVJ7fQXsE}WepuICPf0M-kv;ObOtHRA2L
z)7m!N)s`DPW=-@&gBbS|5a6gQ7_CCXqOOnwVA?g%+c&Lat@1s+%m-HDNz37M>66lV
zYH8cgYO;saH6|d1M!#h*sstjA#Pbb!UVvw|XQUYI*|)ttfne%TAbV#)XiD@TMmzy)
zZn^=T5jlH?RMj9h%rL{y<NT0qBDDG7Ht>nAMGP~#LglzaCGWY=T9Bntm536WR*xeg
z%x~480JDA#{vUIN+_E1bdK-L!ypKYCA#Xt$@9r+Su>mM1mc~D9xN|6%7d(LY4TdXv
z8M06k2xA3=v4(HIMbv@61L>y~-=Bp9o6b+<qp>^9Z_NPdNsB%JW7g-v7u}0aj!I$1
zb8+g$kkEL>&9B|IaFJvbhB$8|GX*0+xocNkyx;H=wMtMW){B$T@;HUC=rEYm{QkbY
zcd+he&f1j&n*(NyOjePzE0!t`C?eaaDOROkhAL)jz4nNG(JLA>UN$AO?IZRn-ZX||
z3p`qhcXYkXq2*wV>k`m4CG2AfYl-8x^=}FYw@{QCHJM0Ss)6lBQlg&iGdGud{DpOI
zhfK7uGiv6#YA<%Yrz>#-jzi(2@eea0)QVRdGbtF>uw<bH=p3>8;erTjCrT`LHM@2x
zgM=X26*YtA)xItx$%(q)15`17ET%H&RBOQVoJ_5qNfjh<IxOIF(FRoHIEG_HMn!_2
z_C#@dc5|8va77P5Ir)b9z;0lT$K2Fl4?4IXl2b;BT(exkNkstR2%b$2Nuj7|s^5jH
z0l>SMRhGskf3>&7E;>V4@2`fjXCH61Qt;m6W1>7oKSwwFYC80o@$As5|EQGvkP<aF
z>kdIAqlOh?0uoD)n~m{Zr}iW(R?eUgp^9Mj>9SUN#J&TqC0%a~1}i2hncBWqiMnH}
zEmkWZc=F3Oy`=O{g3Z@pxnm!_6PrwZxX%{N;71*3T0r4JymJcCPFoH~TOz?C$X7NO
ztQeY#m*5H;FAtV;3gS@vJX|e@ExX}0yldqbBuAX;sYnk9DB)eAatbNgfV`<6E_&`&
zc-`>yPay+cp(|;W$@c-5T$+65W7#>+tos+*6{Rf-H;-pdY|)zirf(BY8r&oc!k7pF
zd~`J^T8NWgx!gSYOJsq^tp5=n1UBvy#iPI%&|Ff$jPuJ_@2`f1Yp^=kC0vu~s+lf0
z)?6vnB>o?xbAyeARJw~^hznJ~R6Srv=!dfMmE|EnFF1vu7kR@^k7x2+-zJ<#-cJcf
z<wv94$dQC}s3~Yig!K;f-JOi11|1ULj>G`xV(mM|tVIlNDfZ+m5$cDX2^aeQ4OMRM
zW4Zx<zE{-%JHWF-!`h=|+I_^{glH^3lBikH!<e^zCB;&eA|V`Yg?arEJ0LO4_#`rd
zx1>sBu<UjQdJg1@kJ{dFEoj{X4wpiI1AML5d^tzGd4H?PZ7)D${z0o?9{YVerP?V;
zGuhM9%XC|b)R`)b*`c|Dxa<JUH4M#liTBf|T{s0cq`-*faIothPVu<dabu(O0B3HV
z+qU6UUhoa<wb+yq!-AGG?m=USrAmSEZZHT4(jbKErN;U}UpMSRIEaCFpu=Q)#Qu_<
zmz`7?37%M*#jzBBx`wYKaCfrNfQbfn5rb)p@!}o;EHHwr=q>PD17a1B;<=!dv7<Ns
z2&)G=E2id-bcZXGA(_;p9rF>8#SGDWtZv0=AAR9dHZ_dfN9+<5jB=z~BDEXrWJDjw
zgjn5|v<cn>!-c#d2n_rMPRtZpZ}7k;4lv@BkW4^!uqfMmM1W%f5ODEQ>#n<#$M_?2
zU9i=rZ#+q(L#V&s`pDdzwu#3tuo1b@RrgHjNHhZ-IehYqb^ZJ$C;gy=Kj$OFL49d4
z@8@lI=H@P&k^+%At_?LVBRFdJRM%MelFZFDu7XW>Cix@NlW;mG*t-Zov47jUskeaM
z7y8h<JE;ttbYL<`uYYFkd0u24gH%b!Uu96N8v{l$z=!^s?hT(PG4G#=61Q^F`xMYJ
zVoBCsUbdfUahq>*4Ym<C`mmaLYRK`E*ap@JB`%5O`XUS4uz}QkU=p&&3eDf{_2#tB
zh@@;NbRqreSzI`<<HBC)`nKAayx5h$g#`4O{sV>9-)BeW4RHC;i0Q!Ih#o@>s8;_>
z?W)~LxvV>AmjnYwdVSm45!Q+0t!RfN$oAIV28{DyqP#t!e;t1XMwQ7N{nH8hjAZ{0
zMnvwE_K6cI)N=!jn`u%`1hlnI>GqPgYV}*MusN~A%oD-&G7(>r3s^~O<~4`@C1LZr
z#>+(oVwY^Yb?MTjpuzFOO{bD%>N+H+IWpCu+*T|{8*2Zs&pJ5M+8ccemPNjN`UTlQ
z!ne%efWl6^yuhsc3DQC@>RM=S-cwZ4WNzNHXtS3gdr@@$7prkmc9Y+A!jDbr=`Bf6
z9@T~JJ7<<WQ#fqnqCa`D6tWquk>usJs9Vg<t6j*v+q+>4;o#DpSU+=f&_ow(>KKug
z2+iF5j4x93rHCt>uktn>>JonUN;#Ji$a^OAmt#AnL66C;>M$G~bJ`)+6<s5}4HpYw
zK^@os;7l4&#Dy|AR2X_&;?(OFVyOZFRnNF-=N9(Oa9eFn|0j|*w$U0^W5R7i&-h^@
zsuONZMo|pOFjnCu&0BDN3>JKi9fz=k@TrgRXPdvk6@6{Bwdn<$rud<vME?u%3RbP#
zIx)NvK$}i<3EKsmx>zT|hpr4aZrC&(7gFAm6kDars?9|@<0Ga^58H008{P;L9<xc}
z_I&7)w<O1=FugGl33`X^3`uW%lq}hG`VRS%+VdwPe~Lfnn9UZ%F{!+rxD`jLH6>oH
zEVP$B=`ozKJRmnJK|zO*^g~PI!z7Movef_r6cc58&Yc_s65eGY2jH{MgWabsSR_YN
zQh)iN8)QxjP4?r!)>Bm=<5rLbooDy4pP3Igncr!iv^O~Dsnv`i({_k3>%YsOhMw~P
zW!q5V$!2@%38c0gfv3NrPZ6SaY(#*+;fgVMmNvGJ{hX0K2QuIIc)kP7w@LE#bTR7U
zcvQw#L@ifQ?>>O2A@L|bqvjw=c7F+dcwN!U#pE)@NH`5<)~$qW<CP?fG9b8(M={Bo
zz>tPM_XFMz?3O_+)O~vdaRYCr?xtB0XjdZMz6PN@H-;37O<S7KP;Ezl<3GOFAGxLt
zde}qgn>g>zRXnGd-?JF@88(pHX({Llx~0%~Xek~KS~v?MB~&PEsC1I~butW)RFX4P
z{r2u?YkP`KVej}Ux9eftR5UH0hzhIWldk~a)l0|)hH&!R&p=;6#lCmOQn0e1*ru&k
zOAvcKaPmj~AQWRkZhHvo!`z)##V(UF%=#W=<FlnCjg0e9jbIH^)`>?|z0Q+{2wnR+
zPlonn*!2&w0zq8Dik;h}w0kS&$w>L$v7b_U_CmZ90(IorPwl~X0XXht`wzu|zlt~<
zcn65rF=<!SJ9g<=akk$QT(4LFF!q&zfbLbd4K<E8_@w`0c?aznZa!0dvhiv5ICaaz
zv7HzemM$G@4ygm$M7+XtAb?r;A%A4dE1TR#AToRp9faGQt$Y-~;?D`H@vS&WIVq6y
zj+X}_KlL|#fg?+=*bV<pUi~0AaQxq?->G*&`>Z40w#?T>dCrTi#4Naz+XDg^QZbM{
zJ&89^$U)68mSY4n_2)8@jEWT{OP5uYjV(7SmQ|Ly^W7C=rd0B=+Q<)8-d?$4b)_3=
z76+HDsGQQ>s9I62(o~dH-Wn`7hL0Ut-Q5^Ivf5Z!c1LJ&g|V=7*{WrwWyZqgp^D(L
zs*1IET2>iCd{qVhs}`@UE?YTvt+6yzSyH)pd6`kYwlcVQjk|2+$`va+ct*QJm1S$H
z%1VM|rS9R?hNPIxr=rSLiz}9ux=YFzuUw4imGO{@W$*!u;EL+t%4L<e8WoF|FDYGY
z%wBRE;J9xuTU+g39;yzymz23xifW^fB~NyjE~_qCyt0&;bV${Tsw#Symn~nha;>{;
zP5EMEEh{yqRg^8R3{@rO0gYDNzPP+>aYC$<-&0muYIs7GrDaP&*HWWs)^*-Mk#FHN
zzjuyz+PuO!Mv<>@);uFnglBKS7<R=K!;E3$#^G;qHU5wf|I7FnEHA5sQ&v%3CXNIG
zJUol#f5l2Xu4DdD{2Rl+kpfQs#^L{(Yv#_IQ#5PF!nyOjbLO>s=M~OR@D<GhGR3E-
z(V>O2eC_$@8FBdtW5hcAuE1{;eq-<(iQhQ<Jort<FB`uc{Kn#U6MlD%Fg%M(O3JE&
z#=I3(fwEO)6~=V1g|BQWT4ha@<6%*%H49PisVhp?GS+9zD_gnTn0dQzSxHbk#fz7%
zOyKW~i~{jptlgvkm$}#dUxv@Q(r1;%yH2~`(e9(#{f&0FYxi009?<T)+P$ZbYM%$S
z`&;dPPrE<T?qk~h>3EgiamxlO|9b8In|A-8-G68|eUM6bOuL@J%3q`16_Bm`Jfhtu
z?H<-{(5>SCTf2YN?kC#y3{~-SwR^XApVaOl?V7_>x+&USuH7GKcdK?^((aEhEHL;P
zF<iMd+C8G(*Dq4xJx3^aq;}_OcZGKE*X~K}{(H7c->BW*Im&;Pc5l_LrQJi?eR8Bq
zH+__H(?%;dI!61)DtCl-ecCP2?%mq`FYUHy_bu(t8mICP%2jT;ZtwfGtH-K^x0VGL
za)>fc`#AB8Tc`)9(~@-X{@!>Oi>=*_-(wGXUt<Fl`{_oOaT$DLl74TTkMQ@~2D*N4
z97U?$#(3AZwhIvVs_|aiP-BGAU<@<H!T)=tJNuXLE-|h%RvEJa?Rv?>eA@t5eFx$B
zG2<~~lCd163^IOVT%Xiz{Lq-1_)WS#X{vFo?U>}5j~o;6JC5I@t~{f`wZrAd^Hs(X
z{H7T`JkP?9-<g6RpIF9Y;(Oh73ME}-TxCp6GLsZG4G8H#pro(=c#!0x5yRYrhh|^c
zo_hGeq#^CTGd$%ajXXnWd(fysquV|IZ#}t^l2cN<bWQ8ly+?Y_US`I5z0c3=)3;w%
z{{a_hG8Gy#48M_L42Hj}5iq)efBG9285bbTk2%M1JdZYdfm1FtvW*-pLZ%pL_@&}$
z2wXm0Xm}*u2uU&07=;{TjIrRYTw}a3!MNC1Yustvg%T!#>n2O8D**RO9nKO)0)orv
zf+s>84tz!fm+poM9L_U(gO@XnK1N@Z#4=Nie#n6l7&y3%p@Q9DV-WHUM~Xp!-7AjE
zaD!{YA@HsXZd)7SuQS%;nef}g?vYrAwY9kbU!`OYm9njkVQp<5{9lA0slmE3)C0_&
zur3H=8744kPubR{LJ7fv=V0E}<~(&l4h64cPL=C)cwNw9?RlBzbZV)5>VFVu+D<K%
zSH+A3ly8!ksTJMY+D4-0#Dbq5+U*PrrtFACXDJD-V@g%Z2wei>|Ig=5H+rJ{&dU8J
zwHtUE9olKgn(=eyQU*x<&qNuOi~qg8(r4P^&P-Lt|L<(O|7q>o+RmMZieiZzeP)Wa
z*S($h+ee6=#xmn}e0v*(kQn`p6_9&VAeS<X0!W<-BM;K*a*V0HM2cMo`85zy=u&CD
za*RA#@-)+!Wz05;jcbfK#$02baV<v5>y7!w4aSYeO~wM_W+~%#NU0@;*C@sKJjqy!
zzIZD}?2X3VczUL78su<)NYZD}vyvcr1IE=xGUN#5@1C~y?=8kcqs*v+e7VC|ZUhnM
z$k;+HO}jw4bu}hJN_R5`K$@*LEL6D0s5KTz#R)%baDGqtedA$VT~J}z;0X9UGm#`=
zPAJ0+^mmRFhQMD8_zdj=%$=}3&_|eac!!jR$l8wZ9L$aQIB_9hDR}K=FsJ$?mdsF&
zJMDRyhSW+Ng;YNE-*H4zc~y*0oO931<oPPAu~K6}?-e?%Ge|76BNm;dB%qEd6~0q-
z33R?`-je@?yp@udV`%5)ev{f&pRslc2zFAtHIn2^lxfdf-$`DTqO-jBXaJp2^_$f0
z-v43k4B@4Y7@iFuql1psSxSd8?b?_VVi+moM;Q=5=r!o$Nht#*2CJIcfGq6Hm9x`6
zsqBXMbc5z~!NsE|j)6SHXPhyhXL=9w{678q_sTf0d+*G?S?G!*AvpP&eED$nm^|Z>
zoI&uV4V6H{@LV~iD=Ix0qVde1B&;<iC3Q(n{_4k-nr0-WAjaha>dCI;<fP;zS4whn
zO0oeD!c$X?F=NM$8<%_L&-n2ZCQP{a;)xS4IsJ1fK9}*cZQDYl%eGj{pSN#o>yduR
z`I)P4Gu;mI#5g6jTlapRi?VY@jUAUe{*sGQa>q|dapk7CM&`OwQZKsnGNVgZN9`Uo
zc!+!GunWiKre){k4!_9NBdh-fBSwrIIe7H&;jY}#gTI2MhhRqJrsU?jE}eME#1SJd
zO&K|I;E42|7Y`UTeE6W@xw#W3PRz~i)nj1p#kZDKE?ly#az#}KI*wT86@LKl7UE~L
z_FtymBJIxB?)BPTpxwpVU8>y*?cSl?HQKG!?mgPQPrKjI?!(&sfp&kS-JfaqSK56-
zyPLJUOS}8E8`bU?+U<Uus#h=VMjluG-rC<+y92a4Si8ftdy#fWYIm%5CusLl?M~Ki
zwT3@M`^&U{s`g){-MQLbpxs5<E!XZH+Pzb|wc4%IZi9BE(eUSJF^Q(;)2z#*Vcw;w
z8TMXUnAPW;)4Nx!WUg<RUgt9YXZhl}aU69;b@j3(6>DKIhxr@k_Qf=rk65;J1dQB^
zgUib*gHj=FL9bZ0WaVNQw5!WkgepqiD=Lw*eDSI>H*NB?^Si}Ty^N35qurG&g6_rc
z<%^e9l13}bP}Yh{qoQmL?D!Q13n(*|FAkQJ8`mZluMP0SxI!?@Sc>#+7}zT-%T~H?
zTfBTZ?BL5Pt3p9Hz;=jSx){q5rGhVDuMCbUSy5RkxUe!Mx1*A!Wh<9ftXOT_cE`fC
zYpb;}sB(q7WN`(ux>qj?mIG_|lF-tnSQ{|f)0M2K2raMdG~EiIvtp^cbS)MpmX)}*
z-5&@_K?_S(mZ7c-71-<?!#I2TvdZevN+<b3!JV1#IeWf^BvV2u=a_zNu&i3cU$VGV
zSDw^W$Sa@;iQ4gquWwXg4S^ltjC4o(rHg}$D>}B;GB$Z7LWQ@+jKNw2NvLS#UcRil
z8f~faNecIvI2Wkq*C|)5(rtQH`m9|mwm&Qj1rrH$4tRkbuu??cUb+Gd#8N<4UxB!_
z+TE_*liIzsP{mhk_X+KOpxu$vRs5~m{fTzp(C*+FD*h(zKBC>1wA<US;%963KJC7s
z-BCp<{@`iuoU2s$QSIhmt^5yZcdvH)22}XN+WpH+<<Fg^+~wN+hj#nSR^fBB`yK6W
zo2SCh)in}6E<B&@$2m>%*Q7aH{<FmqHse#Yn+ms!er9-A{L=92hF^F5df=CiUr+pc
z;fJjt=k&wg0xoq+S-rJO_~+x7dD;(`&wVBA^fdnyKWC!-@XNw4ktY2U${T=ZS}v)m
zvJ5Jdv|KvnL6wzfH{78K;Z!d<xAfpQJR#i4NB1K9M&Or?Ut;<H|MUNM=>b;g<m17V
zWhlP=v~9XKT=ne>cbMVs@a+vQrLF1${FsM*$V4ygE4{P_>`i?oy$js$hV4Y<PLVlQ
zI&uzxZD<g<p8VbyJ+&`-eX^wLj(_%pu8<3<aG4_Ub0c{9^zTiuO5Lcx3*t{s$juUR
zGptta-y4lv@Lh<QMffq#>G@Pz!f4Osgx!Kr^<Avpj%gObE~Y|CU>!5!shwPOJO8*4
zb^6bdn~s|p@5pLLrY6QQ%n7HgWt<cCP25D70Pzh!v|&Ar%QwctE|v?I-#Xarvaymf
z5|+KYjr)vxOsogPl9+>3SHQN%kA-xFutH9Sd!OW*h5tFQ2mTp$$qhz{gk6o)*TXhB
z2bRHgpe)aevV=SEt1?!@#`9-bCh6XS)(F9NS#8{g-yMjZY+QoaM~we89>ogZW5(mg
zZ;dCh8uv#j|4e_U^WOiezX!&*AsFY<<%f&3(08~()KB_Vf5i1e@9QtIgVCD?$dBtQ
zqmYXJ3qi9R@Z<9^SZN1?rX%t1#&<GOT?m>_klz&4b^?C6u=Y&`mA&$u16%JDQ2rA9
zE`!zgGQ<WD7eETye`n)&1t@$S;;w}?_!?M;XTnxo1gq|JqX5?BIj|{TinbhscIIl;
zK*)u@kO@7JlYLWt7od-+FZ;$VAg=0z3(*hxT@?Q=HWs4?EkXOT|CFAw|0MRMZ~lCy
zmQ`Wxs|~&4YjnNQ23$oPAQJHckz0ch+Y4i}ve;8j4HaoMO#Uy#|M{RrCPv|lfInCE
zvhiih@H-l9a3g*fgVy8mG!gBWBO&Y|m*DA2q#1+Ox(v@VK*t&KT!5#^0^xGB$rQwm
zK}+SLE%+nEtB`vFo@U~ABXUnbE8U1TE5b8V+=zCah5tElXN&(@{1?m9b@-nvPd5V2
zRd`mu>m}@J{1>7x-UzeTB$&s>;>i!~!}*Q^uc_~);D%|4ohGZ^KCFE6J3aoL2QHc~
z>j^hVSWl$=-}?=&T)VJr&9b0@i8dyjf!SW))rRldVq@<0-eRM8cCiFqXUv^9drskX
z*#G4##PUW_VE|~(o^!Qv)wMH=<!|A1W2$%B)$_0|>}tbXT+FRiMYHA>Vw;wC?%bjo
zvy5rpKw#n2Yl{N&ie@bwzi@oVfQy{~#>^?4XG{yso_p<_!iB}yX*M(Nn^QPF{yc3?
zp?6;4Y2Jm?j0^QHwa$6BJ*M9SUh#0eIDO1u#2_8dXGgX>X&E;3w0I|uV+}tSofc0R
z{BTU+XQYl#L4Y$pF%8Ecesa$c&v4EK__^#f_)Z--Kj7zz)8d`-Id|aa`R{wx1O6H3
z{5Y@RXPVB>^n~qvIOpKU-$^{@BmB%fE#4`ga}|E(ora$ZRr44=-*Q^KQ$Nme_$fOr
zo^)jz&VTr+(D4p^op#~8ho5R4p9{ns*u;@@B7W*li+9?Hb0vQMO~)6UmY?${e*R0x
z^O<m+ALkwX{8-0ta2P@bi=N2GClcZl>CZV6Kii#nhaprj<gofY=fs}|pLRv2cwNWq
z<Z)+s?!;2J;jRuXSz3A1@Y0(NH@3enUM`Qf3@<g@OklWI$zv&Z(cUBps<F$p^k&&s
z8_zqryHT=Yc@?+nmKaM)+!tNshII@(p~g(n;iWnlkyl)ChDhv=x_#lY>V?%X@l=#$
z!`ux!T8^RIu}hb&tOl&=wab^Rs4z-GD_0WAlCc$wt0C9a7TMv|?q$_t4|KM&GToRd
zOK4JAxMVGJFvO??X4UQ~?p*ye#yy^KrDfI2R+g16RF#xM;w37xjH;3<bjj%m=NLm5
zV{<Z$KgQ4{W2V3qxk|&&caP7_1$|)tD+wAfQDW~gS|NKyRmqCdvV|zOWaY9YPMw{)
zuBiHd*n1Q3sH$vj`0R74DwU#AR2Tz9s0@Sv0YaF<oIt`n1PC-J7!n8&2oNDm$`Az+
zZA4I1R8&+{R8&-KX+=dF=Lu)DQBko)+X2VcZcP2}yZ1hoQ$@hO|GoFS-}8L;JdkzP
zu-969?eXlh_o?=s2F$7~g{v7MhC$x9m-)6aS(ecua^^NWv~s0PinUN3K_}ap5Smip
zP@ToGMJ2;0l*kUfXhPw{g0b!GiX)?s0*-ZGMLWvvQ<P9gHfu-fM7?{vdPP+^*W^$p
zOSlxAssmp!e|~4X3YB4DP=<>8yHomyI(4NUW$(0d1459lv&Zy!k0R?w#r&$uavH;O
z>?|yfSI<GkSy+X=*<6E5Wg=X$`I9+Q`}SA}(udQ^*#(CP49iCx$Bw~%X6&Lqo!%Jv
zLF4ns3?4@5Q~fBj%Q809G~`HFum3T2CgqPGo<C?*VSRS$Q$JzK=s{ygNw?~ck3)ZS
z^*J>k_30lpYAog!|DJwk*Y>|;RN<JR#luSS#}6Gfe1Z(~Y3iA5-Q}1F*~M(AmOQ6)
zaS7iw@I@PXp2fNc%5pS4?N`~1P6K9FE-WjpT#WWU!+tHXn3Y1IN|0~u7FMA{V{J1u
zhSvq?u{5IUw^kcXti)PAUk*5~3ZyLI`vjd#D_L5)sAS0k*{&VJxOMOqR}*w6YV%e0
z(Pb`(POjs^aFn2*mts*8TAfN?j|WlwC=d811n*anow*Au7B~#)TRmjhLyER)@1OmT
z?61W^5xz9Tc3W=WM_Zp)T2@)EUU%S72?}sAUM<b6te9U>&GG|5@608u8jr^|L5>%*
zFg{}MZs`iVBSCV6J~W^|#*vh0%_ZgYtEyLIE^cqA1dGcnXJyV}f4-=^x^(7DIe29o
z6*HGJc~|y_yzl3<KcjLXU(hK1c$+n2Nj1k-_JB0WG`#QUaCt%bvIvQNU&@RboiU=8
z;k8sXPNK{!k=_`C@tO-S%~;Ks<GrAIA%*vYGHriM0;=aMt~ek2khCdd?otlS@=!}A
z{&vRyCFSj-$cvZS)RY)$DS2KW^#+FLV|=<{R_J3gtOtvh$hRM<Q975l*If(?rZ6Af
zq3t=E2AW5RZ)NymvqP1fQ*<@j;?Rwng-AQP-k=EWtT1XCjS9AuWQo^R20O^n)KgR8
zi>{~z{X))?UWAfnFR=hs7QKY_qa0(7(-9kY79mA#ddCp&)RY2~gv#pD=o;d*=&W1t
zoW?oeF~6r1>sKe$F>;H_Z`d{OG<ni&yiexDu|!tfC?k>FQ$WA7WeiS@Bwx;|nG)i1
zM!syII*yCaN1u8=T83%`Hrh5s>cUx>sycCCcQp1A9)7}vl647tV0h`;w4`b#E7Pos
za=dLWt!9f*O#_n>R4&YmVl=77ouT7eJ<pyPq2jY^nupYx^Q55>lS)S7aT>>zc%n%f
z#UH2K!m_z`%b{m>g0X`}6b@FSm|-liBaXL|a-!-eQ8angs_hzQ%filS+(uZ?|H13}
z`3OeonfRw<+s>A8?e%%`-rBC<aShkqsPOz-6fC+`!KZgBIAynjBkoi%MdNqhq40eg
z9=k{3FKB({%?khURt4YI=~~~X@NRn)?Dc?xtF?dsU2yU)WoM-JgB@u})sn>+X1Fsz
z-5PaQO#G!}9ru*-n=z++2F4?$id%tV)0dae)8h?i#`dm?I*s+nm&nHzEuu<Rc3J4`
z7scwwb4&HYMHm)va<RHZK67#FLY;;f{j(M=oX_4N;(*f6Y}O4)5hiXFUsvD~JP%;s
z#=P<pO*kdL)eEI|xKLe=laV+H>QqL3(H+37MdjrVi4#xi_K!A;2Y~XBp4qEb->&WA
zcJ|X`X=uTc`DK`m=>(WTE-q&`QHp;yFTc8){Q@2+su$w0CJ&iX1W%plL!y`%|7Buq
zMF30dB$2&6N)1mUcp6$jCWdKa!4k}sFhG`Lp90Po8nX8>%9d2%{OSTs2vV?R1t&xo
z8<@di8%$N^toD6E=X5@2T4-fx*0jDjYpT8HgO&k1(cakSU>z<+d5b=ra|hWiV*drb
zq9M#^@GL8BRm=*_VgMI}IwK2+jPx*strmS9;jZWQ+gtM`b@FWr>O5h>f*ur{N8iko
z{1zH6e?#H#zOLX?hZIB)I>V?4bqwM0yW*VeX&8)47cDAXVb9zQ42D(JSO}Pbg@9@~
zkAtKt?h;J<=b+FsLR}3!w4X}sr>7|cjIxCbd9c=yx?|=r?DJFEHWyWMjOK}2=}gyY
zaEqHxVqM}vU_Qz6Ol`@K;bVqR7*<$-k)f(&QTePHXkSYfEXMKS@|l?!ArR^I#^TC_
zTmVrgP1)^}fNXP~BEuvlIEZxW%E$gp@*`74iS!H6fKn)jP+Peg!OE7*m{*SK2NjuU
z;vL#&IK&aa%!L?a>`Ho$gU4|f%xTIE!#Ox-N+bi`aKy&=)xK^7#(V(J0Sjm7vvBm4
zN>vs$k#lJ0csVy}TpcrU^dOv1)|XSRG)gXi{P_GSXV7!T@tM)DcWidr!_n<1A*V*n
zh$B(Q5o<h6p=2^MSca-BvO=WTg^Mk1;Hbio1yg@|J1H#V8C4dYo`^X8ijG6nwBii$
zI5l2nQMpt6%n$Qq<U4El`3DOBTEibS{8huShHfnnKiO_d<T-n20<O9$K5C%911{T|
zeO5ApqsIobN^`O8ZDyS;o{yzdQlBldY!TX<OcK+&Y*7g#`tgj8FA6wxR#wcw&{1b{
zu_Qn~s;)ADCa_m=pmu&Dm3vV+H!SkOba7QFbUSJY3ZE%;D`i&g%ORwjs?AZ*!RI`b
zbt+1LeC?n77=rHm9M&AcLrRA}6~HKMQGDH7MGH96FDjQ2iRIh5#KR3%WTLrI`Z;!=
zlA*dNsc!q!^tS%_<yeY#<deNG_1k>nj){y`6vIbDQw*H$N1uQ}V{thblQ1d5_Zq5~
zm16{y1<hv$UYS@;<xGrw0oj4b)mR6ugb#zDJ4q@h?fKl6$`#~_g-bArkUK@?%4Os$
z4_Lj5_)&^^!W@hz@UWBg0MGFF(!f|ba_BEgaNVf_UzWh!0%CpY#N@XORDNtdvents
z5$v1FYA0=Dx`X^m6_}o=3d(K1YCv@OqbeEgATXGPm52C&g~(ShrY@O`OZ~;$2h3h(
z^8t)Lhp-f0ifM|xPWg@oAIw5JokK7Z2Suy<?gpRc^o~#ElG5vlw~TYC9bo&@8&!)I
za{h)9U0#rvvu^q9u2ySMHQ2=Dqn^z^$G(AFr<`d~9cEO=>#%?ND!|$)Cz@RIaX5h4
zg^i-FM6+T!)eGm9FQC^dkwkT(Iu;W}ICjX<50@{(9%K81C0Op_W@rRv=8_rMGCOgB
z+)|A;&~8;bCpN8JUA0to%&q}hc<tZk^c5+lcGwlcc1RcZ#03~YE98t#m#Bj>V#3%l
zA++TAa0pw$Rh`D`m_?-_$<mE8QeEnZ24?D+%jV$i6>B)(K!x}KpvO~H3vendsOG7|
zoBsF0|5JAUyYumXyZ--ZoJajm`A_>D{_n+O&F`e&9K&Cr@mn;sdyGZ$B>@JFNFSmH
zH`&Y$xy~SO`7p>te4s}+qu$HeEl#!;yo}TD+omqT+u-HuFTN**ZA@7{BP(QFu*&EY
zQZ2;UDWY{ob%4(Ku-%?MZ>idm(MrLl8g|fdpoZ^g_-1P*my)93$g>oz((q9YleOGO
z8oydY_&0OO{3<LLpo_r8`H3Xxu0)-~!8bMK_3fGkv(PEAzo}kfj42&syB&eI_f+;j
z@A{vE@9Ffv2miBn{;Sj5{{C0%eKaPXdo*5fu8Ok_J>wMKR>PA;3jbb1RZu4eDwv+9
z;1mV(u268pUlg4Ci-a}nI!h&o8qJV!-MiOHSpLc@grSlh<{-f1ONaF$ymf2K`G9$!
zZO^_HaC7T}``-cVp7GN>|6rr$Xs;E2$scU&IDGLRx-T7UJU?dk{HN|2Z1mqU{n+G>
z2j^{kc==iPH!Udo_LFyxwH#S+<=dk@ubrqVfL?X!^vxHzAAWe>RYQLIb>J7)*xb=M
zXJ!97Y}rL;_j_{jnh(Y{U1E#J!u^*XzV^X4w)g9H=dQQYejeVt|D8V;{MPXHoExv*
z_?q|8bJ`AGxO--%XAXaY6Z`oL>=<=kM|Irn_(gbmhH(Hb<fHtnd+fj$?>-vX<FosF
z7{<|o3V%(fE9$LM{4%g~@WL5)Uh>Akhn}DQ$IQ!~9r&*mHy1T7cynO1|91H#LqD%3
zdGpJLudQ7FS>!#tq8l|Dvg=y1pn|VC(0SqFT@~IZ)~$NfQ7{9_Ufwl(2rhZP3Fmy|
zVhyI>>;{%p&&n++UqE?#;USVXW)@&u$3CC`;Y)W^|GxotL!I%8J(cU?RhNBZ&HwN<
z@IQIsaP%3khA~$hFGv1kDvr^q)130kDgeBel!p)}E-sy2&R3qHesj;m3#LkpJOh0A
zN}*gpj_g{p_u2U%)QK-J=VPH&e(q4tP%-JAfm4kO7uj+{_{_!KO4v12B@d0^p>EE?
zWn6id59&Bmr>$XudcjOP-Lg3=LU?hFV{fzPREL(8qM=kT#M)DNxm^E7qL~Y4$UQi6
z8w{SFRLVKk)m44Ebm6xJ7gm-o=sX(-7?+fFhNE5Po`>v+R#x98@pw-r@Qt!@wc%{s
zFE6eQPX@dTunO>sNwwhvgny_F9|mkPxi<U@;3mK%n0b0iZ8#6G;_TY+96<A&+HehE
z%Cy?>A;4jP#{s98)P{4h@i1pqZFmFVCxH6^hpmQQz%Kz$0H&^~4STTxaV1~~@HW6)
zz&8Mk07Esf1NaW$X2ACVcL9b04*<5k5c&W+0G<Hs0_erTt8RcHz`lUFfCB)F0OtbE
z0lWsV2Ji;JZGbxf_W<q$d>(KY;8DOmfWH9l0}KYxqXK3EJ`b1&_zvJ?z$Y$3J^?RW
z3;zIHuY(@IEWo3HeJ)0NY=nFpFc)yz`r7bxz^<3T55T7Z_W^zbcnGj&1M&lycq!r@
zG>jF1xq$E806T!61MUDEz8!G@d;st$V8M;GVQ!e51DFIj>1NmgJO;Q8aNZ8+2fPsQ
z1fcg8$Th+qO~7ox_JG3xF9xgv{1e~?z}C0I9$*nZC3+OFCq8SM-Pka0ychlh9s=A3
z_*cL^fD`V69l)yqPXK-c7;It~CHEsAfOi5;2F%@q^ne=ycL9C`cnGi?ezxHkz!v~R
zO>w5~L8JpL0h|u_Am9eTjECSC-~_;ZfT<579bh$J2pcm~{)GGh-VZn(aMvTS2RQ0c
zqyucTAMpdMeG>TsJa_<pV#DU=Pa}VTzGqNx0OOxUJOB>>?g0GLb0}ZHVb3FffD-||
zI5bxV7y_IPm<#wM;AFtDFCabOCcw>rZvgHAOnedf1zZn!0`PIbAO`uj0kZ*%UP5}n
zF92%*&6g2pz+}KZfae1q1^hc8w)z_fUV(kUKChyF0zMA79Pr`S;5XnohtOUCYXNzP
zuj}h5f51L(BTj(B{|Y;RTaO@~fX4w3115X`{{S}tdU5b?{D)`<fNKGV0p1Td2XOUA
zC>Ox<j=~;b#y^n`@GxKy$D+RZ7vchV@HfZ<4yr{w00-c7{Q<y3fX4yL1isnb8f#jv
za5xWet|uI>0=&f=4(|Z$*)SYF40x<@IP7g>7*m>u!?}P9lfvQ2fWa2w@N&Qh0Ji~-
zZ;8(p1Fi);1h^p?-|PxuCJ2}dcspPb;Jtuz03QIX0o(_;4RAl;9>Avop9g#a@F?If
zXNAMrDTZ+pa2TMwbvQg7a2a3?;HQ8)06VsUzkq!KPXO)*OiD$+6@q=hD!|Erw*giG
z=BI?in*lEdJOKC-;8DOY0eOhBVJgxCo&?MTY?cPQfP>S+;SGS5fV%+C13UouGT>pr
zuK`a02JoAR-gNYrfFZ!efVqGN04D>w@%i=TfK3251I_^41^7q6=K*g5JPvquJNVHS
zXH+wh9<U$aWWcKcs{juGZUzjrNBjV50e=B((*fx+(BA-N13m*d8L&r3qyxMea5LZ$
zz&(IPStvKaZvc-2PVR*IfwjuF0rLPa?1Fp)o&?+l_*PfQ0Y1?KayU%-*ItkVJeiB~
z1+2pFCv67&0dNoC(mv1+*sVX}(H`vya2VjM0gwl5FcA6yTjrx40iFkV7%(sh`2ida
z80>(0J_Pj$FcZJlGzah;z#70e0e1i{8iw)!Oc;*x1iTdx2T+WjBk?Uez-Ix60Tzuy
z8~`^0ZUAgM74`tF>9CW9eiJYo@K(Sgz-IvG0G<Hc2AEQcd;vZ+7y3J)9nOP(z~=!c
z1D;h0{eYJNZUB54a0lQQfcpSz=fgk1ehZL4z*4}Z&gd5x!VX{oeh6#>;QfHR0Dn9W
z@dM0Qg!%<|9$-=zwByCF2Y3PCa==a1&=2@H;9<bamcYMktVu6L`2Y@F2EBln0PX<%
zJK*zx+wlaG)D`6km<>4bcElC%@SVsf;Kp5$1AGJUIN(13ag50L@h+4nV7t3fKLK~$
z3;zN40oDNW!Z0H*asGHiEDwrS{y6Vuq0T9z>oTSfLmv&?2n2@&l14Oau*_Ry3~brA
zL$`FaNR_?-Fll6M7^cyQ27*%pUYu1jaCQuREa-n@`ayx<73QEo(k5$AAauEFP#|-o
zJ3o-U-jg55T^lzvu-UX;6oFij@&lO=fhdv;f+~5@&)xX{+$i+j)K?J5Hvbjy(#M1N
zfB$HFY8(*s8e!Jh$#C)u{UrW38B-fRKf+%U;iDNFF6dhTes}844+PhmLjya6)j<S;
z`L-bCvcNxoY;E{X>XCBN*bax7jAt?Aeudn1l+zdEQOWd0wc$1<kTb`lAh6u>n5Pei
zw6h=jhL5ieqp36B!7?~YJ8ywL8T6#zw=*<QV_GNA5O?ZJhn^7T$Zue5`W?TA2KEfF
z{&d#q9nXS_YUsQ5JdEMEr@oD5ejsVRl^+PLbrl5i%-aGX5D;LLKFe<><Wm>bhRZ2G
zfl}+Ojixz{Wy5-L5d1md-%7r|NIwGl_n_z6L_pGi1ijJX+VI&ibiajjK%m?4B%AW-
zpw9puP1Z2R1%jhtnDl<2pAY&N()Go9QVjYY(Emi*v_SS+&wBSp*X7nG)7)m)C#GKs
zxdGL+{B_#MMfz3{+Jla+K5~)18}wfF&<}!M2)a8Wt^7U$dQLs`A3<*ex+_NB4?+Xb
zb(51^+D!-jU&s%VMK03&f&MqpS*EOivvpjGLH}nx^h(eJ_4u<+>yPz+JLt!u2Ox6M
z?p_eys)znE=m$WL_5T>?ERR_FNzixHLvI2{HrGSX0=)+G0KGweha<ntdjaT6K|fA9
zs_lB#=e5?*zyV<%krg@8jmZ9}8uFbHhrej~wWj%$T`ySQw}SsV_&1V28TH4#-nG%X
z+%(q(yfXjbk6Ci6A1{MmKswsL!;gYM$a0GqKhhy`67s1_Yr{9tPMzP7H?OqCDVOfS
zTnBO+PL*3@%hB&qkoyU8Z&A+a_hSKXcaSQ<ziU}-cnkSx_m^`#*vNLj-i1zot($#%
zO&}8l1W@(<%<oR5GnYr#Guqn^dNa_kq`ta-VKrk(zmI^w0eopMI)59Se!Jof<2%UB
zp&rPgJZ9PDA^Sh@d#}JVR3q@u+;7YNw4l-H`#<KV8v2I+F}nPipN*go1icLR#u)T-
z)_T*NpgbXeH~1HVU!R}kzYP8h;M@5{KCZCyLAzgp-)|$v1>D<L0d8D~*D%n(VZA~A
zHnChT=QzEQ<+7gR^jc3rV6(8^6LNe;3B`=hEZ<Sk^UdY8;Z0P2y7FBWUA|1W4(SRu
z)rK!QQ@W+m>16pM-Bn13M^{~L#dda8`GbEc_!nrtZkHTl7TM*`xVYlc&p;00iCm;7
zgZ?h)cw~%RtXJJZe-HGjq&n+WHcE@*7MeTLPla5<718q|(yKww0DTVAqaQJ61ibxl
zyAkxIpy%jvsHc4tSt%kq5Y&N-_4H+=pR@VDX1+yz$v(`5x73DbBaXjY@AsJ2Nbi~J
zeI@iYy}mZw4eIQR@mL3XHs}p(A|T6mJLqYkFDKn@4;6LoVL$j6fS*UcY`5q@R;bw+
z(;or<2Jp{u^37r?z;ZkZ{yX5Gr}>fkQDn}s%aMB0;aD52ISq@_qsp0j3cw!<zTNI3
zdh*OjKSQ}n$nAk#vDV{|8)@64+*ZgPf!u^xx#{Kzr`&$X#bNF1_w*fuTsO#F6RWSt
zyxi8ua`5}H#sIlNlq(1ntwN~jPdex?{Tp^hLGB-rJConEQw_OPtkG2~J0WwSYA+i>
zUky4QxoCg-9N1^O*a`Yopucwdc7f^o6ZJL>`hSe}um(7udZXLxa6A8$^CzGkLGIpI
zxhiv~El2;mL+*9R$$qXNP-R}K=BcAVABwfbUzuJ$8vGdPk64c?!4F|gk@Hz&XyAlt
zZ8vQJ@;8FN6KjlbGN0fJ>m}jj?*{)5SbO}46EVy#EbCp%=4XNQGWgBzstrGj`>1?w
z7Utu22FSxjdnX~k8}ez&pQEPLD$1W^OmyzQ=k)x3;6I2p&oC9r+0H*~cjUZiD)?LO
zs|`OwKE{LSdH!_sZpS>I@!tsfr2A{bKU02MAkQ&xK5Q$d++N824RUKK=Pb`6^L#s-
zET<!oE80^VMm8fC=|6&ASP$Lb5Nm;;V_Fos7^ig5+krlrRN2p%lWc#euK@fK@Hdms
z{``-sK1>DuUC;-TuKTYlosfE0g8wu41rEObWJ>;a@LOUH_;l&_gWntcC64s=%!TQX
zfWHa+UgS%^ZSA`J!M`1RIUkVxNVa6VPYz;@8~jto&rsd?$?_<G+zH6Z=Ur!cgv`y(
z@~DJd>4UZ57W4;k;%LqItpmLbbUDs~J`r@*=k1`+1pQpf$J8H`fPO+GQ|0Gn$X^M0
z*`M3v1s{qv|10o61^;alCZK+)=SVsCX1x4~csKNrUMH~A&r|8UgP#Td_u$KVSO5H`
z2$6}JzcM~Ek*@z<tj*&-=6Udar5$|=SQ{aifVKNOC|AG!>E_j^>OY8d7a-kjOc(vU
zd9kgZasCQ&KSNHAzZfbPfXO(!Ft1I-JA!x@5NG*S;rr}%0fNPges+iamw&DeH^lrp
zwp@k=4p~;%?P%FdrP5U*-BVB2hDYjtJf=Ue28dIV$$n}l(!GUu6U9^{>nR@;Mn~pZ
z2f_C~RU2+gzP^~>BcL}0UDjVFS*qIQkDxCH{YA=ZeMRP9q(0VzCXF#(;2lWU2p<C!
z?{Sge9sF+KGj=Nd+$erA_yfUzEyBlOYCa$Fw;KF!!2f}Kvc3s;N8xrO=r8=GHvBLf
z2+IGA>t!eW)^#mTKi`t=ANo3fP#b=bc62_coA=bsf51NgelwPb9apQNkOEADi+M~(
zFz>@V4z4RvPS0E9BH8mX50<R&#gH$?JCN15cgSNzH<#GeiF#K;?rzAPjMmGM)B2$v
zy}Kd5^b`HOSLcTsf%Uwb_TPfs(fZ`3W2Dw{w0{zEBR;JSKg02_PT$bLQDObrv?amA
zMfoheTl?s<+VJ35`9s3$Rge5s$bbJi`rmrwJI2U&hyIO_|MiR7@YVIUs~VSevFDTq
zLcb0o-J}z>;rpW7ugu4-F%6jVKSKVkA2Dul9^uUQ9?Pn*qVvsql#U0i7Qg6vBDDsh
z<|PH-H~h6Wd<$eT57;5h>!RAjOz=0Kfxiy?#DCVG9z|sA1pi9#WqZWaTP3uQ0)0Q|
z_kbQ|{rSE2azI$0o?)GncKmpkIsN3R>qP0G7lDqjMJ~$s1ATNo^2MO{2c5-XUzD!|
zy*=o$&zb8$PpU_LJLoRZSsm<)diH|;{lB91Fdi?1{xRrXem@?FqSfpS;gI8UGA0HG
z>hY^P=(|D3<7VVyJsAc1ji4_g)gC|bY)h2<O7Oo0zmf!-KTYwwgR~L+zQ5_`top~l
z>}AozpY-z}(v3tq4DWJYF%l}-4;%q~Fz6SO9z8B<uasXd^tam~w}5hW>quwQGg<$^
z{}TKmQT#>Hah68`_(8nO?MD7s_5OqDrh?uP^qWYx^Q%{6*bY~Me;4=#<Rib%@o=SV
zhFAb64;S_AhWz7@mwsq{%d`afFN6On_;|%D+x1#g2Nx*){0jU}z?b7BR{5qQE#u_E
z#Oqtozs9|zKR_KZkJ-He^=CnDZ&=UM&~L0YCrA9Fo>Ac62Yx5kzp_Bl+PL+ejqb}`
zo2)BL%cr^w>Zyj@Lq<5<9{04j*5t~uy6ERt@b`o7oQIRX8}z$Cm(TM{Rh&sb2>Mr`
zrzjQjFX=}>|EV7OkD%AqL-)7B^Rx)7^3b~IZ#wARKp#z-^w(q+lNb2~;7<p?kQB+s
zpuSp-qV!`X_!onZ>2~BIeI@8CK_5#h=O-i7{A4TW4}qRZy3`k0j+FIaFZhpvkKtSM
z<*N{4a-4b#{QJQF2MICtii72sj!}gE^H(>Pm|-<uJJ)T?l|Sj=zX|^7%BukUBjEpm
z_Lz_H`uPX+R#sR&&&z!1$uz{kGFIYGCir8RPRA`9@7}n6#x}7X{7K-SARqate_fJG
zuIAy>EK5o|$DpScdSv~Oc1rBxlkLKV_gZ1_u^be+Sf7(Y{|@x+q#~VTz2+*rU9cPr
zAXo0fJ7vl-|Hvjx8dE`k9Q3)Q>-=S6v5)y9e<k>F?r^xjgP)Ch4Yu@qJNW6~S3CGc
z=6oqYyZgak4!-PPXcxmS{eBDdTF`B~4!=unzuEtsgj}8{99~8Jr__@?v&vCVSRPre
z4dZgi?`HcxZFv;%-RZTbTPJ3|tD)z+xNzjTa;-_{t7X3Wfxi{}QC_?w*LLb%2Ys&I
z<sR9ey@mA0;=|!DIln1~J5e3cLAhok^AEW@67Y*;vGcP%!b*&ppE0gk=vc49-W%>A
zw97NwYAIBSfrg86#gN+=tSdK1{O8&6m*o$+!;q8Dle&Inn=7R{^0$NEH?e;HDDd}#
ze-rqR(|?r58J-v9;{DDuyilg!{t({(HNhSQ+{e`S`<;GwhujU2yFkl1%a48+ga0%5
zw>$XL&6{Mt824)MFKCMXu%5VEF>$B9osd7fx$a*gaVm<$=^*%9z`qf)c<)pd`@ZZL
z_yO#V8c06Iz4Ot&`r-B@=siGR>jHxKol?)_8r(ux%#;JdYCP?S4y6Wrp^79${b9Q-
z2AzAS<a_{Co6p(IM<wWQg1(%hk$jvN$;U?UJ7O=@&E$^>OqcI}Hmk0R>34&FH~2S@
zFVojew8?)N{I=M0bv60+d}F;z&+`2W{OiHrDu8JFc+|RFNDr7u^~+6C@m<dl_6U&>
z@$*tCMLpfYUkd(Zn(wIJ7uxlNahM9Z!;oXFjq!E+Lh$)K#6BFpjsxPE>n%EWm$j<l
z>7R4EL&ZVpE6fguKV*A{KIc42E|b1$IeIe4;9|T^BHiD+)jzJ0pPYt2-Rt^M*7G9W
ze=~pmz#joV#aOS-MW|W7i$RzOdPmZSMEi5@Ul5^Zv9;l4RW8)C4)R5i*UvXW`}t-&
z=oO&v;6(fP;&jxq*2SMbPO|)=@6XuVRZhPm<!_$rD1PaG6A1qdx$Cr?E??~J5OpsM
z$iqed3m`vdKsY>6Qq&*Pr-FVv=<{Rf)u8_q^g%K7ji9GvuNj7=$OV$I6Mx!+-jwxr
z8nz47?Wc$=IMd$CkZYC~4iAW=R^@yQ^nReXC0*t_GX0m&kuEUu!Cz1PXO440V3;-k
zOwUcMH^tDmEI%BcMtgQU98=ehtHIw3{yZmtYF#_s3Vs;;Li!Usk4~+dNAHJR^5Aed
zhk9hb?A2v84jlo%Gx#GlKhjP^<{-PBvTeFDu&o7h-%$?vuYaCpek}Vzq=ZQ1!G!rO
zKzg$vtk!j<AAeAp0gw7;g8wh*Z>-~cN<WJ}5<i?)UpFh;=}x4775ckC7x&*_nmi^D
zERZ%>KMsQb0r;<wAN`znzwHS9_zH3t6^6r)QSS8lyr;f=79a^u2OGa3{Xcd3Gmf`K
zh*$2ZyV+PztD)z9?3ElwJ^ErkHiG^U=rc(}93AC#j$K|H_xD1s74}p<z~G;`zRG=d
zS0~r!35}@s>%xP^${FD>x<mG3K|VFoPBQ50LBBQ#<oE1gedU7S>Fuyztc1Q-uorTz
z3B;MdZ0r1(VPEzu+aVvq-pIWWw=ZUSFX;P0A3~z6Z|Hp2s9ucmeGB|gz(@6uTuk>B
z=--0=8>uoKcMvKOrt{+g=Vk1<bdKBfJ00}TL0@gDbdmn>K&rJUX1$DhiXoqSK{(88
z+84{W67+1)FC}r@M)!J8Ng!{?+PEvsP1fZuTk?P5|3=_{Bk=!91okB4$*gYH(9So9
zN?z=GdHEGEPWbZVU4q7U&(4>3SlUz9iBbu%1SBurz43UA!Zn}$AupS6cR$n3JW#Q2
zRvTVOm~G_|7;gC&>kXbfdFRpibj`QdP8tctz?KtvVF^}VO*OOuyHa_5ul%+9${qTK
z{V1<E1tQ;(FY@L|icLQer*JzT(<N8^9vN?K`?X<}pF>(cta0tGaYEylX}(tT-wu*=
zdBhrO)*w%kGBoU|;SdccX*f&6r5di+@EQ&8(C|+hKC9t78vaegpEdOOmEC3<W@y+`
z!yy_@(r}iBOEp}t;WZlGq2Zr2d{)EQ{GJZa`$5$YyMD#W-SoWjx0C*T*+eZ6|FoiK
z#L(Y(QqhxR=vO?h=uKkiFFva1p4;*bUUqxT)%5GNyiLF3&q_WaM$g@kDEdj=UTyg-
zO>Y>Zf7B~VzDW#y=-|P9LYW2SWfl0mQTNWhI(O}q(_Y;eF+6ZPbtMls^0`hmE!9$v
z>i*`n_Q+H{7w0{uF&mGhN`6nTJSp{0teMq!Dfu<iZTa1k@}!vE{$kT8`8&#N`9oTs
zd*AE3l>9g7laxPIXXi<=u9yqgcPaT157_d1F3gi+=l7^jTCJO##%Gw?EB$u4JaNYS
zHf|}j{E4@f{$U-?r2owswtOCb1&CL1q~nfGr~H3ljV-^Ug_6I-?pUM6b@`TDW6Ni^
z)%CSsjG#t!e4e%C^GcO`vfUBKBvbOoU$W(=&QS6XoTj{HpyufMCT0qJhad-z_d+YS
zE8hLOLeY-tje8b)teuc?zuk!x;r$B9O*1YDG}9IL68NU@d?ShOm*Vl%>T=^V3P|fd
zj={+~2j%9uyaH*hbZ|YJc<V01pKI{n!$0^TZ?Ej$<Gfz)?I1wmPf%#Rgg<dz9|0x)
zIouxhHWcdseH}5%c!Q#hqG^WjC-~rPD!4pnrg?q0BRAe=8V&j~;f1%kMw5KsLdu(@
z(U5N#vf*u^(M(@&jGx|?8qM}yL$sAfbA9I{1Kwnf=J~1+KW}S|4)eW=oO;`6w8(ci
z4TUs1**6d)xi?j$GG1xZefKhLy2zC19N%~JIYZ~D$`_>19W+|)yO(H|sFE36?)#W&
zvjrcsth5^8OJ?G(qFCY=3EziwBu8|HZYyoA@b#vAPccB^8-(uxsv9USkn)>_?`h_8
zn7C2m+l220;=?t*L--C6AEEJG!uKxmks99vd&EbH?lS#8;lnSt8{RR}dn@gL@J*n-
zB2ggi9~6d_hr9U9D^Qf~oAHPLWktX;cM-ybGyTUv^3R1{AAWyJma;z)92;}_-LT=q
zug%FK_jf~%Z7gUcY=?gD-Uf@HB+2_IL+<||9i+!p^bP-K^mxAtzSlnm`xU$g%A~HK
z;r0F<>AYT6JNNDQ!?<bpyk0scsl_(6F=WpM5}>R#6nAk&tfdWIF5hjyf`3D;F@ij#
zCW8NDs|n5r#R|?sSX@B^BJSW*pnHN>K`_p+RzuX)crF-;URTp+0R0nC#I9zHFe<!Z
z{fbz)n%_r>psU3XfQ|5tRlG3fEhHLM7_L_9rL-6BQH6D!X_61&wsFuEN(0s;52Lax
zMc)3M+|*yeMPqd3AU=snuGV8g^}kNrZI~5m#;2VOSDFh9v^AsY+@*#qy#ug@t_JS!
z0fS#ah0%;Z5hj8yP%dUO{z{k?%wVp9UqTtOi_-H1x!)`<*cXbu!CEAW54J$ue8Jbi
zZ4jJ_@c4u8;65QZ1O5bppF*->a4%8?gDLbdxCz=CHRG>=H4di0c#~i$LfbSLz~5%U
zSxDR5u(IGpgZL@R$3{b;Ht3bbPzxzn@ES;YgOg!D7_`6)1$TmSzzFsPQX_)9;8Tqm
zYyq=1t{}QkqlPgp!wvelPa%Zf>nUc!TMDFkqF2OSf*b#m<|uI`hq&Qef)UJRSa-sI
z5nl$m1~cGaNF=<=G~7Ba0<2qzwZ9mHoM<R5rQw4V<OS)!nHKc#p@KxkOERoYaL*tA
z37AQ|6%7_OMTY$TM2Puwks*HqZ>g1^w(tiO#+=ZwMR9*a_Sh{F;E&5(^*+Rd$6@m#
zGx!Ent~G;Ph+StkD;#HBYzF@fvGr!N{0YV-X0rnP?Aivi+3+F8rDpIj+`r5WzK^tj
zG=t~D_(mkc@4a0Paez%`v$5liE6m{2D89{R@Bv6{F@qMgUug!P19p`e`~>mcY6kxV
zD_5IA6Qy^J8N3Z8b}du_+hzveLGtU&;3yEUH;tB4fF_wY{szCBOiDwZTCn=IDyy7l
zSS_1_YFHF8?`F=dayXf=O!j$YCT_R3hFz~W9e*1<2(i3`o8H5{KY;s$9mjCX*!>J2
z6K>Tbjeiqzm~flIg8ruvyo6m$WTqwg|3Ibps`3f>FNVp4hZL6Xe+s@NJgTrv|4{OD
z_mky+5k4n8t$5k~YpL@u3hVCwJ0+i2Sg!vS@?KO}Kf}6(&RoYX!t33QzsY|1YPJyr
zd4CyeRE8WPk}pF#v%5G4^s~Oh^J<d0PvjxYttZg+M}^7zH57VGFqp0L5nyw_V5K(N
zoP|H4o9x`}DMMl)4@7l|*O59@2@&3m0x<=@RST4UZo~i7!zOlLgD2vx%?t8nsx(t;
zxG4*(dSYU{^{SqZr;Flv>tF;KXL`G*i}7_Snb|AhSAc^{+aIa6qx4O*g4GQ8(UE>+
z;6s+Ur4Q|Bzaw3ubf$E!6B&l=*2$5beb5L{Mf>64h+JXk@gEKIC@aq{i^mXh<~5f#
zQlK}4FH!?#q~;TyHNP4to3j`HJ9PXrA}o5B;NIHu%c_p8AtMISxR{XjAQFkeL@3|s
z2vq)Ehh?lbDh8d8+SvJLu$Dol^VhgJfSWF{g4qq>I=joR0yptil@4@Hs@B9n_lGVS
z>>ncWjSY5|47Q!xNV6UJH_E9?bW-fp*`aN}rQvI^-@U>RLzw55sP;LJY0gvdZm;sr
z^qy;^y`t%?rSRBXiND3>VkFDit3&h&l6)(Z6l0I-xO6d&5jJw3(R`}(ptz7+^f7Y&
zrpXODA$p1&Z+%o32hkN8#9$+5ro;4TC0J)ZXN~6egqlT?iwIi!5fcG0m%>Fm-xRvj
z7K)DujdQQT*VB?^xVG(64Z=wKOlzj!%4eg;Rcz4LxP@H@{}IeX2=I;)u@k@e@xg{S
zfkA>5h=+80j$(_xM$Wdkp(XdEG;qrPjd({y40tW@PY~Olzo8BScO@9chhX)zFe(7&
znDahldR>Rw1f12~++y_l0XBeoX=RHyx3l(VA~Kpg&WThzk&84^L9xwF<R&Mw+lf5t
zM4opd?>LcTPUL$Bf^LFcnb*sv>Gg6nXu}DfRU>$BM{;Fi9z$fj6F@|H?58)rR16`?
zSX*|i>CNvr+vw&sIW4sODr99Q#92~3joiMPd^K}8MI-kTS>`~DHoejQtrgM(+w#v^
zAgv)h$b}odF?y|t*k2k!Hm~VZW?1Jd&Ym^7S2%4x;6QSo)5wc(paC?(No&iVHAc?s
znnCYV6+;X#(mr>{+p<QR64YF4o%GfAu|s1Ott$F@E&lW_g^2Q~W=(Inr;!t@Lkp{b
zv7vtkxvcf5N7luxrbDsdB8P-KsU+TdaiwYjeP$Te6-pK2Jg<?m#D0gTgy2@Z)i2V7
z(CE5F5R4I*%f@7@GIB4}$v<Tg+@=v0PR^e-!q~Kf2Qt5#*BH6aJEcB!NR4(#<@{YU
zen#@SiXjSh-;^VCcp7)c@nFpyWTZ9MWSX?isj-J4kYi805nwpmEI@#)>t)RCSii1Q
z|1F4ct;Zk6{Q5}!V3;+wc}>bj#M`=_Q9maUgWfk(cY|GHa*DJn7Jmvf!5Puj$eHEv
zua6?j>XKWn8H{4i)f!<HEs;`_*&*lbccfnKO#PB(WFs0z-<|Aeo_5KnWAOsy`pJi}
zr(K*(_4_B<1-Psq{a37*X_zlcI_?)6=1Y=p3`hdk{Lm%fjbTS+Zj(G<pfB@^?TP5X
za@aL}C{y1_`~#JUnmvth8U*#wF#qMs*6F%^XnUy%#YmL5V#NZ({KQ2=1Ca=Lm0^A=
z-6#WY<g*;c=@jL*3&K5UC+LH=;ZK)XZuTBfzeM8f{kZAY7+SC=dNKRefLl&r?5tec
zEKf2gK}M{`pPna}r+}OHS2Y3tCiuYD0sn~j8s@Q~`!e9o(SP?m#Ar5@g8)x56m(&)
zo#<wEL^I&Cn7)z3rxEW(eq)J`!Xr#UL+WcL2bCXz7oLZnz)W&)hJI_ywlxLgIEb{8
z`aM`R8$x&8V5+$Fk&MG&49y0kz|A2fUlNz#<wwCPdN)|&L-BH?pqkbTB;E!uL!e~2
zVHQd}0dvo^u}$-6z+k0ejm<`L%UX=zt55ZY(!HUKuJ|g*d8!Xd-D-NX)4kal-O{b2
zx?f2}Pi}Mz>Y&cjaHet>#k$hX8u&0Q!E%LRu9B7y)AC>~tSzf)K;o)3%5JyxEpTB@
zGW4h2r0amwM@|JW@-XUNFKu|eoM_9i?tppO@Lk3*@n<v*YpSrzeUG-<kk5hzP4pbo
zn#wWz9MDoYW?NHT32J|43WscKDo5;B$mNJ_P2+&=X#<oawl$3db~(_{Vjye_Hvvhz
zM_b}27}+uXAjV@76mKnvbgkn-n}T`v+mLW|QuFK*xRkLRC?B?r;i4^cTV;}GyZ(Gq
z9$1+5!;1I^s#waMuxXWX8qy>M=;d(FDr1hO6O}nCV~)79PUWbKIXXsE=4b|Ul${Dx
z=4b|Uv=Zph>9ErsAE-90@-o~$4_ddcbjDgV&jSft-VmZbm4-E&lL2c>&6+fu!-9}~
za?Ki4E7z7?t33#Txf;ar<{JE+jABd|Q{t`VIw+W_vrzK2>S7J8ighqDVj@^HkZaS2
zvG?mXRZH#Ffq5G-=`(-vY{Qz%C|X;NuI~1}mPyqzag>46mCETut8?9&GaWk9LK=zW
z;Lz&R=KwC)YKQA|v$XmJw)!-i^KWUCF}W-flbp5M`{nR$4OGjZ?!cVmA<ftf#x|RA
zbhVNDwq`Iwx%0GFawd7114+A1BmBOXRJvz1a{s9=;l~u!Tm@dSY@p+0yEEDjV^Lot
zhf>i9y;uf@&1*Om8Y9K6_-hXF$U1A+)$4oafr=?_8tUxLndnC4+<1tG)sh?K)ZBQ8
zhxKwdaXB|0;$g+)#<revay-Ptnwi`d9ow($CdYeNE4dM^kZr)6=;5@~+Hz<`Asc}?
z*`wlrU`0Uz5}M~od4C4dZ$`~9r%61U_;)aDmPq{ZcF?zi`sRA*E5_@k1s74@JP(I~
z;h+`BVWCpuPqc^peEPG{bH9{7QB?3T8ns#FVWaeQfc$Fm&y)C5zza)>S9_jR`U?s^
zr2Qox*$;Ju{A}`<O1x1P@Yb}y!t)yBcN4E+elGB^1Dt|CYIIm7{eKmB!6XhVt0lf2
z#aJMRts05H3B2$c=5MWz*XDwPOQ?UHjMvmI;CH6~8$2IL|27XUd=rMuOFcIOSX(v>
zE|kOOWzs&H<luroF`iqb{x6VzU~~Gn&+~^Cc}M~LpC}mfA<qOGzexa}<LlN#@kecA
z`su!bw-HY9t=9B`T$MHB;$CQ}<OW_rzlO#=-%8^Hna`Kvi*q#oo&kJZ-1|0v3FF$q
zH%nK*QLj<Hsc+yi`nMorXUJxxOW}w)iwd5Q8M_5T?9fBN3*<`or?Rxa0kL2rqjk*l
zEuxd&7482Sovj4z=IE9Xn!+p|mzpwi(5#MXp$~PlTI^_6Yhb0Dow`VCxhbOM3#sLL
zYRS+{t;Mxv+aUC+=v{XZj*DMoZ22YMliDpE3T;KRbegXs3cr*Jk5Zw{j3|_fpzwfH
z=%G4l%lWhRKMemHAXMlu;<s!b<ngAqPU~!>Ezw4jQ2bz_zhIvFw9X?mN;O=MgzR{q
zQ!Vr8pfsBk=^2j>lKH8T=3QGh5RS*_K{(m9We*|7j16n@rDhmet(DJhlP5`~$@cvG
zWi>xPIw)s@mf`&TDdj!q=leC8&kye_G6sx6M$WSi`R}xRj*;`TL*AFHdritW(6*^4
z&B<u088qBSF$5G9I^-uf<a5u~3^}#$_I9eu(v4{f9)W1##b^{(YuWwM*_@BG5KY{u
zO$;`28|gIiS$UjBIKJg9&`2kg)vG$e5F^(%!hyo*cB>XjZL3W0ILkJjUT1o@7NY4S
z2%zM#(3AU-CQH+;)0F~gx}!$;kT+Z>C@^v=HF+#NDwX8Prnkn(eZZOaRgKW?i*;JK
zZD|MP_-1=6^Dvt8qqq!Z{s9fG91*}|ZiE*Dm$l`@pqyr!L6^SJYWdt5Z`u1EjGVz*
zhL4{HQZt`}jNH|l%zPT%F6g2x-KQas0F6Oqze29|vZ&H*)_=6N-yN9^blaSxtUT9E
z!FMnbEV$o=&gT7iPCqlc0UyhL^RMw7AFlzPvs)+PbKGI&Kl^RulHEC{WgO+lyV2UW
zx{RE^YH_-m2>r;ewdKHy-)opgZoGDiy+Cd=jj+eanWYh`Jn!FEDcgFXo%@_iv=-)L
zhppwb`AB=vVf5e4gOQV<M-R@%n}u}l4>9*D2;*E^WbcGtN%l_Ym1OTUMfOfc?#;=n
zWaJ9T^BQ3l$@zyySj~q?&9a*3G&@VBU^6OF7TG)X)ns-m%N5z$vbn&>JzFzmlbWrO
z^PqIQPTa%DxmlBG>mf;=jJL`;uQ_zS?9};<X2@pLuyvlnYZJ?HZ5xH`A+lQ|uMl}#
zBVQ8vQ6n<j86lO1oSYJk>~4rh_!I_ovU|(^L9A(;9IR<ktlUR5OLihhH4=yMH>Y8W
zQqJ{~D^w!W+tJ7wpy{-8r-MG<A^)UJ?_}g`cgVl%pugmh|JJ5=FmnFskdI51`7php
zw@<C}r;SbTV&qKLbo$fFLBGTyU!>@k&n=9c-nuJGM=qC22HM@`3uI>$S<cR>&{F*%
zwM9wU;k?Dc+8xb$U$YprgUYB3+H<-OBmGDnJ@*$)msMauJC#FO7ArI&*RCGW2%Tx2
zCL4=(Cij?T`4UiO$(c$6<%UGd4bd!FaW2#d6Xo9HKyqHx2ph>dr9tExxxZ<$Y+yaw
z*IC&eZKYbXroe%m8#HnrkT;YZ0=?46dC8&R>nH^|-)q)7r17NdZeb77q;{w?nxYtX
z2u5qx)$loIkw(~@huR9zoO4!c26J|<Vu)_&v>o!x9P+uZX@+e6M>N9be}hik-N<d+
zQ8{%jyv@zmh-}+4H6l}=rx6Z*@9ETqM$S!|%<=AoCS$yNTa%?yD@$3BN*ifJ)`@-^
zVSYNdm677CV4)_<lG>?}z3{I@%M6hf{kBMN|CyFy7q(2ws98aJCuLdYpsPlhgB!G>
zLL;|QlclliG{WpWsb!Fzhc#Jd=a@!hc7D)^tdfm7D{~SV<3#2=kq0#*Eyi_GX;|HR
zWJEQK-kP;B0VT6kBYaZNdB>4xZge7Vw$jH$Ie8kP@++g|=4zJo^>&TO2KaZ4a24Sh
zl?YRk)kaRMu63>+jn+0vv!tsl9Y{`cca?~5ZO6Bh`HQ!n)g^~wR5J-oEciH%nS~lT
zF;dEr6C))@PIH-|hE6OotFbfZMTg!SY`upgdZU()PEm%34(Rl9l_KYC{RqkV#>Yz0
zzcYoA^Nr6VHSk@nh1tx`)Y<%{&Yk~Y?po;QP^w#Dt7}$~Z}5s)96L34cw)43H&`p;
zJZp<mgv=Yc(;Rfe%{5UjNyz2U=L|QON4Vr*<9rC?l7bWGBfrE=L%zf3L$1WvV39T8
z<q}Ud)L1tPxx`~H?TqN9>O)?4Eb+KI=p`ITaS6xW1Grp>yist;XB_atPJU>)NpMNW
z+%h?jzmjL&EE)s7k!-p2daJZyZYj=rL}%<BRQXHV%Yu-r)kuo>OPcvBn7JQlMD|3c
zc8jZ2&!}X0vx52wos2hYN<%Hvsw+;|X&J_{g{F50JvU1u@;z%$jnD+*F~mep?o;uw
z<6!Une6t7Q@pL2}_sMv)>1oH~J{gaBzzc>V=hpo)!;b*ZnWK&TgaSAp3NU|V{f6sw
zx<+$H!?`OZ7q9ASjI?c<uGgJa3ZJ!WwW?!ycE%#~p2)Lv$9qr{MT2*tAwD7$V7+jE
z34gu@ee5;JB(?w-4iqRUk7;$J?9qivVc-Zv<hpwj=(3{Z8if_mYL=Oum8gDO5Wo~o
zsU2*K4m1ikviw(@Q<UfhT5C6;g<HtF%&eBI9Zr^X?owOJrAA>8MPP0-Z<eBlExH1z
z`)6p`Ym54fLVk$VyvKY|igvVp+euNjmyc{wXiY*K%)RDMQuKh{_7QjuXyMQCU_ECB
zvlxufDOxf>mw`LqGzzCs_I0zLlr@&>EH(vNI1d)hR@NUBOTTIfNY+jCv(#E7S$Vbv
zW~r!^3y-z8^Ch1UMI9RexkDodVJhxUg^UwdAu55PLU7;1cs?7dKci8g^3IqbxO2^C
zw8CFm^8~kkj4z|Wjrd~}i;t+jN>y&*Mui{G?ORF_QNDnInF-=uIOQ`w#$WjsQS_wj
zIf&qRN~u3u=TYh`)jB!e*6HkEjKf|Lyb;M3f^BWQd=oNGJOU5>-GtzjV!T{xo+$Ri
zmcNNwhQ6Bg??EsoiVg6`-$v0n7~ArT5mA39Mdut$(iL-@aM3`P5Ny-q*-0tJBrzX4
z{f%i-aEj3Z1}>oCR!R}46w<JY=tR*4arP%GCKquOQ@hNsb@)>ilS97k+KX__)luBW
zBIT?`WqTqvbAw)l2T#yBaNG1@@W9nYFgSv%|2F*rl)tN|qH|SW(I<)P5OG%@Db8j6
z4k*}E6k|fME(EUrjpu6hcrHPYXQyoZL0k*3<j!Ov_zW+rgep?@3D9vC%r$&hC>f4L
z<I(-&^AzGl1{lZjvwWRMl*K+#px-k5Emh_@rK<~@9frT4IrzIM3C?FFUHxI5MCd<&
zXa43&f=?!OI>2m$+UCzxOg^kSlI!^2!m5#>BwmS<K=M_r0&NwO&#iUI!Q4vM(iD>q
zp;64QQDglf#pJVF6!Q@jo@<mU6VBM|it-E-HC2iDP@=LT>-$7;oaRy#lMg9UqcKVF
zb1|+#vLN{!(gCDiEb~c{#EC2`=xxkNqDsvP_IUQ_O2tGmj?5N{$>Fpvgto-3FrIKy
zbqGIDg25lpJG6Gzjfo-?flPQ$4%dPMr|J--oUA<KL_U?gAq0od@f_Awttu8Lai4&y
zL1Dr1OEIR1WvHb7&Wf%gND;i&L|MQbvfx$6EdG*+=V{bU`@GKGlk%h>e;dH$`3mdp
zTo5dM;zAv>u+%XNOC7VY)G-UobRM&?)G-T_$1Gg(n1#t>7Or}aSwK6j+Q%%QkjE^{
zm*}bEn1#o2%)%3W%)%3W%)%3W%)%3W%)%3W%)%3W%)%3W%)%3W%)%3W%)%3W%)%3W
z%)%3W%)*l@o@Tz%)G-T8AfA_~I%eUCK4#&GK4#&GK4#&GIcDLBIcDL>5wAjb<d}u0
zr}$9f`j~|$=9q;i=9q;i=9q;i=9q;i=9q<NlpLw7G=0p%6LZYMQzUpo!Aiq1iv~Of
z;o0k##~?h9G9(E+2H|;3MaM|sF$m9o6&!B@k3o1G#~}WQ1dd}6%$J-jk;(%Oa<0wa
zY?0K)Mu2B@JQKwusA68P2gV!TE^o{57xh$bmA@>2`giagP|Q0T;`SNElpE;Hi@_9~
z<;I>{z!ceOP-1eYwphgu*(`$v@lYuUUhi!D^~;^w;>~0XDhb@FE#7X2TQki_;7)Dv
z?#)b<=1t&EZE;v(!36Hq79TJXc4{YZr?&Wnewb;Y1n$%p#}$^I@D!-xTZLsNaHqET
zNnu$D+^H@8p|I=(?$j2)D6D$|cWR5@6qcL7o!UbFe1w_S&oH@DTkxGHa<LnK1Me~4
z#bO}uxkFD(5=<I&d3~#4BvGCqNz7u766Fb!M0tWFQJx@4lqX0M<q49+tB@=XlT(O#
z8y6yNBd@pV4!{JSAn`V%QAEcud4j~-{8CB;y)9k^Y|IlR-j=+DMB@q^d|EH1c}9RL
zOr9X|Cf|d<O@iJ~Enw3;bZg!edCL<d-qg477lkcPkTgp2w(fweC-4M`w+*vG%{)Qk
zP5Ve<UZWXKka*MG5NqU(kDEeq9-N5xs^A%od2qtUT!wikA{!sy9dafQI{4xj;<mXw
z^Wc|f9(?|rsDx)8d<nc|ZQz*)UqE5Z&rH%O?rX^Rtw{;&KK=b?LwTY)^N^^{JS3_!
z4=v=GheUPep@ls2&_bPgXd%x$B&stHiR#QlqB`@?LY;YNq0T(CkY^qe)tQGxb><;a
zoq0%9XC4wiLF~4giR#QlqB`@CsLnhjo{M;GGZWRBhs3Be5B_PF!SAL#^U$CL11`@z
zG-%09c6>FBb~2Yaiyw`;wL^3<+aR~T8(7i0nL5nAyAUDK(^SpJ>w6=?fd+lUgFt(k
zs`@1Pu1B$pT#bf&^T_Qj)tYIUzO78#$GlzEo@}3NUwyTq?!KW++fSppzCm=Ozp0vL
zp6^O>2WajvA3qH)25NMak9+n+o<@s&&#;ro*J!b?1JOYmo$ULVng^Q=&`+3Y(|xZp
zg9T=9S?}ifej-|^?N<3NrO!ik+U34VqQf-0()T&N8X<+{iMy+qc%)=oY3S-NAwEju
z8-;HhJsD%RMVzfPoUpr+t`wOaCB6-3HNBJImDkI1^Lkn7ld~vN?iTdVo+OOV%|i^~
zKDIMHgtTXMq@8m2NF){$TfalEX1kf<>z>#y+J(WIBR8;#DWMfBW*efy&2(a7%5(Z5
zd$3m7`XZ`Y=<bBXX}xH~>*e>2Q|Hn3kVn|IFLU_tkBAQ;kMcoTN%bfzM)EmKUE`JA
zm!0yMLql)OO;j#wyiN@ld9{YLR@AU2PS~j$^v<Jq#t=9u9!BzXZj^!qyS>#Qwv|Cy
z6GwF~0?!aS#jz~>Yz7jv<9pGoZ^)Nw+F^O`2QksewDnr3)9vtTGzW1=WdJMVgw5-t
zHCdRNiI!+b%2uVcH5SD7GRO<!=sfYv_BsXg39a$g^cveP&m~O6TvtqDC9d%ZTl)r`
zhNWBsBk5&ivx3|QmC9s|jQ8gelNZT|6VF_)le2GvNmwaHR(@g_XLy9Id_bQ(ng394
z(DN|>(aH>Ir4ppJ&0!cgoBuxIGN?18RaYOpCV7o@ZI;|EQv_UPe75vrG4PHLX)lrx
z&WwW^VaQs+7Tm%T7RrI^Kp73RD;W^&rny+W>exur2ZD~@^!pnt=nZkQD%sxWYY~QO
z9g?c5bb~ApF;P{<8)a!A)LCK@+tf~_!cIEdq2jrSik(p^?x<5SH32FfP%7-CmpfGW
z;HC27fhZLZ)v1VMt$HF(Ft&EmD;+9EM^ro!rQ$%HiVDW!Ii<o*daXkRe}!6k@m!RO
z7wS~_nUO;(BX-go94g+7s5lg*;*B~LCm7E6<K(7oJLzo>70qBmdGUUfiX*m)4&n*M
z;#i!plilG+K7+|uvYs7_<ESJiDrLu%vSL-de^bhejZXMYObC4wCu}8eXl1)mAq5Ap
zwtcDX8>#IV5LK=IM(Qi*YuDlvQsZXenJ;P$k>*>Yn=iI`iVNubZ*jslQ>%rKAf?Dh
zY}$@ujDM5nGW*%)ev{^^fvZLnmgWus&-^*o+^&eZ4q_>D7w`((jMZ1QVAlOjuy)p1
z_9Fo=tCbz9fa+9rsDi3fEk>V{O4%k}VJq=El>L>;HnYEI5~Zw3l(J^FvMkY-*=(sg
zd0Ua+p|CY{siJEc)yXH@oqPw8#exZWg`F(uNX`-HtO2wUl9NC?bD=1IQtSMgz({3!
z1&3Q(QIbR9eGz{$qx|Vm=g$GE=<F4CvXCSBznFX_{pswb3EQ8}QT}At`NJb3qPtgc
zxVIH$Ius5-MN;wU9_3HZI)4(VqK{YD$+8{E|H$M;3}7EGP1yeQiSnnP?N4X%4Sj#t
zE0?@%MFX@#e}C|fLu1>ONm7bWMUz2PZRK65a|`gy-a5tPPWCv1(X6xJ!i$)xDub;w
zqo1m(FH-qq@U-m;x;s-A=j;K%8?!CV^pf`w@HS1!pDkw~c;&S^qgWebmog1Jjv!0r
z2(k<##kra*2b&8t!mw=6qTU@GY$&?HDcVH)MXmQnv>F|gHJ$St%!4?S=qv`Z2!^VR
z*%|sm3-VKzqCeV{%E(Zek&$?Q>)2gONY^H4gs!m#G8fV{k!^IG?vU*GxkjW1okd?Z
z*DfBxNq}v0eSa0yYhgx=!z)5HW_OWe_NO4K66_+!=q`{|CD=ud;THgJj}gDC9Pyt6
zmeE}6qjLvr=kn}9I!kle6Mm++@z$Zb$&4Jy2Rc+VfJexmZxudz!E+dCrmbqCLshnt
zIz?6HTrI>2P~CK4CGOP@?#^N@%j1Zu#da*V>Qp^3$r8^%cRC+pA$6mHbL$|gm>lu4
zRzF5u&TEdyBK{G0<`r7Qd3CiKe(Oop?Hur4_Xyj}tpgA^T%87izORX`?sXaB7eH+N
z37vdX7D3a&c8~v-oF>f%-sLB4?gp)CHI%eI%tT+yL=QnIqk(3!kf%Zb4!M>Z-O?G0
z#qc>r^CP2_aUrsTixG!_k@0{w!?L|bX^<(O)AZA(>?GJ(ikm#b&TIdHc~ot@3(rI@
zo|xOVMC*YB>*nGDI|et&7(5AFjdD9=o*NXxnJ2ZoET1$eP{nIxcF~&k#8rCUNxTi0
zh2asl-DkAaAgB`iBK8ew|3eT}ks8u|hat9oQ`%n&JY$^JK>N2j?C+_^erGY8J&_eB
zo1Sg^x;zzwr=d<<fMv3_UENaZW&|cM6u9g>tvFV*`NU;4v*gJCF>p3LcN`;@H;e_W
z^|5&RLY?dv@>qJSzzu0G3u(II##_0LB8E`r94*8WscSFbpy%R3x9Fj=V7uNSUu9uC
z?29X!!^K)w?jG_nYQu2g73_0*$jQrF#AOzG$Sm|2p|a3RX5m7K;oY~$jbi{FA-(_$
z05bbu6T_+QK2lTXk;u^Fj_h`TY5Kbge|bW~$avq8-LZ-rZ_ROJmqH%xJ}ba{Da2T@
zL4cc?q`8r5y)8O9V)831ZKjHe9g9gi*?2f9eqc;^JP=ZRw7dyK6@yF}gQtLJj?*bv
z2apRs(WwW@VonhGyJ+GYx3Kjd*U|~2K;MJmwQZtLN^r_H1w^I)8~HqcJ8;!>PRM8W
z?|^6gQEOn;Jr@d8NgElvG@V1xDoHQ4d`6z`ATnOjY<8wMD7G9uRrm3><~rM5+QY2&
z6XJyJ^NK;LzVsgr`qCEgbs%#$L6+)!AS&M{$k?<UWBWc)PHxWwp7JkkX1LbWdWRnh
zCd*3lI0Q06nju>OEa=`VqpPN~`<o!?%5Pgyq?8XhN_nw?D|-@3*}O_VGTIsVSZn(M
zCdGi3_$0y%h?GHk;8<)*=q^(b-9VI;-n@zvfG>e|J4$pbxuc43u8g0K7y}hJr<{0&
z>T)w)(E6|Fg!%y<iYVT4)eV&K)=9l}fu-ZUp&dV8VW&1SKhVipJrDrYsBwB_ordJf
zy4z?-zkAFIz?qdYb7B_=J&}=>^sSe4Q{Bo8tYijqpQ8M#+ab_<Q8_-ywVJYhn1_8x
zEvQbd;S-gXyhcMR?t2S@BG#+5D3R34F#5@*ruA~Esh{i^*2_xUzXvPD1~)YikZU2A
z%F5ecE=64?m!kU1m8OkyrOD{q0#*f1?J|Y<fU2ds4_$OwsW|H5a!UUWAc&9E!QYqY
z&?oA?2dmMiE@=||jJoUpASI4T>cCf_wtp9PX9?1?fscSN09|ksH@o2e&(Viwl9ktA
z)=G7H6}|HSe7>W%$_{%pxmy5aB~|QZ|IQwkFQP?LOXlL^L3tz^`4bg<5;a9sv_}h(
z&kRj1J~Ny|skW7K_NEr+>?6k8EvTu*oUaA0*7KTMT+bUZ0k{lelEpsuN8;adXjb?|
zQ-FJjx3CzAeZW=k(b8h{4ornZPcWaOto-{~NYkxBoJfm#*0ciUXqOuYtDAr(yqFB7
zvb4rpTo=4#8Z-}{fEuxExRS)kY?ytPorS$W%R#;y0tNGNbCfqTaZ_+Ec8Fv{YRFn(
z2Z0UQgq!IlhB5Ry+{9a6yWzZ{b+X}<LZfUrzSB0GOJ&2cQyZD@>*QP#)ZHTHSHnjs
zN3Ydz9~2M!BdUTqg+;>MgPDsp??D(wN<MF}<#A)7(d9+We0;Q0RMr{_UO@oO60WRM
zD&x48;f4$oe5vFpmBd@=_7i+Y3$1~>Gg{eFI0D(RKr{XYM#niC;hv0)Wg6)Sgx`LO
zcqiw;9Uszc?!qvJPe+tjrJ%%?vZhawRsSi(dH7~9{B7`1HI3!I+{OAN#*KI!;cru<
za<yGUaf$06uv73?@B-6u^BQgnaFY@%IplM2c7QYF2Q52<zYBVT6dtYWTWa9Sw3Bs3
z9kfejBzurYwZ#K)PF(LQg5w1pKwpe>g(pB9(o<tY2I1x|kcW)H%}2aB8#hf+&4<jw
z%`)Cp;pPV13=f(3EuRo57lQIDC|$;m%cCpCw;KM8Pz<>e+{zia*^ZklaMNX_W<RLm
zTNJws+;73nyiZd(2I*1N$b3~3BLh(8MfuW{9=VL+Met@^2#WSWQOQi)JdK+taMN+t
z_&g~)l?A<CBh)k)@(5MDHL$Mkb1vL5q&t)gSlk`A>Ll{P@>xgvwWmw}juzTVi?tfL
z3&{O4MX~6LoMAKTYLC$|Fd+{{@bfRU)#Xx+y{KW+6y)SJ<fK(ORNbPfjLi?BNPIGF
z=}34c$Al;2u&xA@=mVWH+b5z&@yx+mJtt&#V2zCV#d+`yqc<wn9F<f)(cI{u+Z8Tj
z+F&KjY17qp!WrjlI;Ty0B|U1|v|h70F?!jNY?JOExoplO=-N)kgPP9egp*1gead*r
zA>SmmPX1eme3qok$F&S^p>mh{3mo!Unoj*w9rA?^dH!aL?N5b6expPFB8U7=hx{E5
z`TY+0Cmr%{IpjZe$baRKKk1NnrPcWp8lv(=|C1$M<+rz{Gr!#(^3xphqa5-}9r80B
z^4B}$S32Y$a>#FW$iM55=Sd4)yE0BV<PSRJn+&b<|A<4rlcv-EA06`J9P<A3I{kAU
z^68S!*C9s6CWm}Khy0xm`C^CsOAh%;hx{>z{5prccUYbO+a2;Lnoj@sI^+u-@-I8&
z&vnT2XuDnCE^^49bjaV}kZ;nqPX0-Ue3qoE`tX56zQ7?bhS&K&)ghm*>3l4ymUQ`m
zkkLoenXiowJ?A>~>~!e)#v#AoA>U|3o!z$_@|`rD!}Hflo|6ZBOF%Pd*qu?A;fo!L
z&XRPM;hQv_Gmybbo?nTO6Nq4B0`aPrdL8Db+EO$pMk@bkuG(R)t){cRZFHE+(R4mz
z+@<7254-Y@bSQhup=_Z;*?SIUmuotM|BI5hd`ZH7^t{cXF4(Rv6wf)-WlFjV#ZiZR
zo<rU>s;&$sJLLVE&S_tjL%yx1GbS4xbbCU`nCx)qxx*p9&mnKm|0sXRA^)<Tdr|*!
zhx`dmr#!wU80k|Qj8Xo7(b+IsNV=S88W{sMgNnK;hU^SxXgU?~dkuE^taQkiI^=ga
z<asW`mfxr8tXo$qc~wcjawxjnp(r@EF49js6s2oA9ev*+Kg=Qjy+gj#A@6HnSMnD-
z<WnVGmHd^O&dI<~B_D5fjGhB!KB|ZJ$edzB%$&k~JL0|q$>jsAz$#3GM9eUcdxiZx
zHdargZY>A>4M?gr;^T6S_!|(_O2%=yCfsfoN^yiv;prlC!BrkE?{Igh80itV!Uwe2
zbfgiJI;dCbBjvi}ZjhAPk#b$~7vSpgY_wdLESQb%|5}}%-uFdvmf%vDzturkU9IN8
zho6G5^|(jawp&b6g?9lIif5rjS$$kueGWur^+{>9@f=uvQ)_1=9?(`X7-a^vCg-Y9
zXSwkeuXyBxu5HWSx>^EtVn;{Y=B+Y-_kgHu?vyW}exl93S~qRBMFP97PSA7)ufL?L
zfw5ZC8JUR=`3(;Gd<T7-rt|H|#dUfzZ*$1kMH0Ei@g57?Y#=JD&DlnqRMwhB;#rVz
zIATLSWUzmcxpU`1^slyP*l2SX%V3T8PKmD5qA%H^o-D03(`d6W0MVO8GDz{(flIaM
z&lIHtU2V~sMw?PUMDG+srD)A%S~LY{o5BRJ{v^sI>!|G;SyIa~+{kQvYP7kJ*?2}=
zE=BV$*IH%+ZS!Y8Sf7Ypk~RI04puHt)WkQ~2TnuoMH<D!8t&V<FI0$8JgniqLnAz_
z;l5KLqXiE|xa~s`+(<KqE1P4ud^*-B5_6IJK*$t=&n#og7}0U!QDi3AMKpkn7%jf{
zLBj;KkRrJ8LuxQai)Bcg&{{JlN79d$`}YI({(Zi+8H4}$y>GFhA*_9-H}-Q;Va$!7
zEADuCuB0K(m9Sfs4yr$+DMEj78ibqP@fmYI<_kXB+w=qk&O2Vw`7kf(W08O-8oXT;
zgAem#m=ts_XzK5u3qIG|bOQm!chG50a1LS93uvH9>EW}za!tl-ygXTgkG%^%H>w1q
z#ib}^&&zr{`Vunu2X8L98+Wu=9Y9cf>Dck<PX)C|?13S7H%kaU1=^7|@G#_l!c-?<
zIM=9)n+%?kn;_m#fQ25)OO9%`_b1?tceJ9j$8>mKEDu!#c&I`u#rq#PXc~J^i}b$u
z&9L4JmB9X8ii38OMb$E0ru$js%lZO;443?*xYYt}+;quLidz{1WJ`Wh+<GbwF|p()
z#Vz?sajO=I;;k02=(FS}#Vz?saZ7$u+>)OZw?0K#G_>|YPtcN|6u0Cj#a;4~;+FiR
zxK#>on_BXd;+FcPxSO98H{(&{^s&KFK<jyAB#CIF4$x-FFN|CA3*(mj!nidVQb9|8
zVcgmYXAc;b`og%i3oh1}Rtu!VuWELMT#eW8JPd^)v-M@5#^JM$W*deAds)3-GzSck
zj-AckET}S5w@WPO<*Jd{R$)!NZ$X9GPGL#j4;)xBw$yT+$agjVG*IUN{OX4r62#{a
z6s^SDV8s>-H=mFmfJdSgJ;K-+@BJ%PG2adOhs!xZ{%LMBP$v!&ucOLFeq=P>GB)QU
z9TFUcNaDTZG@}A=u2LMM0CmkYu0Xxe)x>I|s)_w`Bs0&>lRBPZHTj=CKB0b^!rf4;
zU`^vsQ@EqgOt_=ZOt_=ZOt_=ZOt_=ZOt_=ZOt_=ZOt_=ZOt_=ZOt_=ZOt_=ZOt_=Z
zOt@3UBk<o$Q)edJ>EdyTsxuSr=ra@U=ra@U=ra@Um@^aZm@^aZ9Pt<Ej+~ir_Y`kR
zT%Vb6$DEmP$DEmP$DEmP$DEmP$DEmP$DEmP$DEmP7m4?zef!LWTc4S5Kgy8EGZXH|
zRCEk^X2QK+1xKBka68US)F6S{)GsHd%$FRRNoD<z)Gur*e>&n@Ao8ap%!7>~oHGRV
zS|66caUK4yKtorYZwTOj_=hCqF@U(n2}qmhjcYmwP#yz_i#`Sr*L)l$f^jXb0hB)^
z5!aHp=xp#q5^;`W08}B50mLOQ#%<$ZT!=pqBY#LDE=At*7(iSqkDeeK`iCUqT7M5*
z9s`JL!>mv<j{(G`$*<t0sUMPvOMeBthUoRLhLZp5en`Spz5Yq%W1}zWqwMB`|A`-x
z@at}V1f~v+WH-;eBR&bLn`d3&0T$KGmm#Y7@rMM}%`2=)g6ifKmXx5nd4(n83rna~
zUhhPx_j-A>wYjLo-=xSNkXbnXrs!dlyuQ1@Ot_b68qg)%5wG8NB%Ztk<z&$CpG5Z^
z^d`Q+WGC=)-rI<`Om>`tjg=ofa<K?>|D_naio9oW@J+aY0<C#V@iwsUZKK5#GRR9&
zm_MO2u~dZx6K*4xPN#W#X9lKy-nJD|OLjs9dF>WTEH_~eu}qaNFX1^Xe|S4Ak-TAW
zh?6C+ml^hYN%eXU<GzLX5vfF5VGlJ=OwL2p@j9&n<W$TBT9)A@VOyq{G#5+a)1^4G
zaVyZ|Dlju>@~^}=OlC6C_IcQ}*WnL&)MPxMRlbF3L~_Oa`IrvUna?OQNXtB~;T{Yq
z$#~Bxf1?23p)*<+YtBO&wi($Bo^_^%bHPupn7P~#U5H)?G_*mBt@q;_)lingcMTc#
zNE_PjU|(vpyV~qj+Xz$3l>Ia-MHG9M8on^!0vTt`*EzaL!{*G{QbP=+8)waj8*4R(
zioW~*D0>h1sH*gR{GK~A$xLRFOlS!$$uJ>=3?&o+0bu~8gH%Ob6&qql2?#6Awu%Y{
zu@^)U?23wI6%~8iRaSBBYr%r91^c?T|MR@(J(HWb`F#IBKAO32J#Rbbo_p@S=el-A
z=i0eCK>kBJ%e0-!*8;|lLKDK7ZL}z6Ip=#_yvi??mp6F%b|iTHXr))#R$JN%e7(hE
zAD!i1WmXA0K)B2iHZP~6YCz@D%JMZ>?yxL)l&_1+XD&z+8clMtUgZxuwI$b2Rv4F>
zjhwvrPsh}1?tjvyBH*sLx?rwOkWj2OsH!3kLRF(#f%Y2Rj0d)>lw_18=~X2`^n1t!
zd}t1c)f{Acu>Yde7gDmLaV0+SfGp6ScN`LC7GU<(u?W4=bUYlm{ZG`&@5svE07y!`
z6KP)o>eds=OH{#N{WYmlXsH<{?ShBa^=;0Rh>_<Ykj9;a2n<v@BjBYw2BFH`fhrjX
zDG7@ElmZfkXM$4PEh4w^RApG@PlM5iSqUz;btzIjs{>l_O$dZz1;ddvE)1_I&p9y5
z%)?C6h9gOr=g-q{BpHsE0d+o0*`L+lG$hz_dFRqAKN)@CcBQZaia-_fX9p@^NmKJv
z*mao3Zc{m?1Tydv$`%Kd&2-B4ZCRPu#Tm#lpc=L&OHOco4P75^oXel8@|iH(JVDog
z<UD;m$Jy(EOTViOU0A1|1OO_A%}_arD)%)`m7B7EL6yfN0y2*7%kZ6d3c}Z3r}RVh
zHw_ksPu}GICpgmml|p;G^nU}5rk(IWn3JBUd`ww-rUGK<!2y7VqQ`mNx!Mui$Qhk6
z-MQKk+hl=S^FE=Y^+KDaQpVF@2CtUf4d>$CR=UXa8jdDqJi;O!*9G!>8=j#I2a_@$
z0snV!=kH_j96<zcg?gEC5|1~AWgj5)l&dixPw*pYhE9}8-|a1z)&;z@rq5+u>+tGi
zwICm>1-40V7KRJoD+PmIN3BGE=H<5gOyhN@XDR6MH5a*#3O9KT-Cn)vYv}r6zew~z
z2;|{O15aNd59!<L|LZmN;QQ&3RcAm*-cOIL=3)LM{J9hVM~CB&!G&ZbO1+UN2~B6g
z`6RrB|AjXnJnsW2h=)Uw(+p-7p91m<WsM*qYXpU|Mu43Y_-3c95hP@dAR%i630WgZ
z$QnUH)(8@^Mv#y-f`qIQBshW=C3Yfv#R*v>NXQyNLe>ZhWsM*qYXk{dBS^>^LBg&P
z$ZRnb`v6wK##Y;Dqs$f)GFwc@qCjF6$jO8(3MA~JK*BBxB<!L9Ha*~?K%x)$uqaR@
zv&B$(oez^RkcTShJEl)b&K5(JGr)$~Vv@7PP!|Rfv&AH5i=nO-YLnz_G1SdMWl7E!
z9fa9p<26VeR~_|eCh;)}kK2qOK?!;JI3X_|C*<Yh1Q)X+iO0}S@)B#os4pMqw;lpn
zUUgiG-y~l?{=-$ra&q9R<4OD$^SSN(4m^Z6#k}gc*7|}(Q-xl2T!+I}xa#1vqBUPW
z&QHmqz3O-#*x*%1C5%h*<>UMcx<bwNs^e9GqFx)ke4JnPGa)-q=BjKY%Gzj)C#SHN
zX6_HrR9B?)<dry1+Icb`RC6haCR_^aJlUoP-;&aK^4%1(^JE@U%+8Z-KB8!48t_Fr
zPacJlBx&c#JS4lFCo6l>&XX;aNZNU_g_21-Po~kBCnxPZd7NmeOWJudH{kHogOYZh
zY~`{^J5Qb|w6QRV#TJRu;YgI&Nb~{fd;#cKpE*F3K7+&83yMuY^p`TOfD|N+)#jCb
z58i^d<}RDfGJc%1pq+xrvKq{|3rZC%EBgvuxS42~E6c{BtP0vISX0K2a~5<^u&#_B
z=Pc-`;Gi;ooU@>lg4wcpDA<B>1;>`XhzVCgg@RMcZec@}3eGAU4lfG2;8B0ZV|Ll?
zl&vza2{^axYua3`9?dJ`$2qasWgV<9yPaSUvr-&fRK|~U7BsGal=0)71$|6C$f5KZ
zrtDudq_24gy14>UwkP=q;PHRL=bAEpoU>rKxmfrcOc_7USuoaclnkXWH)Z@dXTdmy
z*PF8KgvTp<lPROo1rrqBjP?jOu7H#cV|pfw_53(z89&ZhFvWZeHrX}8&mv**nqh$R
zC*u$QmmwEbDIe!dcx!=5^5dKd?*#GMOY-BK4hkpvan6Jc>>P~x!D9y{z4lxhDA-aY
zyHXT9$dD)BsRHUD8+|XyT`3B-+Tcf%+?AqWn+<jnwRa_`ktoYf&IpW~niq-EFu{gk
zfM8pD{us0uo5Ip8iTe5dKuL0g0bkBB91^&}fP-{{0Y6p*zM>;wd8J=?CS~|#M!(4R
zZcm0(zt~z8O=2eC`N{hw7RlshH076A8dik4H9=u)HTCguu8CGdZSr66*~BivA$#@l
zZ2%QmD9VxDBy{K~mg~dTvxTuNDNn+-r5Ap>E?M3dVii_wP;w`gRNBsyO+Lh{!j$a$
zo*tWAM9!|ZQ_o6HB~8x(v%MnOH=!`GFYV&K35A6`q+Q%Mp|Hq89Gn;m**BrEm|nCh
zGevB@H9zHGiaAoW-k&Wc1^YM;OE?0x-bCA4am<4j2BX6XB#tmN(9K3p)#({mnco7w
zBc^{N*tnUA>kKoJym>R%M)9B5;Wla<Ersml)&%7F1w351n9&r9KmszIKVzGZ8xeBM
zU#L*we9+E^R5_#`7rXp5Q!4Nn@Dsv+Gw7A;mH9*ct$>A38k+bW$f<3LuE%^P^@;+t
z1e0VuiR$_NM3rl@{GcpJ-d^=+ngd1pc(CwbB`{U|Hlg2-h4d=Gu6%O43ut)yeD@V2
zM6kM8HC%uOafh?<!-=@X+W6r_dGfr!JV5ItnFbC8dF=R|M=^c(8^Z)TqyD0*Qwu;V
zM1|LI-Q#}48ae^E?vm*H#reMhu9ano2Smq+g=%kS$id$5mDb+O%z(Yy;fvV3ST9<{
z=96;3)KI}+@mvWWmv`b`_2~h5k!{Ga!`~*dk2I6DBLfYRk)hDbqf<TZU`hPfIBy^L
zQ&u9o2p*U{3z3B}th4{JijF!Jv-q=7!WQILv8rAcDs%J@sFEW}!RM^zsMly!dAt5r
zqffDJjD#+K5z1;`C2iE-T2A1MFU3*|hF-@hVUhlZpriK~njVoGcfHSTJWe^LJ5dx~
zYJU}BO;)=Gy1?~r_?ivgo&n1p8ddhW%nN}KpMqv2%(u4?W<UC~WXL&-s#kF~m-$aX
z*CS5X`ipHbG*7o5{iUg{OqrU_>i*S<Kh>fszcv-G9vKi9FLt%q@^4K=ZMUfV4)O3a
zk_EFAS?z=FnPK<r!|#du8K%82yX7jToZS7S&-Nt2)*C5OZ%HqYDte3q#UEr`ovk}0
zOI~jhvTQoz#xaM0L2To^#RN{mOCEzb-2amxzbEPsngRZk|BPoR_u%(L{XKcM<JT_t
zD2FNjNH%V!58(Gi{ZRxS2Jb+=P<_$CS%9ARgZ}y>-!8(7BC|kx4?KhR#X<MeP>;<S
z_dFStiJ%NV0ta||Q)@f(oN8i*u7xfMv-_UtAIG2`5@sjuRXaoee+*x}n~I`OjM31Y
zroVlPJ#Pp;*)@6+Ts#xTW)4@%c39UAR9MIFiB{Juo})c+e9crIO7b!XsY72wWU7eB
zJ2@CZ<$I!;<CRX8bFE6O9c5N2x-#o|Yb?6)d!kS-&sv*NUM3!B`c5?|*L<d0sS}`P
zhi$#_d!h&c7c4T)Z!*PDF%o9C2nItV@;y-rS8g4w`hq|x;4;^{>bNu*>LKMF+7pWU
z@QShr=N(?>$2qRy5d+53)oA2sw1|IyMQqLNGStcy2q3svu0Jf%GsNHI46z^9sIc-5
zB1g_=0o8^$MEzYf4qApGP`=6gqQF}L*PhHKUlRD(({(ImD;P^3*LthvwU9ABFNW>~
z&(ITj;tKnmV(`_B+9iY|KCK>f25RI@b$iL|EG_r`j?3NJwPbo(M&GBwRQVreI$W7*
zKcgkDizUTp;`GdZnL5;J=&rwJhv7@@_~<Fd05GK-fde025mH@F=Ud>dkd^r_MDKnO
zsZJ|XuKfKL2B=WM=k{#o0)aAc22r>p+>);MW($L3sNj`m3Q~KiBQj7Qr@%$%-rQFL
z%ED_JmgS+GVxdn}sh7D++1TcVuFaN>{;*k_)t?3A#om@>cQunmOs~*znZs-<rl1&X
zGQX2#E=Ei%Z&9Z2^tV>#!9Pk-e$G7ItpxG=aRrWrMy^-FC_g&ItNvQ?>=rH-Nb9f_
zzUSSFs|VX`p3j+I@mYA6a61SUoVVxuN1<j<0<N|P>#RVEwe)PjQdS8m&UgO;Wyuii
zMW?83PsU;){Cp1JL)cSV34GAGVB{s)2Gk^H4Xp*e73f~i9B$+Aq5c|W=_F<qtc1a-
ztkT5WLlt29CWBd0Fzb^4eL4;mw8bm@n0@7HE;C={yP?0&vGSZjRNoxXD>^T4QD<2*
zonGd<!?GU#(I{TQh=TSlc7$Xz1=Z&s(I_vn=@w-(&1Ah^n~$`@|IyzA5&4RRhhYza
zK0YVIBM`*ur<F*z(Sl5xhRs7x#v*UE*TQBqM6z-kxQDF=;RUKevW5!!9-u2X9c5eE
zs=s#jwwK=%uG`t0J+5{PoV}qnd@c(w=%BxEP(j8ij)uk8;Vt?)xS6lj)8|+NC@-=T
zTa+EuOx8;+(j-Y4JrT&*CC-w%7E@l>Ok3tf&DfbR=ngB-$KSowPfEB7giMV_om@K{
z7vG;-u7rC)_`(tJ8Nf`JK!kdtlZuxQv}o5J&FvZykhd?H<AUnF7Ui*7UX$)oUC=zj
z(Mv~o{3mDVCKo6BG?PV7y;z4F4n>&`8e#&kTUT;BYxJq|GX0dk9rUj)U0z_!9HBN)
zuml4UV$eiziP9-pYw1?-+JNBrKMGdg8xVw25%Th0@OUA49QgCN!kv|Ee9bI5>AUH|
zAe}bws{S9~?8r&2nZ-%1naNA^S#pU!g_r1+t(3X1{$fIB4&W&3ornLu5#|K^HHTBe
z=^Yi&A8n7DMo@VK8KQO9u9g42E_b6&Os$+H9Q#8mHUNsviI7Wk_^##j=M13OaE1-P
z2q1H?G9R1uyxHJI1pMe+FSS<j^vfG5+k2a%#e1jzXXPk8AI<dZpv@f3X3hsnt{92N
zEN8{#wp=pLs0@4Ci`v?JSn;vq*@X)s11oTy*+P-QKB-Tq)ysUL;tWz(E6!VWsqYnk
z6}+`q#Ut?yF-$r^JaHcEHy6(1-)r=Q?{rGQPM{|fF2I$stoEEx8Ny}98tYdLnBdoH
z^@|}ri6OlV?3sL3M<?%Tv?f!ncsluwb8>ErPM#=Ex+c6#PZg(=1!$j{qLWh;FHXuL
zA+3{3vxJvNcSf2iJnz<v)6UsvRO~^RY$kP5r|aqT{;RM$Ad4XNthNmRC7a}e*H;C+
zK9yeo1cuB!)km-Swkge92>gYLr`NkI9=EYu^m>7K?V9j1w+F<#p?#^0X)O%!esp0o
z@hvLOpbfX;v?{et@xjWtmR)Iy1jz-b_!wImomPWX)mekIgh6TmN}|#qXhdamAS%lk
zmAAo=c}3e{R36p#S@7Qk-1^PA)pAspid(J;FY{Btt#)YN)j~||ZL9@aC$-SZ%cBFM
zOkbYX&oIul^(yi^T|BfLE@G59gL%LDLRSU?z6DSmJ_$^4c)L2B>Zcmsf=p(L0!;U7
z*0NaWkQVcGra0zQd8t_{&Uj@`4d_avQOW(YEtbw%O?6dY5)l7C%I55*qIQLYeoE+y
zaZ?z_BW1&Tvr;O=h3z|Sq)!8aQeUAJvXT|@B2ZPleQ8$C!06IpjmD2$h~ImGf;pcB
zGY1Tr&4B>ywm!3$XI=_8(;EuJA@8yg9Jc^8T_g0P=ZQnE2`}?c6=y#fW5q@7`-<P0
z#cSP)NB^k)Lh&plEiPL>Bh7TyPlE)(IX~uDh~wYY@W5m%H3$t1!k!l)2(r@Hz?wQ6
zpcE0g5Crdv5fqeD+eKuE$k{U0Mm0)J^-+K|m4Tf2-txlT8u8s}_Ns@fc)f-b{@Ep~
zk>+jsa+&zze7H)vpMs@kpOpG?8GSi?Eui^}@l@MoOz0f|#TRnHmlE}bXM-!4(EoxV
zv%hN{#y@6_m&h+vJe~5OK%A;;F`<`>Q?3awvsA^I&@wA7YR^^t&MekJ6wicStoSAg
z<vQ_5`38YmCqZz|_c;#Y_*Zu^JiD`t24Nk8@OPkWRj*?Z+FybbByY2rbxfbXCMzL%
z6fy`&WgsNiF(gNUJ#(+x!cM*;VEYcmGbF8{KteLR#gJSpA#qK3nYRLJGge$e^51~k
zW1ZTD7S*nArq*aI80j+tYReVRNMEUVM!Ht<!AQ$#nK6;^q{Pc(Oh+14qPa;T?;<|m
zNh45Z|FlN_CPsc2P&V>6G4iQPc^~Nb<Dfw!&-vla_IOHWuqqml0FQtk1k>*7WcPrp
zK2qtrU>+)15vED}oQk<aOme0?qnrn#L9>6Ansf(E`VlB=(j7Eu)MeTujs_RfKRb~A
z%}oD=V91=Q`k4M#tYwm?>lM%Rw}OKIBmH+uo?H`N=4KUVo@%YQsNJG?=4qtj5%}tD
zivL5NXuRa9jh9DvN1Cfx-}g#TTrfHu4|VwW6g)Ehx@u7FWl#>k+zom6G8uOOls-W&
z1Z9N=h1t5F3_9d}qV~v;7gqI*MLFao7A+5X_em_AX0N(f#aTcQmB+#4^uISR;0@j~
zn**hN4#OeS(g&u<fvov2q@Comr$K@ej+mE6sZsKI9`mkoAy}=AeF;a+vTB3^>fYtS
z;42991w=pZ1hmf}XxKvqmg=whV9;cs`(KGmpM7w!5eJpcnFj9<N-T7(MlUl%g&CnN
z+L8#J+~P#z4T+GG#!7iWTtxreqUf7VMG+S~E&_i>n)wCr_%o>s7lemY@0akwd<eTb
zBFLYS9YZ6p3FVk~*gD}_@!ys(rTR7%I}J`UVQZ#f@a@(HI>yVjor!j{X&TSCj>Z{g
zA`=H2_=zL4Rcvr=pLb#wBwXoT1=8!?wKli1Hfyd%Z9Y%ETiJ9yK&j1L;6iP#)#&mR
z_6Qr;?;51*Nb)~Q{?MBB%l8<-7PncjVfg@A<9lop+PeVE17r>QamqdcaM*S*KV1VQ
z7qx@bQ&wul^304AvNTZ^$9{)zl7rbTEJ^s$CnX2YJTLPn6=&xyg?h$})1*rRYWK5v
zOfqz)^~Y(_GtJcAtl~_=Nmg7Qq0T%SAe`$6T(fya3EZ~gT1zndc$sel{0}&OJd2&0
zr@7(a=Z#^3{G_a27y)|XM=+259_a9z-OH{WUI*l!zXALN!GwQrXq`~J7&)Wg7|b&N
z36%3>i^qGpEuP~ZZszyzD$cQUPNUjXLT%$JK&D&)#{7I`S^|7Ob%{OkdDr%tEq14u
zo3@>rrs8M8OFQDQ7-htXdwDG1k@7Vnvs>;jxZ-|W#p>1}Y=_oj7V;O&X3TC@7`l(W
zf4!S!`8RM>UZ?D@>aVTSZ&;_DuEojpF2ze;ym96U5b(sb^eflY%9FBChYLvvm@_ii
z%uFV>Nnv7_9xwOM9lU;dce#mf9~pZaLekYPf*`uu&Dzy^RjJlv^tTh}b``$0bp0Od
z5#s?$WbE_7p!HsTnBv`SZ`6X9F^c>GvFk6)cAKqo#WPX$R!J;W(?aJ66_nT;70ysE
zb%x3}W{SQ@rV6|~24tLk@6B|uadYu1otK4Kxc{;qo*&!;XEcn79W-j|mruYz*fAHw
z)OFg5)Z8Nqa2e}2Ycf8@o!Oyi_R~@*L^v3KFS9E^s0$Ll2`Cz43HUNXbyQ8$aaWYU
zi!U%#nl9E0XMOVIES>PKUeE0Jv|e<{dBKNk9Mm8_rG<uC96Ep}U3@cAN;5ljB*)XP
zjUMl*Mu^AzDKHJI0=v~v+=rbXK<A@zcx?9cGHV0&S6DR99hn;g_<;fZLjnB0jri0K
z#qZe}^|LF$R3Bh68UZpPNc=3C!6Vsp%LQl4{48kL+j%``OY6`@&g8gXr_OF$%4GLZ
zX!p{g=aSlA;rEsf?M8Tz!rPaoGTNksW}E^nhIlU<0~Et-MKgz079Co%d#RT>MG4!p
zxYg+h4OmaVUI~M+3O7R)VdLt*1{9s(_@OBEgc8Jx&lTY1<T@4RrZch7g*xVWnbK3x
zB>r(+x>tDkz4y!@Mbpw30}W(mD1n}Rq&nf*aRL6{9RGHBwp<B|EATvTZyO2dzcj$#
z%cAj7T=1_C=-)^A`+AxC1N?^s`5z1LFHruyyv*wX{?$SL&y_%XHY)!fUM8f~Kz|<z
z@)s(B{=TaGL%mE@fd9)N{~#sw!~$ZZE?52g2KdV@+GhTU0AXN|aB6@sB}h153H0D-
zZK1zceSLsm1{stCO8+xXfyUX=cO`$$0-N&z*MW9hUsw9$w3yc~W9g4~rM+xu0SASN
z3U6CBl=m&o6oof0OTDB`+oDr|0n6)?D}BG-w#fijSTqv8%u6MdAi}*AV8u>RVOz16
z<tlcX@~~o$79OeCQvwaF2sW@J*uWJE(7GG60hI5Z0pW+8Fz;tQ5g`0CNO(;N%)%F{
zXgJpQ1N?c2tR3#5=tm{6;m(#|P)CKD3WjAskUyma*3l&8$0#~5z(2?FBaE2|0mAYi
z;ZP;e&`VVj%4I=-UyOtjl*`2&DgR{4#g)mN#Wr<kvRp15U{5E1()6!b%F~I1b}wP+
z9HKOglJBu}W-Gj1N6n)Y-nMk;CvZ>i*5Hh`bm$QBpQ!ZpONU;~Qaf4UhNYR?)NF?F
z$bPx%dR@`Kz|y4_ZM#==p|zdk=f%p8@w1Df8TQ*9|9coedniGwai#*S#($}>twwj>
z*2}C=9#-S`!XwpqOQ3<G{#plUAhSgYbfBvxaGJ17(ah3NMPr!sPi^cqGc6iBNkL6Q
z2~=~u@}r!3Dw<VurlN=7aixHotAlC|2@viL66OZ<|4kM3^D<`y_&*BrUlAbu79?y4
zC~CWhO&AP)EP(EzXoTStMHi321-L~ck0|fbMU8p<lky{vy%fznE^zz}h|gFhFrF7E
zKZf~31N<9<{EL;qz-?82%w-w^{I3T2ZwT;zuKehpj|BK5=qb{(nD$o#gz_Na(}1Eq
zEWsdSA?<T?Y;uslLx6B}kkBVUSP>vpPYw{AJ?QD(+M;Kzusz-N@E(7*QQpp;e$GIg
z7*4lb_F}kU`S^-<B4yzf%O{}kpYD3=@>GL1CB5e!1sKv|=tA3kOz*jXIW-n-FI?XV
z@DEphMB>{3|18JP>)CuYmLWPhK&b8*Ac(`@hQs_$FK&s5wa(Ffmsp2SxE{1Id)lGR
z-ZsJAbs5?mguzRmd^=y=U9oKF8U|;z!n>DdrfS3NlxC3i7)8A}U{42&#<LbE>N5lU
zeUu-a?A8GPc*l>kdFDYSaFjd35gMTALnUyO`?DqR^CrpDtat29YaKs!FU(|>K>k~D
z{Hdc9%`rZ+L;;3(yA!4rtCc`2K6Qi@NXR1rt=^v2eOU2<q8XJ^MfdYk`5Jm&qNS=8
zV9V8eDZrK`e~1<G$M?=~2Smc{@^;EH>*0gUU;YrAKYN$N<<CJbe^)f-?^WjS>c;%l
zYs0kkF|`!=yE<Ucn-*>Jw<*B?b<VTQivj+E!RiAe_l^>NfzfG4VE*!#S~r-F!Ir@M
z^;0zSH{J0we@6uPkInI?&Q-MJ?^*>I#Rex#EA9$tz1b0%zxM-Lx8<~EA{t{x<uyek
zf3=F1{EbsU@;6(7X8Gf1w#`PHKbN<Yms`j4H!y!gG2o;vmmOesFS7&CM$OTC%j^K;
z;O)ye0Bv#^U7op4o2IR2q8vEpAcM~aEV|mF<!PtP%K`p-lpntBRy2Lf6snEle<M#u
z(bj(j#Q#GTX!L(M>o>un^LFdM^Sfq+^?wHae|IQWJ?qKCR|MPNfN02wbG!Ptd3ohu
zRCQaGtCe?p?vUlCqaaXui892Mflt8QDT^~#gPgfm$y`0#faVyVF<$BsMel?)ndcSY
z0?xCRhYNSr|4}?=I(%;-y28W1ab{~9*gna=DB=7mKOLIz?`1S<#tcKhM4l%3%qkX_
z?K8`hd_J>Wu@O$6v;b~T^7$_0aeyoMmdj+HZ@JtLuy!L`m@3cleL>h~znvj)dXuhI
zu@S6QZE=h4hiCwfg(0i=5>NS5X=Z)^ztQ4N)=QnOXuc?v*%aW}VR;hxLauyMsb6_N
zJp1*qa`4&IZ&Z8ZBjg__m8(~MVHctt3(abA^=hVl5Y3tHRez=OUC{3#%jIJGOwiuT
z8HoYL909F;klF#4Afnzxb3e~*hx*3F-Mv$OJi>#|_}KU#s_~yvD=)sy_9+~@5mnPm
z({-i(+C{y?grNr*CQU?pdn)k~{WVAUgAM?G0T@yv6*&MVr^YM570T4X3ee=#Q9;Ui
z3QT}Z^+gI$f%6&fa&TKjKRy<U^7ydYWV=xSUrfY)c6Orx1)fCaVmDe~UwLCcRBQMg
zuwfe7@s<MiLtN`)GJ-t_`DACi89>=TC%7Z*j`%aGE8#`hTPFc+<jsW~D;P@9dcx~S
z8-#)HDYWBJyF2m6n`YjH(Xn~<!F|&v3xfO+9UTDTuFOHG?MRd_c1|^~;W**FkH4HW
zc(S!{ySH%Ej-dUcn%|@5!&Ea%yHRt0G~5|6;Kq#PHfNID6Gz^@ZaV}%7-p^_o=3nR
z0x$FTwr<=Lz<+}}%O7Kef4jq5q3L)kAH<PD+X)&QZi|>DOC$0!ula=nbQb$CuBD=(
z!ppN*f1rl2%^`wff%ivN_}F)}uQ5!1J9c|7ux%mB!$x*yZf^x^ig(#KREHO91!;4n
zfp6EB+PxJvYc<v04_okWF&gmgR#+js#a@^@*5$oA8bm*u&uz1OyM==9=a;eQ>`n^4
z$@>x|<NJ{p5L-VQ*%iSJkAu*0@>k7+Y`6;O{M9^+^v9oT@P8iv7^=<UAU|q1BZH>z
zp()IFwxfL>0mbfG7b`aB10}oG#gbTiLo;cwfbVR_+L}!QMhp1PcC4L($pXH!9V=C^
ztl%qZD^swtfbVR_+ACO7z<0J|9Tco9;5*x~jtUMc;5*x~P6}oV_|A5$T*0vgd}ljW
zq2QE)Ti8&gg0l+v&UUPed5#fE+g<BoRpuoD?XGpPYV~Md0pHn<)hbwDz<0J|J<O@%
z;GzP)vmL85EF1Z}GtUjNKC-a~-`OtUJKM3ohPwvjcCCvIFdqr5yVk{qn=?cnpL^yz
z+p)3c27xa(1$<{aHcsL7rhxBk$HpsslPTc95u2d!X0%6mA}+<)-UFt9FKWgni}ieG
zyMXU($EKKnOZ#rux|r@-7kiK)kzMOz583G0UF%|7ZE)<ab+K(W+evICbP)uiQI<vI
zHvFMqQb)wHJ_O5M5(LX#>kKNSh`iCLsEI~)!X{MRV;~4ScSR8PeDKr(C=PRTiGse2
zaxxq)SODDr^Ox<z{IY$x^-##RiiX=>hF{szF5Hg6LhX9tpHLU!(iP-LhTA`dU-`0q
zxC0Nt(fSxK+;Np~b6Ya12=mMK;ZE1%uuU>t$?}&k+lNye!rF3kiEx(}fW-^X;qndu
zWiPvM1%04O?kW*Z|5G6QN&9dWwIsvw$irYS`4qBVsq9WtBD<56%I+j3vO7tM>`qc5
zyOWg2?j$9$J4wlJ5Q>$^?j$9$J4uP`PEsPfla$ErBqcl1OmWE;ge6%byOWg2?j)tM
zJ4uP`PEsPfla$ErBqertk}&tOi^r;98*Gg8EKp*1Fb#7fj70PUV4_jRrOYs*?Q?&C
zW(4epaft$MS0Wq6B}5CNAv@P460)lXcCO<_7>Png0eg|?hH;6KLn+3MFcPhJNHK1N
zk!WqJl9~CPt;j|giO##p&IxIvoQGuRMi_|-WtR=(5-AJW4dW7BEMzx~OH|Qlw_#kO
z>kp#EZWx#7_KQGv!?;9^m9rbhC2D<iMnBCB<N6@f(I_2`Mv09^kHT@QXe7TUphE5{
z5V73>CBa<<92EA#H-aM)i{fuWb`^*ea!H_&y9z{#Y^Xfh)-O`*T;i?*kz}3}RkDz~
z3PegQt;`GCT?NhsvI7rILf_%PpIYrZ{5)i!>^uAxVqDp9nCykct8tk4x+7o{-AT#s
zaeg#$+X_gx!KE^j#24|r*7NJ}3{~q*C`l@vQ4YpZHMO<8%Gbd{iNY@-Wjb338D9(i
zQByw^N(!fU0BM2hFT4p?0uDlqB9yzB#00Mql78eYHjD|mpJ%hcurBoceCop15?<mM
z@KyQ+&pN(%6TXD<6_#Qu<`>$^Nfy3KNW)y_b>yoem3}LO9?^CvNv)qnDB5E8TF-Ao
z3)<2ezwMuRXvolxwd95WMs#Tca?vO)XjK_%GZ0W=0fx#@TU&5m;XwEtYG-{$<|adL
zsI(RMTGfPx&LKZr4eiBN5!%-C7kZ&#)I$%${Fqs2_(*_>R-G_Dg=XHA6WLEi3csO(
z{h1~|9WH#4&@2ljyiVN!;vO{(a8r|qPtO7ZH(tqj9qKyI2L}(Zn{QMqp;MBXnk!O{
z`}u$r2NO!oRjE!V!cM=d84kSTdnv$AeCIi*ki|8_(3Zc?g6n4-YqvA9w9C8vMxZmi
zL_-_>*v5yzRPtSGVsWwMT|YuNQ?F|)49m4>1$UQu(USUJ@ptWm1$2v#g^t&a2)gh_
zWUCy25A*f!!k2lRRxj1=jI8LVcxN;TwXsk-C(&GdkEY`3auweJaj%GH>hkVLpQ$v?
z#ru_`?k1p*Ltm$>m2`CpFyiWIz{1sS>($lqDngs?ayAWX(WaEx<fOgSu>tYjPJEvh
z#k({UUmXzd4a+1V(W|X(e++24sd&}h0dWznYf-eSsi-Ft3I;<a6m7gBhO0b@?q@Q_
z#qkH#Kk8<nKLrEhnPEIH1g2vCp8*Z=u!k6+)GNyTDI&SU`oeXFs!tSOXTu{`zvY9_
zW3l1CYhdu1S*XF4;w?a*oUjcoXG8OW>G~cpW;yYX0<0d+esnrJU;I{p`7DC73HAb*
zDpp-=?@tiX;;qUA@QOpnWS1^)Piqz#XT@UWoCbB~IkjdHtyu?*wPq2m`3zvy^#7r^
z+y3mjz2!9Tw0)_318##>ep|7EeYZFJ?ioPIE0TV1y741GDb~lqg<`F{ZUnG!ZIh~C
zu^s}N<oxhpwN1|f=zn#Rb0>{GDO8*T%|a_K8G0$8R#eUnmQfRxeVVGYWkfTjjEcP?
zI@WC=6Es~W-_Gl<XJy5QQMZG%xX5OBx|9+y;w`c8_C41%e^j$L3Uvidla^|usu+bM
zEj|`HF6VgjVPuAw?6i7Som4znk9IV9on{|zoT+;$<6AU&mzsP$P40FF%B~-a=0xJ>
z15EV_sC@-UwYF-2;-5ia6vuO09<=OF4F^b=Tw4z)_oYy2zALt2I)H8V#UemOJ>RE0
z;08o;89-~oK{Vlcg4=2TpIAYm%^K4%7PJu4q^qFG0V@|nJuN~fO)XM9WBP!_$3hLk
zGH5cgA1pC-TD__(1L9B_3q8=H=pju-Z3WRxsh~2ih+cPV$NqzbF*xo*GWBd*LH~kp
z=7bW42Gb{h0E6@AyRhmw2fMHiq{LT%q@tFB3*LXH71jL>HM2rh?L@QOg2&&JbDTkU
zV;TQ_WnmvleI5XA1h31flV`NV-S>j-Ht8^f#a(9sbUv**Sr0#}PG(?-;=e>T+rw^~
z8Jq*;%-c;ZrdfTIiZgQ67{%u-IV;!?npiTlnI&=tV1y*_g<cV3+U+#dq(8zi9xmX=
zY8wY3KIR=T*}#ur;BN#jb)YhE=Zu%Eaq@wm^x*-ky>2l~n*6=ZpjMveRGy^_?@=`g
zR`uRg-Qympo*z(M3p%1=Ri74A9gT7xTKg~?7%N3%jskN=3S=ymWjNN3WpQ}5kF`T%
z*GRWB{D?vZC$(#YNj8(XhBMqAoEF^-q9L~}Qi2kzQm=?|-Ktom6Qw=p$OmfHQ83=T
z*V;KWk?PGBfV5*G?U)3pEBANuC$h(03b5xIm3~uyYq0goBvL;BwbwATd8JZb)?a^e
z?*oBue=pv6=Oz<FaZpF!uW!ycZab{$y&R-N$;>aDUV?+3%^CZg2TCk7Pe+WZr&Up|
z!mbNeSd&p<om7~UgxTq9RhVUqf8F>+QNO!+t_@sL()7P%h4ui95rTxMJ3|z{4<V8Z
zh3*W(Vt~@E--S53^=3Dy6{`xGxBxWil8*$<Y|;^G#Y`vdrAk$tMy|5r922Vs1=Nbl
zLD!5BQ)Ob-L}jL_N(}J4vXLG}W2I_JyrP$ITwBLE)}@A3W_q=?<#(x+A2;kYm)?Lj
z`reH|naeieu%BEAUfv&vQk26WVyMHaCn)OMdPUUMEd)|%sbTvrv^D2s!HzdZ5J1xv
z9b9@@Xek?Qb-yi2hyXf-5Vl(nEoFz=38<PS8d}Ed^sx_Mv}6|vEhl(7KuO0Q(1>(A
zuIcE0y2kBG{rv<Qs?Wo@DRc(CxSwi{INl4LMH}A)RQDm`@^CY$(Aj*RzxQt-mHib5
z-{W8i4th3c>>q>MWa-}q2Z!LGPX!L}ny4$`_f>VSgkKHTMw1f0LK5jDVQs2Gg;^c9
z!Xi5^dsTNgS2{ab9WUfsz&z|sQR?CYoeNd=4s^9VM2|YL!Mc2_e1=!`UnO(=u+4##
zw?ubrm#SjSCG82Xh#4(^w>^?@zHzC(UQ>Q9!eIuKG36jL;X8n_Q`qx4g{^#0vp5<|
z$YR!Ysu8Mz)1(bK8@<$#if1rCuz1WAg1$Ei=qmBuX~mP=0r3=?l#aEzMe)^5#jDl^
ztg=zlen9gjAnm*&`diNT-~D5a3q;p*v&beMu7ba2CW2+pG{-U|2Rx*+hvV1>HUjGY
z4{fKFiv0&FtE-U@|3udCTj1&WdNUr5)+dqr8>p$zmCEafPpzXERrGwGE>OMxXd0E;
zqRc#l@*0e;Ed~Bj#dEd1CV+oI@hr-$;um7b>Y!@*xhmD+b-Nf0X0V*^TogL5%(7i?
zkF6j@I@<CW%vhWbOxMFiVh9+104SZDOel}_I+dzk0+$S*Z1ZM4jL^utH^T_7CODbY
z@dWPzSaZrzxF0<627tc<?7l*+d|ZDIM5?OCP-Fx}_Q0xnb-Ehh-l891>S|?ehj{Vw
z4{=N`@s@dA(kr5Us_d;?uj+o~>JP3iW@>bq-sFXXIZ9&L@~i1mcdxftcSEG^oVQ-;
zWEE#`xXX&myzG;J+TBj=*SXH${90r}Q?*sU2GqK8mTQsPg$ReAlC>gJjo4>6O-*rH
z=5@Otus>bq9WIeiXhKgzu*?u#5Zm&W3#_@10>pspPv?Mp9iXnVcsHG6{Eq--<~)P7
zKWZDGBhb=JE-qaFsE!*x3{dSO_1B;A0I<C~;?JGn@wy+YgnRY35EigI9LNOz1eVkp
zN?~{S59H|W5~h)1thz|4`$^(v`lmuHHC~bIt<_Kn5t;i{%~S%b-|9h7-iA_twgklm
zW6pV5=z$N9At?KFc0rlVI$r{u4a01P;aPy<_+eZ^YxB4U<!}b2`xDv+r~-YU!3~lB
zRy){hpSA|loAkE<`%-Z=f?j-`W1{2HEOt0kD$BAC>fuf-WUgvyo^gcKk2Aol>aXH1
z5@_A7<aB!#u?hE-`f*{nLYWVTKV~Hw>%0govZT7kOJAVWV~_%`+f0;Sc)lUgiCw=s
z3ku#UrTE$kh}VNf#XBFDJ1(nP=!NTvpYSAt@k~H(`sV<Untr}jcsg2)VC|c!WcW^2
z{CJp{zDxlQl&KpOSO;KWK;lKk)AqD~fmJKO00r)%_~8mX2Vh}9e1+nr!A%NCgZC)F
z25$;TyrXz&qhwW}!4W~=I0dLHeQ5wlZBT%U4Pxnhe<djXrUD;R+}H3+lQ9KINu?F|
z4Zv*GwI+)Si-pQ^l_dKdrp793=@`#j6lnGY#fzbr2LP}3W{hg#HBt%Yb%<n;^)<|H
z1}V1($hREyoq|3XzDUOKen*{hiWk0`j3_6MN^TS-u8i)w*hcL#6p1;v3kI1Zg-Hu)
z02lnjH(IEy>sr?1jl5y@r>D?y7qg)o+0Z`#*0CCQG+2GttKRT!-=|O|_kqMm2M69R
z2iukoyg?4uFYVb}qW`0yjCvX!zV}+I>ulA<Z5H~xAaW~~r4Ll9Wa2OdBu6WQl!gE$
zb-M!0Q5f2oZ_QEVI@jB6j^0yN=BTq}mB$m)5w%8=R2Kve3IJaE6ODw}*LjU~MSuwb
zAa$|=z0uCuuATLGX8uzpj09nwBdl18M;tE-=$ab<QY#fW5+eU_BG8rIq6GH8s+f9q
zD!32;c(v3+Wq%N;w^Y9iZ5vmBrz5ID_}1gSk~slFe@DQ>lc{Y=;D|QK5#9qKt#M%0
zp5h2AmUHM`Scd6=zht>rHC~z6o^5M6R)S1V)MBW!44<x0f4Rh3HU|}AOcj#DyGotq
zuF@K>Gw)Z2I@@}!tl>plsGJ3wc}CA3B@n^cV})CcimATU`nxcV)7-z=uH0ok9CF=<
zG~*cq9-LQ0U8(tOa8%7z4tM5c?yCALlCvea+i8i1Int3!I2)?#Rb#w%tpg9gd8rSy
ze0UPtf))@5EIQ|g4vZs#%Net;oP(Sj*g!-Zqx82<I@^LYJ{Q$gJpGu8v#RYSEdwP}
z`IuM4I1e)XFnXw$VW?derd$d~@$Vr7!ORDj3>cwanvMYl3}i2t4kV+Fl-|#x-l|np
zTHMndM9u-C+$mk)IB+lTF6i!zL=Vt`X)tsRlvWntg4A3?(?%F4v0EiiLqq1ot`ucm
zj8L;=D!mM76vBC02vj)gOyZ`buTpWIiBb<Jz`#xfUD7hH#lVh~z&fp7)iWy2iHC^J
z`|dCa89P9<MuSabB-jOB5$%medHZyzd7n`kL$jSr4_=lP@n`7TRn;g&7(SMU4}FdR
zVl<BYhXN8m$pb%MRX<a{Q-GDvUz|VAC@+;!GOu+yLbQp^UTT_>*-`shGT%2%EmS-&
zd8YkAEPb((8PTe{6ktR}{p=Q_Ia#9VY{#sMmAIGbQi`w~>_YKx)psjgHbc6h|MCUf
z&>=kh5xCUz%D^0a=ZxFjm<O}BmwHQiPEBAP4}wknX0GOkvC~O_Nf;U$mH6`^8I7Kd
zxb0;|(7+>{VWpSbob`Mj2ELXv@JJfC7`W6As+X(L4X$x#ARg*hdEWcG*O6VyoNa9b
zO#joip=K9*$ua#=KhC0$Rp?Gyc6xV=b(<9PFa6zE<Knr1=2pD`b2lrE<_-s4nrk%o
zF(nU15RP=@X6B||3NWp7Obt!LS@ni8>4h{F8<hb@^i<kP)bPVr0V^@Rui`nbqz+Jk
zH?KZ*tvFM>)X_?2u}9&3lcam8Q<Xdc)1GdQ>}>Q>rw5de{v-LqfbygMK(4wbAl)>8
z7|$NZ%qnz&ap`&E3R^%2BKl@ots7=9(7{mp`D&oi&-d5MqQNK3KiUhewj5K^3DqD&
zT6YE50V^OT%`a@R6WYZirx+U!I`J`>*;#Rk{3(i;NzN4tJO`%K-3q)9V4g_eY<8YD
z=%sfkx$)#fXJkB#dqwnjsJRz82wh5dTrgJOV}o)dgVJR<_8K{sJeTnhlbTb9&0x7-
zZo!5H5~RMMAxKAPkZQQddKIrcKl~fY{2U6bXaBh4B~<n?9RMyhAKq%)=|1a9dvK~Y
zoEZigK5iDeo-45jZb$dIOnE|ATi$FBynBK%`3YK%m+tCQH!H^(CAj>}Xz&}0YP*s-
zz+Pg>5L@J>B3D_B&!Mij<OucB{c$?2Q?ev@k^)Sy2MZ*@TUt!;lQPP>pkPCA6=&CK
zZ^iL4*<#!^Q$jn8!hIcK^I|Xkn`;mRue)=8mj>Zs4Z`z0G2#8>`oRnPdZ8CAgpjmV
zKDM{gsoh?W%~F)WU|jDAyX(F5O-kUjApKqd@VdK3&$`COYtNp@z+qnKm0aV8d!Ze<
zw*MPwI|5dOiWcGxYL%x^<&MC%_f~?my(9p5-Jes)zt*<>Hrqz_-?!P{UO%h>GvLq%
zxng)L(8!s&MiA-F>#PR0ezhYs{Mk!gsD!++I2Skq%t}431kS=<bcD@+#^(f;KzqIJ
z&a@HN*#-{ijgE74M_Bb~E<mvOGizc){ov!g(7!FPxqjF`cwYNF7rZv=C#@XWD-gWu
z0O6n<0p`yQ5b7OaHwd=`2&-}gg!@$`a8yZss{jl84a<d_WVuVXrgLOJ`bE>iPM5E@
zPK&Og3Q$*9L_s>q<t^&^vZ=1rgDTGJvtd>o9d*8!HX2!}k39o`*WCqu%JtTcBkM4N
z$gQ0pIfB&x12Z@T|33sSBY>Ofp`W<=^`MZjeRt@;y!?I#U}~1?mW40pK;uYqjFNeK
z<E!RmTzKUzwYM@-^~%Ua!8k0!kdilFX;&(ZJ+Mk>=pGHHd8yl!z|`;M2%AA@t-f)L
z*v}ERpXQ|}D8bgD3&Fn>JGBqi&?OWRL-)OxJr5t-3FQftCd6Rm%hKX#Au<|KdAR2o
zz$0afACoHx8EB7I%?!^+))1^3x(P&Tk&+pnA~Y`PcjRDr&QwN*r&bsn!*jXP7==+*
z3ETG4_bEY6Y2BTZkKd5>_%GZK>{ad2m)femo9jpYlW;qQx7TOqv9Fa1d@cO5!RaXB
z*eU*dp-uwjy`sVCEWznckUPDH$|X1x0gvj1Y=kOg=?D3%Pwl=wOG7*w{);nwGlmg=
zLnEPW-$0jc6Cm_*1iCs#33N4mN&rZ$RDc;c+KL1-aHW!&frjQ}W<WnqoZ6_2%m6pm
z2o`874Jnrwc335J5aRJQyXr3vuQ_+Y#o<m~dN1YU`7wR50-W(yZBT%VfHL}{6MNlV
zs&3h2<G}}%N7j3I`^gQHBQY{&auLnS!>~PMt>O$sd?aeOr&2f9ckifbPSM}9`+<cQ
zYrR$9?)tQ&Ne4;oP_vk!b>PmOm_7~=?stUU=y`oMT2t9qw>v_^5-;7L1g`I;K39MX
zH9t5mWIkQ0rb&c0D!>SN-CYnKQ0zbiBg@b5goa85KJW^;9CiGS){Z-JTqA{RH@FzW
zQ8|~h|0sZty$#<sXuSi*y{rw;>9r8I`G9f1DnaI!`)C6asJ&;0F#-)j&C5;kDUyK+
zP&Vo&p4F!2@|8Wb4DfWJpZF?FIqs;%UT8)xgQMi(W(Ol@XWnJ~=ys3&eQOWR*}|Ly
z=~c?Jz8YoqlmfIX^_l`{oT%qQQe0_R*2Nr#y8f~Mk3GFq!QECdPuZtCmd(q&^hhO$
zqJ0(M{iJ&=S7R^Y^lu@WK0uj9bOW$U0p>gHthZJ5wuX)Y{?0YI8#R)DleI;b=qnT;
zSBC+OwU-{R1UZ2o8{o=1F6z1@sOz=>*Br;S9VvY+sH@^;+dOOc0>{;WrOWY37=kdS
zj#7Xz-J0V<XK#$@<pD*nI+o2?Pkm7d&!L-tmm|phc^SeKxy2eF1vXrP>1^~A1&#wy
zJy3$-Ln5_7@#g|REP#Js@f(3Z*y8PoG(*Hn^>X5Ike4{}W@krg4<&O}velAfp(k3H
zx`ztpn5NT`^lX(EKaN&FZcv=A02jZ1aSd-@iVBK_UUt`FsV&OIb?>(5RkjBr5$`I2
zBSLza7PpM~$7ugxlV0};x7k1*pugNw!HyMcWEA+@tK@RjSC#7taM=!cnRZBA7aXTV
zmf>~ImhH>Ds+*L+E&&6Zc88_Z@AQ`6VXfJ+C&wN<w;5WW>%7?;+h9Pr-taY@@IR5!
z?^P{hKL`S%`qLI;e@(O4r}A&NjnUqzR$gWUsS!%xHQzj^*v&P(edZ|n0w=TLRAdE3
zv%pK=tTY*wKUIKzIo)1evqQ9VwBKfH!?%N-!*}N#9*N7KdvfQbk+=@pq7bGV5{w5V
z82d9A!&E(ku@98}AHle@c`&A^JcDtFmAAn-JU}=#N5Gwe8v+FGtste>fITz!yVLr_
z@ZIT5X$;?KN`Aq~1j6@-(j<JpDInqNrGc{Hb732(g?+_PR4u<c9C}Ks_7;RBTU-kG
zX_;hwKzL;t;O7M{d(HFqUXL@;WkYx-@<M-;^UM^WQ(tOJe30k_kl~lV9DnUi_mH+Y
zs;$P@IR=LCn)l}CVJgER-b?MPdN`fB&+2Kcd|b6FnTp<OPNoucjMOS+;=>Fce3Yy<
zwm3~5r?^g;_z-N@KQhgL^<L^eW#Ucmy)2X9KU6&HW~mc?wuQ^8P{9k$>ZYo<#)HXj
zVjbFat1Hy~y3>6{3mw#tZfiO=rY;R!ZGUaWajlQ#i^r6};VgCNjkel&lBwQHjKC&Z
zOK_5jf7dgLu;JhCN4?ZV%Ez<!aL2bDr@!ZwAZ7NY4x3!|P5q((ZxhY8BH=Z==I42-
zxDGvhu=gTM3Ffv;$y|xN>ks5~M#-Foqy{O#!EtAEURE87DLqn|IA2JO(2%q7;$h9h
zUNu?CY`l3!e!3zn0pSAc_&<oI+FfbMOxQ|C9@|1O_|YqyC9G1#Y1mCp+*K=<fR#+c
zp7|qrppt3Z$A2JKx#c|CCT_KCmwlu*w?O7axFEu{L|LQ64YCfHz>YQ*up{)YF>Ylt
zyTy8c4n_fU2#&|#@gXqq`JrEc8#~VmP#eB1W6w_?$wQ;KEuGqUj}>1L$98IHOpKh@
zxI`W*@G!6065x8pak&`rG*aNzc&R4>Tt7Lk%}sQH>oetINtd8;v?wdP?bH!gbgHKU
z970A~rp8i50<p(V)nMiM!wH&On`~>3FnwlRboRT~x;gfBMCrhhdfSQzSgHM3S8BU|
ztQvbO_frt!IQyN9vs)pXu2K?vG42DXfONcr6<{fR?QC}Ld#OJwnWfNYghtxC7DxDp
z7&f`}8Y=k0j#<t&FLhQx{S+tfGUcVN3#e~!<jNM+f7x99tpW9SI(e63FZFCd{a22h
zZBhMK&DFoG^7~*UFGAR*&KiUBc7WW|ksF<JiJ|mFN6s0S9->LHuM2W5fBciBxa--*
zn7hE8IUa{Rm>@3<x8V!J6Zi^lqzx|ryuKc^M&ym#i5tPy?-(yqMuN8o59QWA@45{_
zj~d?}1sUmP%!{hG8})jV%s<gy=ocg1&J~;6!s1&NT>@zzGarwAgNp_<yn)H+6=*s1
ztD$Dh#FmdboqhFp^RU1xmXBap_I!5bd%&LM?l~dj)3z@FPd*fFFIL~Tqko5fGarq@
zt?w1U|LIK}EWp77JUAW)U*lk3FM_A1&j)nOTbRL~r^5H@?+uXde-)@(K=r!6q39p<
z_X(0Wf&4ki=_eJ<*8r=M_h*5_9WVe$uIz_0<$myff1f4%uD_wUU$!?)dJ?p%x1q)n
zBzvij%J%M9%#XnbT?`Ee8TraxZ>9U=;EknYH_p_=0D6w12YTsa72N^csTB$g1aN^<
zjqS727b;;2x$akBE`YxZ7d~D~1E%2{wzzJ7R_W(~UgezQO(*HY-{d9=Q!&kfP-ST1
zT=W<G3+=kz9?bXfOh$H6RZn?70|j_12H!}$6p<_9yYN%FRZesx_nR<gY6isUCIz01
z0l3iu)81$Yr5(6bi$QFzj<eIg>;P=X{%8=`*$#UfD{BbfQU}&`tZ6@zcbZ~df137C
zDX<4AcC%{0hA^<F2pjM)PwiR4_Rm3RNse^qm*QRcHaDw)+hBR#OxfC|7+c#AG#oeE
z4<TW?YzY&_-p+h>r9ID2U_Q4P(}RzcnGg4h7Avuz`3aUK`&dn!-&i6y%di~#o3ZdH
z+@Hz}FBNBb`<dqpfXc}Fk2yWp)P80(P7&e#<>JI}T~17}cI<DiK-9y7MGsdisOKUy
z9?qJcbmKY45B%R-1HX^e!;4_6hY0}jeG2uE9&dP2+@8x&z!xTfpJs)487vWGD{mHp
zu!kk^c`awqKx96=pBTiu0c5?K4$QKwd>pIM0Vnjj0mn!Y;*(eu>Vz3vc(fJbLP(>v
zR%k!jaVXr|a@^%OAbA%p7+~?d<LdZ5ltOrlb&>tR;%6G}cofBsM^cI&x^sK^!^)Y3
z;q)Gf1Gg&*kFiQQ8MfxoVzl@J9UN|nT$^dn*aOeKkHULf#aupdmW=2K{J|E_l@y1+
z9K|0##NxS<VjIy6UCfF()DpRz(uDXhiL<Q*Tuf;~G;HoLOXP6Xgjk=4=}p+G{e?uH
zDBAM~zH@-zPri3p*hWTs!vU&2xA_2`U;HTSY4IGZ+LK-WpwonLT-d`Hj#Z-0681C0
zkl0rFR*GYn!*i3j!amjzj#*ZlwI+i04v;O#3i}yjCA``S%oIJoD6LyFy$Q_&VN(ws
z;y-&e3pu=@jo|p)j4Ax;Ab=se854f8gzRQaVY_EjBzhold54l<cT)=4J)1&yvnC+9
zSyRYv))cavHTm4EDYEJe2>Dep9IobJ{v`al6aULM0gM-mMxxYP5cUgp<2U{>SiN`;
zl)j1o7uNal6MzZD=fK-=94AzawT}Ux7hem;e9vD7R=@TA01{EZZ7V>sD~>N)aA8jg
z&*vEHm;OwSq~AUZjv~In<#*sAIEwH9e8+1+=B5*oC{_5}{l)Lp8HdG5zml6XC9@?!
zrR0#i;`m)g1B<wY`y#1{GQa$4z_K}xUqM%>nRlH0^i&Y2yX07G;8Ardpn`B-WH>?=
z{}hZ~E7=?;E}P@DlFf1AvN=v%Hphv}<~VWL949WD<HUc1P%JK+<HTiioVaX`6aQyE
zEQlWgdy3*a5vt<2Y>pF80aFr}&2d`E<~VWL949WD<HUJ=-Yz}|vZbESrxo&Io2-qk
zE~br9NyBg83db)6S2R8g?I+_Qq@*%_12EgX_y7PaO#CJYtnlOQA-^IV?*qOSQP1bT
zI{DFSL5oB;;%{qnAO5z<{Q;W6YugspUY1|*Er_zOPJWyQAds@JPJUtr^dXS4uTFj;
z1IT@K+WyiC=H!=jg2%G2PJSyMQjGiR<hN$c+1zf0NF+-AktngKRc_vds(%a;?VbVQ
z^=Pq)0au!#tM<zrP*uu3jiPO3r#0v*<;Gyqb_ym-YakIVRj{n|E9j1vDOg#`jlrVr
z6|5=c#$eG73f7f!W3XsP1qYRKW3Xr^1+%3rxM;b8V@tU)ShPaHDW$itp-Kg3m2zXS
zXcsdE*7)h!rMFYI%1jb)Zt2&wxmtFe^V9Q6leD>3!TM5e3>NKSR!XoIm2zXSXq_3&
zD5Y1JQf>?u?PKZ%KEssC6H$H5bVzYyu+lxrKfoLz@VTb+E~*=DE*Aa<Q~Ef)94lMo
zh0>RsQf>?u9jEYmQ_79OqT?05$&|iEc!I*4(H`N6asubZV5Qs`EIL`N=f+^AG$cC3
z93$;xW3aNTnXoNwPeD%0q7O18vN2fnAsZdLF<5k~4UXLyEV|8>N)qM4=tQDJp+r8-
zM!#gtB9`?b*u@Up8lz7re;q*C3n?Vkg|aE)UPulKdp`F<3dJba_6TIMGF12_Wq4^5
zDzfEmHy8>PYt<HVFQibi28N*6WiO;qiKUf!J~u#$#eRa0_OcgJTW)TYj3sK&j_idL
zE94>j0{23S6<LVm92@q@9xMKxhaciZVRq~d?nrbz{&whvKQr-vN3YWlq-`+n9CC}E
zOJ=`K5wLXTI)&N54*e@|oe#vh--6@b!NW28DgQn==awI=z`+12j#Xd*fTy9TQl7W>
z$~P!}74Tjst}2*S#x=X?uUTO6^b>R&?j~fLU&ZG8{>wEl;4*;aJA%#ssK9k>KJtLo
z^j83*QBY_;gb!GG<)f4!7SB=O9~7w%h%63@+#M8oRe?__vNIrZTTmqRSKGX_Qlo&x
zWw-(cf&aG^!GcdE7aA(BA3^7#caAc308^ON<gC9|2{wA!&Ir>y<Dxd`!K{cskI)#5
z&KkXWjNZ}jy66db55V&60cGU{D%=-MrrIg6F91!P*NLByHCLHjE6VdbRGE)+tzE^|
zu71z8Cg3iB<%cUjLz22lfunN`AOcuD^1AS~DZi)PK-1tjy$B%BAzr7$XutyVyvknq
za28lx`o0hJ!x+SDu`Hkg{{YU`s(_t8z(wKkhb;d)TkY>&5b63W3^0qSAMdCvtEL|(
zDc=S9YyNyG?CAC*NW9i9cX&F2qF1i7ps3<l1+E6L6+)6Xya`c$hZ2~#^4$tZag?ex
zBHu>=7Do)`Y2KwehF(7c?cra=Vamno=;FBWB1ZX@N|06_4gg;HkAdiy4+t9Yv+{{G
zzQ$BawUYw0=2F{^E7hqvV<svSjkz;u%-Kq?r8<kbn`~UpUVbzyz8r(Zm=MM<o4d)(
zUEWTYI{~KwtT_zN=G!E#UtWWqkEdDy+1MIrrabzHRV%*q3j&8Jumxt8uM7Yc*D1h}
zVjf21T+VhXL6m)_00UFrO05@4dj%w90~BD$Ub4zu$WG9ZRT{a|QZYwa8Ms}+b~h<O
zviNKO@H&M%BV5Cci(c$;>+U*)$c!s=Q5?=F4*AeUQNVKmGKwRDQ5>0z;_rcG$|r0K
zL~&sdSg(LY@!0@S@wx(x;(f?xE{Yu<3n)t|AW<9_q)Z7=Do#*<QEUshpv*<FY=i9u
zE{fMEE2G%Uva%z4<?kp#qWF6N@H(BxD3+UC^q#dAzJd^$Q*eXL)?zuMc=<;ziUJmX
zY@=9d1GjA{YcZuEUD~}4XWQe7!6MslceVKUmUN#D{6OGqvB7jT&+rF8Pxl63ljL6H
znQoeirJ1d8#MF>!1DLAzebO5Dz*F}3>LRE))-&D7@fJ8LE>MoYL9h-~iTsLXUd3Zd
z_z;AB9bx@43?{tOSMgmyZmuJ96dA2e@k~&$LIG-D?YJ1<Tb01Gtyj@LpzPip+fuK>
z*-s;OIKqmhG-3&Q(oWUFELEg55p3(fIbPfZK1m4%i4*s>LAIj9(>5ez?~XVMg{Sy^
zlweJJ>j}$N4&f<|?Y$*l`C?_03b`Qwc;$m0w=zOntAO<OXM(`b3P^Y8q3sZ;*joX1
zho@Ylu)6$0C5W;og1}d5flz)>Ksrj*Gu9fRWE7C$W~>72D8o>>fsQh$Sw~r<tn4WJ
zTULDd1{OV{1o8FL0N{0c1-vF|)@k@B{@vQq^%J0{;?m4^lqfsO<G|Syu7E|mY)2{3
zz9EBlT#I~p`3tI1+U)#Xz`e0SV2J_}-x~rz#TEq^->$fPm)x@~e-FynKHsRhVyOas
zPzSSuBF_f6%D)W&6{BCU@{=KQeo$nM5+oyA13*Rb->k@S5P2jhGF1s8GD`tT?_YwH
zRRK!HEebHboe}Rqde6IlgvWnw9DGw*nce}G)sBOenluUZ$N=DVx{v8S*toPlw%wY3
z;4Yxov~lS@nCblyIGbJp>pn%;`8>NhL=(KM>d_ai_ywxwU${cAnZE#EOh3x<G%T&^
z_LAi}S$S>&4+q6L9L<(MX;mNPh$_cf)Pe!>XscuM(ypf?vSu#r!wvkU6-TN7M}gj8
zcB4SWrApw)GuaU~%g8eyJ@h6ep9^(IJMwniRCO)$Od!g(QwH}MmO^Tnn#I<xwo*7V
zdF96_-VQn6Xeh|_gwu^X8Y$;LZ4%uL)XjNs`D#s#)W_pN;5h}P$L~~tC6Pf4M9Ve~
z>aozq>upVV6|L0(R>R(oYxfddSOhFP*b&%o)+j+Po~~7Zu{qOmLA?Bab(6*9<ufJM
zfh<?gzSrY4X66xIT)I+v?H@MZ_aL?A)V2uV%c|ij@V;$Tn^9iH_lmv;Xznv4ZtccN
ztdnYZ8iWKCfPipSj8ybapu1YMT;5fj65t=2<1b&M=pVpezFC3R<+u`gNr5^5R6bfl
z`M3+E*P}B;%mehwd9&zc>y`HzC`l}OSL{+H^y+SH6<)=ak#XclwZ*H=%e{)eN}yLC
zG+H@T(PG#<1)3W6bfaPQH0*8~<_v28iZyH!4ZE3!tyCp6j8E9pLl}0Oq8aWZEm}T*
zTJee!XxM4WU+0y7qi8X#L|bWU*b9w@O+?k1+h~|G=s^{^l7@}M5_UzcVrbZhjfPE9
zH1qmv(6D+X(6Ba8VC$fKt)j)SyA^0^*!D)lE`qSRiH13Y{;eXP(6Dth>{-Rou%+4%
zZe)J^KXv~zr@JTbY=>}XdpCa5c;UDW4|>V+Pn#L&ExmYWJJe<p4tsks9Cqem-G|`9
zcSk~HguK2yESE#9)!ZDx9!I>h9m1XM!ZNG38})kq<i3L0Y3Ph|!rcJq|8F>RTnAhk
zV|Kce92hB=?ZFN8P6HNq8aM0YpzG~S)fbkfVR`p$Xz`o&c1-?|W}N&vPA9v8t(kuc
zJ|XiFO~Rvm%ewNy-F#vN-&>ZE56JAI#3hgz$Veu3WC0>mXy1H10a^z=3iJ!0588r*
zNnhaLRves(g8{R_wdeDIUItV(R%K7r-vUVQ`6j5Hzl6prhdy7)-AVok<e4Ow-|%V{
zKX@6L{rlMfz@ixhLiG>e{XvDp%3%Jzls1MC=T%Ts?kWB_Xz?m;RPGgk_{O<(<=q^2
z<uqIIq|!Hl{<fv#2^K96aK%Dz=KyR-_9@QWjcM>wJ5~H?h*!E#0af)^6AskhT4ax>
z%P&uWNzcK^)KsPH5;?gg57SE(Ybs#*Vg;yrUno%ZsS6d~22Ah<%TM1P2DSVrE1)bD
z8QBZHJQh=L-VP7N&&OdNmqYWp<i6f9#k{V?>|IYa0E11;R9Dx7Stl=ZUB0n_d@hr}
z=_JEm*9~NP^(&FwrlpzpJivVRoG^NT7-GDx=aBQA_P}5#EXVmBI0y6Qe8EPp`5H5r
zH|GmBDZrca1vgq?h}?GeGiEmw8=g_y@GOScZh1%8?_t=W;hJR|asYpS2>6Nks2T7)
z?MY|GOQ~|}2Y1PN!gM-#1Ju`#zi?*i@VsH_54SqF)Yyhg|Iob<-uMUFwJxqFI{x#M
zz}ppY!xO#3^X{}i&FbN)U2N$HMZ7!h?_mkNY;yu9uz|j|0j}i<-Vu*SzWlwc5WBOC
zO;GkEg-)>evvNX{Y&dvV*`H#=#8ob*YzBo+vO=7$+b|80yYqe)i<Af-r$df^EYgLo
zmnE#64LLmT+WY%hJTLbI?=0h8X@86*@^a1+C4qa%M|6By(J-9iGc3L7;Z)1dIedVB
zh#5=bSWDz=y$NwG-8sk-dG-zv_mYPY{J~;6&k}5DE8K~-k<r-jq}qnJu&@~bKh5J0
z5muhL$odpQf$z|8=rlad39IM_|5|!DRQNenA%8c_5AY2b;pb_t4Ugmxh`c8q>uHHR
z?KL4z1tY#%Ba$2oZA+|hD?Ut~0g1cM8*!j()01f)ZgyAW_8^}a;ds~PP9lex(eNn|
zvDI`9@jMl^;So+&Y-OlCj8ce)Q8?I03D`dzuUthu5rtK~tyLVh8cnuo9xC_J@gW<-
z;Y-w8bN4b-6KgI0aMbGPW#t=i_y&%}bwOXXyx!Jv2&8u+2O0YzqZcZ1UP82X>##S-
z8v$)l0u%f%pv~{fQ$y1`-g=wd-T3~TY<&(Dw&>@GhTcv0Z=jO?i%8HL=lTUC-i8mo
zx*UW^bTrBOO&Q)o53gdMl3VEE)jZ52$CLO!pMMN*US@F+#hvt5@ayi-+gqBED6Y7%
zNGx|YBgN)km=oun%}7#i?cv5yoOd=OZOz}oh&!8c-r0<_Q!p9loy|z8f@Sfqz!fP|
zurkg&o00Yk*2FnvM>;527w4VLNJj++#d&8l(n-N=oV`6#uHe`>?`%dY6r2*jg$-3I
zI4jOOn~^SNI>*`c>^SdiMykvK0?v)|&Ss=qJ(?Gndv~=8*2izB3q8y_ad1)meahCE
zIRJTQGtN7kkv?+D=O>Tiyt5hUYYv5O-r0=v&SqqQIZ5DiO`LZ&Bg4(jBHv)*yt5e@
zYhDoeauesB&B!=~*PA%+Y(~Z_e3Oau&SqqS!kf_^;fdxiBL9Gi^Uh{uvfg>!X5zfF
z8JQxFK!wt{v*~AHNnXu1q%v<i{_uaP1@yZq2vb?U*A^Uw$3kzu$8zKCzY<U!6fTUQ
zjeL(L^L~0ic<i90SHwG~5&fi6<Uxj9?wm#*veCD9P9s}w@a>(`$hOg<i+4^tQ9QZ}
zFyA}%7&kR95~X2+J=<YhgZF#@#pLzJ;3ztURa#7i$#AUT4WRy?Kb9nqg~VE~hit28
ztnJVEmB&J2?HFdn!#)-gEB%lh$yodD2#<U$Db|69;K0X{VjZ^#H*c3xg*+A#>y!tE
zHpy7!0r-`VCB;&5$j3rrU3%j$I;A`o(yA<0el}ovEF@MzSE!kfg~ZZ>LEvKv?eJJg
ztZFu(R+VPT7P8-sA;e6TCXu?sDgjNS9<uvKVi+;gFC>4`T;icREdQmBpVtuPGMkWS
z;p706C_ISJ<rLzh6M0lx450K$814BNbOH5>M}aIW!`$U0P~u|CG^5JnpU|}FGRShY
z_>#8mr(hy3jqR^sGR_MdGfVXN={7d=%W}=N@1Fws0Mh}Of^%?OX9oK_*yg{gKp5g%
z7rb~D`7%R=#5To*y?l=Ia3apPGR-jG#-|LaVhd$SGr}*)bM}w)o&AT<#Zjs{8kczN
zEu0dN^B~J>5gU;9Gic#H{+qyd2%9;fp&*qU1LQKV;{>|i+PG82fAo~W56jF2TPIuz
zwdMgnEE9>cDmp*L;Fn6zcHD*k%)$*g0;zQ>RjN{*pJeM73curP8{mI~{D*;KG!&Sb
zop2pz4`+Ctuc!p-DicFLcOvZrqQq15s+@tWg3hCu-20?K$6Xna8m?0JsZ@C}4Lk@>
zl`?9|SQQXB83Gk(<{*g(0#QDZ;XmC-g*eXIfW!t$U=QTeMJFW=q$iuKgyZZJka(XG
zSo_-~I?c=qY|g#OKIl2at9+Xt-D0Jk)a=)?2pAs2#<h_dhLci?k9LELZq#B%-$m;7
zZlNs%oId`j6FqZ}#AP$-#q?r}xeERHW76mLVc1xZdw&h^2!IcmanQU|z`maOtAO!u
zAe^M|gJv?w{Rnr%?9V(ajqL|GeH^5p7iEh9R;^H9pU~e{kW1t8ZmXEn<6A6ktyI$e
z`YS3P78R>NuU@Bk2KQHt_1&<VINYn*96%Gb7woS-K#@#cEt=v-L6_pnzMTe*I;=dZ
zdT%fk&wyAleUC)xa`|>v`Qg6#3ji1DBUPGZPJG2lWXTmDdtCYJET&_9am(?a5RiLB
z<&Jf7-8nHtB-h~t?ik-yfmYvvL_#gf??E<n2r#@XevrLoJAe$AI<|lXOC9grI09Hi
zdzH#RslO{h?;&g0TiIv!`5qy<L}~1QlR#&P79vFVDgM{7f{TT|&}&b`D;C<718`;k
za5rAryH+8)Qe}%JyrK{B<d`O>OPVPs(IT(-1{_!3!y;Pb8@~GEe4g-nR-8BuMhc<l
zEQWNE#OoO#dsbBn%n0oJgGS&l9HV2Q-8b0?RC}uB0)(4a$m(5nXT{UI<18LhH(06W
z9)=1Q+pp_7wO&nEm7f8<suLb^ye(dUepGoQZA*kC{mzrMDsvT#HGAW_)_Rl(F`?)D
zh>n1MSs0=}uK?;gOZoqzzw9SPLhk$@B=>klFVo*%(AY&{QXFC+XMm|@p%VY9nO(|q
z=e<y`=3pf;G}<p<c$!1ZGMfr#@CM~P6&lU@oZ-tP6;A+ZQ?blvv%j#}bxoU<9hAMw
zwhYQDtJ~?UdLs*C@Pf-vpq*6cg0f0<pAKY-`xZco!`a^f_uRlTScMnJu-5ut1Pz^U
zwa;#N6re8WR)Tt=oDr`gd^;{FO@mnW2;k}$U(Z4i(Sg8FG)K=7j_Q9Yo`E_rhi9<Z
z8GcnNhi4b7%3ms>`b6K*66eN6>Q4U8p!F|;`7rN9ab`MDUG`w5pCra#3s`#X-e5z`
zZg(|1T6NIGcXOtA)l(JEg#FlvuUW46Tu-gr*is$Ovvus6(*8&Tq(8RuifMDNQyJnp
zzC8!c0j4*+m?K_zm1{|?w{AOkUsn?z{~5I3Az(|pUPOw1aapXFEFK8BZXB5IQK|d%
z*DUZ~2D;Bd__GO2UiD_BurNLYR<l*}h~iy7mVmkYpIN${q{}&b;%{a_K^URUtSH8q
ziFr&X_P5Nh8hv6B{iH^}##518G-EA{3TBcFdrr{x{MEGLeIsVL=5JP=r=n4_I*D*#
z9DiTV&`$uB!d%Bf#lNXl>%c^-Znl}M-YZ~LN6-+6Sg2zQmW2vFz;^;MBs+1h`mlif
zK~BD|Mfsi0<(H^DPo(p$JiATJ`HHU`r^#s}U8apz7Tu7_D)ox#cja=P<j$}|fQ!l(
zs$)BxH*-o{@th&WbNugs7g;F|0S^$CA>a(@MPUz1r1z+XkMy^Td>P<O>GgYoq5453
zuy^-G3#=pb>*^O3e>RF>yy8(yHSZ{%qqOC9!=_jHQD>NWgD>Y}XL`T4Y@OYP#!RG@
zbKwSY;XgpyQS1h(|Gkazx`+!K#f1jKGH`Dai|+wkou?Yv`#w|4=ED{{9<@>GhFmI?
zf=|UWRwo(bOq!;wzd@_H1g51hAw5Z^u;YE>Rb`bvMSoX-B`s6Plchi}1yl7{C34Pu
z3K+B>_H#lbk$$gcsB)c%{-qpV-{;vM78>L1I8~Yc3cd1$b=tE~nu>&s*B{>+JJs+4
z!(TJI<`iXSNU8BuG*g*Z360}?VRG7zeA^~q8dR7N%CF~=GU4Lc^eZ4`q$L5p>Q?RR
z{ZBd^j}=XplZTnIM+Zjk07;3Nmc|_VK%aI@4<kx{S3^2!JIh-mN;n@+lQYeoV8N$*
zlr~F$Hz?1agy&=ORBuo{99?#T4yR(FMJ<lklk9ly4EAasQThFCe=C$1_@b57(Lv?7
z0@mr&42Jwrdm-ZjvrLUDh#){m=K^%7jPd&c*&k_`Eom@QYEDsZZKhzpm-rq3I;7j<
z>~JqTz}faH#9R$ky&-zGhz{T^^fpGBOal?abEE+~?;}A*gAQIX<@$a{L(ezH8F%YD
zHjC?NWT+Hbl#Au_rCPrLvZq|joNu_`vS%K;m0Zi5FKwI*I1NiK5KA5g)MY?9^sf@?
zw}9*D_w(x7SNdxj%<XM)(pe1J(0mLg%^3#qxr;+V+4D>s;N5R`rubYn<jxf9Tg>BM
z?0EYBk@wzlRu)Oy@ZIN}nK=^~W(dPDIh+|7!oU!QBm;sDq5^^lDk@P>R1`#A5iqW<
zYhaD*>WT>?=74F9>zd=5bIxfMv+`Y6RrNXd8DMvR&-*^#_s8dNm+9)NuCA`Gs!sRm
z_C;Znbrsgu6YcNsyJ33pJq12T1il$H)|^=d_|MXyDRDFp3cXP5{`Y_qL#=2Wa+RYv
zjH$cax?RP8wZ|qk=}$Wo(~NitEN6@oN0v*pUWtF@x{Snv5X~V<leIiJ3J;!;Ft%pH
zs!Wi^SD7^gjfYtQ@1GbFFld`z7%VQdnt({$Y55#OZnONA$bZQ4Id6C>Mc<emk_Ju7
zKgz1*11wvXC+Kx%1r&Cn>=bxo`lqqE87gy&VN}B<G+cN%WDT-iFk&_)wOkIt?(Z{N
zv-|Ge?g!NQR831A9c`o>s=0c{T`*t6%T`*pKTuH_7V`D7le2~gBRp<%y~K7s<)Am(
zC`GUX<ZyhMs5jnb?nRzwBS&J^0LC$#{9UdyfyPEFlC-*6mnsH5)L~sVNG1Wkqz%dB
zCr+3bbYhL$$bpR;NjbeZyILJ=$To67<JyS#`ODMr{DG<)N4(EJCxjpAc<AQZ9SJ<*
z)eylyAOtnl&QR^9K~X%~!?86Bc*4dv+o-4DDJrTrqEH#1dT_gv1`&HS%1>vyXO6>7
zwg}^-SqGr;W2?%#G!n1k+MXMeZSoUcw-3vC{s&k+U!$ly20Rj@Er)O89DocCL%4Xk
zah~N<eCE;gN6PO+-3k%ivsz(<ROW+}9I~$97OR^*0>jTytUl|E`0O*{XT;HX{<ha0
z>qy{BK4u&i<U**arC@<_$6C|HNai9FMsmFwNz27ng67_MuK`Jmd3Y;vDiS|VEXK1j
ziy?Edm`*__);{K{YSebQ#36SoGRBHSU4A$;uq`^}3XYn=IQIz2@|-BcH{lzT<wiDz
zPZ?HY&6_8a<=>E1i-zS(fuVUW7{3tApRy8P*k9Ml4LAb%>p)Q75!reiFmD3W_=1sh
z6hZf31v(8v;nouV5E&bt)See6^Q|`Gg7$m}H4j2HI?G|}v~%HI4pd{ha{>3Ow*5|!
zZa*6!7ZhXpY`puGM!Y?LC#6Xl5J~4)uwC|E&{K#u?bYO@vl!LuI9E@NjaQ9%p?)<{
z&ZKZl%5@8JyvPs3?<=*A7X{8Nz<?-KD|{JXu@07kb+p;Q)yyW&G`4TsUpQz2WCKnD
z?rRhruo8*hosi&{0dtY4_eCDJBCQt#b3HJv*CO!&62s0!B0D<SDoPw?l(f93%S4sg
z(Sx@duQrMG`O-n+Xe-XGsgJaHWKBG1yduOFy^|eXxfPbt9H#?sk|%a4M_6g`4d14u
zZ+x{C--zaHr>wjdZL-yGR1K87z^O&t3>8k0Im!Zw^AqIsVu1|kLoqkmSB7%Vi}sfS
z@RF}Expy12&wXDX`8G@q|E(%SpRd7?rhB>@h38|))OpWF>GtlO)o;ENo0tn|{Gkw|
z!g%a$f87smz!}KD5d;H%kHl|C)OVz6y%3lk@T=k0E0H)8iA23I;4I@n$U=Wu0UsG-
z`J7NNPbU-HV8SCOBK|n}lEmRI5_+3&)TLJLO)z)wB^&pPG_I)_zI&ljP@75bQx6`8
z6GP~$AR^SB)z4O7XOwnafL9`p6zCz!8ubBLmS;y-n`yQ@YDH)TiH{7R6&!)$VpN6e
z#z-qVj;qm}PC6_1yn@DmS$WQQC@_rFyYzgpbEOa$8t`H^zSAb0&!f0GRqE2EUfk+A
zhb~|d&T&5gh4yu+EFvnqKt0)3{04N0)&>!&9%vqarZDzC4b{0yt=3n!+{(=W6StpL
zTbZm@)_ed_?c=QG03$y`6@mfIsv&=Vmg8!bzvsK)-L`=LeM$c3Ba~GyH~>%Z)e6g4
zHy7+sBLhX9G-Wa}Ca#5N*GhX6kta~}BxDXgp0YPYPKO}TH7Bm*u4peQau2X|+gL4A
z?eDgzs8-(k>myC+*&Q}J(U7#DejuQlR#JXxg<LS#=oxVBO1#WnKYgbSV&LZj$lSvU
zE{BCQ8pAcnKf&_-a$IN6h+UL6XdG&!VZIo5cx#4hjM5IgqJD3b`$A;*9=LM&>m?*N
zA**qj;Xl;XFAw#1bi5?OE!3T5&tQ!aa*B~aJlaXN$`=YJ3=)-?5G|CAV;n(^bG(DX
z9jqLD$-eJtyEjpk-D^FIgFTDB6A{@_h{N0YB{r^*4&zGIRb!~KU??^Tm&s<f?q(b+
z+tAN~y5&w2P`vGB1L$oZLRu(4JKDNcZ#x8^f?_Yr*AgVY50!6#2vYw1tquW8JC=9W
zR_>#Y*77o}bhCWFSH32$24g#W<J=hPV6iIBE9?R*v=Pm8xpiJ~i@oAx0A@ZERcMN8
znQDbZ9S0jgb$sWWvvqYGpw02Tg2r>LJUgCtoW040rg3tAidz$v;Nu0&dcRG2YfKLa
zya0kRR<7~lw)`U`TH|{L@SvEi8P~9TMK%0Exq5EnjO#7r`c_g6fAD<Oe*Pf#)2kF7
z+QSM^*^hx<+4~67IKt3{hN5$hbG!q^t<su(jT?+|4!FAe>wO2TO0Rj9)chi7xJ9r!
z%B{r0o@U1^#rctS&mbt|7%M(GF+C*cG7zQ<nmEkR?7j7h&W<i$s2+jlgqLKnVqZtl
zc-<CSD7)`FABm212Rru$*lmx+!oi$g29xCTOPta=-{R>XXix5rcDM}*?a9CRb~pb6
z#k(5G6#MHgi7o))fPVtF4#g6chTxXnL}09!Tei1+%FyCV%PwEb8z#6I@8<@v`jb=T
z6TewLHwG?A<u`URzAGA%bp?}0SEIq#INzRojpiG+i-f&r15G8IUWNf+p`mZLzx#qh
z4>hmly!tiLEH&H>_IEgFxGcPGJ7}^9H=(p#X&5#zNGvgkGtFH<OEtjc8hsr;mSZTu
z%Fl??wmA>4LL07*I4}ID58FVC*&r%&s~a&GB065J=OGo4@Ks|{XLMshQVR*!%Sg9-
zn53(b^aY7V)@x;-_$Ux1-Zwt<qaqMc@)h`34*6QXGc5OgTRb0Wa$}Wo^~ZmlvL&7l
zHEs7KH$3}d#5|HZB$eMX$V-o5G3d95hI^#$JG#q3#*M)vb;^rv-4#0J9e5tc_s1g6
ztLWp8+E5zDL1>TLqseccKPJk0xDqphR!*XxlHFMR^r&V4>v>f+YP(cnmuv&==QV+M
z04yPweBjgjT&bQ|caBNA)G8a$TlM{n==%T^tGn1pb~lnTkktHzbv-NkzLa&n$qlCG
z1bzi@GrRT&E7;u%x)&mk_JWuF3An;)%(6QY3_Bkf{`#cR7qJK{zeqtptT&GA)sMi6
zy{hvUbW`H)5H=G+iqp2S&p9t2ZBkh1l)LJJ#)X#ayL%0Eo|s~cxbrr_7_CJ9Y|AI{
z>{NcsLd)lbByoZPw22dp2wW3uLivA96;2%a5vs(0Jj=T^lz(C<|4GXypTAl@*B4(%
zKF>Zd*@`U<TIzztI>R$UWTLlKM?vBq%V(o1Qu&RqSw15*XtSd?ZgtA=wodT9@nAgV
zvFJGYc->9b34piSc^_-DTF}w1sgECjCi^%n);I$Bu*SE{8abuiMMk8{QL3fTSV%<e
zX8^^_Krs<@>(hZLIvwzwgG8&9KRFkh!djl=cFUfYFWxVoVNfX9*C`A-QSg2r(T{%C
zZ&utI<V=ux<j>-W{pB3~XF0)Yzl4;(ipRCzUWN2;lAh8o2XC9iJrGHMBH4Kn=blb7
zJ5QKRsAHk?gpSk3zsMPkY?izQQpbXNW<XGc>=JY$mvQcP27`8;1bF3-{8T&PD|W)u
z{e362`%b77;XPO)eL^zy$y)1^<~DHu&6M=@C(6%Fj241yz+S+;UW0}6E=UyD!lgS>
zw(bW^V;vUG%aPa%iMkSF;+ehH55KiJ7TC*yZ5I6+#q++pSac1D23!rIXg#XC5Qzj5
z^%FW!w%!KJUw|2Q9}?Nod#x3TsYXbzECVlz4e=mxl;zW`_SF3B=#yLZfD6<EJlmk<
z7%ML$$(07smKrx0z*wcVArkTTok5~5gt{^$%t*`UvFm-7&(QV0<@;k-oq==EO~ehw
zVddKttH!RD&vVjb?YjTaa)$M$_|**tPyw^hr~kpPCa7O|>j+w&3p4vV#Ox~1Y@e+z
zVRq=iEb+6I=Z3-kT0XL-DrhM-I~FHZr`*H==RG}cb_u9eo$|eqQ@$5+$`8~j#lJoj
z{}QiaK}S~V>bu0rbpt%}uSt#@griVjOKOs|%Yyw586(?e6uwhN;VDBgRk=&Dr?g95
zcS~LEg>=q)RR$R<@3&Z>-b}{g&7Ffzta+T=9O<@EZ}wiC_)@*^8Q8a*FvNTFHtF8%
z!IGWyn_0s)i*wIJDL8kdxy4|Sacq>|(7EZ&&qL*zpJ^qhexZNe*yu@v;d|czSCN44
zeTc*~B<ed-wr&DuKqFk8&qtkt#IWv2U~=z6NfW^HjsHiV8~?8(ueYGwFyPMa1-2at
zTBic@TyJpO8wt(?hK)x8dsfD_?ptGdyRqyAeyxi^liLJ-8J2sM{cSxAn6bdL9*e}`
zOq_<qwMZno8V!B6eP9RAN%S`?eQLI1Wnz-p&Jg_U;Di){GY`&Artn7m#5^OSqdlZV
z+0hfX>KpgjX4;iw0{Jho%*yjavro5DN#mbFm53+5y46tjK!*w-;+3XIP7%gHi5fU?
z5^4Dq{b<eqchiL1J8(`sXXQC>`g4fyTb9px)2*7HwdRkj&WsJfJmw*53M2NDsX{GJ
zTE48hf<&?LU;x~hB1_a-K0B*;kZ%jS<S4Xsm|@vtLpxyEVVq7*FdByTNk+r6^DUnp
zv2-hCR~St*4z~WNG`ylXNc>>ZQ>?2x6b=#v=5!S6$qrbGg^-`<V>IlH0(ho$^TS)U
zqi?h`ybt2w&dO8#fm$9DAytg8W1mnRhxj_)+^Q*U>`+JJK~|p4hkVj>th7$EFfIen
zdIQ*w7knLCpU{ogvBF2Lpyj17v+qL8Y7yf^DO(?S+Bz^xM6JI#@Ql#%GVrXohNNbP
zjGz*#^Mg)|!Q&i%An10}Q0+tXwqI*>dk;~?-8)pbvUf`cYJAw{0iAS_1aUdAt(LkY
zE!2PbmGYSnJeR>UWp;dYAIy%|8Oh$*8%w-t05`58pcSRBUBzBq3Up^<^A^xmipGM`
zV~;iLO$dXn9*a`fTRwNtCR;wZHNI*2?_oBIie!hlWtK@Gee1<%-`=Ptv!g$3)kbG%
zclg!^Ek&k29q)O#I!-QwcKub&UcK}FrRsSd3UO11`4O>yQqeNM^`NSnWKi`TcH*Hs
z2LojYoYEKjVEo;VYY`5=2i$Ui$s!Fq*#I`|Wb8YOoo(G{o3&xSuApUonAu|?W-obW
zTQ}MP9hfDaxAHXFue3akHt~+-FTfF69Ia&^VX2ddo3^+DuCn~4=;!X1PjBUeN7kn;
z!z`b@(6UDe@RrXX)w*Im?eJaklF>Z}-MQFswftg#no<eN_drSQQb1i~lD4EDM&HA%
zDBE+dmmBRl#`5`r%uANP9CH83@_FF%ou`*bw!BNwa<gH@hQ_%|xnYr|-|l)D_xMK5
zXB}#HuTfTPab|g0Wx~W<Sj)lQTI6R*+48fb(*CfHO;(FoN4fE%bzF&pVjWvQFN<r~
z^t^*agO#TO?$h$JM(uC;{H(WSssZX7{GGr!$6tx#1W?XBeWTtmy15Y3-8MoS7o;_g
zxoF%z);NAf6_Ls7i)`94#z303)&Mr`I28L2O>^2b&pAk3W#!ql^R>J*?MBOI-?qG9
zfHsY5?=cBZ$RCuCO5KQ&*!Z0dkb9onBN{%)ZA+P%6Xi%dRX!znh&!I!E;$JMY!8!W
z>bq6Izah!Jx%hrl2+-SaF>lJ$r-^??(%T~UpG@ID`L1J}+{o^l^tjfm^)KJG2}xBm
z)cf`}s@^6!QouC7ny(O|2>Hw!;DSntDjuzYh=rj2&o0*)p3cSlX;Y_8y9-L%=3A|U
zKQ49s+zBYK>kG(_t~r0zfG3bR3#=ywXlv`|fQ}i6x$F-}Y+xb^l|);RC_rKu6FrbP
z2#H~Df(C<)b^G*YF!;kLFsTK>IuK0X2RY-J(;qpHA}2_kY_f1}I14BrR9>`v{;us%
z%ZGC|z8A_TE%JiIUY1EKdPIq{qwj5HUJ;4^T~4^XoIzrLE6(lcw?i^yZ&W?;cQrqT
z^1E9;W$OmzL5?h_?#vi=DiTeG<d-m`6<NFr-v{DNF8ed7zGgroNUShIhRqpDC>IPR
zt}+CxU7`rubmRAy&&_{R6O6mcgco=6JxfJAr$up;XO@6*Iea`aC7RPmzp?P960~e%
z)~BAr@72c1D+jpCP)yKU=hW|2Gr=HOX%^Cqa24rRS|L_?0VpKmkqTz{v<ai*W0jcY
z$Dq;iv07ME4n~-G*hG<beP96Fb@gaz{=aKirMAo06(s&;<@qzPN3=Xt%83f>CsAUp
zVNbkmSPozfmd^o<&l*wb$Zwfo`C%>bVh;Q~Q`+pc^Q6)3kM_71O-tRqmP9Meg;wr0
zt>}*hdkB{|sfFJe3(>;422cw(pdjS=cUmY>EqLBR;$kaL!+J!^OR#*%^0hrWE#gHO
zZjko6Z^zOfPze7u4nccnBD}EI2l@7BEb?GU;#cEJtqujTnC#@BrP8?Mfm!2z2DBj{
zn0jGyyg0)R)5?9N$NU6({C5E>e|Ib@pG_Jb@FOsC0^k7+gCv1wn|(Ao9gQA=JWhAF
z5d{w)3U?j<qq3!xZ>W^Ag`YUk5PaL~SC2?deeW^!Ybf3oY^8OunIA*^`uhB~pryjZ
zXRCvjtE}15tq&W(Zaq<p;Ky-W{V-~{cB^k#(DF@~Sy!u{%%1nm+O`@2aQO#M`%}!O
zn4BqF7$xt2xOt*#-wQ7r*%Ii`P1+WlpNkG$9=Lhd9sEFaKGW|}$JZJ$bvy>N*3m6b
zhwB>UHnP|EldkdXm;bE2)7*+`o=aA<pH(yBfTjE5+b%-fF&T}C#^UXu-=jdD=xJp?
zf)+Mtt+K7sGRhECe#=w?q`l+Z)s>Lpay@eJmEU3{k5P!O<J9ag_iKTc^F!={F$=4}
z;7e(Q8wXlWEWVV91uRq&Q?`W#Zlstv0~k*7Pc&?}V?o~^^q<HF`2A5pQ|)Khfa+5@
z*=t`%2|tr`(61MZcU5uSCoFytegNE6z6$Ao&_JJTzp(;z-DHv1zMkpsl9qkN5>4v9
zVh{O<q<!aV(DanW3#1(9c*~EwRqOHU@YkF0_I|e>=0=CS)vJXL>46f?0B@6OV#Bc)
zPaS^sOB*<2n)RFhbq_=rKqmwG1Gf{11|*R91c~YQ!f~^KY8{50>qekw7yqhd7|qWa
zZ@yRMmz}2>mezK?VtJn!PPjtFp7h21M<<E<Ld8Dx#hzY?d(ccms<*ML0Suwy@^Se5
zuhtf3Rzp%lB=U?U^N0ETsvwcDe9kwf_<RiTLqhq&qYA&=qY;g;TF>{&dMG-2dnjuk
z;NFKu224j{;7IIBcBE|G513WJv@S>D79<kw#)MPmr&6^iW`y!T^!bo>uH|zoy~*-9
zIvyCx=R-!6cm-5+ish&OMr}nGYy!poZwk=y&9rvkphq^D6+9B%3zjrsEpVSg*a2rD
zvCk-O-x^m>*?KiF&jZtX8xpzOz)-$|fbA&V`XF+~GN%f?)54smkaHn&T3<!tBP0@!
z89#2xzG~8^W&|G@mP_4lJQlj>ZgSGL^1v8v)~(uYLWp{gz{Xt5>4u>7;8R+IlE=aj
zu<=T(j7NyR+k=+RLt&+*)GSOw)@}yy>-Lrt!@#e`p24i8F~F#W|0J?aT~YxLZruRU
zIx$>My}t_ZFv3%NRw6l^$=w<lXfBoO2DUx7_qH?iJ+hfm<hmLBL3eze0yE_vrX1YE
z#BSc5Uoq-GhoeSG1$(#(M3Fq~uprBETXpxhiIjg%Kq}ZXbqN$d0NnjCX3k1p8AZ_X
zIC^)X-pifC;{?fd{4h}HmED6{@-{Rweyl~)+ez{S5K>&FV;+8vz*}#ES9)UR5Ntx@
z?f#|_=v3a{)Mko1v&R^+4O*d1dF?2g_S%s>W2CPg`AeD7UNh=&x0Bw;v<MvSMkXdR
z=HQ>R@&8Qzlf02BD;|$uh77xrDcj${bOa>Nu{)Sp5;wx+Y=rW02h)WD#&hfrCIt&~
z><%UcOLD#h74BeCuqwyyU{bI#XILh%rG{<Ju{)R)+nQr{Fe%uUv&4b8!id{*><%Wy
zPR_ZC6;&B_MvmRVbQ|Q4)b5kBo@MLY-2yJmu{)TwMN4w*4kiVc<=7oeOQeB^=e*6b
zsn=z4%Ft)HgJ~Mjyn`vn?qGTVym<#x4#uYdcQ8FC@QE(R?qE7n=udY!_p{OM?gD|&
zbvbqilfr9Vj@`ke@D(n{?qE{*deq1Asn=z4><%VMAI0l3Id%ur%ToV?F33Hf9hST!
zi7K%>l2kkXjwDr%zaxq4c*{&Yz8VGM@oNBQ&_viSF&^g9J|y>JpIeOFF98&YIi<Z>
z)Cmt~jesnLA7q11AvQY$S11o>70Sa|h4OG#VL)*U<>9QtGeDSpI4c4~XFQxW3xBu#
zaMpIDz{6R*q^U?B&SDZ)Tf~R6=-0fKC>|#ZdpK($lErv9>rVXbq7P?DQXkG*gWSMw
zNa~D-vpxiD4`;C{<g5>8QOV@pRUXc|A5h+OICy(zCf}ILuR}UBi%Aw)GI(i_8E+P-
z4aS8;Z~R}>niX`LR0qw(<IL(5%j!A>e+xgYq0at+e_i3@wO|wEoq|7WvtnH`!2bcH
zvohEV;GcgL7-VJ6(dOo#LtK_ZdHMSiiYru@|7!`L9I}YimgM(jxm?9n<zGt5Jca7=
zdCyT+KHDFuZOnJXbu!n?--}S8Qnu&6Qv;~8LObRUO#mwXTFOl>TDmOA>M;Zj;=@Yl
z2;tWktX(#R?-X;t><D2BPk?a*g>~TT3XcXlQaBj@Mhm}y>BNHWpAZpo^&l<z7t?1u
z*5^a%=@wG?#q{H#>9KG=RtRTP+=|gID8>Bn9MVq%&~q{d#Zt_X&t=ZZ%;8HjrMODq
z&zB+RIu^heJ?9a<eH-Np%ASW9c+-VhzODzX&eK8Sa^a)peCI{lw<f5#)v$drhz4bH
zq}?EwN%>+U+!%5WUSshEDBc6#)HN_Md5jCnW#g^EbNj@&v27JaR&qR9$K$k?%Kp?z
znG*p$=U0sGeDHJ6f^ijUD3iKAMpl(P@lfVy3xmfxye44utfcyC17@NUc}TepOWV6K
zq+vtPGd?t;O*k5*-4&P}u?hXygeQ<wj`dnUYd{@;NW1|QSTT3MK}*#;E4~<2><yf}
z-22Eiij_A{|CR)BElq!UUfY)rDk`n`X((PjF2qatyq7GBO{p|KgVOnEIHPRhjj^DB
zEvYS{iT)8+Sg1HTQT^LvTQv1dm<yZwM>cgna(cja{z%)o0f4miQjnmnWxlOfhUA+F
zoXGgwR%JXzWb~zjiob{3`bmhF@aeIBYdZT=Iv;H-Ws|nXg90|CY%-1K4ZZ5j+WFU*
zvTPWK_Kv~;$o9U$_MVTN#9V6UZ94Er1iz>U_zs=pyzwq*K*zt!j_1_1@m|zW4)3AI
zeM*wb?OYJ_deAER*8WZhN#Z>U@<l1^Z#NKCe{4897aA%DcD;OoeNDoR<Sjpw`xo8)
zcPLnjpX+_Yn0_;WUcHTQAN%`KvZn7?(<h**A7r@ou%!opXKnaZD6Y;^HH0Oo?q->P
zSJ#LxeH!$5%J+&@xaDWO$@~qF1<)Hf$qc@Jt|2l@F$)hNs*g5A4<I~s(A!0+;v(le
zqF;tef~!dpnyf>L*da$Fr~VO>iSBxwa*rGazi6~#eT+F|#n9urQqdL8Gu>cRPmuW#
zOvBmR6=c3&J2W`m&}ZA<A5j6jvx?n$D<~>XHH?I$3Qtd{;zC2UL4t}aLO}Hm2JC9G
zEvIZv?nufu$vH37w?_6kDsuA75QLi~VQkn07gWjbjV3u7<MDv|$Zzx}NhExR@Dk-m
zS<81Y_xu5EgnNE<y(+c(U8{qk2z`K$bnHaCV;G9&OmX5<z9^<HbbK-tpXwYGP{zK$
z)S!lh6Q^=V<zXuZQYS>}esdQx$zuH^1}7v2_x}~vi0v{OW%Ge3F<|au90c`p93Pwa
zMn-?}k0zlA1}fC5kO$ig?7KZ%9dlCHoyYnSqheBN(DE#F<+P-G0yy5%(aP=~MA2F)
zncTJhI&k<}8lW_ipfoZgC}6Rc;jH8`snYG0uY4{epCOAdfUcuI4v`jKE=lpyE0}Da
z4C*0}=xWwAaOie4_P?=<hW<#N_q9s)OH|@Nm=;i)|1$N1MU(pr%gk_&k;dD|DP6Tg
z7onrw>aKwdc{4=o>n2*?pN?$weZ)fZFd3V77dF_LJ!-h@`RyT%`WMPH28ah|7vr7*
z>SmT`aQTk7XW&<K^Y)oqUo&XjUT$O^v@&id7mVzI#LrB0LgJB~F~`^kB%_)EZ35JI
zI-tHqI4T>195-t;Eo4_?_B5IGay#S1YUF9ie|@q;z<klLpW5G}fgZIB(1%PxsC?6M
zuhg+cLS<ti{PaoeFtqIhvJo_bowHQlHeg@?BX36D6(~RQY9vPO0x_2Wv(4WCWk)-k
zhAM8eQk)pnKW@Mxc<q;vK|<E*RYCnvhTu#itCJuoMny$j>y*+h2CP8ozDgvw&)3g3
z1WS((l|DXHy5jE!a8gzAc?hU4$<|6({J2!{`UcBqT)ZGzAKn33U<gW8vCaVUt>0w8
zX%O-0P?7pxIa&vKeH=nm9Bv2^>(&rZ|4#!LSH|M7TVhN5R)_r=5?Z|8gZk}rwZ>~8
z3a@z*UB9&=s6W&Y6lGZmQSpQ!M3jvNh~{_7Q(kP=<)I?=hZ%yr?hPXzGsKf9@v=wU
zi<efuGsFi#RFvl{UkUa{7$91`-T;y1ix5zsSD<C6mYFcn|Dcv5I;drp6{lJb(c&;7
zsAat&*c85Y<n>kYiy@?gM|RTM*{&Nr)mpS`Uqk%HcAaW~3~4ZnpUuM-!@@q-QZR3f
z4-6VX{cyAXyD@p}497;*ijFT2;;nV@)<jVKxUnRQBwmUKjceg|Ll9-!4ubEEcnAM{
zY1D7gSKHjkZ;-c?E?R}aGwK&WcL5reiAeg*R3thhaqTq3mVJQ#6e5hOM$Y%h>A99A
zngAWKD+q@m(RVrspGNk>Bpi#JOOaC@>8z@m0k5Eh%Mng0HWa2Zt4A0`H!KCvc>Oec
z%yi4W-2RT50*-~dVPbNC<+Oml0_~G7S&N5+{$hym)CzIE{$b0fl6KVsVLiWLXzKZh
zFgm2?kv0mDCaLF09D@n?5B2>B8+kz)WJgP`(I##_+|ShE-j5bR{cc4{IvEYxm~7Bd
zri=RH4ZRTPe4KHz{*|cqYRjj|@1*(J(Q~(2?fj0_Zm{w+?fD_TZ-n?>_MiDK>d5y;
zE6?UUrseUd8k>_HeQv!rHK=bW))ZUyZm9M_md|15XUkuT)=sc|a_xfgR(ky{xXEE5
zMtu|^>Nzu1U>9Ft^-2-r{iGQ8hf434Dqa1P<x@FY)e4)kaIlvtOF>Y;`9Q1O)aj1U
zX@j3G>~A}<GhwmrdhC$&k&CL1kV$353_qznLMD~_0UmZbXDPqKkC(X0S$))4nM52V
zlZab^@AZwD;DOy$aUbINewf@Gy~<`9Z>^}0bW<d!PGdk|qNC9g6e{WrFVS=d10>Ea
z4gvKm4WP15^=#Iv?tV(@?i!<F7p_w(4$t+kT0W!UJ-#%fe5Q%M8U-pE4UpOwg@B;f
zRVCVrJxz(n;@ERrnM9qFYU&e4bS{|HgTVJv#g~S-o`^hS@i2f{O2r=t(iWSp)mktV
z@SBSI;YP~l@X{18WOFLK6cV=UueNUB3if<oEyMM_hTvl7p%emDfjd@nh-;_`KYOWv
z!YJ8Ee4s}wO7_vGhL$n*Oj8VXnF}-0RzjEegmw9LNPYF+7{Jb(=!>jgC2j6*Z4T<I
zO-pR;T&0rEYqESU2>II%sSxd}m|zGI>o5Z-*2SI*F}UJlL$HhC8hio8tyS0XF5wR;
zA~WF{QTUg-##(WWosn66n)Sq4=8!rl$^|_GCQZcE7p?%s3OH>ar{_J~cy?}_p7$s)
z-oI+YO;*Rw+m7@4VEg1NHS}%GYnO|jB7;ca7*8jF><sYC#&HpMgSO*ZQ2*HpJR}wD
z;7-JxE$4kF8}V*E>A1zdU0?hYjF+pP@WPES{X3D|KtO&@Eh0#PBji40zWgIKd=3yB
zaNO#Q$GNO&x7SjH2^abkkfjfzNEVm)%;FVWk>QfXg*oNlAFG+nT<5q<mMVgYa(b1+
zCrr3P7GXiSp7P)tCeFW=u-zVx5q_LlvkKl%5t%MoobgRSOYH3#$>Y>Xw5ci`FF)Lg
z%+Ti3PEtru(T-S$_im&(XMR54o(!6U_B+m;e7-#mB>9{z`23U6(%c*grH-?L?MSg5
z)dv}QeNJR2t%NS2y+{fm?I9zPfS#ZoJKnz?B>6ODUlTw0hz!-57<hdC4b;sLt%PyM
z=VOmOz{^1FTgMQj`8&$(D0s9;_)DD=@FNI>%1AH}ZL!n6JCNk*-db~qhI$QHkzOFw
zW4lNs<1thnjb$u4a9I$EXM6;oi0C<AM9=vm`uIvjA76>_@s-H)d!h9iv1rbf_?szb
zDVcp7WXzPaluS8G$&|B{OgT%*l(Uq~GeDjd#8!edTD*inJlgd!{EbhAoY8Lck;LIa
z5c?558|{8GDGH-Ke#GBwo~1-fnFK{Po^<QENz(BkCr%c*Bk)fraL(gD_=Y#0)rOqd
zM`Ts@0+RWK(W*A!3V6g4t(GK@SfVxEkc$HH2t`&&v|=&f_%jr#k}YI~-2IN$Rs+E!
zmQFZgiPmio2wK?xWc<zi4cc~@i|auU#Pr~EEbFg>eq*OHSs2fWUr7cob0a!5_89)j
z7;q<YI?G{aW+!(d9Jh#votcG>?Lo~&JnYQu>Mmi)+ISHUJ2Sf(SXjiv&dlxxmK1%7
zLYXB7Ru%EEGqZ<*jYT}{%q%sqxrm3InLQ0`E#hHkW|@I)MN8PK3Ip4Vc-Wa)Y2f6d
zt5{K$fisGD*qK@59)hfq+I@=FvuvGvT)>4zJnYO&Sc{ev@vt+qw}H!wc-RT^p%x>x
zhZnugvdwNXD&T`NMLg`x93W2=@UXLphn<-N-Lv4$!_Fcec4iK7?+ARNE8<~i=4c$p
z5P!NW;$dfIySqr>b6pV+J2NL3yw(-*urqT9gRgK!JnYPzXz=x@kMNFezR0t|74fh$
zb7zsBhn+<{?980(K9c$$bU`uC;WBUTatOM&B=ZicB>p;#BlAwxP7r^e9Pd))#N#vJ
zx0&~9Zx_OtPeXy6IL#uL*1~p)Ni&!BA-O;J++yVZ2B0fxyU2N8R%RdcMx5t;Sy@cd
zetF)P6(1{5Tae4dNc>+o`}4k>II}WhZlB%oH}i`+6b-sRfj=(W`6!Z8ItH4+D~23?
z1GK#aTY}k?=L6)F$bG5VY|S3K;}~LWJqwfUU4k<N%mg@N5A2FRZ;`1#Ch9Mt%AS}q
zt(n|YE}Po5r(8BQ4G*+ijZ;7coErd4Hb(P!RUIy-?TH_{%bip?@#~?2oH(7g`$h`g
z*?D368jD9!t6PogOR&?|nJVkHr<bxbrQC_2NZFZE{uy9dqZOu7M8d^h3f_s8tiOEc
zdeqs&`MPFUvG>8l{R7M@umjnHn!&3ZqL&`5(M_+E`g*WFw`b7(?-aeO^TkgxHb>6_
zo1w5A>booT{RDDU!ClGdD}utRD_M=)3!)#FE;{7(YE6n=HLxD_RXTSkc<VKAl~iHP
zyOg7n^5P3GJR1g{)l-om^ID#sJ%$2~rR%WsUQLPWWIwfr$@=ZdwpMbX>pJqOla29u
zI$WZ@miR_yn@N+Mm}94)D`gQof6Hf92Hgu-Vvh3)=~XvI3ZICEy2G()P_ix1O#FRs
z901_7bq?EsPi1@bfy=r%tZVo_P*MR5Nx|y?mY{WW*t!o1poMeT!j{=MHWGQ~QeJ$g
zepDkHeJc24ueR_;t-M!&U5{VEzBf*I4rxPut5C3Mzn+R-jhagTXaH^C0g%FmvZD`O
ztQ0UM%$s4+Ttk#TV5H}w+&fB&#V8#D^#^6oggB)Y4EoSAI+rQWHpt{w|AN@xcP_FY
zhD3dLN8(c^CLvKU#|8byA;C?m{!2jK{5wDckllPN5=C>7_%jlNkr;5X5UxII05?Fg
zqgB@Q=2HP)1A>81S-q<&tWBu7`C4F~0=D#P!`^{5y@1#)%^!b5viaH3`Xqou)dpB*
zs*<3zxLhgopuL~8cqG1OTI)+|Lo_8A#nQ2Rgs>w8yX$5g_7Bl;Uz~m(pOemKb%^FT
zPt!q?(?c{@c$#JDd@c*oJnm^a@VO;K^OdJLB%RNrA(}22Bt_;9d|nCBw0fEY)A@WE
zqS@2abl|foM6=q{EJ){5YTeH`x!!2Rcr#Yu0jM(CI4xaP%cZSG{5q`SIVI*612|?!
zr<y$kr3Zzmc*ch&CaHGvRAt`o=wK;|lv@Q&b!LOV&>zQ!402zXDvD%Bmn3Zv0;Cya
zRk}eo&9ma%MJiom0C$c~QC{+smZrN5F^*J!vS#cF;2xz?x5n?;In1qjZADP_HzT5-
zh)7%aky+^?;k@e9O7)Tts`PII_6GQT&nXOg-_Q*=7zLFy0Uj?^?44?LN?oN78R=?}
z9-yQmXgE^66k>O-XE$ey>~c*e>gWa~Mcg?mC>>*n<A8YDBUZ1ZRbjWR^hiT<3<%I3
zNNid=idqwqb`h~>NbtNdR8J43M_;TAnqD`=MW`njSY53u`m9#}R^lL`rIjPZl~h)@
zd5CB)7|pFl^9_!bsLrcMu?!SVu0~7W4xXh$44`f=)0(rRTh{G(Bc*O1SJI3%53V>f
zmhMZtg*fsl7U``mtM?QmeFl<rgPb6RdXrjw*wEA>-$d!4MPGSXkuQZRU#3N}qYJm#
zw*{u4FHrdzzVg+pd>2kIG%J7TzpMN(E0T+8@f%hI)=+k><u@XqZ9ra7I?eitrj>`y
z6lpuQ3Y%6LVmzoz&oF@9Gft_pqw}}eo-2%$qs>Akjl_>k@0$lhG$$*K8=g+$?T5X5
zvyx=3c^JK18%Za8!dk`pUfeRT*NlX`ep8YR;g!az%$qYgQ9p6U(v(vNP0!n0P-0+U
zGYJNp{ow#8f#1ZWRMH^^BGO|}_LH8Vv@kRgIolWC@|31NM0%em_3y{0iC8*3MEaR0
zee7a&v~<!BjFhb{#ByF*T$4`oqy<#c4B84!riC#Y&`wIj!-k+~fFT$&O2>zS-SJA5
z9o;>pt(2NecMp+X?@4EEk#xC{QoiSuw4)uJXe8|WUzB9acJ!--IP$8*6czgD$Scpx
zmb|u8k}cR#X<5j+_fxV+90N|smYTZT)O!}Z3oEWD27H;Vb8;+G_`IO&N~8xl9<aIl
zou8|pY6YK02z7&j<23#Lv}yYN46)<qWA=^d`~zgo0kw3vl{^?#ey3u|KwG-f5DYPu
z;E0wJkrdc9_ry0D%|Y3TMtHmi5GfrDmY2ERBaSk7>HJ378c5-~!b2$KBWY4TLMi(#
zP$?f(DNkS3fTh{vq~p(TO4o%%zS2vEUr3bRVu(LOlBYc4D@JS_z->@-4@$o?DmHAB
zr#f94wj8aT!iM2I0IicB`;-N?y_aksstSg1e>>wc?lm|!g!|hW>l7I3=2t?{snT-C
zwRI~cZ{>=um8}bgxwl#P!HDdAIKE%fD*wy}vQ_>GU`sH7RY2jlg?w2c+UDB8#&HEB
z41=L=?|SS+=nj@+z-i?ot@RStMq0dr?f1$#8&nBIjNMofQ;?-6m}D$+vhU&;!;}HB
zBT>hrm>ou&+?AkpoSFH$xq}*=>`3P5<UXH!$I<@Uc+Sy$J}&@>>h6x?bj{~KUxzJ~
znDSZ4d=XIoAqXW<XG7(;!_o1|m$5_2t3HQ1ZcInVX%jec@XUGdZ*-RCa~SveypA@y
zk22#3o5qZ{<VI&Jl7nR$l2<TC_fn1=G1HK|;W@guA~`^&A-PE&-CdFNZ$YAqrl6;y
z&CbyQeIAbpvT#H|lao#b-TGSO;WU88t$Cwln>@OsimLq?@barjuy+HriXU2{bB;uk
zyVcER#%;65K%qhKb#D;r)~sz)$7Gi)k~t694DND8vY5m!S0;D4BJno`Y74TMScd<{
z`42wg*Dc{}e%xM#TjPn&kt5JwB@GU_cpl|9HwXyqwdOd;lmzo~4hVyVxrfbzyL;j;
zxrh;)+$@+IK4TB^;zxo<{_Y7dc<d{(({1#8eY`w^7Tb<`UR-Lkt#^CMJbec~ZLhu{
zo);g(;<}3rF89H<^WwWAuTx%pPy8tqd@S}DT&8o}^>HU4vj`g$ePkE4Xh)`)7i7JU
zf4EaB8p7V?u0$<FMwc^D*u8~YbFt=Ux{rHDT9-R-Ni#mJH5~;2@%u{;#&SMqF%QOb
z7E@&&%*&l0Dq5KHA+_U?U2^%Rg@;N2g=ouix`i24<?ItKT9?CLd?m{^YO@YNS4gwa
z82LFvB*H%F`aWsbMx+7W*pBx{BludMd-2^c_FNQU3NId^V=s!lkD|X@fDIxT$R!bW
z+4X>+_Yvgz0D1mRd3s*|3h`_}7m?>Z#<Lq<oV+K(TsMsz?-P!-`+`3QM5*m+K;X}c
zd(1sxN#O2^ip-wxpu`xUU<i=;MR4j4{&z<y^LFUK?z0Ioe-$D8HdUb~0F@jL<ULVV
zpSegts9ND(0)tw?9TiNX4<d|p(7jP=;2J{sLA*l!_Y--k_8x~WhP;DfVs2i}DIs}V
zVych9G1YN5w0dxixzGp9b7+kGj{?WiLj%_uqlrQn{L^#JK-kId%G>i?(4e|_2PIs$
z3{}P+!o1)9s*F8iRK~u9=HnLNST=aw0!WlGD<*w`0T3WstMDO&4<p1*SWgK3rqI)b
ze&?Y+2LM7p?j>?h0>m%A_ZGR!-lnad9vf{kmaj2I@Rv&!n5|$_wnC;?Fr@pi;&EqY
zNJsldU1|l{(WhD4&dQ+T&O=4rmO|BMWf0+}b;olEXJt%B)1IS5bMYgS3~Dm_KtPa4
zq0xj8yUrELLjggzEL2%TQE$qU>V373SoQaUPJUHFL%S)9_2(U=rgc*mbvvHW68r@F
zrYzRE5@5+8`11Z10UrfezQK5fnvPmesYk7MX|2AtNxjB^2R>{=F_)iZ<}J1MK3HqL
zTWXz4Xe!KGpz8pYV4wXSsk879KyzSQ_hzwwTNFh1D||8Gg9)*Jr!NJxG)er3f=S|{
zWiF^1N&VcP)ec<^Cj1N~SNJl(G!KQk9!dy0R&XM~@;e%}Nqr#-I~-qOa7%0<G*C{y
zgX7{azU9}L298EqcadpeNSu0q0$B`8L*jIq%;nSv`g%y5WV-+quMu~V9vBwyiw6D`
z2s-a@8FB6dRKC#acwIzFGsV34T3W<iY$0AlVF!DOy7$(GR2&A$>aizFiztxLwjZ*(
z!x0K3pj`rp0j*G=FA32gI!DN@=x_+|tqE`;rUUSWyydI(RA*paZ54cd-av$+^J5y{
ztkyl7wDxwCcQddz%GxgwUq1_3-C^bzNGN%m5c=-|@%8CP;LDJY*cyc|23!K}7fM|C
zg3vq=uN4m-`a6JVhC;g&LNhLsC~+?#bo50M6*?UW2ysB6g9t&zmk5{30o6=0u`fs0
zWI$T95_=cue>WhgImeJspi_BJoJ2;~+=c6N-VdR-O-FB76_ocgO_(>ymPqAsY+_r!
z8-d>QsyfvOzlK2WWm8#OK22%V3MdH@x8>7kmjhx%A1lyxgrEh5ej<dQt&PoR=p26(
zdhZ0|%eMItR(UK1n5+W$ieEOuqfp8nj9DK0Y_bT@V<iNDqfE}94z{}xI%GLIVsbv|
z{z4f3JXr+#5Kt{GXqS98&rL2tywh~mD#&w@RYR*tMOFmZT^Qk5r1CmS_nq3am+H|z
zW6*YduLK_M2CR`N-S=Y83s<B5*@S4a7ZHNZDD)Yi+PQ)IQE(6js`^PRz2<1B>M#^j
zaHfDLr{D?!QBc7P3BtO5mifSM0->ma+aE*ZZ0JMbqX5?)4ps`fnI(tMNg~$@F&HcI
z0R=IfDV%pKc)@Ugk?F-)KpMY(i?l;CM-U4`R_HoFbzMy_?B1Z~BKqPdsyVN*ca7p%
zkh@ZB;Zk#-ismYggRWp$pNd9y15}IhpPR1AUkve1brpOfsC=Bk@Rg`Iy|3WAzS>0>
zfsdPy4N+F~s?2syIbOTyRhjL)Ob8VzG#Im7j)JcXZXF?r^oGn{UL(X#Qn3E_1W{7K
zc7lfk`=-p3Rx1cqD}0H-pjPl91(WEH1xCe+&N~shma*gQD0RInVD^MUHv+2p+4RA|
zp#|+rMgnYY%P@fx**sGM`-4AMNz!0@qkP*CQV}?W{gSGzi8!ym`hKd$k5Hw%-PBks
z{k7*wP#j#VR(j}ffXX`=^#%>jJncsJ96+9U9hVN_`Tff%tNsAKoWrntb`ZXck;M+#
zLHKSUbO0fSn}(ACLB|U11Bl(Tqu~BbNS0U%-%S{9va`5J{EyyxCyDho0j5S3noVd9
z)+N)W(&GTuoZU~GPUW2l38|x_pwyc!{|Pj5o#n4AWHeh*7?j^*Sel%c5Da9myqb|@
zwwkGL|N8z~$sMTCC9su1J<Jg^U3ZG=VUC#MzX%~-%n?(ZeX7YjPmuQ!TrxOt3VyF3
znxk;rX+T3y^QG)bfNGaCgL*-92x`Qg)VHV*HI*g}JNnX2=?#EQmExI$(g9_Dz)h7q
zGgcvAn%0aq28@Xhgc(G04vqvh^9_9%0`-Ssv<z@^qFuApXsEyph?l0s@--n2DU4eD
zawu75acq?=<RU>Kbz1o%HGiCH-fR5wW^HuV>CpTbY?V^;$BX92tx?S%FUmcg5Hx?h
z1_40S<?jWW_9sC5L(vMJOb~;QLiY)jME*jMHg=-0oqYyCnCD3nF0K*?NCn>#5Ya)w
zZfAlPq4uQc`)K1VKsDc)B50inNKa*~!p{TGYSw0X`@<))v`iFB$OoD(BjSA1zcgB|
z6IOx;7n~X5gKk&0F;o2Na#V*)SGY~%21T4NG<AShwEtPqUmf=6sJ}r{I_qqR3ylqy
z@>2mdI-@SMzu%!cvDl&FaEF1W+~d6HOCfZxo>rj2{+1x(jFK|vp-i36X2ijX+foiW
zD>c-(t07bqgjyv+HDSuIDl#2yX_B3SRU#bH%w}w9I${`;)Nmi!l+f%_a6DQn<nKj~
z5z<mL&Qj>XV>J)KL{mZEztG+)GGun{im(++F)C#R)`aL)nZZ!l1jd>worlco473NU
zK;&8ymDI>$taN|ieG+(02K^pnVBJ2BUubsGD%xeT-^2+|yUg^PmSQk(m!(=0C;aU)
z;b)U}h*JhGIxRH^>#&J3(eJ-6`D(g!UNXCM9*BMJB3vqF)Usn^`OuK1FekJWHJnUB
z97}WE=aYy<n(Ti_L$d1TS1875@d5Ib-lOs6VZ?nIZ|=tYZ{q_FqCm0iV4!^9?25BR
z-`*}`JF9)(4Yj(3Fkaec7r7<or*q)ZOPe7}muwoucIOg?w{^+p6!Kw!C3C2cZrL=9
z;Lid>NQIXw40?rM6qt%qc*J?6pO>UR2XGZ1xib9O7ZATRN&gdJbdHuj_^*JHyuY}R
z5aNO&r(XnCN0C)`5$!9$^i+i!E(Qd}E3|AKAlQ&X&t49QU7=vcl>$Nq3LkwHVZ8FF
zVC-swh&T%VqF|DG+<HMnEXBV9xJouV6>hx_Lk#?_MAXY4kC)I875o&)lBFoC;NTlj
z_AhKwkL<os_Tz*%rr>oqf*d<MrPAQ|O~C$4Y|m`^%j<wkX3s;T6%KAj&9r|7d1iwZ
zB<fc98lXAqmu1t<``rQvjZ|pvZJcqUAIh`2kmVT(tN?zTO;34Y18C<kd@KBq+X+LT
z3T{#m6)D{1PNJa#1#bjc^%FL@4Zi7apm*dY%vB=E^M3<=0-L4qvU>pEOE@9TF1{Dv
z=2g=Ech3IOB4ODK!XIQ`Hbf1*Mf_w~{=*X$E{hYtCVOp*!KaYl#n~qgGWbry^Kvd}
zHF$f{ugbaI!^abTIA`w>hR-AYZ@Fb-3=VL5<AVI#w^Mi!2Z7lm6<9t>|GJ-Zj>gHt
z;Kjhbh(-*ajl|shkeH6d4NUBSMA!R~XhUKm6GM=A0*PK7xeehtP_GAEFyt5{q7NeR
zM<ix5aW)dyFtHYir;w<*&}88dIRQf05Lxqy<#U#^AeoQ(jT;`6?`nb*sRa}f1VcHV
z_;#(u(#6fn>xZ9D41NarrGJOq|3G3c6L%wV4HB*VNM*>YfHnde@&OVh4<Ye25<4^T
zGZMcrk%>WKpMOB;8^)^QhGCy37u>xJ{80}iiLUu*Wl;Wjh$uyX-^`HUGyGOB7|K!S
zv+a~ufVQ|!`Oo3E1cTd<{~#(F%)`_^4<peViLaTcLSp74kh&T4LnZ>c1<;UPk+|zo
zB=$yPkH?VM4~bWqSdPS^$B{T1iRYR4BNDeiiNv``?EDlGmm<;SX(X;i;<RUw*nq?-
z&m!>v5{sTgLe4b*iNq_&d4`Gik;r-;zf$`ei9c*_I{6X6pdAcw81#<!KsJDXdZ06a
zdFBN*KbjIaC7p(ItfaoUoziZcxhHjW7|Fn4+QigWv|e+h5s$!>^1=`?zfuco{%Tm(
zb5{r}+cvivk}I8e!pPW~b64V<d3pAt=GhQc77pu@qGH`aVO9i{LCtSQbXEqw)(jJ+
zvFh5cTB5AGg{hQP9G^LziC4>Nf|}+K<*{K(&o90r5NgnlH(LJS^~x}<a+MN6&0a=D
z7kXxMDmUB~3kQd|eZM)KaqBukTS9J?IBM*mlq9!CqoZu&H>WdhAB4E^#?GyA`#!{N
z&E|Cce5_`)*&FAp*L9!?YIY1^p9*75l4}glt?G?oeA4uAA!p6cA*!D6-=w^0RLAe6
zI-(@Q!c?+g{Zj}#GmJG!)`#$ih4E7Qju7^oFxE;xAHv@f#<O(!J0WaRb}b1FHrUX`
z1DH+WvYax&;<KY|_U&*`Ga*FVgi8#Q+>*50C23Cx(eAcI+G&@n#)6t>ZMdWE4hz%9
z)||dF6VEG#@aLrCPbB`c5dOAw{Po2D7{b4pj$ccBY*?!AHiq$HW2f10#4#+t(ziOO
zxykam3DMv3WfLM3zM6?U@M@kj3Wl~llO?ejOj^!eP%%OqHim27H(~}aJ~y6JE`#Jd
z+o*&LUTech_4<r88xTu^nvF)r#r;E@lbJfRMyHzlL72+$b%tl)%Bu=VB6vnhy52~m
zqDakQDmx=t0h-AnPSdtP!=Sw=L~~>sjYQlGJfF>`tuQifSY8w+OA56T%+?wecjW#a
zrqZEXys4s1o6qKbv^fpc-QP&aCa*fAfe@RXHUVJp7#OBWb}oa*)DYE-ty2AYoQlLF
zox?g(1vQtBPodA=938dcm8Eal9Q}}?>0Qr<(bnD1gz(>l@#x5)=Cu&Eb4^$kh%GfA
zhOqt9ur!eib{rG%Kh``cjJ2At3gHh*$BSRz7Q&yFju*dvFoeG@9WQ?UR0#h>7%v9=
zZ3z2$7;DnGP~6O~4YfQ5lSI@g2;uvt<3+ljA^cA1cuH5E2;q~?PRX#-^G!Xbi*xdw
zUqL5qC4DF6WA2||#+CFOIg819fh%W1BU}))0pbbSynL>hP6bq6ZDrXDsK<`3Gq5o{
z2xHzr*TOZ$ANB0V*K_w?+H-G!f%~Yh)_023*YhRR$7TO1`N$7m23XBYngMgAe(%eG
z4<$>5m%IXaOoPDL5b%Om0n0k|6giXH={2yE!=qE=@W{RHg5k3Jaf9&Vp;`$y0u;Of
z=#n{D*DLtXH@INLQr#18SXDBQ8zTx=y$Ncp%@x|`Ev)Fyrf3THco*>66nrD$om21u
z?*pEef<FMvwf&7E*n=Ms!eUgxCqDv+rM^Ose@qBVQ3e0{DL4&*whb=&3~(=UR{TW3
zB?q993U2c`K{QgqjRd(@q2RbL2qv+w0Ia%*_HvWR)$k?Y{#3Zae+A6N`^|zK@)fXC
zh`m+d7rzD;8)&!XzmLwV`xhWs&+TG8+Y5viD)`(tC@KqRg|oi}@d1nRP^-cZ3cL{N
zR`|z_z)$tiE8hd+2F)G$XTuC0`2pbkC9qqCHvz6a)I+je!7sJ$6dSAg5yXJ*5)<G4
zXF|}ef`|PEu{yIw_Xy|XHesC}P`BR}T)(TDaoHT=*K~SkroqP&e@dr2JbWbem+17j
z>4u+0`hkU=%nfv1-&FYcEW=;M@*j4p-P7Rf3BTUyi#-f}hH%fqi;TYJR`Wrg<L(dM
z^mh(#_;_?%n=)ZsjjdU|3M-LaTx(GCe5k|)=_PjDLW!23CV!Gv&N`k-FLB{{iVD|(
zVXlvr;QZv5a0#2wabhC#6P|1TX^QgTIc=9l--Mv%;N3Kz^OnKMd^9Zs>o<<vj~f9e
z3VVeKV)(@a7hV}yP?PXYBjoJmxGfQKcfICwqhdI_I7}s2H$$aiWsh{ghN|jpWEA?7
zFqs#+Pl!)(FW*|UDh6Ry=u4$_rx+pEg2T2%C}Yh!qvD)nZkP%}L##M%eYCaUT_MVo
z!j!&Z;rEhJae{JPm`eExEvAD;#dX`On^VcU4f88$N13?-X|sE$HCTHoje1^)dT2Ve
zs>cn6;dtJM88xMy6{b#;wsd#xI_l`8FqOBH_?m0HmPQyY=j0b9X@i>Cmd`o)1D3y(
z2ZNckHO|Qo4%PBWvLq<5gCGW?MtiA|aVcBa6jDc;$afnR8#ZWjD(R|cjfNA~J;OA<
zLt|@R;&kHk5U<r?I<1lCM>W3~4Q>CgX*9&%WzmNUyeEW(gK49lG6IVGeu!XNTBBB4
zP@^Su?z36b)9m1a5bdZmTG=W~qrE3YyXZgAz8s=GCrm5KLO-Q({>`Y_S$Br1O?8}$
zwpu7=t3KSECXL_zMoUE&^xaGYUY#qAOnQHFGIPS0jf#CXElg$jA42#;!g#Ts3>$%1
z`cGl3I7LuX8p2;6#-r&$%@o5jW<L?ey0Jm|8KI)d@kov-2g=v~ZV~RYa6#bbg8t*~
z%Qs<8*bffIIq0H7evq^+J`3mf0*eY+;50&*Q!FY(mBFtrB6G0)3pqV(jR3+lNukRL
zVPIb@<uam?ph~8S2MFzTfH~h%=tDrmW#XuCWX+6{IhX|;C}mg0$SDav46v5RNs7e<
z1!dcENWQAD-)xOCWornpFC1cU&HJVf&aQi)byNwBcy`7&(T$z^B0{)k8Xo@HC9-DE
z3O551RJfVEAh+Ce;USk6#NH`ezYRFaIe52V_-&kIY@0C+S=rIxW|gCmniSGSo-`H=
zznP>vXRH#^dp+q)fWs3QsNJND^8^*#VqAzCA#YN|UUYb43N$>A9r-<E2u8^rK(UXU
za}10li4L~Whbn~BN!G|o$RD|kC4%!XoJE4q5g_eT{|8VlKlS%ku;*N@`HCSR)C*=>
zQ7)=i&P4x5&rU>7Sp*jH>_qfbCc&)@e=_2k@v{gzxr9YND19l`$t{BE#d-5etPr;W
zpk!?j--y^2>*`Ju5U*1}<XATY3*)?bCDz@*lK7XPij^2x73a+>u^t9C#(DEftkl5f
zIB#CTFFuuXYn(T)#L5h8i!Xuh@Ck-u+vB`>C01$R<oH#rsLH?@ao)TVt8te@{z&aU
z@%1cQ=hh3jFwUD-VhL-}k~nW(iS;&cS)4bo#QL};(!j&xZ?kObnTa@WUWuiinTYe|
zmDoUc6L|CHl{ou5HpD$3@QE(Yn^$6^-H~9&n^)qzc_r5FP7(NA7w63@u?YsRb#Y#-
z5Zl4vD_s0V!V?X?-o@V_oO)&=&YM?aJB#$u+IwA`H?PDdyGNw{2VIcOn^$5t=g7?~
zu{)@eT;9AAyHm9j<nrc~*j=iecrI^ViQPL#T3;As#+RT#X8e4>c{CBWEB^!}m`nSR
z+?RcBF>>DoP(a#F?s-(?G9A(0uD`W-zz;GGgJ^}kgE*5EZr9FoRfYgNWJH3ZA8T2h
zRBlSK{2DoTH29tkT(R6AEw3Ov0kF$H`8Z+2(x_+-2)<&@>CE9}z{SjJ%tQ^8nLsyp
zF`c|zwB`jGK4%Omg4LjOAEVCBl&qYReTyuWO~8|~5PwCs3UZ6ASzJ<Th2H~p51H%q
zz&75R#Z<z{tgBw?@^$QO<Wxc#Y*kxYPi}5kh{wyf@S79Dp47*K=TW)KMJJbv1bs+T
z9fy2!gL5DH$FTr=@?MUfAj7>J`)tsb74rr@*N-I6W=DduqfLsHAiEz@^x*GZzp{vj
zR%A!tN&>iqqHhoW-qkY;%3Cc$QCB513?MJzQ*x_Tx;dY1()p+bQB<+3PC)@%m&cB7
z_L-Z4?oUID8IkeGfegmGpbB938;L32TQRq3t%9lG@BA_^qh&i+!Qc61u2Y~=eq5Ku
zcZ=A+`p-_NQBoL1vAT%_7hxJ>(fM7}!RYLJA%9=3=d+<8)SoZ?A4lg{Dmup`I%lwN
z&&L1dYRs)Y3KY>Rvu*>Oz7K>evyMZf<b5DqnMEcD-10sUuFSenKz$zwS7s@w?*rk=
zECuy_AY7THV3oWNge$WY)c1jKWtM{aK2T;)1ND6%T$!a<eIE!5ItBH8AY7THpuP{3
zS!JNU50qJhANx>deIE!{W<4yRz7K>ev$RF}J`k?VQc&Lq!j)MTxaEByT$!~U+RH1m
z<b5DqnKeyddmji_W<3es4BYZQ5U$L6LtuL!2v=tLz%B0s;mWKFq`bWkge$WYUaRi|
z;mRz9?R_9znWeD350se--10sUuFRtJ4BYZQ5U$K(1c}xnaLfBZnf5+V<{eatybqLl
zCzI&We7!PDm80(iWhMi6Jbp5$;&GZq#%1`2?Gig;F6~2dzxBC%ALu6l@;*@HK^#J7
z4W#Pu@=MOPaPa@x<3O%Bhk-Qiy3WU6c^t@f>kGCJKZx)`JJ)?@QWUx#XW*|q4&+Li
z1O*-ka-qk8$U+_ma%D@9EG~3a58$sn4&<sO$(!q3&7YBrsg2xR*SW-1d<j?{2Xd9$
zB1z8jZcFW@0_o#GuI^DlXzu<6U{WYI*A?o`b)91IjLVt%G57}E#_c*8zuxG9aX->+
z@}$W@v@qc?W)^;e_>fU}Ul#OSI1xEng(JW*UicddWf%5<a&row0yejBPsFOc!WWRv
zFXUxJ1%>aj?!uc<s<5ycIh_kn1-GJZyNsWPhE}8UE`_tRF`yL|;NNbA3sAOu5a|OU
z;@K29!p{n_<98z&k3WEaySsnl-;(4%$fh3h_|xr@?3~UJA%8u~<le~QFsF|(I%Mb3
zBJeZM{A}X#*=#;HmG=w2;wa4SJe<Y8>Izg5lPvZT31y7sC4lkxD=3n85_nC{E`N;V
zN0Oj|Ns?Eh{%kx8skJ1Ct5zs4zaOC*g$na8Ayh}9`3BP5PJrs45iZU7i->D@QJ~iR
zg@hWl9Dc!p?_IKczb?3T2(&3eov^|2ICJCiHvAh+djl&T{~mcgI>&Re%Ax*zj+8kv
zSAfh#oR)Yf7DO%wMNak)D4=gi<z`M{8UE@vH;YM@;jeCU<NFHK7Gy9n8~+y<%nC~7
z$CvRqvpU7{x}J!?TYXC^FE){;@<1&r%+UVPx1{niwasyPODZo*A$?0K&!pG4r1ElT
z2>vapyj-QMlDDMt(%zEF%U6x-TT*#xZ%O5)y(N{`S-I$2QhCLVXhWn{-jd4eaR2~$
zOR6W|WODi@lOH`#v&lj(?qha;K-<c&n(Zs~t_jMIF>HPwjHDvk2(J0Ki>-i(ZW1qj
zc|Qv8Mm|?ze6RYZfkc$+TjW*!CLl3=b0a}DzI==Hpb0DhRKv@mBh}PAP83(xUTxJr
zXn$eMLEZK+^+*XLR{e>|<oPHa)IMx<uiM|LTc!Ue=@V?{`$l{CJe@v7O4^~FhQPpj
zwD?@GY2-xgdYiR1@>fxfm`%p3gNAaWoD9m_gc7r~qm43XXbmxX+cSD;Ge!e~hN&US
zT*x3*7T&I6rK)TR8V(Fm4)T=k9Vp$TpqFpdp^y#i__LMTORVto3zYK&bVYC8AQ!2-
z9!V&EuNq#;9cf_i<BFbHwK?;Z^a1;uKp?E?2j7bHR+`m&HS{;!AE*YEi61C6%&`1R
zkpHCSLyU$wmVFnp-?!}HLBqk8{SvZ&(`;O%wHJ173_-UmzukaOK~?UB+5{k|onfuI
z$^M=XQG4@F?MO>f)MbV%z;a{`@X!o5p2|<K`~>nFE;NAM%D|5f$d3NmcWe0#hNcKX
z!|kTiZBX(q<w!lEOf)CJ&oiDf{A_a0FzJ5>;Nv9mN)n??(D1zBF9ALqJp%FA3yQ~Q
zc;AOq(a_7}xD&+vlo%I(2j$Z&|2gEB`>qyY%U7E)p90nJR|BG$ULWKu!(~+EZyN&<
z`8xx;gX*jhRj=O+(F6q5h#p5U=S))OGQ3W=iPPmxor1cn0p#R9j(-an&}%+nB*<m(
z%#Kd}b~dQ+X`tQ%!U>dfee@m>10IAqWL&O5U%5xaHMwnJqK-aV!rl$~xfc;rI|aND
z1Sd-Phuv55HR4MNLH&pGzo5T+3zB5a)|cNLACD-Je<)Bh8gUJX2Dtsuu>7isbF^!m
z6XL&tt`fsp0X~4IO_wluY3&2`8kxn;(W)g+OZ0O$VmRy++=YK7S~}Xd;#%A-<d#kO
z9XqHQ6-;peaES$NT6qt0_u{k6f*ePqZ4UbC)89j!6r;f^SzlZz%vL+L!qFTxzrXtd
z+Rj)Kk!ihSr<SmnL<VU$6q4NtlEG1xkk+Y)f%33aUM24TW}f^*_F7g{5|1-x_m!80
z@~TxRTBHyopSPH}{+dsV^uo%+;&#t8&C%z-fU&+H(^0jKmRZ93pqD6OP97fXqa7;m
zf$}0(Ub%BLLCqWNTA}FdfzC<ifJbLnUr?MIE$CU$*%i4$$Qr2&a&xyq7D8ONAX+dy
zcSP<4l!{qCB6Wsy6N(-3GOL3L#r<I|c$_B}f8zW@;_PBbmz#^S8Kld}S4J5Vig|}&
zZW5bIY@T6JlGuD-D_WWWe@;4_@Dl36M(`?wN;(&Za*MztuA-7harY3eONu`xrQmLa
zn45xEoV>ax*yY9GJQ9Z0Bj%--8cVyUfjv`IVKQLCqGbptNkVCLh1Dy#%6?!%0UPor
z6jRr2ndgknWAm#rk`hIr|7w7ybb>X508S_#lovs>YEL@Gq00uKRNWtrfko%68H?=t
zFz+gnIgw(DSmt?@p;H?P_)hJWDw!rzZ+KqNl%izieL^4v>st;vSZGG>OsTS8Mlhh5
zBKOaQj74zN=0TP-Koa0F&^Le$Z&5lX2Z6Ws3ONimu`(L+(!?5Kx`9SXHZ%l+c`KL)
zs-0n}=2P_HA@%@Aq}Wd=R(*|3vBDO)kxR#I6DAgEa;)P<=cpz#I-{*^sWKF8Oh`NM
z)v?q~5Nx{{FK-0nP@KJDEgK&KA@Fv&Zr4oeX?rGupuL|Po#)LdO+ypHm=1=vgLDws
zO-vF&!5xTp^o_!GYT-7p_MJm*1e;0X{b=1}lNJs<I*$%CC0PN?eWY0VE*av=Q&X7V
zw-vB<MNdoSi%6QeYcf;3Ml+|UGJWCQG>hB@S#>j#RN$utXC||Z8%%sl@y~}JdNjhS
z4~G9Y<Dahru`fLo=BGjx!&pH$x^&WDSQrk5oqaGY3J1gDRD>dzF5zI<HB|%RANVJO
zVRs+?O47q$4<97|Z5-Upvb~p-r#y?USP`;pSaM|u1hy*O!m52FsY$U<bHUmU`QDxC
z%>T`u>O(T1(nL54HG~3bqetLZEg?xzq<7MId`$A~Yf43(K4BvBD^J!pj7xLbeql@p
zZ?sTK=WDj6Za#nvu*Smu7<vX;V-0LE4I9Wvn;cJkoE4rL2pM9NCgB4t$|Ag`7~$&{
zQ;%R6UWF&em;WZXTBO6dqp^`lI~o^}p`Nx}gwrvpFoY3KLnFiNwv0);APD+VXPh5(
z#%pNY&W}0U`!T0IB{vOlf{&#;bPR73L%d}G-!WBE<JwN?U8QklXN_!=IAl%^6DWF0
zzaSN>8L@CjMv@AOSE^84+)7Yn!7awCa6G^UgielP-f1&@tYH^srbnBs^f(bug$9O=
zY(JUH(ZG|NiiLTpxnO>{EgfvWAZ1I`d?!C`EcDaH&M5_xV2jNQ%m4p%IR1ZaI@;AW
z$f#MOw$&r7<h0;X8d5QQA170Oa>r0mX6|LaU!Iz9Rrtv21F(@)`3Oi)tPX|78jsLf
zsLiwL!a+#`h>x`r8PcbrA%~M0BM#to#>il6b5eD*v~cT(`6hZ;D#qrfO(0V7)kb$V
zAQf7Zj@Cb^%H+fVku~L^TXnPl!VbN|WU8HHd3(oZm@bpVrLY`Ipdq<ozs>W0oA3R$
zAl+3vrMqfjx~rxyg~G!<rvk~@ewXlY-__d~e(b~8&^=k9#J&<Mh{()f(8D($XSv}%
zPaBPCeSQ{?GGXfjSe_cIJB)G_R*s`J2x*dJV}m!$inYKTQzNaP4@h69IYezp26zA`
z0@i*yL_H17ucngI0IZNgmJX{7SKrGxm^8i3R1M_lFDo*d8*Ec6>#%I;8xjKT>z8uF
z{wZ!9MtF6m(9n*7-3!lQHZ-hb`9#kcY`o~nsAWh9M9YVEbiP*ad>G2r3o(o%fubW&
z)b}Hbjx<izJ)=UL#8kHNBPs@Pu1?y*{?uVe7?Z+vz>G~{Hd~Zn-IVgswC*04Qn_ku
zd`LR%NMJhPn}XF7apB2ByI&EdmQAw!NUH+NCh1jc{zT(w;EqYr{KU}DLDQB`x_C;9
zag&lILlG-Afk;NI&|)er;-zL0BJ*bR2p=}nmR3rYwy@f2#7m9$e%!_0Ps|4b#*F{t
zjUdnLKQ4r9<W0cN|MwO^KK7RQ(AYymW2s*m^-ON?$oN&3GQJMR%tep)AUIS-iZIQz
zDnn#&9Ik$n(TUM68ChyV@rj#2e)#n?h-{%416B$1SsT_HQUY{{z1$A+lA>I%RBXZ+
z?4z0AC22~@Yx_Zrr3^=XeUR>#?tlG#lxYs<Ggzkfgi@kvSTk{CS4bn%U@i&#=8wfU
ztW7jpwWj+~nu3RI0q0j_n{NtjCB}?QG3lVZQ7KGXwOrQtQ3u_>*+vm@Hh_#V{Tnzo
z1ft}&#>j%rI3H=pYsXWM+a+b_7=X67-ZIt*cHuY{3VCU=?~v+tji?h-mK6j$>Kd)X
zLMV;F&Y>tP<HIB!7AA)*K=P-gw4}4XUBVe0h|*R?8oK^%Gz$g7&^A$OL1i07y8Eg8
zW^m|C+Zx(xJoLeek<Uj&n0|O;=)ax;h9`fye)5OSpwvEh$E~3B31Fx2Brh}@#I`uZ
zOnOj}4{60dq;=7d)-^fXlStMr2};j&PoMmi_?BZH=tE&?S33jfNd<-?VVW)Y%^wRx
z6{*lw=|dN7xGEIhl5vkGshdTh(DV+IyHv1}iJkT<4JQ$@HECdjj~3y02SUU<-C5<l
zE))mDd*29)$(db;0Dx78kCEyu*aY{UkB#t@J!5vKo`bOG>%okUajhlkz@gdf*?KlG
z$XwWBo=oxl^mT~3l}zlylbS6~?7UFwXxO7k#X3Jv2!%PnD-nuso(kLHRy5>nqr;i%
zR~;sS|5u#Kucxy7dP>fluv3wM3Ff4maBjK@|9AVWm@xjY@3K;Mo;9hfi@W*76#_Mu
zR~8xs(=%mX;#Yp`DoeKuzqCpjkSFvr59zEl7JlwwLray_lp^%=SRP2xGi(@<1E~~P
zYxZo|uuJ+WL2{i%S5I4M`4|8{Of|HFi}emQ6`m-L>0O}XkrYTnLn~JQ3UUBY_r!F>
zw*?*<3KF7ithRK%F)&p!Eu6Ka;+H?MGWGezmw~eQ@^ho1DHX{ss@9>)E`%U_o94Zf
zOVse<3)nQTG}ZXd4Y}uLOQvm7+m4}9n2V(14{Hm#X$QSyrKVz~w1-nHFR4yVlH&}P
zVd1EdrnK;i42MOb`AUZx{d@(%4o6&&)A|y7wyBN{f*m;EOw{0)w)zUSla{tqst|{S
zom1^mTS%?HVDo7bV-e<?o|Zp_;Tp>>6|5mo`AjuQMeJ!ECqKLTfoHlOX?9DstPDLc
zBUN03bBD<Yo3gtO+Iu9m99l8%nao5pH1^I4XZgUrmu9jz{UO=^@Aq5%WTv}KaNxZN
z&8gn+U{P2O`mvk7Q;MDoO&NNsNrt9E9qhZ~qA(Rq{Ko;C2VehjfQ8ra<R~;}^2cB>
zi!_6+qiy+MS?{AQEvn=CFw_+IN~5>c^yOe`&X871Q`p?nFnvNU2!;9Ck~A|lU$Vg^
zHD8i$=rCWBJU?IZ-s!`7XqsgEU_SOT5GSJ)1F<d35QxK4cjzgeZux<P5!#qoCyWUD
zI3lzkHSpPhhITCfbZI&|Oi8ulD*=87Fvbs!T<-abpdc>yOdAYY{-Xdy77Y#KlQM?_
zz;+rOwh!Yp4un1v@KJ#G?gd!lg`>3+r+pNlS*hr1)uHT`PR##{jiT^+C)2NYvcl_~
zj;BxQ>zy3GvcfD{zdg$HlfeA&QV1V`rMkFNcqvp!4)WDd_{$`IH)I{aZSLaKN~cS5
zJ}C=`uDS!&Eg3RWQ6kOcabn{QjxmBE!%R*>M%V{?hCH~;BU1b1NoTgTfZrvzwE*XD
zo--u(^EZ@I&+^kY8J22N#5lj9(Rl}9h)6m}XcdJJ!O@PN4jGyj$<<Rbplo&RlnQKp
zLJlBm#8$Zah<+^umN??(rtucO6-uq{LYv*x;-IAcCUs<=<lsO%6{I>ib!bCey=iDV
zvD!RVPaFhN8%GkX6gNBp2S{5xY5qt$RfoygRu?>5c9wKw%Sc%<tuiy+7q)P&lq@du
z*p8puS#g9fa?A6sl>E?+4K7gk!14z>tZM6>&9Q{1|G-Y-Fx|xB6h1Er51w69v!f1!
zCytqX8Cp{J5Qr`<F*~ym+XHN*g5<o`&w2fzD{^poluqUsE%@cD`ZYfqC{H<8Mabv=
z&8SN=PpxtMCwV4Z@+g!MJ-q%wv+7c|@4w1}0i{KVMAGa$#<vZ-w5hn9Rt5tyVOD5E
zvV4+~YP|Zq-=7ubga+R&551|b($aprLP|G#1!AWbNzpPkEW#3Y@UIq6MwJhu<5OgO
zry=$;*gHPlP$NKi<3dPUH4+TV0Ree%*!8^t)utRT<dPVCX}u}u15TaNHY)slcPm4e
zkN0HqZ}#-ygWhW}XoUw5KWss1bgpdAFuWllk<V{PARdbs`f)7Zk7NF0*QAPN&=oWA
z27+IIOHbGk&^ZLchl&7(MucKhABlnOqT20hj%K;twose*q3$6DXj)0ii+Y5-h+iQ1
zT2W0;7V=Zh<ful&r5D<{h5rZ)LTD(4E2iQ$Lnr3F?2;``H@u4fO`mz?{!c$p_Er41
z=ThP6&Hv5^%6|VA^9#1SM*_-8olBW3r!2<zVaJW4P#^TOeyhT)C{6zz{F+OUPzP71
z8<5`)GLx)L1u9v5=$5P<yemLs+<br58y795F=Sr7JOTkPR5R?cNgM||3ZY#fwWj~{
zElAoiYT5@Oewy6O5q&_?D3d`Y75|`WjWeO`TVFafKT(>rX^G4X9){eJpdL}qxt}p<
z#cdo&2ZZ|{y7Z9#ix<u5zwg|+{SR*)viFcdeHSk}@X*8i?t9>&{Rj0M+JDi3a~B_q
zx2}ZJfXylAELyfSjU)&bA2fHtqQ&$3EksqplG%qWoqtHbediz8Z*B-ag6aL1E6vhn
z^XAQ8fHVYKcEpnTOOeD64v@X*ASCh23<&Cz$en%2zDhiD&Y_DIFYCMLz-`Fxpe1t;
znrGF{J?MZXNf{Q;KiotRk!CN2M9Y*hxPiB(5mzH`<+qVl5FH2;iNxG){AXhP*cWRe
zy^A7ax<nd^<6Yv#`$i9lzqdR-FMix3(Jt}#CPw-c$G^E~)9{(`Zt>z+B>G}byegWv
zLo6EoVp)6#WSpNHe;Ckv%Vq$$Oo3MgxK@GZmh}VX*4#Tl^{Axpk@S6%epu2QB>jw}
zuaopEl3pk2cO`v+q(77NnUdZp>60aWY##Z)xok%K(8$8#=wUNnM54Yp{=p~lYa>lv
z4?UF4T^{{i{Fp=cj^7Ck|2M2ld{Dgl!ub0WBinR|k9r?+-W^|1{A8qekH=^3yG!qx
zdmS6yIetuZP<-U5XhFaD`u~TzcY%-MxYEUYy0F}SMpy!5$4O)i7&`_8b`oL`HZKPl
z0YVaDMj&Q|&<lhlYi1<Cwy-q<Kk~2y&gQWRgY6`1CkQ{1-NeXFoHxRGXM=DyyGd>U
zJIQ8agA;p`yX*gVs_W|-W(IHefA{Y1cS$_`)#<8Jr_MQb>Qr^lNL}OY-|Jl!{qXVR
z<0{;*uAQ%{o7GMI!o1)_LG<{iyl7e_237HXHL}Z_*`+R+uby)fi`34<;+|wuB@;_x
z-oUyC_lDPPj}PCTYMG^*t|&O<wQLCsR=q3K#RpY5u~U_aVt<r8ku3L;>)olvXOikI
z?u?L%&m4zurlRT+cUowi(r~^vGv%%;f)(9muw}73xyT!HubYG+y>O8?U%l6z8aksc
zIsCx4zx{=~*Q@V2{c2I<-7D+7+3M|H=~3?^PY>*Mmle5-i@dtzJzmksht+M~%ypks
zljf^S2Z#T<*PSupb}j3Pf*-1jj`(u-7n~Zd*gNY+b-{jjO3^FJufHdjRu}fG3y--s
zPSCYi;M4U63%mi0<=fp}saF>D%GP^(qwbXA_3m}Wb>5H{b{`BCdB^MA>x-jqd6Cys
z=U!LjmAf|;;nqzsRdF3^+y8clP(agwDEL454@|w*^=^HUTcNx9O{mDN5-;$MuXn4^
zZ+o#i)#n{ne-m;)8w$D8iZ_TjUe9{z#cSOlA~&PnN2T+r04wp|4N@cOJrmU|?$q*v
z++E}yjk;+J3YUjei8t&Wk9b4+|4Dpe{1LAu0-fQqUbCH11ZM6QG#+&)%tD_sYd%`&
zHM>(Ly3>oiX$L%f*AQ;jUod)9U3AR11wK`QJ9&b-=%6>MidLvC?#$5Ey<Rx#h3n3!
z3l6*2U+RtS_RjoM&yL=&xbuqDH23Dva9z1>o+vn;s(gIGJm_wuPTjU&jc<0Rm#9|n
zGSxFvP48C|BXB77AKMe^-wGmXN8+pM(#ZCVo<{_`@44KYy$(G7{v+rqtX}C$s9!tK
z<aPUD^SvG3{1;Ao<tefAXgWFKO*rbMl3_3EmCtr3AaXyZWBIE8*;xMOu|K{ej?f$g
zR~_H|V!Oo9|58|I+{ZW7xGbEtj+_<H&7z_gk&FdKNB3k$8#>O7?wL`)sk^&FRu=hI
z8-o55@3}>QqfTBJnzX=MpiOrKpQ>Q^c=?ueR0xl{Q%Y3#33b^K^>Aoru@^>2RR1_G
zQIf*HB%;=Rsr%F~?`%$bQMGk{@wZkURS)!emldzynH(5M_Gq4i1!+~e-<?+U_@VNh
zK4rgj6Df!$dv#fg<2-yBc-*)Gkz-s~J?wgii)T&q1I1v$^UEGT3m1o{$^Xl*DNbHf
zykwQ;GFUKrpgfj=)di8_4ftRA)y0*?$*YU^$Oq<de>kc>uq*PyKy>(_SEIv^xZTAE
zQYySZjIuX5I=mf(lsb0%Oz#h8qDOb&zn&M=N6+&PRz=mn+#Y%Gqn}#|QYy9Ho4UZ8
zu`2q!+f!7bKD8^c_u1V>lE>3txi`fWhEuy!Np-X@@wJps(Vx$+mpWIE+^4o-O^B#d
zp@jF4zH_7?`3O3Nf|KRRWU}Xw>X@mDyqSm<2fb^O!%}JeXYuJiFCRZy`OH}KyS*xM
z@PId>zJ6!KqZGrbkvDvONJvn!6v4RinNmM>y_tvhv>Y1pCY(w>?@lgGBBngnomk*b
zo8T{q-kr(%0jwmik6WRzO!V}$?riBv9!eepgHXX>f#&{?D{sGP(MX2BOfDI#crjg3
z@vJ*}qBkWOE}sp)pWETy5PHbHq459ozZcybE_1J&h)?xR$Ln{eOn7PC!`^`U`&~!e
z8^*i0Op?#WqK8po^bx5$6_i30$EV~2>qc1-=;OUn_b~+d$x<kE-z^Qs>-y#3J-!bA
zLDKOU{K@l=coTXt{uM1)y}X(3)QPXE54rs-kC#_KX`l6e^Md-<I|qAqtNY!4_4=JN
z)sLLW_Vn|u$dF183_acEP4VVDzsK9Xd|yvb_|@$%S9R}x{u%XG-U@ZCx5E99J3%U{
z&gRzMr(@m>bpfJmaT4)x*7IqE!2$J5pV#bdP?sbQc~_}RBF_wjlN-Dqd~Q^!UHJJu
zb#QxP1Z(U)>T|my5cvD>lP5xl)hBkj^Fr!D&zlc#|K-kzH-TO;+SBsPF#fvQi3;D4
z+AGA9l(?rlGc@4SVc;J8`L>zjLCTYGU@8dOg%1}_@crT4BYSo~?w*fey$sRBb>4~3
zoWz@Hs*aYKDXT=HgSEGy4I<GMp^0mwUv}{$4xxPr`L6Ras5!j;FDCJub|ji~I-Miu
zIl}tcDSBInNw68r1AaP4gGWX_A7tQX=kubFA5bAvLMKxv;RdsYPeR|JA+`Mof|}|*
zs4kqJPI|3~R;pK$?)_13D3x|^FAA4?vs%2BNZqQB9DSh9Yw^m{s&)REXW%JUiGL*e
zuiL1$9Xylt>V{<|yOQj?o|xYCuHU0(9}K5bWkV@%Oehj8+*byYLqjQT;>)qYbe)<1
zv+J?LWzb)1GdEh9u5=C)iPryOyPR#$b8NXN4viXEGIO<!C%W4@TISgGwyW+IadHPa
zf9U24y}A}e_7_CepWM<@ch`*#|MHVD80pt{44%CQgU#+%r7~CDf(SlC1w-=rv^P+`
z%qJFXN1Qm^7jduFEio&#IYR~Be4<2wr<aX_L1_{}${il^3Hu9rzP++yK=mLgyQCii
ze75i4e__`bQg<n@)SWponfzi?Q@fV08LN!?=^gIXA;|u>sy`gA7)~X<;gxb%C#uWq
z_L`*-0(!-M@+x9y;xTtdk!oD=qb4=Ac?e5o(ed=?P+0Bo66(Sud!u6&-eld~;Nb!!
z!KnkI-Yh?L#qd&QbSnTKFIQjO6;a=IPTze%dUB<xucMA^K|%$`Pzy^47(egKm#B*g
z7xwm?@m8LJPF1@sy(e@{?=s=-b`@bCP=q;mcf~03X?^Q3?r6{q;FS+)D;*b#x6FGS
z5xv%{YEid({nc-bs`4Z1*<D`09>fD5iw;*HxPRU0M@IdO`rsYjiczv^ecyep6V%d!
zXGTw!CsQf!s^jVguT(G41qad5$u^6VUOLt4>7Am!r=<~PB*UqmjB2S=i=N%Gh#Q$j
z13~q0kMA17KRuG_F)UA@I9!qco>bNCk4PKus*zN0*h_m0PQ3{yH8n9BRoe%>G4Et~
z$AZ0e;q<F&)d|B$cMhwk>x6F<Dou~VFy&=f!~OlE`g31%T`Hw*uKGiR9)|S^b=R(A
z>a^3W#(T}`tp`u0Qg7Vz;|;1L;pzQIfmlg9K^kmbtns_ORPUHK;$a)&ojT<u0r9_4
zl*+}7-oT4qkvHm{aic{@3y*qN0lpLG9{%N3!R6ip93yy>Q4xIHM%2>$WTSe@->qI(
zjN1pWr*k(Hx!a5XAm~Q$m6Meg6udU?d6dux4)A9eyEBC>ANb$1UJs-jK?1FLc?)nB
za{wYOz<=fL4@1T7S3}Z!9-3@nM^Nb_x`KFyD+`G`Dj%Ng(|zbJzx2}zKSDYaM>?aa
zu`|QcG4A>v5=|Xg>Am`@)D|PV>L<6)m+R2j(J}A1dSqPx9=$j$!q4QmPSyYL;?UgL
zy|rOeds8f)XlUGuc#D6{-3{BCV(kq(@MD-h1^czeWTMGGj^pxt)?VvPmXEyWalxXJ
zxdxrR;GeZnoV_^M12})7fRrjYH`HU$r+jT4zW92>cK0nZHb+eh6^*EyON&NeijiHV
zMPY>5i%b1^AI#`}I68J6tuuYP1SM@ytOVMK1qmrid=yjK(nha*xV*ePg=3%-UU{^<
z<!0S1Qm`PUI)&2WJ4Sy&Il6yp*NHRwJ{b8^T>`)v2vmB)3IsVO%nV0UQPnncq)xkG
zf$a7|Mi}4C!pG~tu_`f?IwP#y0#8S0F!U2r#Gl;<!e^pkuV~}w2hhb&5HP36!Q-J_
zhxe#Re;!FjaLVul45TiK6-W!JBRCpQIEY)@+$pj~6-R(O`n_imt1(^tc)p(+lL%Vg
zl0rX`6MkIQq2%sXVd(mCWcv6$DKNVApbj%;p@z<f%cJSK@aS05D+-4f_>5)HEz$A;
z%)nD>HI5MH93D=UC&QYZ&br(i$3J)+E033yi5e<^1dn@r$Bk1<y%Q_cw;Xp?Xs^EE
z&b$nNxVXq&U4-a>aNsY9KDAhm{45pGM4Gto93RCVNKQBrxhA^@LK8Hepi1^bMiAY1
z7OQ6W+xTVaQDHrGd~^uMrTej4VriE983dgtO-o^f10HOS<dpUIeJ4`>FoPvQ^oLU?
zUo)aQ*PTE93HOE~tnbmiDLIWCN<LVQkLkY4xYJ~nJqg>^VJ#UObIXfG%lI43lW}7}
zT{3u;ch%Tf*;S+Xh?ePL%`OziT6>?=S;!}Bc~yGdN>okPsqy`pJ;;G5{y$F+MAv&8
zbQiJ^jvmm^D=qN$s7WiL<*gNGyxnexpIy1LL^}8HLzBF#+*^vgv^%#*b-HsyYGOZD
zhpVL6BE`4&t4(fsNWEizy}PK$|G$d5TSMx4RP@XE`l=pSnefbj?x%4+cv4jepPTxl
zSp1%H$3jIL1dVyqV4CUZ9{(HiEvD)2mLhjn5%!Nln_1%baYvC`2XZlto>cGO<(*Kk
zIsNJaw=6WY0qF#)rUu;dN$y=RCk}Y0xbM9LqTzaDaZ{_iv1kaHNz&~IVFwBa&>}V$
zhzDVznpu>>-dSkwya`C5O5Ddop|Mk=D&4nVy%-uykEX-*LmR+v)SWR=w}tcXMz3W>
zkbOihjjLc@x9sxFyS}#22ks}cD-O9e6L1VA^?j8+4e06^;kx)spC~N5XLQ48T77s|
z#4Vd3_Hpkl8a*IF$Hw=lZ}y2+oBGvA=!AO1ao-#A+EOP^o^q>;y_Qj&k0IUAd7I7)
zrFb?-r^P>fUvtaGKRz;?ZhdCldFmr~c+Jr;bo$0_#L&9r@NJct5I<8#hCJwLy*^Ja
zKNUvJ^d0WCIGk4})P9s6xFc~Ag;&%;yu1+#MX(OI&iVhtt0-3+y~X;ktdHkj{WA7a
zXDx*1*an*;O}+MIu9dR%UH?V1^gSF3jkqfj>QqZ&1Q8Mk_8FhWZeOu?RIN*lV1hIh
zsp+~7e&u#?v8qX&l!!Wv8IMT*g<Y5c2-x4nS#%hI^Q26f6r$SI#VEb#-XALVo>z<a
zpG0XCKP@Lt;2kWGT6n<VKIg~2$;E1OP8CFyJ2PukA+ACkBz#l+=_7m)O7U1jvvqIO
zG5qAP+g6-*UkQ!Z)cFPO)+;da-Wk%x6$R=Nw*}E#qOI!m_N$_Z`+Z1(QW8VK-A{!=
zDts6Mqo1=So?V3BJ}oP@y+K3<GwD1}vDp2VW{x8+^;KuTs2ZyK1ctszf;}Fifty+T
znlyI*N?*LUQT*mfNO&RM51jo;_a1kmO7<t+y`c%JC+oVsKaBmGdT+!#-G+Jacpn}|
zVIGaX@)13SLh2i#Bl`HGK(ZCo_;Q~+M~wGO=$N`-Q1!TzMM<u@Snuk*SJs0asy)_s
z!b=W+;v{O0g$}xxVQyWnGt^g+MCCtKI_v2#{CC!W$8%yi+Sk)6IEldA4zf+0#`7rv
zCO+qkU&B9tK#jAHh&X{zi8D2rFn&Y-L_%XZg+LAoEEDPFpO}esS*U1tQF2uM!71%k
z7nBy2tIJFAfcKG*z$v9gQFS%S*wUo$OFe}(cc*?>7ZW|p3BA7&ka^)sz;yLiLKjtU
z0uMCtbjWLYY{NI|(_Zg_bW5_OC$&<gLMMvKrxhW!yrc9CT7?P{1w;O-C)w)pXVl*-
zlTL~ym1L+c650XpfjTu9I&t*d(OK!cbi?@t_3F2MN5V-Qi6Y5Km5)Y~(emL6RqLJb
zqJF05PL*uIE5pLn-H%_NJE=Z%yXR*?pA#l{z@1iKQ>C6bt~@(48LY?>9SwWm+@L-l
zI+1?ym4Emvb$LJ1!m(&mo%+_DC&ELifwC|jTd5y}B6~#00-dR1Z5#03vCpVMJEOWt
z@?2kAI=^#gUHVk{tLyY}j+_v<pIezyZ`^sfd^ov4T{9CYQR<NDJ&cTG$$Bq5vTsOE
zPG)&m4Gnn3>fi6gnF<d0lBj#vu9?MkMUj0i@=x_PtBY3PD6qdpT^N~G?u|?i{?mig
z*7Nk!9sI^5bXzb>T~xa20FDg2WL*mJNL?{_%kX5A9$lmJtUaNFI7VKfUUCws6i%zM
zh;KHW4;84Vaem>ArV%}&=_n2_PJ7`q>T@`GKHcY?#^K~u>VZ%*mhVGhBr=7O49=-B
z9Abvk-Vi!2FWM`oO*a*_9tS6{qCQopcFY{TPrZuW=t}RZ7Bw$YG<1#0jYKXVBB{LR
z>GFz^4{cDLgPFX+MNN*_`q5~`0dGj%HkiWRR>cQXk|XMrx@Q3ADJNCYU>I#iqWGWs
z!HyMU2%qZ7g8k~Aosl7ZisT=HB5~e5pk7mn;a5k8qTY`*m-z)>eN{~uJo&uD$Mo>n
z8RTE;Z|@w$lg=01{b98e4^(~q7a%`gF`V}5QpVlnAVU4CbHq=UT|Kf93AgcnKk4^L
zy0s70le><jU-f#ua`n+&k<lo81Zm%xI_0?6ht$sbFJm<ulx#Y!x{e_P`c1Pk%K`Ps
zuG2Uv^P+V~%A--W0-FgrSCE5(B5&5wQFl(!8LY3{aT<2f2@K>qZ_t~CY!ByRqmt)8
z@2tSv16a;*GBzH8*gscs*^i6%=-G9TnUzfPW%pf^Wa)xtS0AyaVaBV+?zKj-_#TD)
zqJ*(K2Zu(n?U22J>fE2HBphd;LZUyH_L;tZb7~>dsE>(*o_uu}&W5=&hOGCoUGrzT
z*NyKTJL65lvc4ecHjVdgj*4l+qp9H(y!aRfiL?UiQM*^_?`VDP<1xM#uUK`QC62aP
zN&kSX=X<ksfgQ_@mx(g4k<dE%Y-s#iF$>-`kfmD`@=)KAlxTBu@m`GgI-MoXcu0Mz
zz{9dQwM6ZVY}mf>s2eF-HxR}7KC<Brc*3ue5%u`aW8Uz(0e8uyU%4L(jrVq_o%<hF
z-#IU${`QW@85~flM_up4tLyOKXmoV1`$(ur?O35M@Dg9|Q3sJ`CTFVg36bKR#cm-M
z#BX8!ah)^gTpa(q*2B!l>#~Bybmn*V$xN_3V%_5Mh;@+5BP2z;&56zi|9B)|!XtS;
zX9?Ctv;a?kUG!Vyk-2?yO4i0(oP`)W&R0H+7skSM{=@730^eWlwY6MrpSiOh`NsXb
zN>?Dc*ohgGg2&(-6M^t$97L8>i;?wNJJQD2q);8!*4?1)?=uG@a=sA8GaOx2)*Oi)
z$DElaKHzp52cp4UuSgwrPNbg1p(IjLA$#8m%cJ>A_j~VHk9|%OJ2fH8@)KHD=e~P<
zZ&EcU)TN0ZtHNXIqkYY()EFXNY7D_SJk&ar@r1{nF@9iZXh?n5P3W+p7p=R&$PME$
zLwRzgr%ze;3F~iSQyf06>W{g1Oj1`h<Mi`@T89)&O=({9T{X~m!d)RRjJdZ=<Y%$G
zLWW%_ruHlliw|Mb=x)_}Rcy_wi|=;#go?xNtSkIi&E(egc->_Z!psd54+xjJ#TnI#
zrMP7RBHx!nc%#L8M!neQMJjqeurQU{oAOrn-Shr?)y~2D)Q-XXalEW9=vTdic(#Fu
zWdjRd#mhUx-qp!@afLTmE{XhBt?i$uW(~S)iqwlvBJJ%RIr)q#J}hIG<MBx%_+meI
zhLHx$5sSbfcPaL@i;G&^r4wWZUst3)vdf(w`n-Cy@8FY99rEfve+aK@J>|vJ1qXNE
zKY(q&dQ1QAd%a%uX9S}icy9OCyZY7df#2TjO;JTByb5nY8gIfNqdAFCi%<lWEiH1R
zvMG5%-rQO{5yV@HWdn-ff^!l%GDf`GHUTgCoWe@$o`;$ITg)2Qc>%thKh6EWH<OWV
zCW2%)c)gKXYQ{`v4vV??CX@QCIhr|_WxgJ`+@G&kq@wPUVy_Gy9o|^9{FztQtL@G5
zf*+Qui1#Xv7rfnP>g0b2c3Z#bt$HP$a<86rMjhCN?UkHk;4o}`vAhE@fb}(e+{1Ct
z%8dVCgTtYeSNG6e<qvpU)Z0(vym7vIk9SZ_@lJs0rXuhjIU^>)3zDV!dU^AYqscR`
z{z3I3?glBqMcBe6&zw55o^8CV-I?RJJ{m<`ulSGdZAE8P!o4ko<C)pIk>quky6=`o
ze}M4b<es#<q$u5bJblt#ScDA9mDgK8kGG6n2Y;FJzsuY<x;9EcJS)^@M&=-*npcX-
zrkV))5WaL!H!yE@s(gX}|B9yX-cVdtx2`UVQ_$9E-Mrc1@&!@-|Mklj&U)JhY|&;;
zT8uX&>dvG#sGmDCC*mQWx@^VpRJ?m}B0Rb$c?hqqX}8xe4;2VjBl_^Kz^5Ql_P2?C
zf*bbMw;-t<QvV+EjuhkX1HwKddPRTVQ_02+YVWvGJh&Muzd>E>&0n-`FB19+^wp2Q
zfG3kno^XT;bfDGS3EfhEs0qzF_fTskpAM-Rg9sEY^MEB{)U7<ZZ{9k&u~9zsQ$Wi=
z2WK$wU$T=38`^tz>+o;9g??&-<Kx!Ua8!Lae&Thhh-2W9XAtDe7aUh_j5~qkYi8(s
zXFfl)Zy1SN@}ceC&7<3s?^QQMHV%Jfz}u!CEyOFJQ$D$2-i&!qBxhC3c{cfNuyM=1
z<qM(}D!mm;!?A(#o5RtHG3n6NG2U(38%{-c*WT>a>po}dPyMJUq=(TOMdBbtJjWjN
z_dTL-JX0Q8pdQ#YcyqeENBuf9Q(fZCjD|<?UMpT$*wNfmUcO~G91i2Tv$o=TVd1YT
zS|@t7trg-;^06>Flx|dOWDgZmKXy*1m+!4mXKp`O6uqnRp`rEaie{X6U@ugmmn35>
zZ5=Hn;w<JAvfT9Wf<LO4Lf(njlHNeiUZl<!4yqmVqh8VQf(qy|zVRzw`-XCvysqAk
z&1)SN`TWA?RL2Tc+#fyAqRptEMEZ;DA^aUk5v}l;Tt=eFL+U$sc%>8En~T+TgM0TT
zcYPtbR@5D8QQHq<4OTzCB%!Xx`&&^zN5lfs`tkd`232%eZJntm`L1;75pVde`T_6h
zbW6)v%cCL)j-4U}_aX~kbsDDiy)06oRvp9x?ZZQ7M)h`PNWU527HB)pEAWmL)Qxzv
zp13=P2RQ0K`XbnRA6Ea~Hy_s(EvaaYH+7`<OUV|MIE?qTRrh`s_XgG9;UW1ueT~m(
zR-MPN!xMtKx?j~ta0=8s_QHVo$>DjsTRpuVjzqn9ohqEKx|)aZ3THa*i+i}B?v_n|
z`kAWlS5uD-?;dk!<7jwDp2!c^;{o!M^{Mat+uoCB>fNg+eE#vIx+vkD-0&-$>3hr7
zrTyN54R~*$s2*>ps<#}(j2<0QBX=HDzraz?fxbapCDRb}`}6VU@~NHJRAG%B8O6VU
z!_GMTCGWvuES3-L9{z(jAvFsOhWBZQ8!k9f5XJ4Q#V9&rgbH-HnD=;e?{M^}w^Chl
zOpV=v=P|jRWp(?^?Sms~eB|ivC!#F}#vTxk$(94<@4UsED0r{2hCT>*!@RU{N`3MU
z|4873f3V@rz<Jgq>i*7yc-VS;wET`1b=M_>>aO?+JoNTbdmd2R_pAO(`qjO0Z@%|Q
zb^m$ZY4y{Kuo=UnXDn_PdZ&jE;ruHZpB0W*q*Al+Ed3x}1jGFFW~T2}m%yt1>K*;%
zWo4@Nu$r+VJZn~~oTi6I4<OcI3WV_z&{f{7k>qi$lOqLTBqRHu&;_JEy$Fnw2!;xp
z3qFl4;M9o&*aN0}e|5%t=Y4py`74JGt;Z{gi8MBjPhvuC^omEGbZ1<V^k#dP*ST{q
zcW;_BGCUl6QH|af@$hVaJl;jabCj|PYX7C)OuWi~7ntx`$1u{cpS&>UJ?QVuPZy{r
zc;m%h<R|JK$6gvqjiA@7P_=A$c)hP+oX3xxNv8dM^63I3b~v%owd%d1*YPUqjb3Sw
zSN!pf6)h%TLpH55*aCT|v)h|CIy^kAe$W$nbwFKs@a{WfpYry;G^DOL=*?0~S0J+W
zC%q|HZ}8?-#pcSU^*HMp8}_C`+T?4)>K6`Pf=2Q%J0vio9^SRWOa9SIs@~IBK#pL~
z{1f~wTD*@Zz6uyo!>BRqC8==?Z)3Z2CJd{$9XUDV6-N&tV&G%$ByTtw^{)1AKA_(3
zogR@lvqJC>Rp_mF2yX}urgVNGZ}h0)?NHBZ?7Y?Y&Uf(_KJm}J`ck<(p}x{{3?o~w
zUU$4Bqv%6zIxSuC@(*yKX<li?D-}_7O+=m~P7AdRBp=`Y`XQ_#$GxA84Z}*uyayp!
zQeEjaw?A@xo!L{bC>VtqTFQ6h$(;_e1^Wv|!g%K*9QG#fp3$_rrLJvW{E_g`0EU>1
z$|2xI5$|pA)A_r-t-JrQOl@gS$*SP}^UAu<dpB%pIoY_OqTG+CWf*HTT>ix!YH#0Z
z_480arWay{YTK_$BA}~nC)DLSHsQ?BOF!N+h78}kAFpAwRE!~Qe&h+fHG$<4Q)yQ8
zTTi&xOiYjAXsY;t`nx*^)pzk~=Fa{D2lj?l&x-Ka5Txi=2k(R${}@WBUpn*e!gI!>
zIMq31yk!3V0@aIb{q)9d+7O2e@OIHP82<D$zWU%#ii5DlJT=j4{^y6yB=No*Z3$y@
z=$FA`k^1=^{dm9Yu)3&UC0B$;yy-*g8mwErXyM{rl#irlsf0IwoqEgQ&`>y~wysc<
zBFP@OvP`GR-c?C&;pbBEd%fa^5y&s<_ljC)g~u>^lU_MClsM|w0Y~2Uxk?L>D8Tz$
zc-K~a$3b}fAik=Amj*x6cSQYD$SX~?98gVz>dNLY#!@sU2ROgE9WSDOd>owiVK{&e
zlqNQsb<VwZ(nGH$U)0QT=2q-pTX>HduDYZ-dFGG0fbXdM@#HCQQfu<m@UMptc}bky
z6wBG4`WvhvzjlroAA)!vxc#8|)3`_-CPUj{Jc~P_ein*&v&iSQXgGYG<~hIMdpixl
zJLQMfA3~AQ)X1><^qnWvuigIP^3fC?x$Rfi_N%7TDX#?2HIJwxp<{=3;Z2q!aPt-F
z(!(A$yTat8rxOl&lHM}Zf-|_~FH{T<?bb_vfp@sz=xF*>ODCQgu1lzy-r(LO4tH1L
z$^0N1`v=}}wbEZ3=jb=VZuU0#+QK(`qys$NkjoPJcug&qf~ywjOI$6EsGCo#)`%DW
zn+==P+Yav05BhG=yR`59_oeNB(f8Dl%yU<zll#nkK4X7&_NFYEXr3EO$XhmX{iU`y
zJ7&>GDdvy+PAYoPJgUXC9d2pGcgVu842`uQWl)zLRy$9~(}K$)WmvsLadB_ux7N27
zrPHU%e0T20Haj|kS73`$C$U31dFIS1sfVvq;i29*Y<J`@CA!X4`23&U>H5b`+ZynG
z&YNj5|1MXkd?WQu9-n5u=X%x_Ea$W<IM(7@PTD?aKQt1v@bB)a>qGMOyfz$M>BQDg
z;|p}Y;-@Q^67ohU5|I)7hyQ(Q_@760{#)STomF=czKb-qcoxoP#2%k;-!&0O6#^w`
zxzL>-!np(<7-GwMv!-s9rLe@Ce-wLldC0wE2mbPAvZ>42+!^cWOyJ$E?zXPjZOP6=
zQ=DI=jNzM^c!{g2qb1SmtgehLTUZ@iw0zZ)<*VN3#M^c@iMQIiosA8NCRVGCu3WUb
z!r8Gy>N)rtCOYZt(x9^|wh8ZjZH?h{q9fMb)QDHpHK!G|u`syDRxetyba4&Z>SIYK
zwtRIg-q6z&lRy3_oZ31zH*Lr5SX&%8(bV10m}u*10!9Af+m0RGO`DUAO-}XFnkCC?
zor={9mxMKw-tM+UQ*2X1yvezBbyZj@tX#foZ8e%m|FI;P&E)_VRjghd){Sc&3btx(
zMTHX+*`-N$Lr1(_h8$hKv|@?u(VM%QM2e24UU>^G?!0f++S0|P_)_c4*>)7Ve^lOz
zVK^1bYnE0mtZ>>o;t90e+ypZu8wECPZ*54%6HS}j8#Xzy##T7Gvv^@eMQqX9<rOu{
zSH)(>W>cMwozi^ylBKI^M2v>+?uH#`lkAQ)cD5(Cb?ADVI$=a8t+6#GfA$ac{P*5s
z+7EQ+%}}JXV(rRGoYXdSC&c>BmfK=z6mM+ki1~vO3v6y{OmsE0b<16CBzVfE?uPCi
z(m{tv+Z}hJQOJ7htxKz7)in!imTC=bYv|tE)Qwt=txb(v+uOEj(c;NXP20PiSj<0Q
ziZwU1wfkf1ra5XCRxMw+sA6fXV(F^))hvrGta@L?^6DDR^w#ASOTjYHxwWYSOe*oG
zT5F=QTi32yT(f-js#wfPcEsCSI+`|@ieRW2?`{liT3u5m?!03M-eTO=Aev8f;MK)$
zT`xWxWid*i>4x@pXX(Pl%g_(Lu-pjcVd&a+@f{tBhV3!5?Ch2|Arr~CbR~-On<u+A
zi?@IlZ_uAz&Zf@IqB8A$+WGXX)PvG9M8s)_eQ?=?S1XfU)@+z}9WAB$BN!f7I5o?b
zt`hEvZf9Y2_44<v(xOAL(12##-PEu-)`i<^*7#!=^HkM1&0Vq1=H_@)LXPRh*(z37
zudP}dt6W&MaHVj>L@qN|xU+A`xCqqP*#&o_DzHkmSl-K5!NDs{7dv)r=Nt}#K(b>~
zXA(0(ME2Fwu&EQi2e03;qoJ{}smox@?JkfIjcAN`+qSNDQD|&aT!*TTPKaUNqlq=^
z>F&!X^|t$885BZyQ*$F!Wg^;Q@f0W4+}_X<p95}PG7H4ZF|9URmFanlCd;d1dLC9*
zFI~H2wXSGf2g`ag-n4m+vuNSsa7`6H0xw&&cIBd_RbUSHz|h34dg3uSQ)eR}?LYh7
zD9B*Uv=yCnHHvaO+c(oXnn$O&r_AG+j;}s$Zpv`Hc8TKj5OECM&iExFS1+caABG#c
zy2L6On(Im?8qW?kHz3$-?o1;6&<gP*skB1R4T;#MPBULKL%XwlRrOLhR!iVmj26C2
z`mGVeI}xZb6o{{x%c!)n#RgDNL!zy-!|9M{6gML4KpR8o*$hvV%N+l5gMYcvzr4$d
z#U<21M*J{9JNwW9+IP0jo~G{R_Rd~}%ohCDq~~Q*!oR5_pZJaM8er260h-&oG2LU^
z@Rfg1I$%$k=6d~txoFd+71c{)%Wn-P(c-G52!XN1nn@zr-2s4J8n+trb&E%I&!I~$
zs#>@TF~&IPTJ4}%ttu<9ST%1$Y;K7|yGxcv^cuFdqDDvU*sadO%F3mymT-dfG<3r!
zIlnN0jK^_gSb-5II&}z=;HgJZy>4M8gz@7T*0`1?^VKn@yQ#%rh_$9P6L4s6l10@w
zA0`h1OH5o9K@YZ*A7lVC9qnbv88K3dqB?&H=$W9GmZoMHdNUk6kg~0#EfH(ljs;hS
zyJYFD%U3O3vbxIn!X{ZqB}echr0+Vhcq@X47~h}B?d?sN)JC9KOH)F}3-rEyQ&USu
zu=DNYZ1ZQP9>}|I#87l<A?y%6IyY?*W{{lL4kD@O9?l?XdSLphrMCuQpr&fAzYc<x
zPG_2v9gVWwpcS&AhGe@IQhR*d2GN?O5xuatbzm)M+pOi6R0n|?W^(jcOJ$BjI?N|s
z2^@RkLC4Ei)h?`9F2Z%SbS66KSzJ{?M<#`7FB1h*yhjhgMjXz<E@xJ2=eDL<$V<9f
zn>uE7b$5y`;<L8g1{RG7<OwYM)iu$|r6{-Sb*?=wVY>&|4>wynp>H7w8H3jH=!hyA
z&9<g(67XbpbjEG)HKE3LGrhX%{H}62I>MmEpgNxlEMe9iF-UdI>Z+x+n8g?xRtWJ%
zWC0RRwl#E76N^``!ZL{b$yerCODfciZ!w(xlOl}d8R1Y|U&jcsqPQJA6DcqJ!B`m6
z*65(M0a34`9T8k|Ssg)iFz>>cF`SMhvJ99+f&-jy?W*vq)$3NpkdZEwjK)D8(GZw+
zVO13#SC|Pa%cjI0r>D6~o&+`{OlZr;7B9m(z8H&f(D2rUQn9@O;S7D6WDwECpLj?F
zxTeAw$YK!coQ~wSO;}_Sorr%(xY5kd{zTBtemgz4{FKF?ih3FgRdlEe!dm-4Ocp<|
z>eic#0Lx13Ac^MM)`nez)7ajGu%pv5<d<75CzBuHyC(5O%ug8b!kzJvpmRTbptr1Q
zjaucB<7&aN)zLlsj%G)+xoK0f#X&}m;4fLqCZ7O)@L+s9QnGC9a2&)?s43_*SjVx1
zG;K#+aKTtGHJ~BUUBfmhz!f_>H9giUE4@imV~Oq^G3+^T#e$9Sn~<rE@Cr4cJ}0FU
z#{!D|&JOvm4Y<H63>3X>iPo4z3N4Wz)HL)Hdf(=vcRi|@S;h2p>VU><Sl6Vk?xvo$
z&Sc!^7R?%cuLXyeWFih%4My&d$&nE>ZEurk8QazbuWgGrBoaFuto2Bf9jz6(>Fjsw
z7%Pi_R)e;d3`Gpn)Dcg@L+sqw+b<-biAH}z;|sxPg>8rUx*1is>};{lTFDY%j+_2w
z24YFJr~A<!4+*4YGiF%3pUY=4f)Ts0k<u;1rm{F$<|d)j)L2V<=cWeaVY)8Ng}mDi
z0#2mqNIG;Qv7IFC#y6~PZkR*8b|vF_@5Ve&OfIA27<E?P(v5URXBC*NGE<pk#x`O1
zpf_`RJ<axTOh^PU+3Qhkz%HcezQd!?D6ve|mo4yGJv~jro-r!y>JvKV#kBtfZSA;e
z3emQi9ya=zqXwfGJv8YPM+EppUa(oLCE1{^AuRlP-Gl&z-)}PGi^J`)%f;BuAko<8
zrJKp1tUR=XPANAhw{6=Yu>jsIUHaj~_U6xe@omIt35BR6GHa*R-s{h4oT+3AYPQeJ
zkz&{-bW7lnL`N?mh&_6U+L_R=6%PvC)}RkNI<(uyv=jJxh5H3Ran-3~g2*gE3SlU)
zoA|pQ6-<ctgEhw6pwsuwNGRB!uei>RSW_ob9dQ=Xu>@}8OuCW25o-jtnIB@bc&~q}
zx!roI115T|$vKkN={89dFkAf@+_X8SXQVlXlfxi+DGcg~H{wJ}tR2Vkh|XzZx%V9G
ztYWJx7q4Ejv|3Irpf7l`4@B;>T5M`^;y5Fc5A0a{<5Z_nCP)`6(gX2sTXI_$b{*J%
zU<%_m$vPzpVFO}*puj)u2}+$^IEE5od0Zxgkc<GqYm;Po{y>B&+#Y)ejW#13;#a}8
zZED|fmQX%(eXP^a0atAH(`s&QWq&3)j2u|$(1{tO4}By|JB{p4$AgZb829@OBn^gw
z15`;vkh=wSv7||6-(m8VM8no5eMS`%e~|qL`jM}FI(`C!%-SCA$*#lSb6~;HKjkJ1
zha+VFTcK^6xBJZWoZ~lB8fD>XhO*I9bF5h(3i!esArN`uSlN-E`iZ1z=s+5M1S6v8
zO+2?hzL{ZJpBgC1Y<Okw)`{E;Rz=2!rB!w=aN^B4X3_HFz{_kOIyU2Us{_l;7I6xQ
zhZ9p@LbRBzJzEk!1Qw$kcyAkyA^jy@{1>^2mYTn$uo+x%)Q4O<7N4UTfNKL*dXNk&
zf0Vu^4VDN9e<CMvg?sqiby}@?_&U_$=|SnVJQkQ1SvBT6e!tG2vW*y!-Xn?npkAj#
z?=IV#eKrX>iZhd_yD2zQ(Q;xx4kj&-z6ZZM5KIM=#QF|t<`Z2RD+-PZ5Ya^2IP>d<
z^>A3J<=iBZ3xi2Wl5>_i<&;(KK#5p)9GOua+WlmsC4mmJzPY<|TTDEwt0B>fc$Rw~
zXR~@yf@32QfkblBr2__9$$F-}GrOIfJezMbV?u1pxvfK{&q(Ax`@7JwuBN7~dMVUm
ziKyL}IQqNMjMLPcxWCD-!3b`^M+uEtOmz{gwg&rIy=-7x+9UCo(*o>dOBB<a4;cmC
zz1@af1v@N1d5?EWRLznGNoK?5%{q{4u36)0+J>Wgr+I6v6{`mpF$d|YgbAq6m>rQo
z&MCJxHFd>Wu+>A>Eb$0Y8Bxo0rqdJb9a|*-m4w&VyjV`O;BT;FIIQpXbtn5BJzxw^
zOla6h#*Xz?0+$|NOhUQu4#+e0c>pqJ?HjVi_Ujm4Aj1u}HpNU}&(g7<)^#^^wKp_2
zZId3d6oKSIoXtubL|$1gWvKC;ei|l@h99`}PqDPaLF+hz)T|vjw9rC|rn35wrQVU)
z=^M`Wg&-`JPGCp0xw98jK|7SJ5u!r>VBxIq<fA+6r@Qrz%_J`1h6#lqq!in2!4h+J
z14)v4<<LyWXwB9a2OY@3#d|TC^>)>)&RSF<*+F)8Cgk~2Fvy%<Fg^U~oTW`|d+4bR
zyUHFpY-?+V+xf%9N@G=_D{gJt;mG8a&U42h9wr0OUgz_W$&<yypL70gGc_~Z%nxx$
z2ILUI*U8!K;c$A_?laI?gAQuwNfKhyZBu)*Hjzvj)0LlB$N^-w=ujh)Q*j?W`;qvU
zknrQ{!1oNqO0!4d42k(MDyVdB)%z3Jx1;Z0qPZ^2Sojvx330S6h5AQ%W&yz@Lx^#<
zm~|WN^m%~O$or1WeeEPow<Qs5tkTTF05=Zm+M9U(f@4QUM#)e0dIjso5S_3R_&*Vg
z20D%M6I<NuLgML|%E)SR7@&&Y<7z24qqGexe_I!_uOMgAsl*ol2nMw~4R3ViBgEGZ
z97&^XFd}~m3+S8MdfJfSNn<<LHp#lT#b4jS9rFSM5v$9Xwjn-1NijdVZt1~+xjtjW
z;cXmwo~&EF@piP4TSkm-oL(V9%Si_wSm>E;?)d4A)YJ71D?f9$M+0&MrB4QIZ{1BG
zwmR~$DcQIc=ir)wKRkcwmzg2Xn<0n}5PFlz)K`2EA=7Wo;DBeS`td2|YL;YrUl$C|
z@6F$|N`9-izvyx{9^Z7#aeCq%=3q-i@E_!0uOP`|pf#O#%kdFa=JV7V(2V0dGpqX}
zlLWvYwH%P?gW3$1{%%(INj+bs8OotETl4q>uwG+~B8f?c;KsfZ<O0KLw~C1ousMXP
zHsPi|elbt2P%<X<&)zfJiY;Oi9s_RLqWZzMoFZ7d$$^DpxM5(rf+>o71`0GZdVIj$
z5{xA<Go9|vMEebM9Aww@FJJ$*vSFt^$GEnR|AMs)egm;%hJZ%NvLNc64b0>pVd`)9
z%5zr#u~e5F1j>Q2n94NrFVt!V(@aM<^GCXsV`wDC(6uj0yuD4&F^)V#N<9kE)SL`q
zb>F(FBTx8acx17>dfCz?8C9_Tjc;{~DzY`L=Y(-bk=B<&OeBM%&~0)wU}f|VVXZ~=
zf|oJY41dY6fN$jvy{E|3zCUEV^06#dy%ds5p2m)asnM3mlu<PL)=$Z}P6l=5L9ua9
z?&!7lf)R?pH|U;>LfDIT<BXw5>Zhx~3Gjd#&l&NESwG0fE**)btepCN0LUZr+0<FJ
zx@slfwvgj&|2F3%`b~7|TthDnvQx!&Vcjwquex&K;-!vW_F|hm@kWHdv+{?JV`+J`
zj^xCz&@TB1);Zm`q$4^{LN9V|2G)r-e-Sjj$Zpyf!CyFW%q@A9)DIFV8G(#kzH29o
zk3P@Q;<0YV0L>HqrPYfU;>if+AKrdwY}G>IEr`~p?KkS3eXz_MIdrP8WtQbt=WjZf
zf)ez4h&d;FWM|FV)p(Hu9;e%3g#|}Haaz=d$7o3QGK7>&2inLZz3vX8u3cP%Hw^UX
z^!sg19r|d5{7v@HVRA0ZZSyTBd13`aIC7;aH7C7GXoxqqwdv<9`eEs+8eLDHoQO-n
zU24qBA~GbMNkHChPTZ_8<}JOLf4b-!LC$ZC>EQ=BF@ds>Lu*0wI*gk_4=g4RRD#|X
zRxe(@90>}TV2{+%jqsumfAQKC)^lgk;<k?FPDdXkL5ikE>}YTt($(4fE=g2y*wT`~
zX}Gh<Z`Iyerhf(>Pq2}YG$KaqaN6UoI9PC!&F%7#q_xeju^I0__;wJ-5hFRx5+&tD
z8>}*$yOHhdodmXjt!=ZBlDFf<FrQU>6AmicT3YRxa5{oH){D%(18;;>#PK>q8&b$J
z{W;rNTY>iuWRA&6%_c3ONH3m+6NVP~;eMQs;B6E<!!TuB{JGWE)D?Fc8a8jyys(tu
z)sWbGMOpq)tTb>sdz#yEYJ<$Ntwnab4t594eqB6xM*f0##oF}a5=j-Cw#y0sB0Xb-
z^K8w3jvPYtZjSr4g)4fV?K6?B*d}BPTjw~~x#7GIDwhWtw<X)KYlMpM#sFT2Xlm?A
zz*cxbE=f4b9e9ICZkNf&YzNx$#|KTyaK)h7p5kos#o0zoNt{?^`@i*bc!|9BiI)^4
z!f1>MA~~PdD)`tJNi*-7AZ%Wal#RAN1VFZlvjl`rsJOeO$4SN;kYzW^S+7);FPiCp
z7nrN-^m@dTEv=AvwxxLn=3L%pC?RJpA)AkL&V<&cSt2u3%wb{(@@FgLU&yH;WNYD7
zlZRK0-@<;fn;Q&C#z_1wODiOPkEN9mzt_@AiEpyB>BRFat&Dh)rOhS2*!79Z=^b=g
zxWo`4;9TNMEv<~W(9)(8UuJ2g#Ko3YLOjvZ3W+CKT8>evyziSqz*dCpI^=91Bq!g_
zrb%!iuMY>jY6w3OkYa>K@P4uUD{x}_#%<g;j^(2Py;jp%<_KAzWsdS9;j_!}N~fmx
z;iuov{zuV{7;?y2L-^x>R703K%r)t=IpHhsM!@roT0>5Kb`|+cbn=g53OO-C4kzT)
z5?V$vznT3cBU@#Iz3HRNOkdZUtLv1dmm0j<TtiNEcC+WqEy|T4qV23UyA?I_)(n>-
zo`|m<%Rjhx8Sx}b%W*yOS{dkZEn&4G`F_Sym#s+Hb5=!`_SuSre|=U(mOf@H5`OBe
ziY)!Dtw{LPSru9OJ6n<Pxw9&=^mSX2@Ox)fWa)>tBH_=@s>ssMZAHT0oK=yf-`R?U
zub)+sr9az>gayW+zGYatz)%rA2x<BJp@O!5d(cA-A$>qOiE(KbGP%{{%t&%$ZOm>$
z`i_XPCe0Gv2NenFJAOr$=su`ONZ;`*vh+|ekTrz#9ls(=kK2lb^c}w<OV8Shg!CQ1
zB1_NPiiGqXzamR7*ouVo9ls(=FWQQP^c}w<OMkEx3F$k2MV3_HAZrNeJAOr$#@mX7
znYPc3#<{ky%4hqkJhrdOXZxyjuI;Px*}f{BYx}Bvwy#R(+P*5E?W^#6lzs@M!9z|J
zA+0Uys!Fp&gQFrLt?gH2i3UeSLR#Ce$Px{XiiEVbUy&sm92E&^ZNDN*G&m{}(%ODS
zmS}KPB+RsZ)n730Bl&C}$z%ISKHEp~*glfa_K`fckL0s`B#-SQ`D`D_WBW)x+eh-)
zK9bM&k#w%@Bl&C}N$1)=lF#;$bgu0q`D`Ca=h{A!&-RgYuI(fFY#;dxY#+^M`)D59
zNAuY}n#cChe729~v3)e3?W1{YAI)d`Xdc@~^VvR{$M*O`IeyHbwPj94^VmL`&-T$g
zwvXnseKe2lqxozf&13s$KHEq0*gl%i_R(D1n?>TS<|;cr;=eI8?7Z#@vG9qEioUk&
zC+{7|s6#x#Y$P-@7A6{^^lI7oi1#LC)FFPmr4<q{!=K`kf9T*qh=t{bhz<&gS6JFP
zJH6j@5ON}f?>8iIib$HJ1GXX|`TG@pq3q`z)1cm5WsgC;+0gLUbgyh(sN1AT+iLF>
z^B!s4_TDADN7_d+`XQz!^6X_Od^kf%#H%f>kofn8rp?O2%NZ4kU$L|tt+UfkQwLfn
zWOIm0NKX0n%exW$B^ddKJeu&Y0#YU6ZH6Sg)}~pyKd89YXJS9ezAdOylif;q<tEnu
zVa8S&G_15-eZ(r$OcmvHhte!e5871`UY}Wyg?9z@))3wrkg5nNh3+C-4h|?`+Y#Ow
zkSYo94M<hzVq~l2oH$X{A23`b5)gmL(h7+OEv<xjuceg|@3XY&#1C3p8SzIgZ7%VC
z<Dl^A*Butph6n-Y5+AU%GUA6VZ94I%EUlFIGnQ6D{HUcB5<g~X23ajrc~6@`z}E>W
zHpC5vKvv2bx_6i5;v@3<LcptrFr(ezIomxOv|B@XJRof#`~-gBSpLZzS(9ezGlq)e
zF+%p~SM(d%PYTPPkmeHpOVDXGA-fS?Re3tC&ev&fiu_f>`TIc+m4xg8CqIPb8FDHK
zX;Rd(L-Em@@P0?2oETwuK-#$7Kz18)HWISi3<>_jHY6-IUWIKr;oA+#bGn^AXY%YT
z)1<u1Rwle9r}764<>Nu+oZ)sFIXI94r%QTDv&>OpG%uT~6z;!I&OJsx%8Sm<WtPW`
z5VBYkKVfKCte0}pCGGPW^@$JL`c<q?+E?wpU-X%UpR^<PUg0itkF@XGd&_u_v@vr}
zWF~&e(6E})Zqx!ugfyJAJeNj(X(oZxA*Oq}&g^uP>50yWlU+jkr8Fg`QgM`<twWHg
zrXL03*AjAM;7{?bJ?jbWh-T-E=x1gm=LgIy2|1t(@Z*JE*%YsATACydCNpFO3^wGB
zVFSlt1>TS=aL$SJ>qa<s3o8*)g7FaU9c2)(bV}Kb=^<xgQI1ygRLPbwPnB$m^Hj+m
zL7pnv4#W|?LA5&<-tKleSEfn0Fi>MHA%}d4)TJq|%(2D!{_QJs#vk0s9(8add#u5Y
z>=6bxvd2YP`>ptdwA7VGK5vE|#+9&`_k~qcuFr3@H?N&Nk~goNJ-j!sojqpEz;liE
z<H2a{B5Fz5Lc)6~$yaPG2D)!q664!<Eh#&!WyCAaa*(p+oNHn{hlJ^Rt||<O5|)T<
zvz+HrOi+eR50bbNf8WvyiGN^e23bMK>#ODt@;E{^liX!(PV8dCF9!{42s0bz?nc;f
zBxtyXFtcIq88I9FebBIq@LK_?lJICiT1%M8J~ziAd)CHIkTA1h?ip5YL;Pf-ui?yw
zxd$M;`y*3Z>`43%mR3l7%+gATk6T(P@e7tVo%pAgR!00wOPfplPZ#=<%ck08;hzmr
zHXy`5x3n_iUs~F9;$K->De*~5D<OW-(h7-RvNR*AbzCa%59SUWmyq3HVJ0M}{Jxya
ztA@Nd49s4_OkTO}oy%(td9fijL67#?k(})+tSkreW@uCqvP43%^7j@0Ij;zLQMK3z
z5N7hq_3qs9M9GV0N027W<dy62=b4vQ3e6SU1HyR$shV(2K&m99^C8?4vPbaBRs(PS
zCc}-0|HaY@iT~BoN{C;!v{K?%ENwdRX-g|3{x?gTOZ@nBUrNlcCl;{qgdxiOB7V}+
z%7{O2Y14`S&eBSWzi4SC#7|pVA@N~L^UkHbIDSD}{$YL*vKjpNu0{S``$?s<GTsRy
z%xHJ-U(jw%o_3G^1?{Txw0k0_-L+<1tgM_1{v*x8Lznmi!U(^#h=rE|B5JZQe_BRO
z7S;ts)MVlIfC!$|*Z9pIG*{ixepATM)0h5Jx%2Imvd1QMvWJFAn>{ehDh_MhrM`Tq
zwPcD98_X5EV8Z5rR7=<ykk$~cH3J7PLh1y(2wQC}!Yu)54Iz~XUWC7}wf=12MMjZe
zzr;W)9AScxx(6>pS^y1qnYr;1b44w}PXwejgr5mWIr-|F8G~bh`Jc(>6VEK77<)_y
zx+V+k-F0qA6H^jh(YKuaq%1YY`Nug!PxPc&qKjbN>@^jfi|Gd&2!9cfstGFt6Ko))
zSs}*j3t4Ei^$2NLU5|wxTaS=N)Ad-mJFxQx!uJQHYQhg15}F=a!~!jjb)AsL*Ilr%
zH!$o5LTXyqV}ao~PnQ4YN}m|0v;H#%GK|9x)^t81ulHF4zFe7R$r^AY;jM-zggvl`
z1=<b7k1k??8q_sept^KT7N{FtlMb5UcL&ZHv?wV2E<^0|0u^k0%0PxDq&$Q#1mU-@
zB+bGLSJOW?{>;GN1*A$su7P=u*{IN)tU{kyl4gloM7Bh@$13!>MJ!N<S|cn_haf(;
zhz06U*JL3>q0a>~K0~3;ol~I{R3@?&`}bxr5PQUk`%R-gkO+SgD0G*XX5rU?_F{w+
zY)B_$0s(H>9{S=`pYp7k!{<Buyy|`9_FYWE4Q4t9H%Q>DzSy+zhQ6_5-?;4A88l-M
ze8|ku;06g);053}^c-02GrF)M)A}^7!f%5IE9DoA7GbKvMJyZ%R9i`SJRq$h%viw(
zb8Ppj5o21Q*J{EUhIE+|choO#_m5mBKN#}fxFXGaWkIt_!h|6yr)x%<h3^IRs()c@
zLfgmzhB42tgHT)P7{kyGSSquXpC`%QX<E_2U1v_3{`>`VFVE>nw&o>8*<>8@vA|a=
zKWzp<nP7|87iLSPiO-q7{uuOGlP5I2?yJ;#fKzEQort-f=TyQ|#<5su$OS@Pvu|9d
zDaSMExWzKHf1wDvZye(5zH!+O?m3tc+PO32(2!d340q8AagCuNHzBmb^*G`pEK?X%
zB^)*Ly1?<Pvdl?d0*{kJ!P05!z}bGs8uaOW3Fkv*3OpH1g-Sw3Lv18F2?L)dW-Ed7
ziY>9EvfZA*xH)HOKQmpwVMQREVI~~hkZ@^0swCv%2$?<_tdtD!B@zP)mc9MzNw3XV
z_S%fMzUC}@JE|2-PO}E3edoDq3WFP_WHOkX=D4Vj|5D>@y*Xw~7n|z^T9Vo5GELHz
z!LZj5Qtph}*-~ZP%I=d&JDZE>DQ9dx7kw+6OSTUEs-moOaM8E2xjbQF#gEK2^XV9A
ze=_%A<a-x8CM-T_u9*!;`=PlPa-!M&F~E{Hf+Hb0>$ze$yd&ULNf--A)r9XiBnhL$
zkJ)O3R;)@w2KhX}mQ(i`vsB7KBk{AAR!ID1ODiG%nx&NzH(l%N1cw>VIV?0AB04E0
zZn3ly;x<bwB;I0aUbeb9h#wh2a3DcQme`{al2iTzKl1u+z^jIkB14UYnY?lj{C;bA
zydLnXB;>I2YzoNp&WsTgf6vlNiN9}YUbbe)>mE}Fnjt(IkTwvKQ-00l@~R=PZw9<-
z2{U=+YUX~^ARRQUBs?6Da-N$gGraekE2h;x10S{|gM!N}gASN0mcHPg0XK$xFxOmV
z77(wuw8C?>d!MNT^%7PFq&0-(lwZA+;g+Cb4Pj=(TwU^RyA{+U-eGBl#P?fTj=zvs
zA`oIN;r4)3Lr9MPfLJ1bC?i{6y!FF?*IL5khLm49Z1|I)VGUts!(8R??jKA;u`KZi
zU0*)X%7{N?X*tRvFW1z;011-;shW_S@((DNR}FdX3V3ZG%;a_MF_HlsoN#BrtCld6
zSMHOv3rvIif`&P-pRfuUBD4~|IqyFjo_{h|u?6u}W^RL4NIcona%@3f6HFc0g76AM
z@)ge#ndR|H^13|WRYS<u!mB3DlI4~2<{-yI1~}s;Wb40}7rU93p$FoXmR3l-%F=T5
zMP3VoF|H-N)sTFBu|#Hh^hI7v170<RZ0(PcCCe*EU(*Z^GJw7a+4?W$b(i5aV6Ng{
z#2>V@LgEiuT8_TR>t0g_Y9M4YUtifFF1KM#zJ|H8m~0=&kcxQF(h7+`VreDB@o~O5
zl68exNEjm2Q9_)wv_j$@OUqFQg?q%RgOJS;1_;S1zlO*w9q_6lq<F}%2s3%*Dvfu0
zGh`>8dtMOU3yI%rX*pvguaw~hlM}Kz<RT=e{A1+ZH5vU8|HRVDh>uxXj$Gum$<%>d
zgx?8B8wkni&E={O8rBg0Fd)?vX7b9_J>_Z+8m=Myc0j5n%;c53>})X&ZVwt(65bJz
zstI=mq)NiC1*B?1_L%2nino4hT1liJ{*|Q_5}&ZN9P^OZKL--5C1kVww#aQ*ldoZ}
z;&U6W$=5Jf%arG2#&C#FSz00SZ!E2Z`1b|DtSTjb+0sggU$L}8;?tIvqeja1id7>a
zSz`7Pl2d-o{?YKbA?R;*da1$7%oPWsUYdnELp<M!mp(Y|YA@%Nrr#Nk6bW;XkRtuX
z(ovG%2GY&V>5t<(6V&PTh+nm|LSnwZC^4S+{`0M+h~IB%CBz@Fv_j$!T3U{!DBFdm
z4s=1t=2!~|$tl03$m`O8R}JBwfK*MG$t!nS{Fz3y4f)C}c|twDPBK2p^h2hZ!~)_6
zEUl1upQV)$UuKkqwxz^HmR3SsY-xqW6D-XjD;#CxyP8lnA)7<hgyfW8)#P;`P)`jZ
z#e)kIX7b8a^~VekGC<ZwNCtl~FZMJeLl49+Sy~zKuPrS{U*uJ5?m%CJhXc|E!tVy8
zwS;7zUxj49CTLhgm<UL<gzQE+J#Lx>b_9(PX7-t@YW7(dbg+hyJn=A?kUX&kB+O)=
zyCiHhY&!$?m4saZshaSM0jZLZJ;UDCZ+*m`e`{LF%p(4sr4<tYtEH6?|K8F{iO*Qt
zbmI60exK;0j5uLw(}|OoR!ZD!X(hxvEUl1ur==MQ?1(v5{`e9+kC5F+f^0aDQ+_ui
zFTN88Um@f$plw1*r<^<c(kx_lkn2<I;9?^VyoHeC$GIe7Ca+uvsx>@X0$!D^S)<I8
zfL&s$Tx(lhXW&{(vg$R)HMclQI6fhTyjV8sSG)f6s+?u@GQ;3)=9=$;6*=_<b$UJG
zPg`0c@n<Y8$1BKduc-sC$Q~1`d@QI^LwFz{ts!J*;yAf><=v+<L?V8VedDl{c&?@8
zh)!O|0wLBC&NR*7(1hfa-=WFtrva}T!fOLw)r6V6a>w`;!-EVkIS9!BlY{WhdGYRh
zGxR`wlcg0BFR-){;%`}6De<>0t%Uf9r4<s7T3U|&DcfI}I&d9AHi!NR$tl17$?MjD
zR}CS>gU$#udFASVvEe}m&_5v={KdRB7+#%$T$Mcr-epPIGludVHC1F;AucnIctI;9
zo^5G4S|+d8g6`H5vN=XWNKSbI8X3JMc*a~qc)20@bC#v)wjv?f=bzl{;liNd8bb1v
zhHKI+U2iKAX7-R9%D-cjz?YOIIui3GWqF^F*fAZr&W&l}sR6AlP0Zf&L_Z32L(mLA
z?Pu`2EUl3EJ(gBN{9a2dCFaXd@Pp~Z^K88`;zgD=mw1o)(L?<`2Nv!zL@=C7e6OXI
z5#MiV(}_P|X{E#;va}N7K}#zn9<sC?=cV!<HG_bD2@e{Qa^iy_7RW1qkRUhK#>6Jf
zY?vDn*l>R!#u~z(UFJ_-%pt->MLx;*RhGU`98@HH(UAO#EZsaIs7QFp#7vGX-Dwnu
zt_d@Tk?Z}xG2&MRFG5t-8Q5z{y9|84xkAA&Io~yf@7sEv=GQLO<&?Mb*(-hcU2{bg
z`JI9PZb|PpaxV(x&-wDgFN~zeg6?VwFAm<1swXT8NVSB^15!O<Wk9MW+!K)M2|pN+
zY6-s{km?DK2Bca-CwN1tp78vDR7+SMkm?DS1f*KRodKzy@a}+AOZdfrR8RQjfK*HP
zYCx(d{BuC6C7k^h8nK>mZa}If><CEpgvo$ZOZd5fR8RO+K&mBtDInDo{yrep5>7P_
zq>%>`ULTNZ2{#3#dcwAVR7;o+NcDuD2}resKMP3pgue<%wS;dUALxs4YCx(bygeY*
z6ZQwBTEbaD2&pH0cR;Eod^jN06FwG@Y6%%_pfAGZCLAG`BK$x=swdnRkZK7}1f+Vx
z-v*>w!mEO~R!=xRAk`8!2c&w!Z2_s4kRcG#6aK5MMacMvT7<<WKw^x9cLk(+!g~Tz
zE#b2Psh;o~0jZX7#-za7gf|AHTEeD)R8QC*kZK7Z4oLNcj|HS!!v7VJ>Ivf}-eQb|
zHuTmLz9k5%wS+d#))R8Q053u=+t8{%So`^+iN?PRmcLp;CIER}^5K$_3SxLAmz1wt
z5*L(zvLuG}D}o?f$r!%Qk{GZbv?NC7A6gPa@ufk?t7O~_TM~opy_Up?`b|q>_;iCX
zRmoU+vn4Sw-eF0Mf=^o#L*5@PiSg}*Alg(im~~kaBiFDcF--l&k{FY&528&a1JHez
z#As6<#F0vdmM1KUailVs`;`nDAGah%h|`wDa4;*F!j+u+2}|Nc|AQrQR=+iviItqf
zAF?FQ*XJ#XlXG4$dn!2-<Cer}_k<;Jj-9lmPnm?}F`KwBhq)k_W0e;gINp-%yz$Xe
zGi#VJ;wXxc8RP#8$>YD7VQdQ~YE||~zhqpCeuZICFU<KsI#;W!jLTi<#J}S_IBxcp
zbKaVsY-rc!xtGm4v)#G+C^CF5aBg$Fxl_Ek)6yid`%9eoU7-Se>%hOAEkQ=hYymQE
zovZ)f8V$+5llV`DhOb}TnP%YvBPfX1rdgmY(wdl>L8?u8t}(tS)rhVBE3;+$i{u#R
zTzGjX=+qjxmL1#}On}<#4$hcK^_rbrgq%@$Bl(#=%E%Q-6SJ9d*KuL6>!@ZsE^c{z
zjIBN!tf7^JKM6=xzcSGBUX#mvO}0eYtu7Vcl3y5EJ>^>YUP3mD?EBgLxVXO&2v$o-
z!LTKJ&dKJBwftPH*iL>RD7%@^vfHsf%>#{6xin55C9~BvfoaxEH?Z20villuZrN5<
zxvi?QTdl}pT**G}G65Uz^QAsUZ|+DnF?%eU_@DJ4vnjjIJ#Y0XA2nCeCGnF1ZBCk)
zqT#D}*@ETycHT$K7#|6gS9$XleutIjidkP{;08+~Oc)U`zDN7=3_ACB7`|k>dSAdS
z=iSI}nkqjIq*_CGfoY}tV_|&2Y7HT|>w4Kb{ej{8OLILBKT$S&N}9zN4f%YhuLO(4
zlr#yyIlDfK|DIhxyT4{5-#vlw-gRjfh6CX%|K7k+OQK3!f`EHdj*Dco7dQHhVPUy%
zB-djB_l=tjS3Bc!Z1I9I@IRWXgqGRUx}3@8;SlNnWbPL_@f)GEj2gW2i>w;m0T14J
z+0?+HS+)v?jHDk9^w8@O@3*u<;<TmZocNK~$4niZ_z|*M{=>c8hBf&b<{s{m?Qn)v
z#LnCOvEod$lsIH*IntBY&#m-?uLY#)02)sD2Si@~D`;3lcsd}}1~7wH?iimi4ZdU>
z5}q<7*BR={Hf%7|j3K)Qw^~{uahs*(sD`{InmRBnA)8}OAta~#syWZ_AcOxCUhHX0
zhU~=uW@&}Qf3mckF_KrGsROwP&jh4uLdz+4W!Yw`vv~$53Ic5rl2d+d(W>U1bO+At
z5t|o5g;q#xUNRC|39)$_MrftP96o5%iOuFf>Xi|nG+#`>(}uwi3#aV270QTTw6y8O
zzqYhe;@?_Y3GweNt&sR%EsgR~7s1se3-SvugzN@q8ieHZ<_b1BJ9yO)W;V>7mL?(Q
z7v`klR3q87=8CM2@PU9-O}N*PkPwE_EPNuUw}$YOMicNE!UKk+o3ik|fY_tbEd0_o
zHk^aYe1ld5T~-nf1f=@k8E6^R8%l6#HmJv3kq!}((Irk#$Y0lHPr1#ROtNLVG2muE
zx4E)vz7&p{q>Op8=#LpTkC`j1MEH3_I$svvDOh+(_@cSt=^J-A1(OdO%CnXW;kUE7
zknnsC7efdx+1AAF)qIm#D~Wb}%9s#3G%t?m+W{K`=&diC>X^kI@o7sdBtBzlCB&~<
zS}F1CmNuQ3Um}u7LEK}%HZz^L*V0OfcUW2p@$HsYNPLH-<pcnZmEZM203f{0G{aFS
zAvxs_0J*$s$cw|k%p=U?l^YZOY;;8i;<W8XAWD<RNf+i+*^q7BdQ)YSxyrArKImTf
z2KJ~VHJe*dMs{mT-Dj$ZZxG*QX@$ghTUrTmzonHD@3FM$#Q)pU%838n(xwythozMg
z<L?mYe~_;vz?N3%8qB}vAmcdKSks0-)Is=YK&l~RFLDN+#XP^eP?aCIya+i8SeTH4
z3a?yu`GVo`4RaNDIb$&Yf(d*tdxQZ~s~K;c!6lYfNX&0|<<k~<U1-`tTZC*52?)t4
zziN1w-z1a%i23I+Kr1AEhn2O2c*xN77qeN|n^BQ?pQRNNKWJ$=Zb9LunmQOLA)CW)
zgyfWepvw)9nxMb3bc@050skDkU1bb8*<3|G#8+EdA@MbqRzkef(#nW$x3m)CJ1nh`
z_)bg9QBRq<S02<UONR~aG*{?{Fp*Ksz~GY23YsQYHit_Qk`rnL91NhmdrVpMMa;dr
z_!IG=jC$wd^>K3p-4U|6Z)=vw>`mnQaKJ10JCkhf&v%wAubk~SZ#|VEJMjd&@)i<L
zw6q)>lGiT+xz-Y%G$enFEM07vVT|JqB>z0aCi{O3*w+w}p+9Vv&JWnv5V9M;B1^W@
z9Q{xi<S8NYB_lv#z(40)oE%F`6>%NnD=e*$_^p;!LVTsAl@ga)+H_*B-UwMga9CIr
zg!JC&#EUJhlz6G7l@Pzr(h7-}Sz3<W-)n^WskxqqU+MAoc`TB}c}~5MStQ2-XXqB8
z8>I#ps<7N}#jgqz{yZSn5|W!3HutAkDGD`_XHol&;aP45nkP+SA1g9+L0n;Jg~Y2Y
zt%SJJ(n^WfSlV>rDoZOPj#}DW;;YB`3X}b@%fb{xgxAd_o@!}j#MfBbbmD6*t(5qk
zmR3SM!_o?gXIfg0IjOu;W)PU*gzOqQ5Ft7F@gndE1IX)Oz^jJv^8qPF_;a%&@(<^-
z{L6su|Dj!$IYQQFnWKEuKeS8HejdoNhVVB5sfI9fn7Oaq-ERcE(x^4h+ZFt-Imd*b
zl_TVE;K+oQQ7l`fWMr%4Yyqw{;@o1c5(+mM+-$CSCf1m_MY%FWw4LQVeWGT{GF*z7
ze~nAlUg8^Vy%OSgTUsgcdn|1_@mxzQBfi<v<`Um;4y7>Ho^V;<Ybi3<h(BN|f>uWS
zAxoQ1JZNd9#Ct8Rg!n;AD<uA~rRB^uD(_x12+TD?{JClU506g<`&hWx5K)hi?EQLK
z-jd6|CY!(PXAD=e#L)*K6@XfV?9gACvpRG(n31rX^YHg*v1YKyuFl7gQ}yY^B&%;z
zpZ&8lTR*GA?Eb{p-!L+;Gx-U}tZt;*wT3oiuBi5L18F;u2q{UPcjoiS@NA9@_4#CY
z(sbyY?~hC5nq%<0%oVSa5c0d5F!sHDEIe)MDW}g(v+$LmaV_CD0@B6{jVDeuSNsw?
z;d>1U-}c*;W}(8?BU~4dHWKm+g9v1V13|4S!jA={jf9T{q$<Ln2c(UJB^UTQ0(-(C
zL(=+SVP5bZh>e7GhNSDU&>Rq<Hx}YS<28i$2BeLIzYdzh4lMBZ)N!gwxY@i;qx)r{
z*$`2WFr8VCg(qx1!lQ;HZt^FC-x0)@vh)oGugsujO_-b+D!eA0XKDpgVPigT&1N-h
zs((3XR!R7)K=}GU8hE}D3Nwh1vSY!VW$xZ$YY{F9M#BxN73Aw#69~U?{zf`mgHZpY
zec3wHHTkQ76hssGbBWZVCbGadpm|z3e6%Gi`eEv3M?P72jm!*ksFls=2RY#*XW@O)
zRQZy*x=y?>o6U%^>uGb%(-WiMO-3l~sw~*hSp7S5pWk%HIA~)k4<tfrOLNPXs>-ms
z%Utt>)bE&E>{at&z~k&kf7zA>=~?4$oGW=n@JuYM3SweqwSj+SN$hA^5P2#YQI-Zl
zp^`yi$dWk!|7=OO8?inXOpMBp8^}TA(Zf58Fp~qJ)(}!&jPIj;EHno7st7p<U5|zO
zU_@1f9GR}i!rEW}RfHU_uE)ZDTaWN5L(=tFc-Gb<{9$H27XH!JBcx6>KNj8*XtRot
zU%S%vSXf}|5z-*K9t(SHJwjSZ*JHt&tcrfd*`VuXyF3^0C4qg`5Yh!*r>l@=OxkJ#
z2Hs~$xkg-*Yp*pl%_D&-*U$=Ivm`3~m?crSmjt?4bA^FZEQuO>za<gU#brdf3d@Og
zEoNk0!3e7eIe6&wU>^%iagekSQX{%vw(c1=SXmZ4;%}Hf(QvS@+vFTfUN9fCa}Qnb
z|7QpH_MI>tWQcojUpBY(rcz6g0aX%GFogQK+08Z?1M-Wf5T1~pa2}c!Ty0)BwC%I=
z5_!KZ+o?rowuO(*GnS`wNS*BYCbX@l9z7<n4j(pa{Aca*Px!Tfl;b)-Hn)ChuGq(U
z#4F7A13)V!4qKYht{oJ4y%cn}mhe{744Ee(Ipsh1c-ioHd(g0waA82ICM2&s@t?OU
zG6W~)_uDYQLgM>uy)xqaEv=CF{g#%a2=-ZP>R_`;$mUpP3CStHB6#-$8T}CtT3R9T
z2}>&@K51!%#HTDRM}GGC*QO5SCuDQTPe@Mr<$u=j_<6u9=LDGyUd#}Qn15?VOho)I
zwq6M_f9+hK470HIQr|hzxP-XY(h7;!Sz3-RDBK%?{A&r>98OJ0PWg55XTyUG&ch!a
zz~-JsiYR0pE3-(R1@b2fmgSxv^V^WC%_#Cr0<z!_)<Yp4@di8iLgG(aS{d<vODiN!
zTUw6d*ykow2TnxD=5QiHa>}o``wWkd2E1~dhzt&7h(!F5r4<r?+R{phXS~Jt7dX*#
z4hu64QJjc)mZcREmswhlF1~C!V|(-1fJHXN^MT5I&j;B2Yle+DNYy@%MM@y#+I=32
zmTP{$;eCENOPqpujvY)P@w+Xpg!pbl(;8!;KcgaX%F+sn2P`c|V-(JQV{9#9n`s8`
zAta~#-jmC#hP)^WrZ8b9uiW<t*ke~9L?t1I3c2i>=p*vnoiSqKJ(gBTe7~iY5dVXr
zLDj!-SoldsMdD+YR!BT%X*sH<aGx-BFi{EF9O@w?r~In^nBhTLjH9#2#yE_8Vpl#-
zXNBV#@)EybX@$i9WN9VD)6FJc`y>nhA9wEpZr61EfA5o%#EAq85gWl4w}XZgf>1@=
zN+|oBz0YZ)Cy6LZ>yk(!Xq=-}q;5?_D|)e0cdbiG5b6@GTY^?qTUEE-RbA4$wx!;&
z)*7ENmNnOjw7>uV_df6Id1QU&ca1sbm}Aa0*JZE0&o(N?M=`vuYZ1JiYeAw2?oZmN
zBnphQnv6Y&r{Y9~zUufQ6iGUm^%c%ZT3p|PsDgC0U{2zbFNep6KRnX25W%BdE5rAy
zCaHd+MB%=SA-vSJ2)^I7Ak_r7pV~;O!Anf4fp{uTb?B>(FG7)2gIQl;s%h~u3!)0r
z)q+&x^TAAyjn}qw&J(466m%PpNq#NC*)j{E6KvLM#d!!T){82Joi?|bsQN1pa4mud
zxmJejswD>{h0cs2+~ryXf7-Pm9R#<I+Q>`+_b{mj;;A@8p|3i=2t{TJnDrGVjTZN{
zAgUl;Eto0z9G~eiJi)aHp6FT`zE-v5L_y)Yj3IozYZ3fC*Md|N+(~L9sRpSo=>hRn
zoa*D%2eIghf+CgsJW*h9Qzl+`<8{(wMvk5eyoqZ;zwq^f_Y3@kN@*u3ec*;*fAyal
zQleGKRQ@o&Lw!7>+X1C|d_ts1Qv>C9N@JZeUwl<_iZqBhWdcz1d=L-jf{@QG^8rW_
zOZmpdEZ=Z!Mx$$JF2t;_27hlEtm3@cYE?r=)x0A*#`k;Ul@cDOo{|HA!oe!WhIwb~
z`&7mTKFqZUuDVu++g+=`ovyXQ>kds@m*5sQQ5dSC1lJ0$=UN3`-?cKlfol=Gp=*71
z_E-&0<|g=%NnIeGijU%>w8Eph)uWi=SJzGZs;@&){I1E#%TpA;XL9oL6h(e9VW2z+
zOO6CJ;};arDZguO67Lk((v)Z{6zLyc@>Ant?b)T4nkvWu#Gn7?{<}Yym-rzbNntEy
zsm#?X6;;dI;D%(%N#r8!F&PtyWYEomQw=@eC^J{!;jTq+#kDegoNI0H=UpqqUvMpg
zk9RGYqr^5!ZRArokm`~?5Kk@fkKV0b>c3g=pmntRA)bPC;Dq1UiPs7EL=QEBPj;;g
z4_hxCEjhMVlqjsPqBtzWW!EBj1J{Cl5ZqkL$9RzHk`EA1aX!Wu=HpKFLp%lfz{$p$
zu;6P{OZrLS+Kgd-(z5US85_7U%#wCy6NQB;7OmFoyEbD3@2g*9jw9<wVLug%oU!lV
zj14?&Ba3WB6NU9vEON%aO)@s{Tl!5!iEL>zg|}5Ka>l-QGB)tLu0`;Bu9e|CH?<zj
zZK80OiqdEq{-J9Te79@Cgk;~3GdA$^n^~hT_M`BEibXwT-=8uzaMKnUXB7IWSmca-
zgEBTSUm%Rfpov1$mT3z`&e+$Sv4Q)$7Qq8tE5n0atH8IaCV{+IqOdq)2;b&f8NS1{
z2wvh^FjjP8OSO>`K1g*rg@Je~KH(2jA2^6lY?rHcwfV258TEg6)LlE9Nfq>3!Re4t
zexbGE5rS{r%I3w=5`~*oEE-Cjy=oz}gH^32Spe}AXCZuBHT2biudB@0L@?{Cqv1(O
z>2Gw-Dpva`e%+)Xq3i3ejm)G9e$%8Nq4ch9CRMOuQa4E41)nFd>t?MLCmdenS_Ch4
ztqgC!wT<8tB?>#JC=SbTn`;p~%C%s=FVn`hRhyy<Ej1ZoCN(fq3nY+&vm|Y8>5lRP
ztSe-xqC4VT!Kb(u!LwWox`r=ptt5vsNOcJk#8dI1%-%0%+Jgr+rJ}?d!F;bIj$f<T
z247!SMdAYa>Q5R3rQ6&Pyi29jkkYT+5PbeahLqlSL$IIrBK1g#en^a3#Ww8X8$fYa
z;r%@&75D(xf|THE6Sa}%z&%W=fp{t&DtwKwigj?TNnK#pSNL3ty>+b^_YwZ8YZaKk
zw^%gn_?l!vbb@D^R0Hu;+{e&Y9badguP!j_E9~QuTH$o77(74tLe8Y<-9H*xptf-e
z;744mz{^|<rUSmNP#c*J;C&|5Ks*(vD)d#y*8}FO3(WcoQ^nq2Wnzc<evtIL0`IBc
z>?oQJ`1+d#(Fwk-QraO(@4F$mn|*Vn3#7^7WYFj<=Bo~lHeWR`>nltKd-uw85}x5&
z1oM6TqGaIf01KiMq`EBCAfAf*$X>n~AGZfzkckWCPnZ_Pg|9O_E|BUH7l^0gxXw`@
zbIez8oZ*1K2O5V2e=QR_Jm0l4Jixw%Gphm*bgc}p=2`@|xE36f#P%HvzZ0aoTswex
zDo#b{tBx<ileB_aU*R;oT;sudl`CGM6(7cd{L01D((uM3TK-E;=et?_snUUJPnq8o
zXc7Gs`K`&}4U{HLD>baFy4Ro+q;Zg3QP)#vNMvL6c-I?EopD2UPFBEXP-Z+~zC|x{
zD}vW_yE1&aYZbWRS{YvGS_FUBwO}3*8-I3I)^>2TR+D)Io}^Mbk0|kXJH-&B$>Ise
zm+UvU7OEiqka+{*tKeEbA6LQUGPSSHBmutDwFth;wIEsey58dM1gTcsVfNmeaSs37
zwFrL7wIB$5{m6p=sa6~Wdw-d64)g85cpAb_yImRPD`jF=fp@U4Ajo}>@+j9LnC}3_
z%V_=(A-3neQy?y7Y(YG&yq_<duR8deNu7MT7GDLI)C5Isd6Em#C%NqgaTEs?-gf_1
zTgE~B@PQDv)nv(>&*ug6OyGT)xR<WH$=|i{^{k=lFvX2r>Z{gD9Mk8$)k{3I@D;9A
z;457VrU1SUw}?8y$ttDeP3agn1TQzK3#7^7xk96zR<RCVW>O8z`U+2d?7dwp#>s$Z
z4M?*aKfNnaI90`>0|I9cS`?k&aav8L3y7!UPKLhf_*$m!<BIhLr5CKxD!7(4+O?<R
zK_*qf&zKa<L4vr`e7A%5s?=PX)~`X~ei!>UDA3P=@iDe}|KLoEN9_BRrj=m2+#J`<
z&vjaT+M?^Go8G73qcW^9E%-ET4b8|1-Rd`7M`@9oD(AzZb|(9Mnc%5l5y^XLkqe^f
z$t6+V8Tma&!;5Do%wLKXtpfASvZ5J`ues_=7Fh5llWHKIif3@>tBx=JrmdVFz^t$E
zFlFzXnLfgAyB5LkxK@VWb*%!w=UOX#;=nY+a@apnqHvOmlC)NMs%sVaWY@~@4A&xf
zrfb2XN@ttZMg{?-x_tW*#8dGgtfoHJG+$MakPEKATGjeUs}&qZnCz$~@wstgP%St&
z679uSZB`3>{Ay|9CC6>>39bcs!q*Qh%1-chmC~e8TIz;iUH!`u2-0M6LTU5{^Hm3F
zCazd-P@*MyIR(tN5YF|x)ic(aijyqbU_2hxTDzM`u$r&0yIRep9o$u=fwIcXmK!+A
zhq!5e+4+R-nqVefApI-2_<u^nT*qon$~%5LFqxP)p@EasOT3i9(_D+-lU*yr(_O2;
zvs`P1hv>XZK02eYhKliW0I%s<1&&-R!~B(IsT;xTx}B1Dna*CO!O3y}QmuHZ^0%uW
z(Te)Aj1{#deL-b_7V+8FZwH0pbPx`nWkmt;7DpI<7WEyC>?-S86(n17dIs@TFs-gu
z2Q*t?lFx=5@mSM!Sye&Wl3!om+lL~hyK;@iOWy~oQNQ4fj?1>pSi`ru)&}41nvw^C
zuibTz%n5L|Ni`5p#nUA8RmayA=Bo?L`U=;s1GK_8-KKM^Oz}{a*NlIzs(XI_`TeIx
z@hev7hwJ{eKeT^RY{)M9v<4<alHJIJ=^o?@Dx(^)2X<YnjSR&@|9H8^ioG{vLz&-_
zHDMR2ShF-g%I^1JN{O$B5~Iuw5EsQG!`{0zmUx+i`J3dTt<v8o=MOKxobd(om$Bm&
z3Fa?ei&lnT*Y8NmQn;c-fiF(RhVb9~%bgMYch@uo&lAB7)9<+VE6psy_>>P!O0fHy
z>Q0o{_hzO&_$}8W_-)t9@cXV+;P><uyZExOnZo-jO6M!^zg;WCrFGNj;ta!0t_2C9
z6Qk@)fOYV2mEtK=Z&3QO8-jb<w??`QwaK(@K6PQE?fFJ!H4a;Br$y_Tyr8Hp(aE^Q
z@Bzy{8scJmJ2$v!!9jB-TX28ZB6xsnWq6Ql75J0-Mp|-Or*NRZV^@I>a;*#>>{<jL
z;#x4AYia=4N*Y10HZS;^_XMr>ylx9_RnOO5m%0h)wQBj1rqNGjVussYi{Q&$Yl9oE
zMest`f*jE1OtYC;f~g-L<FNY*kMRf9$1?LZs|Dt7v&x~?2JgL|9ezPv>>Hc0f%kVU
zf?I~AzT$PDL}8GM@$n6>?pn}jhdMq%w*}WL#PunQVP*-Yi8x=dHy7rMeS<S0!MnQ_
z!5?=m2z_JSx2<j^bdc%=7e9F1BjXu9#<d9koNGY@2kE{p-AV)?)e9oP<FOgf@bRui
zFn>KV8D|PRuWu76f_HH(2(?-FMY@$x!R<{74o^Jpp79K~>MD_hMPVBiW%>mnuy4DJ
z4Ls7d2;RZ9GCaz)3cRCht?*8+wZXf)HU|FrC_9E$459FpiqeTO@Go3zgMZ~(EBtHM
zD)4VyE5pyZ7QxTE79@|q`E{>$Lhfw9*G-xT);3JLC05`!^bIPxwYXeyVa2S#t4*4C
zqvH0PnH6}vNfW_`Rg#~6>(}_H7S`F^s)GOA0%;=1Yo$`Pe}h8Hme_THkx3K5Z<^Ev
zj^37v6DKK7GpP&whDj5_Z<*8uUZqkJ8HMZJ4%~k`YjYm>u~d?(EsZ8E?5SHB7VyNZ
z9fga`ZsIi~Q$NGD&-kNIQ!yT9#j~<@6#ig#6Tx$LAmlFa5|bu^SDMrX_Ua^+c?4c$
zQWyBJNx>tN>vX#Qz@}~YV#T|38{fym$6C6(K?X7Yu^E_H<jMpjme?E2VJc>zA9dl+
z)ZCx}{ncWvf$y4B<q-R(9bz@`T9c{^D{02B*R7lxz}ro#a)>=@hggk6=XZ8A)i`v9
z*!-`78=F)O4~g3Gn$54<jHogEq)p;FOGnQ~F*q}@oX{(o4r%xNUvl6kffruP=LPzL
ztB(gXgHL-Vy@`}qw8&jSEM)qZm9$F1Y55V|^`w~uuk=v+_ih4u+d(H;A_t5}+g`0S
zzdSL14uHS_50V}8=FE(DrI!9L%PXb@e+-Zr^RCYvub<M(y6a6d3A#w_wKZ575zyNX
zy2#Xg*`{a}WU3ZqoL#K>{p8#Mv*`CLossWFiK#x(rg{+2r*v1<Ose3~Dm9m;HZ}6T
zCvKH0C+fDP^w!!V-x>W*sey8x?ipN~_u}-oThg5`tGLV7X>}PMa1WI}WRJLctJ#B-
zRQizp#VTH6_SFX!A9o2ndmHl#a#sA1*PrX^?nnM4)=59|gQw!()DA7y?RxT})sPS5
zzYTkIyIuT8P2bSCnk|^>4!ZadOuR6sk@~;+Q*S&c@@L+nIl+1NGCluBrBeo`f4b(t
zO{TUD95|xEp4-%7t&GJq`SVLbD4cq4(o=Bgl0D1S;v-$o(Pj7Fw){>4S%&48c*AM=
zqS~*pdR35m@edW}{(D=k2iRG>3Q|jcPwmC&xoV}g)P5t~#^W?qd8YXajyX=GFX-7L
zz6XGR?^*<3v}4+E^5BEQ*Hnz}U*Wl~wd7-^(G_;V(FsyrRvr*f#ZNieJ1^57{B_qN
z_^O@KXe8D)_-fZ8_!`%O_;=BL`<YE!W0rESZVQ%9TwZI{X0^cAxfa1UyH<v0?QHp9
z*hJw}6{SyQ_%zod_;lBTJ`vnfi@!5JY~7<%rAyt&Jbbrjsuu8_i20f)Xw4qo$_WY_
zr1d3V;QA(2L7EgR8l<BIiC(6Cc*XkC0TPMS!sldbt^=fvmG~y7av2Yjg5rrvP{(Kv
z`pYj+_BJSe-ZIk(e()hfN&_w0cF^06J?3-2sk+%lxA6t|p2`R4R(@IY3+k7y$7Xp~
z&*btNuQ6oN>xJisFa-IL$e_Kj-u`Ms8)?dDY31D}_9lgRVRKH!c)jYU`v<z6{dr8j
zUz99%6lP}(VJ>%Khj5SE1qYk%D(Pu9{$dn}OPP8go{HyH=&Oz|LXkNNW_^Vpz_GVC
z6FYpSYZ3ev*UB(|%}<hcW)p=|HO<KirF@!e5q!F9LDC5BT5VL42I5|l2I8qWX`!z=
zz6d2gur->juP|xs<<AqwGY#f%!o?E<=1=Lxxqx{$T#~k;L}7J(hch;W2fG%*LtG1z
zMsQbZS0rg5E+uIoo{Eze`l{oLP$X$!)>oJ`_O6kM9p(l2IBD=YZdZoCrCM@$Quubp
z5dMy95q!C8LDC3rXSI=}fw+{Ufp{uTTIj2eFG7)|fmvT+(%8#u@{*tym^c69q`}vE
zAItC&y3oZ*Yoahk#dxN{yuB4Wgg@(cLDC3rxhD<8r6di+Q*qKlUv+#DiX;up`U;cA
z-lH<H!$-Ro!N<E+hOgA#O46QaqHvXpanj(cU5nsrTvO5oOg04fHEmR88hHO|shK1V
z#8Yw7LSJ=!5sD-Y%=!wG#$MiMkUqA+*Li;;_-5D2@H4BY9Y~T!fgg8|lLkMlhVe{;
zpK~op8o@oOdn9S#yMrugAfAeo7W%5=i%=wKVAfZdH1@ubi5-5?wFv&LYi0N)*DCM{
zYg;1E>`&oD6(wmE_$1fL@HE#V_+;0D<kE@3gUMtkc-Ii58n|GsR7#Ue>2XzM>Vh;`
zJPKi>bsD7~G74bUS2zkcYm|f-U!=kWC{L1q6s3_Lqq!*fbbNDtE8>T1rl#>FalTs7
zWis_fYW+9@7+;c_yepB?cKly@Iz2OB@C?@?_=~QUVLow97JLeu_(zsycvIIRxZ+wc
zQwZ*I%U~zC!+L2Sq)Q;4iYGwmtBx;1kqH21eT5T%y_;oXhex;;!P~f2hA-CN*O8<x
zYNjyXe{`n|U*cK>f8DhpX#_V#8<n*Sq*`%?!ise&(yn9(%=!v5^e_Encz}I$GpYd}
zp}`l-Mx1^-(?9ro`r&0V%P4$b#rW*ulR72#-IB3^58f!X5oZgVC>)|<ku&zyGB)rl
zS!Wbp%^2n*W8a$@8~DQEnaC(yq+(HI?7KK)1K;b;mX;{omodyo#=iSAHt>&Ki{J-c
zE5i@FR)HUJtrcG8S{wX?Yh&PBH?fQ?ZKAMPMajq*_%_$t;5%Gvh3|B&0{_spGJKC~
z5qz&}!GwE8gMY(15kBDf;>KxbF4e6(r&^$RyG!|D8LYeZF_R9kSp$-z>1f4SCUt-p
zn^Xh8Wl{%tgGs@8f(Tm7q>JXfR##tfpQ3Tg<CPUX4N9k5Z#qHJn;PcbeOfC_wu&8R
zX*~2QK3iU^8i5s^L5Hi0ZFC!-LGj`B!UslSdu;{nh4q$eJ0vabAT6!D+yB<O<UWoy
zpPI2M?5o>&rGWQ$ErLJkS{XjbwF*4WwO06G*V^F2TpI%)txv;bkzHD%aEyxafeU}m
zwKn)T*IHqIqeSXf;1k@g44>p$1W$D>IB>^m@W<*_PMILh$cM)uo{G<+N9BAq%S(g}
zyiL&{noDO44TkV|t=VHyRKd|&ui*3DS!#W;)vAG)snlQI!rQb#3191$dYXGmJ*Ae)
z7HuP2n@Yph-EpfRCcIO5U}?y{3%1?2al5*{&syzVs`#);Rq!V!b%8%u35VNj4-d7T
zc7Y_V;4J{c!(?FT^8W23FMmv(+a|OdGJofDHwwBtS8L#};F6udSHa{B^%ftm@LQ_M
z6a)X6F@yPmBQXQ{gXyt1cuUJx=T?dz)9s-6^VhhOn>3KfaX}*KI8!H`GL#rcImdv@
zHR$Hj^ri*{&q+;p+veL!SLt>&32(<OW|u}F+^9RG$2Tc1)@`OMNX$R62APT(Yprja
zGc-5n>o#5_;n!TNz^}U&tQq*?_m3nJ@F}e(SIgjUOzH$*G^q=uz2cQ6Y_U#@*O{*x
zNXxOWdV>-z$w-3PM#BsFtJU*^)<X3m#V1{|3@hN1A2Es(4Il0g;4AQFTniG7ueJR7
zGC0(vE^wquX$mRvcjsk9z(cHVCrA{<=?~+m69*0?t6<hwm{s;p)F9&gz>{5z;3Hfs
z!&6+Vz(>2*3V++RHke=Hk#<{Qeq=|q3cS$kmSKKVN9-b)hxBnj@^gW{9<RRSKmn;P
zCsz<p#ba=+`rw0(crAp9S;iQ|S;2z0GEZbghBMz8e&A`IbtZUKibk*X+_k{BxE8_u
zsrsVa;p;|gt`nqMaiXYry;ZD(*^1%JWbYFmX$!oQKkRRVN4pk`JieZ@AUeUnnN$Pu
zRNSG^R~=v5Y6vomz^t#n`-lVi2^Me%^EC;~`U<}x^jq!7tJa|^xTX2(&QGI1sCC6m
zf?Frj@~%4uH?mqakRS_YI=eopwc>dO^V>tBRp2W!cKNvR)oBrQg7ZzPfp{t&(RQt{
zz$ykgz`<>55{C}|*|iG%l54?a#Mgb+TqpRDNi`5p#i573>iGJ-`RWF<zQW1)W352T
zvgm->ik-o=Dtq5i2XS)XsDC<gqDAmVt_8`#*I>1gH5#OPnh8oc6T|!*Vb?a9_F(_R
z(z7ZsKd%zU-<PigJudKOlWHKIiU*Cj_O*(2@KY+q73&R3pL0WSnn_(?k4bg#YLmLa
z@0nBw7n{@tW;+nh6!!j5E5-?f?{+PM?{TdR|HHKk{7=`)@O!RB@cXU>14V57*pJK$
z5SMaZ2JuupQ264vb>#OYKthrGGBE3_@0<~gEcIZvVz{n9uAO~Ox3aK;D@>|^Z<$mD
z$*vsFAT1Uw((D>Mzz*CNcpuj)@V>4EV}Y;r)JDbv+|8sKh^OMQ2z}M@<-ZMNKi-t}
z6^_L)ZG3YJBDi+iLU)aH6L1HW<o)bp8x%&nU4H2xmi^QuK3d=@u0`;Xt_2yz*TL3Y
zCrEV}W)M%s86B@aCY!Gy3ph9?6B5i1CrNiI@VObgd>Zg|hBem-e#xrMEWx-cj-9=8
ztmdp1_^Yl(@P)3G;c5CFLh?|M0>4Bgy|P~=n(l8&L@>W86c1*;rv!JCHY(E|9Bc1B
z)IdDS7qOZe6mTyOCt5D)zj^q=^<L^|Kiv)}C4Zij;(;o+#Byi+g$)!u57IsL@Vgwp
z(72zoq_s7+P=~ZDZ&BvEO$+U6TJ&(3*7<FqIDPPiR&Q1WU*uYlW_+EdHj-wL>T)cA
z?rCb2kDPsrGOfY<go(_OCrT84xLWF>X!LP*pN9qVBQ6pah^OLd9{Q@|i;D6N@{-=Z
zI)t&DY{1(!ba@>g#8n(ac>ejZ_G7vArwabSd`-$n@DsKEh1UXyTdj%PD=u&;@8}tI
zfN8;l=l9g)1KkdkCwgbdPcu<o&AeB^vPvzbp6HVPv2niLUDe_MtK115s!~~g0BY10
zEtUA+^b013ZI?X0Zea0QwHzuDwN&^T3Rdi;_kH`z2RBar(vF<RL7d4&PQKQ;S__lG
zCHch{`O97X<Nx!<Op3d;Qash+-@6vUe{d~0Qt|be+Q^X#Qe6%S&^=An*IPWczo>^z
zwT(C`c#LZiyq{}9RQTFS_efMA)ryZwe)#2;jB|KbeJM)<i{LS?1wrtGG5^p#tIIFs
zFeGTZX#F+h&kf3Q&TeFykssG-nJzyO#C~*|kM~c_?Dwpuly6QZRlW)N6@`|(+kSG2
z%DbY;-7-CgKjB&ge^Iq$k)<#@V+fz&TF~ePx^HgA27bo1HuyKL1-{t#Y{tfT^|ZV3
z5cgAVcCAlee^g&`7XeZ&o@e1@>Yu2f&U546M4P(JkAFV4j~f3Mv^j$Nuj3pXUs^B=
z^HC0wDdc<eF%FT*<a_he%F;#8<>>FPyq;?jJj}IVRM=O}*uWdO7Qq|3R)#lmtpc~`
zyM!{8SCl9WQc<Q%1zz2?GCah!2wuarK07f^1Cb#EsV+CDAfAe68wtUITr+^n&3zY`
z^%Y(-9H$kqmXi^<Y8452m7}M{3$$gqENW>`m}~KOf`pOS<>%QvwZFsaRhK9(btzx#
z9^Lh@Ze=NNnHSCPKX2&#{%DWsKKUlKEak~Aq`&B{mULIw{QfA+j=0ji@$>u3E+o1!
zSa;34yEi<QW3**vCc)>q)&`&NS}^1AHCk<C#)0RUG!ev8@r(<7wd3nc=Bpdb`U+><
zr?tXt-NtKW=IRC+Cm*#IZm({LM-B#%cw}mVc#XRmh8Ftz?^8BL<Jv>Fa*hV+q8w`=
zaTT4S^9lRV#bDmS%9mxDxj=)8FUsIsU5ntwt_AZ8Ukj~+_55*0^(7fM@alTSC?T}L
zgIx=nW8aXB4ZN#s5j@7VK7EzdMh*>-YQ@I^L0~PD4a`;yXBK;R%R~i#!nFwgife7~
z*{((KIj#l0q|J7<kzVEpi0X4PZs7A=i{J}fE5jGMR)H^atrh;dYi;le`YyVhg3s(n
z;Y52ueO4QMl54H-G}kKdbl1x8OxGg#6xV{hkraNIQSt`jQa&~W@l-rvUe-?IpnpmJ
zlx%|%QOg3AADMq^#bFw#EFT~_ksGmmt=-l70IvleYEl=-uO5nTklYsBljhSB|DGis
zA+7!7-7uKM$dZ;1v&6nx8dSUv!QXH#f-iL~7%qJEn$64-O#S#b<zV*}#`RtGafSJs
z)dFAXS_EI~S{dG5zn39%dTEKm$5oV$mf<~Ii{MYV7Ic*0mTRMO7YvTpY6VkbE8Vq&
znFP;{X>@F+arg$;+Ta^q3xZ_dO&J^b7S|$pJ^fOSB&HP}=2`@=?^@6%`^p&`c(`j3
z+~HaqTyrgg>#p_LW~<uBA^}pZctv1uXT~`^!L<l}NVVjKo5I5xL--Nbf@o><Xtj}O
zL8=u;`+2Q!s#R<U&$0HVww$YcubbtMdD?l*s?BPFkJjhB@wEVajB7!6w$y#w>NdGG
zps>A)a(IAKvUd5vXy|il6t6|_v93k%@vfEO$E^W5<|+InV+jA$wFrK~wV<a2H(hO{
zQ{Y7=)j&MOV;O$<f0kCjT9$oqnfVGHMdoY8pB3D#=J#8*;7mj)PpV0rRru$wMetLu
zmEosdtH1~9*SeC`mBK+PN+T6`oNHzH5Z5C3Q?3QsrxPz|Ad-EM>T>D^@l>4szp9V@
zw7r6*`du{{U?x?t)udp6X!fv7N8onXBDm&S8LqolfjeDmg(tYy2CrBrJ)&ep7B*4%
zn~L!f4gcM>R`^ZVD)8H`mEm_?i{O8_7K|K8IYI-LkprnNA5VaIDjvCuw4F<JE5{A^
zib=t+EYMvynn^Xk@?5LI-C|j7YryU~xHMd<=8sw5s^E#%Sa?9H_0PQ)=(U1gw5Y?+
zo8yW3UXZ+hs!4pL!~9gZXc2t!x~YeFYQWQ7i{Kfq1;aZ|_Z_BN84{4{a(sb!603ah
z>^ddW7<{U05qz3!W%zX0DsYc$tuQ~foSexi9H8Gxm29-apLDGPALLpYKG?MgKE$;k
zYikZoyT86}B_ALz3+_aywXW7mPPP=NFUJ>H$=Xra!kX*^cgWgN*vaj{Nm)AzN4g#O
z<E$Nphuscbk+q}nrrUvJvhcZMtJ)K!q!QfQTm?tdN@^YBwf+d|P!`;a?W!jH;JP#q
zK1%IU4M*>~WN5yFLt=tjXB_2^8cZ0CBt;Y$51A4mqmkHAU_8VQB;dl7lcD3RH&u{&
z1({+Lr)7={cxU~_aB}9Nu#1ZEGM4Z6uwkjfceEw#;3is4o(%L=i*K|iy`w;V$pW~&
zwvyOU*il8X1NY0?Q8>`;z^Pd~3NzdeT%5I|u*B`a=d*Sce&=>zW&Jc0Nk1rTp`!Ey
z{8`qH!Y|woY}W6EC;lj`X1|@=32u<Jqp-2tf#b4v6b^MekQtG*n;+a=wBICKrUba2
zb)kE(dZlTx0z0h1uDtI<)c1JHZ55noQWtonO7eEnu?-50tuzRp>Q%vWO{#)7nA8O>
zF{uiA7rW@kN!Fh#IMt*s@N|=^;N>QD<r6^!Ov+>=C=iRxD3D2+*im3wiXF(LOzbEy
zE&o3>L%*r1E1aQ!)?s_yhY!ruyC8ToslQHN#yGz5yH~YkKDF~>)vCMpG?OamwSp1e
zN3A=(7I>FQlk;tTMR$GIOsZEXdad9D$ML*tW~GP6xE8^CxmJd&{__osnkcmUPcxL^
z4%Z@>-+(AO#Vpar?$NCrxZscUH!0-G7JSX5DoDcx_m{L=_n2DX@vcSi$-~oxCs*pq
z(_M?;8LkDV%)hJO!D=J@*-&wWOZkB%(%BZ(%o0qi@iSf6Bbb_ZRbt=FOqB2`u0`<a
zu9e|Gs+K%;pzx=RA^d08BKRfOg7loH`{wCZ(gRYx;GzbPf5~`;Uv({lkJBFmhzAn>
zylWBs1=oT|$LhWVbSsg9RF^3S;z_LX1H!K3GmXJhU5nsXTx)}0buEHlb1ew|0o}Ju
zw-OdebqOBCQ$g_TT9IiC{<~`t{HAMV_-)rJ@H?)x!tc7)2EXUp7<geNO|eYQxlI(l
ztD+3~82Ad;+Tg2PYlW|ItpZ=?S{eSHYZ3f?*Md<Xc{}KDZOBt-kZN)U`*v_9I#lgX
z(QR^?qj0)8>jb}%wWIJ&w*!Z6T1x&){81>YD5rn$wyYfm{@#Gtf&H}ai9ZShRTMig
z)7h3r8iN1Zqj3_XOhS;n7ra>eRjsv}MPCDlSoEj#HYn`tcHVSK+v={7W>N*)Dyd1q
z4}|Zj*86)c&}&W1x0SCIUt@&TYWZpxX>aLG(fjLHstrGvB9je#PIna?-we$S+SB+H
z4d3Wm1pmObGJM2lX}rnFg2EIP#bFsf(zOWwtZTvXLvX*+Mx{$2)#YRX;;Hz9oqpQR
zM!J<;Y^%7VOKC^^-+Tn|XTXF&uj2DEObkVz0kiKYZ7xnVe5`8`{H$wj@N=$3@bj((
z8C<OU?$oXH8l<|M2S7X(%oBFKkZBD5y=xKtr4cqKUMx}gvWn942tLcTAbR$FC1V4h
z?OFt1;942}+7=ebq9zJ+Rg5PmJkPZVzSy-OxGgtN9Y3X8$>XmTaVe5drIheEKjRs`
z)U^oyvukbeORh!mUt9|!rOkWHW@ZVdemsd`_Z41Tvae~&v_J7AhR;?_)`1lz3g=`D
z^U2`PiX5pnYsi}u@=H5=AF{>v@t?s!{*vuJBfC5Ajh4>Kv<N@oS_OX4wIF5edpKhQ
zFLNz|m%CPmA9bw)Kj~U4Ja*f(Cvn=EDD0!6<hK>x*R=|~ziVaqldeVZfvyFey=AL3
zfID<6YwGW|NhO*Q3B*&uB2n5pt+l>x<+`BKps<mOa$Nw9&Dv4e-|fIzSvv|}bUX0i
zRx&B=rkMFx?OWVgOM}7?cLt8i+ELiq?ZE4^b`)-OJFw!xwKOPfp`s)O%yc5WSUN%d
z?rQaFV-=}au;{SsvmQdFLE&@esuR2+YnRDjf;g+WQA>lur`;KtaTfOHGip!EGO0l7
z74+u|TI*zMtqOXr?tI|vTCBB_*-2rEx#|Sp$l6hO$L+x1=&_Rc>#NaUy0exBg=gFu
zc&j^WX;8RBMVTdFrqM8~cdOsW%zqW6UcqDge69E*GprV*b!F8aw!pg{SA5c?rxbtf
zQa*jpYY)h^%n$JUR;z|@?_6-+eODc=XSJ%-B8;L1P2-7lD+2&lUCIYdd5}V!$g#@f
zbi0zqvej_KR$r1V>0_djypIc3)J85*d*SU=6Em<aV+McR%|POey}{n)cCBC=y}>9|
z+|%}oG$JwVsS*xFQpGm3QCB6tzJR~%S{r<pYc1wPfqh@e*uZmKi{O8_)&}!ia}q}c
z|I6+AZ1Z}xkr@M0T^2MDPsQ(Huy;^X>MYI$e3@!;(ePr4!Z$O9+P-aYHb!kEFmSF(
zH4slL4-5x#Uk36^adN=`W_^X<BxCQlGO@#>`&q{$cxTsw<m2mZ>rf|1bxA&mr{X@c
zci&8V@G{pb@N(CJxbSt9+DPufr6$!tJgqz~e)UXp4<4t!;)?YKrBkehI{2VTT_BAP
zD4krIRvKZ`MuFXrYRz~m!asE_g1h^t6=iy!*+gNYit(`oPjW3t8;$<U!tDg9F2f1p
zsW@%?cGcS!Y+C~!+MEWvda3!*E5;_=K-<yxJ;6S-s_%P<eQ4L|KKU_%#fn>7SKAtU
zD38}|!EYAiqw7~19Yocyv~wdLO>9RLCs-8iw8+o-$l5zD2qIjL)d7y;Q(4|q(Zi_g
zwH|#hINd#<COc~sa`|*!FZp0F6H(`&ZGNdW-_UJSX-Y+%kYka|Twwz>!L%SGTAi$>
z@hpcw>skcA;#wR0s%sJanrp!%r_Elqk+lJ&x=eBqPsNj*y{~85gZUMn_~3)zbh|P<
zb3mFeIdYelD4e3AR4&7_T#MjST?;x&aQrlmbQGkzoHRf@6?c?h$=S@>YiqPCcj;EL
zmY)JRJ<qDmYJsnGErJ)j7IX(+ms@k4Al1{@Dd9}|-B(<fnXfuX?buhnLCJk_ZDcNq
z>k{+T4pKYz)n4E$IQsGRHS^U0W_@)O`0B8L6bSit^%Wmm@DkS|_%7GV@ZGLe;Coza
zh3|E(4SvwIG4MY6j#PY>>Q7-`e{pIIyq{}rFfT7kN9;w$1Kq9yk8`aI^O9D4Fv6d5
zyI``ByjQgoa?%G0QKmbHr*zKb2jXYy<9SO+TjR%Tr&bT@HeS-<pQt8pO7g;T%etw#
zETMZS)?7MQ@qCx^F*NDVp`5ArI&$C-T0J$oTDKx~4o;<?=vJh<-T>XJTahCDcF=S7
zEupRp^?Nrv*tavfE>q+SB~tO?T&G2PUqimbUb*Xf9n|3wt9)-()85>wTlv}gGtX#H
zx=U3VGw>@KOlnB!e2caYo~a?GhLp~=5vhaY^j+lCkZx?FF{f%@VgLVY5Xgia5BW3{
zoDmqhhjftQi4VVI1J@0{mNDZed}iCQbu-C0bYgD=v98XeSc5lUZk4(>QRHP|Ioh^S
ziC2Y18m-dqUU4tQ{aqTTSaqpW@iQ(Rp~!2d;{FRNO>?VL6lc5iCB<`Hx<K(_mo8QO
zj!O;2t6jQQ@kW<!R=mw6I~;9^Y-<csUO%JdXZU(LT>pDBoYA(3!`0#n4T{A;7EzFy
zCqt3%%9^XC%Ku(hn4~M|3PJfHPz!6-@?E)E4;a>8IV@?z7F+o%#JTY;ICyVWN4}<a
zgFmr@vJ3pZN$udDRZ4!}j>4=c4Op(zK)w<tcKsR@-cUQaMR|HQg?_d)cY$k|)D8|a
zsf(W9XS2N><Rx(l1pKL5C4o>NX-OcYZEa0o!PO>dn`BXR6U99iMK@7A=n_#p?h-Nl
z!lhp+KIhU4ivHSq_n%dI)vXA9Eekz33hvSY^QkkD(8+>4*v1h{L&3A|<?4u;AO|7H
zpvw(%ID}Q2BRx_PBt24*2z(UU^GCs{I(;s+=~e~rF{u-LO{D>)-ZK|9Hz+dgBnpt2
z)smnXD6s??0+}KpNz}^un3?)SB{ji6e>gyj|Maf>_s#Mb`W{ec@gJ{{kBM6<TQ!iD
zTRT<oMT=<anM;}*VHXoQ-$f1zF03S9pijDP#?@z7Fjct-Kg`Zgvs&P)YZ2V;S{WYi
zS_R%p-;<5+&zmW1t)kpdRNz+E%J8<XMeug61@|3v;`17aT*HF6l<Q#-PsR5gp|5s)
z5sIAmz^t$E*G2Gkj3sDh38w$?8x1htieAfM-^Vg}fNQQraNV^aU-;TvZ6sg$2}W5T
zQJ3QTU|8?SVl9G?)e17+Pn0Mer($dff8MnqE*fo9kOLPSZBiX%t%}F7vq9;zX4nbR
zWNJtw`7NJ3NislMlBE))nRN0{nrw~MK^m93U^b5M69(dGHDB!@&BTqiTTc&nLy(r_
zIW3rNG@PL{O82B9NTYH^1Af|C>;M^7u>!L#b_DM?u=hmu6;CYq0@o_=g{}qj1z%@b
zT%Dj-n|HkKwGGvJtXdsB*Q9n3Pw9x869s&o<`qF4NKV15uW&HfJ70apsevzXErP%9
zS{c68wF<o0wK9CWYZ1J}wIJ2(yE|h8zvNm3|HZXFeLb!=1s8ub_pF)J!QY$I4$@fh
z5aH_?uL$Bmh6v313Wtcje^p=c5W%my7QwH(R)+uPS_S^QYpw7buC>AcbZrdWvwAAZ
z()(gFg<cgUz%lTduC>8mcC8iuifa}49M{V59M>ZFtF8s(PVz?UiA2U7eAqran*{Ep
zr<Qn7I~$Y^QUCI;HAs`Gp(e;SVWV{#9cPVB1ZgInNt9?wuF%13qv2W}Hrh_3RFvDG
zM`l};3Sqqt>M@A2(1N&%gAEtj(ARi;G5B&(1ZI7W4;Jm^I%0pdk(=^2#X*+DDT5V9
zxRmeUG~GpJ3m#L3Cbf_D61>6AEPBjhse=45AellSA4JM!G{~Q{k&8XB-kb&^R^adK
z<FIa!KN=zK!Hsn)OGR)Kle)o?CRIUCQ+GZGBQzK{;mX4-`3p+Z)l{b3v$N-DVWCEz
zh*xRhHtSA1i2uYcKl>BW+EXB@)GYW~1Q{h~@zch<oA)#wUs^5QQ}DED7hPgb*KPdA
zVc|PelkY@;FAhpQ#jU~gsNky;N2!Ms%~KV8Mm<SPAP!}WLH8Yu9*5g`ndK6`$h8Q5
zMYZ@Npe72hW(?uiT+^^UuQd8~wUPA~q`IswAfAesRrbD~X%AlES_Hr2S{eSz;50Vr
z)S@N|XR9bDt}@Jzp^6s4=ek|cQGy$wHgZW1Qe74v5Krlv@9Fw5>212a%2o#tP>Yq^
zKCPi9@sxx0GZ49b+PeYoZLX@|K`O}~Noi_OU@4SYrn_x(h7#ABag#6?({YpV57b^<
zfm|siO;Y%w+ks0}O6-(v!=1qis>lrxc(O|UN;BmBo%Fw%ZU)km*bF8_@dn<iH3!I>
zK%=&7Q2dcQRI&}beq$z`V1GTG70-4m{?RJd!G2n?xpeBW4GLLr;nhLttsQUKis9Ag
zi`qQR$YrZ4ws|5j8E^X(Xv@8{=S^PBnKqZEl^gkb1LM2V&C9{UP4^yDCo+sf;pM8e
zh;~W;ljW~Qp!`Gk$aDnXS80vXsk1NXA2%j-hBuJORl%`9b3Zqy9ia81G;Ju1rvXWi
zhH53-uzPJC>a|KU`d`w2NU5}<cf)b}Z!x^Vj`h?)A_6z-tB!eBz;I8k5Z_tAyqFhX
z%)`6%ODo29efc`V;^_pbRy@xMqT4FgK`!c&pRu5j^%l-^ywSECyWrLuy_`V7tgmqD
zcW6Xi7TH9QmqFz^;|ksTC$pLazN}Jnsb_XW*52el{^)DLCCdJ4PgmuH0TO9^0MrW(
zfJ?OMH!O<a06ScF@d~M&cZr=p$tw~u^XF=tO5=%qpe3-DAN|GZ+dCIDKSfP2l?e;p
zsk>xtpV^?`uIl;LNXEx4piXdxO2u=HiW9A3J4i*DF!|>8QR^<NRXtI0x=Z<5MC7$P
zC#bcz)tRrgo0=SLjypiwY%ZPL+o0gCf@PUqGu2gm)WQo~i{Q&#3yyAlooiurf>bNc
zI2F&bighqsF+7l|NHa1nAOXv41+%`w1NnSy{89@dxRSxax6~v~7W^I8BDmpN8UC(o
z75EC*THz~QYlE+KZ45lrZkJ{~QlhY)it)M(4|A;zF1ywWZ|GVD9`0Hh-o&*C-qf{V
zc96WU+RbVwNVVeGLB+@_)<I&CWfIK#3MUM{Ue-*?gaHYrsdPAamEE6CKej<3+dw#r
z7O7)0T<{#>88x93^6&=yv~{t1sUppa75J1}fkQO$1s~Psn_HtaZ|{Md_up}g8Kn`M
zw=`&avO2ZhJ;`q5UT^bPiht1U>ZPgTEj34bMfa^!I;E6;)EKvz+OW@K4i2<87#?r6
zN%3NnCWE9(Zu;-;rQqHtgOMgFvCFTiKMF>rMryq89ijK&EcZ(s*^mS`**NCab2)wP
zuHEvs#?uzV9^W^?Ke8;;mnqWAf}1|t^S=Z=VT+)>2`g)Fk+s*kIA||8Kk=YtoYiW-
zPmw<YTyO^6Kuxx>TJ`G{?=&emfpIvF%q%_d7hS8svt0|8D17Z|L)QsXt$2wFE7qxa
zviYikSzqB275Zw&*DUkZ1!jGPtI-&(aDr8wlArhOx{GfP$Q2iOgzg$xYWc!6xg(;C
zw@CEqcEhpXmf>I8Bf9g{Q+&dN|KwT){<CYr;Na^%wULKJAk~Tohl<x*#X7j$q#Bs@
z6%NiVS^?{V<$Zyg(1s-R0hRDAQhpfNHE2M(C(abSoxbswe1uKmV=BgmeL3R+uA~Yq
zYc;vQ0r6CvJp$WM1C!+iTxe1kc%4eIuX=;hqizUh8x7M;qeLyM1-P|!U^1BX6&?ej
zuMT{TFkh3vtgrB+ixJw9ZLC98a82`71MyWb++)?j##U=$eh@#WCL~e3+@{hi-aPns
zmHL;a-qO;b^uDSsrQVYKty$TVZzbO&xw|Si@_lM9O)od{y-F<e?)dV^JdY5hAIaI5
z0x#xE=RmSnc$VH#{T}T8!A!mIuclt3_OvU<?T=MrM#j(RVcxGVIJ{|Qq>fyC{J|4l
zi{MGF1;;7AI&Btof>bL$D5=Qb<CTLF%vKB!EF#^*q8i=cuN9B8D5~IL8MFLQhpyTh
zd#OG3<>m`?SK%irU0SW%BLL}+%r<#ClKYRHlPyg7zM1k7u0`-su9e|yT&uv>x>km-
zb1j0ecP$uOVw<WqvIc`xD;`@a9&Z)v;OQpSKztQk_2GzSWf2AGfXr_YM{!W$A{zSY
zz*n|nxMK3hx4&eeSHW+X)B#>*QWeB~!6RjMeP3(Eha!BVYY}|2Yh`$mYZdqhuC>A!
z>xX^PMjJfewO07+u2tYmT`R+vxfa3SbS;=p^z{!Kn@lH=YQ@uuiVs@FI=GFtC$j*=
zS99r$#|DR6=&C(*72ND#@}gz+lopsS6wKabYChD0oRmBIOFvPQ&CDb?i9V?&XPQY3
zJWC}xx%D<EFtoC8fuuy<eGDGJ|3%&ZL$@+X!4_+=eXQcKCIxpfe^UoT%;a#8_M1wd
z$tQr^Fo6o57Lyz1UBLr_Fue9@8pdfJ4tSAC!6Q)GVlqiKKpYl)R{k+{NEk93L2C6Y
zoi;n)cWgdw@pOJh(eoVKnN|an;JGpR{+61?s|tLJYY}{_Yr#>AuWQssj#`jv#YZg_
zuds@BkalH?g7}gtTF&Q*eYa)8gzs=If|s~fhVOK(0^j3WD}0|OAYLTlrLMKY_q$es
zf9zTre$cfDe#kW??=gK{uCYnFL0rlN1o2cn0->)uzCJMbU0{pGBG<7X9V@to41Krb
zyPr9#fjAUL;Apo3KcP}{X=b=`KdTYHZjo2lReQ2faFg<=TK~pt;ov=&i0OwGQ?Lqe
zq`TZC`0RIUHK9B5_W4kluE}rd1j_(_A^s|BJy=_D?X3q3>2_NCWb+cN90cQDf+v6c
zW%^6aOZ!4a53e0`M?u6m@{YGP;JP`le@3y#rLz^?d9c16q$Z!YS`&DJK(un)_(7Et
z)8toLD_#}h-?|pTue;U)zu{U0zvY^ew@jPQ=pG3Rq?z>Cr9?ww2;#r^Ag6`rt%W*>
z&$wc}K?%2V!2)Jm2yeL9yN<o$HLC@_-?cXQN3I3=z}FPDk#2%ZOqvMdskrC(`ixbq
zgI_bL8@$-0N#Ly}b%V56u$0i;(N?P+q*fefc;gXP>?o=j-gs=PEp4aU`02S%t&}#>
zec!aGy1?(Klzg?3!cA_Mca?9hAO|C~_HO2-_6f!7UCKM&MR(EbrqYDG$#H6OvU#b3
zj8?&wA$fm5YsE)2{E%xA{D^C1c$sSzc)4q>@JxTnt_?oLwO064*DCPou9e~0u0`+}
zt_4R9eSJ-1lOqSjrCb<;cq%?}LSJ=!?W-ZkMFx0)Ns~Z2CRQLV7R(x&`=f>44&qR*
z1i=HfxdHO!tx;PwD3Wur%uk*%T4Nszv<l+1VDh}L(X3;&x`rukYEl(E$)w=7A21nV
zCLM<=9^ul_iqlLA9-u#|5&cTH@ymBRZP=jrtfj9CGHUW@si{HXEvr5~u1=8wN?t7!
zJ)cGP^9Fo;Fu`Baphb(|vs^2~XS-H`&vC64KG(H2_<YyKz{mSrtWT6EoZxS#j)6~f
ztqq>)S}T0AYZZ8gYi0Np*CKe9Yr)Y;^6uA8$k7Q>UEYEQ@l<?t;_KVys}9l)Iqtx$
zukhTBuLsRnJNTYSlfaVpaDe<t>%(M*XpyAIK?KrjGMQr2+<!k%=QJj(!s9CaQny8C
zGy3V(>Vq|ieRNxJ^0-VrGVpSj0e&dXowo|&yg{q(ZQg4j4YtG|$;&4XO%0STHwKx9
z@+77yXk=Ng=aLMPz#NpN8zkg{h4k<0Xp99=C8nB7xuGcK6E6=@Beg!tY6VY1m=i~s
zNhe6HbxO14rP1`=h#j|>EiYSyFRU_rv>1;%JltH@w^5`!1y9q+OOKkyo?u=#k3Rr`
zFEYCw8}K(w+o=IxZrbPue2r;4H{hF0+ob{DZrZL5_&(Fd1T%qsOU-6h3w*z85&WQQ
zWw;_Q$HxE3T3mrQbFB=Ia4mv2cP&`Li0x<ErYvC~F6G<{;;DEETTj~=ZtaCvt~h_e
z+6(UU{;Ip)Hk06{jySfomS(lUTe}v)+qhPSw{xumf6TR3c%*A>@Mzb@z{^_G5t0wP
z=k}wpTtykSG4P|VwZV_O)(ZdBwF>+**UIqEU5ntSTx&_g@_$L*K>hlJ3^_=3IctG<
zDjsrtJ)jAZBN&{tZrY?Qa=%vGYM4oTD}G!5ikVpbLGf*up5H31u;JELF$MpZ2#&J|
z+Cf5>4`i?7>&RAdnLcoQMz><Lq=&)_D#~gMzLd42aQX(sRRs^*5GlB1BqRK_-lR!#
zvV$fh5eaUA_CFCx!jE)p6VdvkKpUi7jPCBG4U(RShiQk%aU#-2CUtlB=G!2;KUkK!
z!3#E~_cdINv$3mPrFe%+dEdlOj)s-yE$X?Xe_QgeoOIf@ZEY$ITem@%NLyca#9Fgq
z=?0HfsjsT+KS}L2NJE(#UD7`v4JHq4l=i1Dm+XH^?KVtZ&RZy#8hM}Cyt&!ReX{@G
zYPWvsb9%bTqzr?bN37f-`)^k}bvQe4h`}bCuiPQ~N2;AVJUMWP!7o0-A^ZREQ4TS<
zW{Z_a$o|{ZuFnWD;K1x_pqcy}t9{v}VfnvI|IFdLr0DQn(pzx&F6pJ&%;6ipQbHRX
zVshZm>B%2YiO4dyz?V6Y1SEDeOK%g=JC)Mvdb-)oPCM0o6%TRg3yK@-FFDEzJW_GG
zOW-Lg$(?YuL1D1|#FJFrNb&P7U8s1qZj;{>8nZ>qn5`N}H|j2Vqj*v8z)PB1(%r~+
zgf)>KD6Wb8obHy$URB&JO0y%<L5gp?G<NNDZ>Mg>>O938U19}i7{n@{{PEh{@#;Ii
zjE4C^D!Io3Pgk@4rJ1Eo8<gf|D#IS^gfQ3%1bd+cJAoflI(QvAJ^?&Nr9tV!Fjd~%
zMEa6hw}VV$2^-8DHH&&EFtf!D%$x@o^-#FYE>0$ZnMuB=hwNr1`J&*eg5KS2@lF8w
z4OJN(@Ex@pD8FkpXvKyN$~)PmQ<YvEq#xl+?Rko=>yg3g6N>+GDL(`FsXl%LE}jAK
zc{;EKpVWU*kFX1L8{cc)seDgH+ey2^Shke*nzuks+`}6v$689NAVcZKKUJfrbUQ#Y
zv)6_ViX={MW<heMmJ~_hVEI~Xa%LSNZV;I-TbGg;lYjP3{*}|^-tzy)l8cPtR*_M7
zT?ghvUJ-}txU8~QD)4KdAM%RGXs@!@Z)q3{b*qV?xKw3HA;{mUS4)a-spSw!;igF{
zhD#1nnQ|IeLHg41w~AC?j(*rJDu?JQyFEe=+Y5Btue47Ce$Wo-4)7^6Yisbwq5qN5
z-~o0MQXQeVl}qpGmG5eLVwA5c_ckaDwX<ahxPI1-!YAAg>{MyB(%|OzPL=f!VV2wW
zD4wU=q4LCh9htMIl!gtJ&B*lnn7!9p#rCOs9ecf93Rj2eb?C=+E2|5aozJ^8O)u)t
zw2S*Hi{VywC12&@{>Lum*Pv(h@ZpGw*Pwnn%QzThUV<C~vDxp{jOiC^ExOwIkMXtd
zuF~<g5O#n)D#;fND-8-4xLtk*%1c1Zt(i7Kd~V%rbE^t6x8l!ObuZINB+#c(`|CQ5
z-qr0uInrjxs8epX!Rr9OY*KqZySL~`c3od+K~`tEg^3sCf`hez$tS%w$TGc>+L&D6
zwZTOyt)w<4OT0G7DR?EdnTwp5S7Mq^SwFqn+(EbTtQxQUsBYt@?zxkoT;DF};f%Og
zcgkZFkP~Ec>9nTcY?)MkKr6lFmBD|gl-OCpt{gj?6*tyxVmDF?AJ2+h^v%?Xkyvs`
z#x+hNQec&o?{$GbT{}R=B&nLe_>5DSACbf`pZhbyJYT7Sa(<T7bLQo|AQBgBzp?eW
zn@2})x>OWbJ_LsUvzqcac9=1jWdJ1Ok{yt|$2DQbK+Hf!BAH)0M1JKwKD=@s&oFr^
z#)qjGPb$u}#c2Gh^t)4^m93NM_j<~sbu0Y_cgvXN(-ZfI{BTz$RY49CIXJ*O)SIls
z;lUwx`Qt#O{FIjlR&4+}7=TY{(z65b9lPr7Alr*|0!jn_Ngn@ckAvG9@ayKi&hQ>;
z-s?2z!&?uBx6bf#JtJq4d{`poXEmdHLuOICS@}L&)M_B>Ty`XXVUwWttm11fF+%@#
zDIB3%csSHJ3|NrllZ7x5HFA=9KJje9-CT_&VF#W3vdTPbcXK=*ktV>*vh{3FK96zl
z3zn^CgF8I3duC?L;qy!z)qpQHt*rrHubM>sNDqbkGKMgTN(|4?=|jrmkm1Y&pGSg_
zS?0cNgFgwZ+7M0vIl`sQMZFX_+~mVxknxrKYLKH%tU!ibtUx*?R)o)xiv(sy|A~Up
zpHwjVPZW&)q=M0ZA{c#Xw_xy}2r_x8W^kcpvIFFBlI03~$gMyQHnCbu7l>|KC?<eB
za7l*Xo!~Q&3Hc-bIK8gU<ZNlrHJhYnOLZ&GmiGKa3xCqB{JAXfUALRlv+bs7<xMN;
zHmOYE<0>|ljs(ZL-JBi@+v^kQq%wuCswge<$-ohI$1tUo`>&v9b9(O8Na>lxLA-dE
zCg=3z{U>6sfzoQ4{*g8eoud>_a;e|&wBBC2l^Z4ST$Q5Iyi4RUz8uB!BSw4gEk9y3
zOuIT<w}aymc)MlfJEPwzH4yi)d{jX?@ge(sXFjwu->HKtsnV@m2{&(YoR08Gx?Q96
z*4iT_X%gQijrlFer|RzJ(v<lvGt}Mby3N%=K1+8eb$+geUl-Rw{#~|CDfb_<fK#Mg
z1aesaSZ|#~x>`ehNVg)9$-6Dd-JAtD0f-eh4t($`QZ9fJOKA2+VXPkBJjIq5Q0glA
zVcx~X(RXa6?P@5pl1jyJ1?>u#%PyA7HSGCd7mu{YxWo!d)@1NO76>^jlFRSe9dH*<
zXnx@mH^n8p!0gH|yyBkg6z&<MLm>CW@yY79>V%tPF$1|dj?LhPUCeiJegB$EAfFZw
zEX`ZkGjQ|r3Hsck*PdT=fOAxeANi+;X=68?D@+tgOjXz08M>AJF;_T8#8KvtN2$3g
zlO~)Y?aYwtZHBaeU-3^a{Uw+*?ct<pXVUOz802XRSDy#i)n_~N=w+9fM@$~6*shOU
zcmgR>OC{~&Slvo){;s%=9%7l~BC*toHAudPl;&M!i)Le0^8Dc%X*mAxUV0HlH{y|k
znelQOm>XPC#D>glrgLIQfdwZvyiOOL#kTlV!C&d~nWQd--@3T8hXM;xVp-I4W*f^>
zV(48>X}P-orEVq1APq^qr9Jt2D@zosg;bo=L&2AhNnj?Sb5=E>bAoHMIH5;sB2V&!
zg1&T50yCML6I{y0?#SFtc409I%p`M8kQ9yw`W*Wz=<Gu4EVmx9A<Tr4>@Bp;?w}ou
z4e168Osu`FkrH04{g*?ws9?w@7W5+gge-2f;27|a$g;=467A8`K4c)T%*Z=EAfF`5
z^aO9S89Nbtz@#cT+LrN&AWx_z!Haq*Tw)hy6G0wZCw3Gbvnzp#An!#ab`%cPmmj1L
zU}oAaTIsa&>)DAQ566=>C>*FS@<<yX<Db~A$^>AlaxBU@6=W#mVa-oYF=L))2bGtX
zc%Mav3;dgXYS0D#+oUS^Red8v{DW)iI~CHUr9BjesVH`DDZZDrTiJR@uB2{0LoD@7
zcWLwKqE{Q9?qL>gqf;*aToc~OreP<@=P$7toS6?#7kxVXbg;e@g!focc#m0l2U~b;
z4Vce_<Q@_vq<E;|On8qKh4)wx-m07v;sh|~$a36j(WGMnGWp`V%sLjqxGwAq;wZZm
z;8n5M4(1?<{jI_bm|K+Mxjm!wTJrODP1y;asFF;dcY7#g@;SFCpL2tJ(!zgtA-f7a
zTTs-q1=h1n#0!cdUeIU6D}S_}kBoj^XqlV@de_^*pPN+|&2V`yM>NRgy*!x#S*TXw
zxR>`=^OH{`;v_F3aizeN5-H!if`fKpQQjB!%+Q|QX+5morMS!`ke<pUTi8S4FK!2}
zt|!>UZc8n2Js}G;NUsvRe7_Pg-?JWVjFIVA+N}`|iG8@jomOlH53sX;aLat4djGU;
z<0H6R`AFT$(`)c^8MAz#xZ+ThJCVLjytPq{2|;Vsu(far$uDnmdgkhZ+ZK_+`@f0#
zm_kQgp`)(QQE*xd9Ze1$O%5FebNMd)1pg8HBtN)meNuP5ZzfY(Hc5LH=~f=y<-58_
zt?#f}RggB<D$RRIK6{?`O8i#Pw9<$MJ090M<<cqg#ga4PUnJjoi^O(BYTUr$IklAE
z3X|8;C=qG7l$d9n3{Sj-zwXB&%}Gm+j+g9^<_wjHtT|kdBq9e_=Arvb!BSe##w$f_
zywX$9#w)g5XWDqB&o-DJ^5>pk?6FIDPP?g^Kgp(Qf4u}{{Y%yS=+YP3kt{r6eW95|
zq?HToI&czrkx4a>tHGoy1-~?$1ae`J*b%Z{22KL$MPm0+osh21?JY`{sC0vdQ(Ic5
znN<C#c8bqM`4+?~?|vocA_hX%q3}Ex+}OxTqO7+w<LtJk%5BXFE`g(Ls3wAYn^Xl~
zGHD|Cj!9MUPP@{d2tH&|6(rFGw?ZO)RElN1`?wUEuAMvEI|-hzQc{`1cij#ow8XAp
zriE8gx2ltSbsL}g;9pt;HSiB6wSy;V9_3Bgg|b{um(?<Vcw~01LV8~6;bQ%x*Sx3n
z7MWXN>G(@MAJZT|v=EYw%pw&ogm-Gq*R7k~;0GqPgH`LfeBU7Mdr{AASH9;QRdw|e
zXCD5vY6DBN<@7PUL3x(y^3<Po>C#Mf`0`wJ%2#>ycNKTl`5m_oe?m1{r`%=7Lif>%
zQ!~}!nO1#T5<KNETJ`pa6}g{|TZg%~mOg_0w@i~K*HYk?CUt|`sT4cgUwNFHU7~oI
zORQqdjkqR!vVC)D&<70)-&8Tan}b<l<I4FlUQe^kmqlcC8>`Y$HWpQe(ub$Y@a%6n
ztCDh0W0f?nX<e!ke%+qe1fQlAoFV&o@W2#(#2!R-fPYp=4!Ea#C~y?Useqg9xaj~h
ztJKpyYiXbaF0ZqIWHxCdpV}94M}FL9o3^#5wb>3%G^zHaA`6%d3drC{iwk=wa8SlA
zzzkVD5#aeYqTL_|<Uskldb}_)tSpc+$3d<i;#M}+QD?~I3*Jj*d66%8f1o41k$vFP
z0gg~<KxtIGWKi5f<)LycPScN)<X5DV&wocW*t@M-t($%@oH3L}^QqrO6X+-C4kF&&
z=4(6nq)D~#c&@#v9U5dEs)EB*T00YW61IF=t-I)?3?WEQ3Tm-yw6_KB*LPd_-WMD`
zeLNWB@Oi)vpH7g&NG95xUJ7=|l;%CwLt$N;xSinoDkYUEWDY8MgcclBodpL~_*AW+
zZ%d0Vo|pE}H)59&0Et|}TWZ}POtAwq5ijl8GKkogvdl6Nel}DP@he5w4}ILv<X0|<
z`IR0nKsWb1ztXd{7MT39PJx;0j8}TdbLKiDycr^Ue0@>Yfo+2X1Wzdn`nsfObe7oY
zut>&>3e51tOBZ~&b}qJqGsCl_Cm&sGNKZ54vn06fBMnb$_u}7df!}g1g5P$nC4c1M
zYlYg#LuHU^#ozp<;wx6M4&tC${;F4lLe^XOizS4Q3#mH0K>-)?v<Spo@&}_vhj;kw
ze>c;0_@Ayt@O!S6;eWeUfj@Aq6)tU)CRK)^4PMQ)G4PjnOYP(b0+u#WI7`L&2Lj-)
zxYh=r<60{`$F&N4o@-_J0@ot=Lf2aIbAsf3Njo8P0=&qiiQqz$I>8%Fng~8^QYZLF
zlO}@inA8c<F}V!{iM@DY68+icYYIrnGHaUUZKnq1tK1YMZcHivz)ittRg!gXQ7;90
zM19I{W{oNQOU3xlGs1Kd2Yn4vj|Ef*>6QevqKCqF+zzBqi5-PsxE)CBi5&%EmxB@{
z<ixJ8cuzC`?I0may{9eS1#SltVq!;OsoQ~snAlNx-R;10+BhJk-RkJHaFlM7$_uq{
zOIG~VnAGwG-6obp^mrPo+eD-=&JH$tZ%BE3*08T+&9I<5z)Z5{_EMPdb|CqYK<4&R
zc+~Ac@{`z6c-ig1%;3)L?JM51t=@Q$5aWY&e8CYnK7YiehD6NqBwwZg2{JXL#Bn2r
zAR(uQA06|Ae9V%QGcCu&DQ_}^1ew@TAWX3Xi7~OGK$Kz!5^!Rdk9Wd$sj}ma=~k|9
zz`ads2M<(9TwT{oq08*L!J~Idy(M-OW~wO920#uEdF*tZys#DDcp;sq2ZscdKVC#y
zu6x(qIc+H8;MQGJ>2}>_cIA&Tal{eEfg@5{-TysGQ*^3s<14DOl`qt-Tr7j9`XLxT
zw(8Y*FVL;j1J~LmZBlafUJr#WRg|#6o3eHk?p0ClKjUBh*nCt2<yrRtzLE7XNYg~x
zlIDM=;%d4WNtkOWZtm;Tdp#7kb35=zle*_9Ug{F~ZIh~uKqi0h1sAC;+onlcQ@5+h
zxo!0iR@<<F@JZbvClK&pl?KV(>3&-#)=2HTtAA;R{4p3xUoan4aN36qDb036@OvLJ
zr1XYOllohVtA8x*i3GZa;wN2dSDfO~sfs_+Z9EO1R({sZ+TT>%c4X>5HrreI5Z%fV
z2)1X;7H*$bxmCAu)kl<{(5+mxy`wm82X6sB!L(70Un;N2Xg}1GV`&t1M>Td+-Y277
zr@S<yZL8}Hi;+yqV^uoUmZ0inU1eBe#0q3-k(X-o>xW1j0IVA#v0gl@vouZ!3kGLl
z89$JdaQtQQw0r(<j}FTny6somu>s#{+D;9aVU(L!&_{H~#;9OKJHip&vBBs*Z3Exo
zA*HlP=OdG_xg<|fDXg!NNhd*OW@1O-aJK_{w8>;Wq3|si7xYqC?BaVp6h5PqMyBfB
ziubt$KBtoW-Rq_X1?F4wRY0!BX6i&r!Z}9^bF(5-j#-jeQsDYc!T~u!C3fK{s+}pu
z5|`NJXO#HM&z>Z)tF#z0r|4s0#D(E~D3;6>=X*WOVFE}j|I0a3UBx+5WzJ+evY<Dg
zdWmE~Z$8h7NK!K$S<qXU)`H$G2rfH6sYgVwE!tI(b$oR>?NpMV@*L5~FX-8QB!HDY
zyYDhRW`1GEP8EDcrTC{a<Y$X1vJl9UwwWF?pU|yH;65s8Wr{2XV);E?z#p_Vy#rjX
z(g69*0BM;bOTMf|bM?yQyM6@&zGc!Rkc$=>rxiUEs&+{->2SrPT;eL_RhKr;U8BhB
zTU?H;Zx;}g4psCkk1C7x26|1F%|A1o>kV<5pXbB%#)HJi>pxu5G!HDzlD{RlX@fE+
zPq|}Y;W|@KdLrc~wMh9XEz<p($VV-qRgfG?Lgl3lO%d06GPd-XnI4A>(_?7?r1M2D
zJ-(usG6VfM0KcN0m*-0*nB`o~6(EawYzBKW>KyK@&9NDLhAz$G4Ls9U>lwWb3M}Pf
z2ePWi?%;*)4rC}|Gnlnqyn!t9vDtjR>tM(v-{3uVyHW?2sw7Vxdm9uuD@Y3<%U9e2
z%u*(1Afp(Y!3?9Afj*+M^3%DLKVcMgJ=W+H4=9QvD+(jl^8Ybq_R?7t&or1=Wil@e
zmSHYTp3hW-S#zc0oL&m=XAEH$;KY!^j=H?Yp}@?=#4tY{5;32YM9hy@BIZv$aXa}D
zOAPb5T2n7$PqNF|?iq?_xCC-vEv|0prNFhW-1XidH-b~;jv9$x>8|)@n<<#NjgD)@
zyYiRAnOc2?O#>3pOFg*GT>iY&lb@uCW!@c+BqrH-%D1hQzh#G67vu4uOSC!J*3B-u
zu~bhX@|tgc%tT_<B))=|fy1W&vr74=0P$j5@EG8#U~V_*P09hfjVr>3nl`EdXEHmd
zmtJNvJExb(Gl$fipxFhQ#j7l{qZ;t{O>1kw9D?x#hBvUQ@EYg07hNJyR!_N!Vw_k^
zM9PnNlR8+(9Cd))P|C%8wL#%bwM%}W@d7P;$0}Dr0!-}wsrxswvvC#N${yLu4?a@(
zf{OB$=taGJzZ#LVSmOC{wJh05rpi4nr!zTI<WEl`am#VDR|J=;B=5H-t-rO-$c>V3
zct4>#SS!R06Pnx9Bv%wTeI${x3Vlkihomyd1WN4k1GJl73hb-fc)s#%;}+9KHQ>xF
zd@*>2)1wvU>Q;itxA%cwc&+CqAR)+mj3Cc##1VLpEtiwQADL7GAJIcie1VUdR0WT>
z3(?8o`6kuDubDI%yxgQJ*lx?vWbk;Cs^IA+O$IMAsR|CZOW(;LSH+SEa8I`aKV?!C
zWWWmE4!uS5cDLoP3X;cyL;7l6g73DaxC;K&BzvZLuw|;7JA%nBaYyiyOW_?sHyvKb
zde_aIKGLT<=p7E8_i|*hmc^6(JUz*<n8g|k+UvS6*5ISGk8*;0v4_G`8^bP!^<tO6
z>rASGoW$g`1k&5MQJAN(Vg~XwHa3GVwFGs6oJwLdm{mo*kw;HjSN@1yp?3t^>kVY=
ziS>}hFxE)!0Xmyv4dw#{nY|z%D8y#)ceQGgTM9S%>;(U&hjL;^;U9i{gN$=xM}Yy4
z8-^MD#E=5BAU1@#oJtHSY-H2E3Laom4P=f;)u(%yB{%7mNJI+E1j!c2L`d4Dz*I;o
zQ($lt%lz;rmjCSl|49epUp^q<ZhD}I|Cf3w9AKAkRgf`A>?kk@eGJG;Ju4fKOm|oD
zBDAb$o;E)N%~!n2rF@cj&iWTU8f0wpCV$l0o9XqIeC-9~>C&F@7a`<|<IR!!62-fF
z4HurW?@6D%_S`4;+C=!)M~*nZ^}L7n8Zo0JR|T=<zfNmZ*WK^udu<Xvk@}zd<GzWf
zSpQRh^Y#9VM=6qm>-7?9UAq!G5@hulCO4P-g_xbTXf7=to1}IG`~6bu$na9@NG`Ql
zf8^JFxJEtIX5f(^ldZ2dxnJP9(*HCg`AKrLX6Rhq$~*!+X_LSKKHEUQN}mLBF)Sx*
zkSFEx=nL%9fe<Tjf=N|yqDeK7D`N>2<RV#ofq$`zlR(ZA@kNA=K0_*Tfj+u5kWrQv
zK_2&rFL1uis494=Nj30Fld7Q4lp1)K&6G*ta+B;cB~JGeJ-E!STx#IsD#;?ZqK5(t
zxx^3pjq4=PA8^*dlkA*c1*e%*181021y41p2A*S57333Ki3>d6t-!CDR0FxdkTC)|
zcEr~fdR?}gU!Q^8sYnt*zxt^CA3t6gsLYr#05U)edMR*H6+4hqYGOx$Yb~*(-&|LT
z#Oa88Gm%!33Qo^r1(J%S&3rNz=p`5*=Qfo-n>XQ=kc%|&^5Cuo{+eqMJm0l4yv81>
zSE<_uujyJDUdy!zj$8}g6C}39HYqwms>>xQh^P2%oX$pH{aj?e>fkbyYT#PCr}gDS
zIdEN-k`EXu9B6ijgWYC#dQ*eKQEmsGkhP<5kK2L$K29hT1}m;-QaiY@N=bASM!6k$
zh)LDM6pu5h9h_rQCwR9>?aLJZZPMX=Wt-uW^E${d_4VH2RhoipEfrO8sY&g>Qhdgw
zDoB=O?4A!IZO=za=I5xRex=<T@OkFE<3dG7MLzx_4R2^8am~E<B|5eKX;Z8UGOy%;
zJvdSuk&g+Q8Wi@kAgc6i9ZP&2+}fln$oNVF;FWHbkCd7JV{NWqX<j!|k0Fb-e7!J#
zI~L@xll<Lcz3Bu!rJq?&;}&NpS$;{S_-zT;Gar7*{xZ!t2f1VcWI2-44oDB><dp9q
zL-@20A^4g}b&$~&M<7Ea5r7PlSb+m{9Tcm41eC`shzWS3O7WUkZ%|t7hSX)dhQcS!
zWIRZ1`D5}}+jdhWY??}k+dhRub$hIC<0r-ED_@$?6m3ISs5ekPP;dEQ!^R0}!J}*R
zyias<s6Y~K({g-bgYR@Lg5Pzm0{_Fc2>z#Q!3m2tA5t56MGAb}q$>DplRBSMeA%Qb
z__|4*;F~5@L86itb*F8@py~ugpX5jYag@#|bE2?mQwkN`#z}=Y>X+^lErN%;79<N_
zd#Eo79UQAtdMc;%jvIpbFFxnf!md`a4&pQICZ$igA=qJ34Lr`II(Vu|$;wUPbhE30
z^GvFP-_2H~u*k)J4GOnd<r;XuNp<jNUbU$~;kPdKYfxC>VsnGS8|E>%v>vOwNWQE?
zV0IkBFW)eW`YXh<2G(ao@!uV7gZ05&tOc`%eWNqJ;GJEIU|m*YUuF2F=F~9$qRa>i
zH>(&M!i!vs;2*fwXK<`(GNnPP70*<9b%gdnQVV7)hN<0J$K+!+Y*mm>$ib~%ZF88?
zS9RO3v`b^SdZ4{nvkD5w2laL<sJB~CZ~4Hq;+I!Tx94c)E(|i5?tl3|w0}$e>^3N^
z|8d<uwR&34|I6R}o;En$^EKVRI3z89Nq;TzLfw8;{YSL^*R_7${^7M#Wruar?b`Y~
zGoy9;Kehke`l*Naho{?J)bAO6`2Tb{wOf6I58Ln4hdp+mSO3`c<^MmmKTqSBu~8b&
zNBKWy!_@8t-F}q)V>+K+)on@V;kCNGQ@4wB9PiQX?{%BDmif1j`VF;T{t@-N`>0>m
zd7Eh|!LRjU|5_i%&pSHrzqpF=3{blbb-Rmhsh^MMQJu$MT{qqHu5Q;Fnzu~L*nLm!
z{+_Fsul1kWZ@5+JVf41?_DcPLzgM5-U8LKGb(?Q*Ew$fBx1)7CQ@45hWjm!xP0u`C
zdbXL$StnQFKeb<|>&X1IQb#|E((N(2j^x~zZdUsdt7w0h+ViJUKFa@#dffk3*N3Aw
zNh7#HxA}OmfBHYP|C6>eSnD1Czf^yP=7YZzdgvNyk3Os0eE$yBet$2Qhqg-IGA;k7
z_80Zxe+c(sxn>%D*gvOw&b+kc=Be_OZhx)YUG!%k^7bceohrMwrrWW)JwUg4`^Qx0
z3zLs;lUn>*w|&`Pr~5z3p88xwvTPp4jy|?|`+e1JoNoK7Uu{kej?wK2y8Vi7_fW^<
zXdu`AI|EYTK|Oxo*Y%G-ESEDct)}Ox|6BI!ssGD#y&#@Dbp38xFO6uBZu9X`|5Eky
zl5StqE&kT+<9x8Dp3i1$``FQbzP<n3_BU%BC+heR$LktDd04xTeEh#%{~?WkjsG(K
z_q2XLt$&~PoBrp=W4@k`UeoPQKf=DD_ZGY8<A4|RIQgA!U((~_HQnaho7P9YP5uwr
zAE4L6{8A!6e#s9~=HvNK?fK~tezAt%u;N!Z^8Wu*d!D^rtd4lzc4OYLmg~CB+h5a%
zeQEpYr=2ik%8|02adNsn7CP?48AqQywY2?-C(Sr|`?32RG;+q2&uQs%C(hjd$eG6-
zf7Hn1jw)>*myVq>{n*m>N1b+}_)E7lPEPlna`eg5k2~qa4;3cMzLSqWeo9<H>Hn$h
zOu(b6&OUxZTu`Y76<O387ZyQc_5>8YVNp>8gn;Yk%`A74NoM8_vjn0PX;l<#DIyh-
zYN<;>t9`JaR_aRev$fcM#)YbNqiU&WwI~#+3x4l=-v3EvZtm^V?>-N6=lt&fyk~#U
zGMOQr$f=5WDo(FCX92y&C_vBLXebv_6;7KS%Y>4S-4>;|CL}TJP$m=Vk{ITFdxT_U
zJ(P?`C~21r(o2O-MJ$H1Syd5nlSwB<52H>v-%61~saA)$1mmfgYu<;#;f&L1LWy|F
zG4H9q%-e)ZiAh{o3aa=2C+F=G4>b%IdSg+DE&wdAgwZR8Wl#8IddIHW#6PZ|MIoik
z@lLr8^}cwgyDEBA82`+EmKL80gQw_F?~6D7dGv^fv`N3EpG6_1S^&CrNGVJ+sz1WU
z&SVPj{pK6j#IG#1w4xI8bS3oO_`r(C5pR7={1(J-LHr@Oa~ZkrO!{yi`uE~lV&X42
z$fA%^3y|QEo(lH__1BKRDaik_gC+hl%$F0jwchfZbj-bjp6@S+-;Ma)h+mHQ-uwfr
ztLP2arLngQ@pmD93xwYKGv&X|6MtrZOUIaridqN59G{og-uhckjO)bM-*u=(A^H!m
zu%A6#hk9Q)uZ7oA3KYgyhgtF%``K<!g=6|s=Dx}kzk7hh@5cV%&C7}nn0S(iQn!2J
zKhWBwA3e}2@yt5a=)L)0hxn%cHzWRL#NTj{i7EH;;-K0<VNS`!Z~L{R-}Y-s|7cGJ
zyy^eS6Myj*iNAP@#9wu4ae}7(4Bbp`xQ#GOsNq8L2&c<ly*K;^Qu9*8#P5&z{r|)G
zuTfmisfk~P_+|fL{I@7B_dOGT2;vVx{OwW==J=?m|C)ZV!;}8LPo@0(K9z{x@|v)@
zf8>d;K9l(BGl{>Co)=ywp1JR#hpaUDSGy5^x5TfMTaStIo_F%*3%ao_6Tfng#IM{V
z5pVP8O}P#JhTgEU(g55|{6-Hq*)jM2^v1j|l(r%LwCUJ*=+zDmi2vGNQJ(VW;uyst
zrA`ir|5dltNZ09wx$2wOs(|=;?Nyb!XWYM!KLPQ*^*409jMSq>`NucqI4>am)4~#e
zz<}ZkH1Ukp*#YqzQ{s^~d(K0=@p=1T`i`;5_kCAO{E#PtC#c)LIEP|o`x2y&iWyFL
z97Q($eu&5vyEnh|*F7rn&3`Ztxo=-H&%F0iR`;{Kn9}P<>mxs2s?7SQFj6V?g%)4^
zfvU39&(1-r#g`vU>k2=8e`VGUs^Fp@6HsP7P=G1_hblAA7xTlEnZJwq0Gf}jLZsi9
z@{E3%A3t1~d9*N6DS3J`KNj;cW#+wNK2VwYte79E%sf@h>5v8fyO<xX%)C;}2PrdO
z6!T-0nFosbU}gM!F{j>W{C2^EQbiwf7=K*EhbiM{3ox|{J`5>@^uAOb=OGd-RX8m5
zJS|oJhk&KZ|1hysm3u50`zHqQllt%yBK>G3@D<iiM!^2z0QD(P6Ga!7s6_Rxe_n2|
zo$_y4Mf$VAXL>j<k66FL!&`}$sA1|n%x9cGzB=h&iR#-Q?jX)~HhS#br}cgN)pNxC
z%C!x4w!=;ph56b^|4L}pxgyo1!#F-s{U~Fc?!dz>&37Q91L@BCH1u4Le2s?w^CK)B
zCXv4C3@;OYy<l}V_`-q0dA-lqH1NIPwXidn?wsz{g-u$AWw>&oAAOXi`Fj1T6#tn6
z=l@0UHQ?8Qw;wI~6X4`;A<p)<!~Sy==4&nZW>Y`lcY&*UO<K1X3)uS&?=0s0XA;`J
zEBsgr^Ys+Cx?1=$!RmM5>%cAWKY(xd@E5_$k$-G6)a&45Jp4Uy3*4mpA^3(xO*%z0
zuYF0}uU{QZ^{4x1gXHio<nwsqT;B5Q#12K)*U5(8D4f^%e2oR)4!%{ess-P?RP^_N
z^FE&KFJ30x=qH1>+$7wz;|1W>4~qFL;++3kjh41-)`jih%fK%~x>td}4?YrnDfnUI
z#Lns9w}RgYZpym>eANWeA6_C6egpnNlkl5i=LPVtiNf2!w-M)h82Cdem#i+7`UJc`
z_#x0AOp6k~b}S>#cGN9mryTk*hOZD#PG4VV2iQ43fHxE8dQM+v>G;^jD;s=1_%JcA
zT=1L0uK+iG>|^jMaO1~zt&w~hKeiZlzJ0l+m8Ra76X)_CaJ%TuettdlOQ5eVkpv!x
z-tyQtesa?lV&Cg0yP+Q_X4EUNf9I8=Z^Zz66ZW@2Z^qp}p`X+$`USAFANs|&73Y62
zjWaISa&WUut^{A}(N6{62u?GKzId6=cDli-XXxu{@a-P`Dsbf~?}Ok2!A(8?7Q7rB
zALA=NkLPq-z|F@T`@k22n|uyDQ1m|mKNR^K4Sowaj!o1g@cY1xpS%M6VQ`brJaNDA
zat(3q_r7cC6iq#^0)NuO9|GSBPC<P=0saE`CE(q}xgOMA#r=6F^drA#Y2^y&_d~yV
zo#;)y4JL=c`Fs@mv!NdYz88ElcoX>eYb{NTehzpScpiGwUX?$UbWJ~Tp#KE=2I#wp
zbGf!7pJtq{gnsySlI{@b?**R#el_@0#Mw?6(xnxxzFviX6ZB@@|10!+kgjRp{m@@@
zy`|$DJA=qUalN&J8^1IL{5tR}C0TU_an4T~`7!x#hW=gX=RqHXek1gz|6c?B>?M*P
z_IG@JANnoO_w+Z6i*E2^M6T|Iol!Sfnp_3`1ngMQ<IlC!Ht6qy{#xkY0Uv&&*x3iZ
z8+O)t+Hn9mF0QxZmx}&p&<_TG2K;XD(};7utw4TEznuboY?;`pf&L=!HQ<L(`T4pW
z{I2De4j)17%9lf&?Jq_?jel4Kz6{*>fz{yKJo=5`7bBm>pZp#?0!~4Fy$im>qyLh)
zpFcT}CTOm=(;l^S{6%6$4FJC%{HqdqFbMo-zZU&U=#K|)e5{y{0^bV$EUgdtssaDu
zla>xo0zVV{rKg2AfS(I~$QI#0LOss_zw<fazd*ap1)ugu;rUXfuPeZR(=GfMlq(GW
z>WjjEDsmMEU+_{fPlFGAxtK2ie+;||b`}%o{;=-uCQXdL`abwZaN{5D1>X!l3U)SW
zK2()sA8qVx0k^<+LElZ>uidv1=XT$<&C*KKf8Gb*2X4m2Zt!pYsaU@cd=NOQUmZjp
zp6w3>r(vtF!QkZ{{Rr?=z|p*_5qz}A&e`Bq;HRS<XMnf7D)}_|xe`1IPTAI13Oos(
z0sjthZm+l2OM4vwek=6vK%W4=ANpMzM1M5+Gtgh~nx)Bk;M>4&0XOaVA^6?k--UiZ
z_$jZ8ofP;$av+?~Zlr70C!>jT{jY@n9O#?CUjsM(Z4T^|dGeov{;)qwx_83P5~IIQ
z$~y#{|NfKHy$|}y;17d;3~uuCKj1ZQi2W0we+7IN_;BzY;Pb&h2LC5<u7{r^|E9eT
zCx^-TiM}cJhe3Y=_#*JJCGwz(INMnPJI6wQKJ-6-OYEEqei`)Z&`-?#m<8VmZrb<z
z;Fc$!_kzy^H~Oc*7kl`t;N|xh_c#7KKF)s`xT%LjC}YemaMMptBF^<QcZZa#9p$P5
z-wgg8@FwsHe-r%!sJCX=Z$W=B_LJb-!3V;Q*$1uj@Fmc11|J0dPryfk8$Y=Td@;CL
z&%6k3dF+1(u22uAo=eFf*Uw|9XJh|3@Ohs0ssnEUH|3fR{&!D*Xa!fEc3ceJ?a{9R
z-|Xo>zXY%J*m<6~pP&B|ac*BrNk5s1`ZVjD72w7XyaoL;;0vIC5B!W0vGWt~Pr&~S
zz7~8pajwt74~hOj@B!2zIY0S+!hZxlh&bzygWmY(3g{0l75%CbiEt+LyEY0p?LG&*
zAM8+2Un%f`;AVcgfw*72tt8I*TsKtgn{jbF_@TpupA7qVgO3Ft1O6cRCE#W~@Cf))
z@O3Eg7UEnFWxo{r)Lr%U26#ER>9>1``{jQ>>{kvKJ9A*?Ad1N4x*j|UemMAN;1j`*
z1g{+-cFYO;G2j=04=Rxe!@y%BMSm9Tl!M;`Zv6R3@ZW<kft?EQ8K;V!|AL(w@CU#<
zz{i6R9xeJQuyYpp6=Q@~Lw_##a_|elF9LrZ{8R9`;9E}<J7&Lj8TfnPM<HDseD7G%
zpAI_?`0xthe*{m0e+K?Icqei052GFtJ-K&%T?74trwjiAd<pdC7hyJm-vquHzZ7HE
zll*s#Y+u2?;Xfwi*RSq_zU5bvE=AVY6NW!p%>QWkCgBv+*A9B)XW#gxD<Yyde(7Uv
zXPBCa&o9h+mHn=toxNIrq$>M6@`H2_pa_1Svy`zRbyT0v#ZJ`vzMp@MhTi-6+61j1
z(&zK9*~E{eaaYzV`N6hEMZh0gW$7GVP@-=t34Zx*;bvdFNORE?zOD%1_rgxBOYHm>
zksb#B_IHIF`%e=eNS_n6pq|b8`MCi5JBXLVX5p<LIb^nDKG!qtbqsN?hv;XLZVr(~
z5-<1pe6Sk&5!0pKR#Ut3bq09T97~63y3yAZ@Q+qoI((X7H4A+8c;Tj8E#ReR2siUo
z68ykc;iey61%7V3@Ma~~jo{NR6@CNw8qE<XxIGB{X;+D!KcC?15%8ZOpC<p$2H1HW
z`by;A)WiD$`p=;sai*oydq%&~-yG6{joanSkA#0%Di4k#&h6Of8FwSJ9+3-f6JY1@
zgxGlj{dp?*PSnrUh;uRcj@v}P8$3ds({1yl+X4NPS4w}l7WK9OeDYt#j_Fr75ig_9
zTTMTNd9@PyrN@YVBp%!jKJOagkAklU@4$M%tp7KHZ#q!&b0+j#z@Hl;c3#57xfOiI
zLgA*}Uj%;${kaWx{sz8eg6K{A?g76W{RGXWN{^Oy?4B$7Pf-6yg5UEO;TOaHNt*Zl
zJA_ftzmEOR<<QrGm(3G9_n`ip!0$Rs_*&>M0dK@OqHUVKLg1sDEFCueJPZERCBm2M
zr%HWCa|8-*H$%T4^<c*D9pGgc7smhm9Q^zSvG2gv6X2Oe!oLB37CiQz@DsuL@BMka
z{J@j$8{pBMqJItb|98z1x!`v2AhB};?9(=1U&n#p4E|&AO7L<|xy}L~^{%Cr)1jXY
zz6s;vPVmdYmt&lc1&@L6gnzgL{3`HCpIVxnh;rQs{tEhussB})BXYrQJ@hL*_4Y9M
z`pPD)J`ZuW2H4pS{p>2yKXjZ#_$WYsC>>C9d%gaJrG=(k$7_zn3T{=<|E^8+CO?zG
zpFLanD~K~Uz)l?c+P6i2BJ}gXUtc5qk)iUSi+GvOJh&vl{_O$$7qGv^68kqJ-KW8;
zI)qOI-$tDMZ5sY|2>9Cp_IJb1&JV<n@#hB&mU@01<6WK-1HU0J<Q+Jya?O!g!L6Ej
zc|q8`ZGxQ&_}gW8FcbXEl%>go;Fl90*l(!nk8@FA)u#0()O%k9J1?Ps8o#uh?NG~@
zzsoY~hdZGE-_I>=<X)J15d4U^a8v(Jg3r8F_;Bc-*BpU@+dIU$T~>J7Whd;EV?DVP
zasCxx=UddEH1+qnPS*Tzb?PZHjvOe)fPabk!uSUZe2%9-PbJRt>~qMcNoYFs-oJmF
z1D-`cY(|83@U`uhCbxnw1b^g9;n$)8t_L6G@rSp7Prx|65q9neKN$XS0{GM5Gv<i>
zF!;;hZ|@fVB<8#A;LHD8_%EUV0Q{qug@02b5B7qOA1B=S=R;`RvtN4t9pR%yu7+ri
zK*4P+^mE~t=Hb~H#QoMe=R&^><6;){SAzc#`>aJ6j}h>PvzAuAjQpp-ht3s#GwfUg
z{+EfuThPgF1mAd!@FA$T<>0$fURuWJYc=?Ye~6y{j)$-H;Af4ubQsxGztUWzqL=5P
z&+Zfb5wP<H_<%EnoALW0_|@p=W?i=jd~jOy|3WHXgD-W3oApWmVbYF!LNbob`SuX-
z*RbEY7IsF0AAo($N#M2M3sFBaz$b&hfpK>s_$A<-p7GcMzILyrm7AbXf-lE-Ujx1n
zd=LDp`CjZz;6u(3JN=<w1AfqU;h%$VAYP95g|{c5?|j$Nco!aS)f|C>+ji*lw_2K-
z`Q;<<I}eb0UV%7YfG1IJbo`~S1CEt;86OtC@wdl<kA2_Ly0pmEXyWW|H+uYS4fH=4
zBzE3LN1O=$0LBFkbA8PMKMVEt0eB4jA6Vx^!54zxf&8?CUkBbFc1*v$MRSM>ZX2Mt
zQQoidY*T=KEA*?;e<nl!Qh<I3ah^}T`>D@h=dsn6wonB-UxQm17Y~CUcAT`!+$Pbl
z1Rp}Y9PbNn)zJSA^TljDoC3ZF^Q_@>!Edj(v~nZ#Hux~Cdvo9k@KNYLQ^4ngf7xnj
zayj^Q;OmfXGx%!oCitrn;OoJ6-D+vF6`a?t?EkHYg`3Z#p9G)#i11fRB*JsxonHz+
zTd?{Q`1igLelhq?&HMhn`ahr_wOI6fq37Sv;rzUOsc>56>FbE&g%7?>_zU32gU`nL
z=W6h=;H{o|m;k;O-1w6Vi1WC!FzyVuq5tYflCG)eH2Bx>KZ}sAii8pgyEW;i>})QS
z$*D*tm(As4v5JVY?eizivZqa*-E7+`>SUbOc$U7oYv+=7B;ls$>#RP=wxh1ynsCFR
zgdNSfnXDbkFHrP#*mT0lInj#x%5imM*+*pa7jxxnwl;lrHq)i#i@DK!GTB8@3PLu2
zpSMVw4rQ`VrlQqJQO4=pvaxu=vH8oicEU-u=GrL!%vn>Kn=iG`nKOM-^VAvBZM&kT
zrlGM{>_$R4CqP#}PIYxf9r{LYK9W<E3gsZ`EYR<w@klNmif42n98bAvUn8|OwUt_u
zPt*5=9kQ3BFA+PL486;CrE;MKHU(S`>IZaBhbXbGu1K2`>0lfRCv-ge3UD?dHlj{U
zM44(*WU4q8eIMDSJ3Yd?Y|hQ9InytgKI7u)_Ouz3nz;Nb;VkH>v92z=)ydgu`X+MR
z&1bnU=q%b!ge=*iNW@8VR%|lLx1^H`@jV>Ma*pgs8)wi?(f6y{=h^fw;fA7inEDa*
zmmXuf)ueA^SstTrU?+M?ZKvHdv|>Zc#fDgQQrUdQDKM+6#ZKq5ZHP$y#>x0se?v9*
zyS|;EwxOy<x#@@-b*SsaQ=OqiJZcM|;$|b6csj@5Gw+MCD%_QG5R<z&bvkV$o3q2z
z2|JX2wc}Kw@l-1{Uc}9(a&{z^Pes^fR?#TR(Ie`mole3xe>DwtRj@;yD{5!+VX^I3
zn40>!8a>!3Cjr(Ps;Q8a!IU%KUr|?GAMl{2D(FE&z=PWApa+cs4=De>1*@wMGF2aB
ziUzm8sc`|>t*;Cyd3{Z#zp47FfLzr#1eBwZOwquL<mtB$A}Z!)I(Srb_l<PePBNV%
zw^s~#Sj>-;myTr|2R<?DBw}8je(Yc1$_B4ke2TBSc3izz%_Gsvvh(A)NLwEo>NI(z
z0YIa>GnDaa(vH*NU!8UI-^ceYeIG>esr!<z@y&l-^*Gd0B%jIfk1+Vk>MLuCWwsg2
z9-JXx7o{JEkokw*<i8oLb@f!$`u8MgiqzgJlxg+PK;5`%l?-(_Jeji6U)50E=q-PS
ze1;pOudAy?2B_b7W3s38Po|DKvgBK9df$?Zk96cR^x_|}o@TZ7PIhtHaq|0w>vrVR
znx<${4yu2eQ~eu;>LuVoz<_S32^ee*H34Zf)-)*ooe}cAJPPexSDL!5Su4bBXI?&(
zVD8eCPySiIP34nenq6XcG~OAHvObw73+V(6Svwg|<+F58C-jYajB2;(7f$#!pGeS+
z)(#HcVxa`hne7<sG}9p;S^q-UHBe45%kYe<^PE+Yo_A(0q18^7QtPDhw0EZMj1!B{
zR1;4X1*0^d$CIH2TB3j5#7@(%jBo@AVYS3SO5XDvK?pK#E>TmhBjSPnp%#wkhTEM8
zttDU=!EF30Ds@jf87CC=FK`Vx`T{dN-m(d*NB=HC4x>O^kb5M{ZbIT0$f$Apuy8)o
z;p74up`Mlq1@UR2%1yx$G)7(LQ`xpq#tA4_b$z`Sqq=ktv$@iOBGgs)O;p!JK~8iv
zau`<i9N-DtJQRDHC3xCzY%I(lZ42l(X9`S((rG6ZP`27eX$I*-64kf8sv85A5H;1c
z{w-Wv8!)zOf@bkLS}*w~-q08@i#Ig*FAZxN#<6oVW22{X(YL%|w7-Ai^<>IFS9Jl2
z*VhI(uZG&77&Q6#rcobMR}J++bwv)+*Hm3?z#6HpHo#OZ^<!UCH9^^}tqLe$ZDl}}
z)Y1$<GmqW{k^{`A+8p}tm}o{Km#ddLwBe*5Rtlc~cypF>JDe0dZvWiYHNaFNPMZvx
z9(-lB^#Sc%TOZKFYwGk2nx=UsM|n@@Y4ebe>3f9yiGGu%tsrNge3^EuHf@U2Hf1B}
zn~UnkfQgUBpH7T+<{?U}EnXRplhaGMa*rg_DxXNJaCMZHCcM0hX4~SioSK)X1xHe4
z`Qbzv-_h!@%5>TiNcFtqDN)7gSu`Gtsfl`wFynenyYuVx^K@lhMNK1h<Aj*c(auhV
z<E{Emb280$1gJstsW`S*`CP2gruVX0(p&mMq>JI#Al21Wy~&WC=hGRtmG|6KXXngn
zx^Rj;W%^_~+K_V&^S<b4f%?MaOQ$zoICT=K3ZBSWiGA+0855hP*)z^LXZDn4ySZuN
zv?**Z5f4Y~NH(ueG*mj2YtwsFE)e`QCMvES%Q|=3)QOYq>Wb=$I&NZa^kT^84G}jL
z4b#S-+C(;$x@Ot7o>^_)MyFg_d(kNd?JSE8*i)M?q`j;;u4%q-5})5R>+^(cF6!oU
z#rociQnF-F@h_WE-uZxt{ULWB*^=vA$mRtb0=;*aRWhxcbSO)6IHjRaKTHO7fH(YI
z$*`MHx<5zb*-$p?B*VO-(uX0%+2VQ#(Hzucln;1PuA*qUTvxGHYov2h9z#)|r*r_K
z+mzeItWs!3rwWOC>aR1K(!(=WY=!efMc^Z}o;8~6(zF^U8{9@bpiRZuu_V``Ns^t3
z-Qjd8+tI%t*VQG*K)TU+$Ir`8l55}A^M+1Us8ZQ19~05pm(*uQ>V~(Ba&W?pMkhJC
zHmDk8Qs)yIj!tW%Oh~HUO_NL0#~i(FFYZ%1G0_fQ_2}Uv{V|cCWggPw6PTg|S(0*T
z2clE9vyl)VFzThWZfYLY%CAm)+BTk&xVkG*Ryd?f%EK!YqT@ly2KNV3nY}SMwxQJX
z`RtJfCikvPj+Wr@L~%>@YISq;Y-P|bG}Jpzojsi;Sss}IEvq9Aak_d`$S`epO+oAk
zH9*cBUlnAJ%yEdVaviG}I{{DrxXD<+!>Fet(ct8tG?Y$kbK=o_+7nUMhB=pKHSL%5
zD7M)ndX;2H7o1n6b~4+ll1`Flgkl+2I`uAc1(Y2=ghZE<CYC;+V)QIq9FGbp8=!e+
z>t5hfIH9y>08?rDBwo;&cu$lyPDHAj&L&f|?}-?1)j>7Mld5Ob_O>;=Fp89o^BJ`^
zNtVd7MCmX#=D42dcEM>mO&(-T_sUFRqw}z(`i^E@s>@WA5B?GkZ4ELW$KKP~BW@y}
zOeuTn3~EIh@pe8-+XAwU6}7Cr^|>7nT&aEXRJ1LpCbKgxZIJlLJLMMFy6oe#Io`bY
z%u4z+C#iiwv6_>omh<+#PQBXT+{g&F(b?Ji5R?rq9obWnb>}K>m3%5phn~@5$W6s@
zWuM(s4ZZHkmf3_h;P5M~E*y<iY~D`m!)6)Z1wyGcswo!e;+pNUt(!)o#b~Q;+!mWh
zEZV3>>5~ng`YG!BRHO7upD3|(Kpr=4DnZBM)c*AAq<Y<<3r>zF-U^4t(~kZq!R?a#
z6Cf|nuO<@(g{4mjT2W3O|KhS~yd>RD&(gs}=A{D9**&$Ye>ap(O7rOqg<bkggv&$6
z$<6|D)8r@gdWwEkH6Ejk8MWS`>c{NVWa96nBMm+Z;Ugbz1UmkK=b$seHtjly$+3s2
zR?0jJwev?lD2Soc>sq;YC&(;o(H@C7Eq(3tJMCHc0BTZ#{kUEqqC@hG+UYyk^$_V<
zeIYsBBPanJ==7A`N%6E~PJu{J(Bbq^8r5J2=S=1yUU)@|KNbk1sm#&>?bXL)>j{Dk
zMcgzx0XMERRMy{Vp?xHebc7u5yJic!w33R=&(L(`8Q3;0`LNoR8p-lGZBM~_>z~gS
zd6lPEjK1qd3<Bx#MMIm8dTjyJ^>h_ssfwcmDlhtpaR$^=>C6fiIl6Hcy6<w8V1<Wf
zl=Vc8TxryuuZI&pb>T)~xtzps$n;32JeR=@(5&4-wXQ#^QL^?VZ^|d|x=AD*bHGYw
nqz{^NB{K`dUH9Zt|FAGQ?miA)+tVJ}Nhf#<M<&r{rT6?Fzj`Ol

literal 0
HcmV?d00001

diff --git a/docs/content/2.download/osx_64/jq b/docs/content/2.download/osx_64/jq
new file mode 100755
index 0000000000000000000000000000000000000000..47a4f223805d908d3a3c766f58125109619f0ebd
GIT binary patch
literal 185432
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

literal 0
HcmV?d00001

diff --git a/docs/templates/index.liquid b/docs/templates/index.liquid
index 39ee0c5a..d2d06de5 100644
--- a/docs/templates/index.liquid
+++ b/docs/templates/index.liquid
@@ -16,8 +16,8 @@
                 <span class="caret"></span>
               </a>
               <ul class="dropdown-menu">
-                <li><a href="/download/linux/x68_64/jq">Linux (x86_64)</a></li>
-                <li><a href="/download/osx/64/jq">OS X (64-bit)</a></li>
+                <li><a href="/download/linux_x86_64/jq">Linux (x86_64)</a></li>
+                <li><a href="/download/osx_64/jq">OS X (64-bit)</a></li>
                 <li><a href="/download">Other platforms and source</a></li>
               </ul>
             </div>

From 483f6f2134cbfed6aea39931be38fc55b0826879 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 19 Sep 2012 00:34:49 +0100
Subject: [PATCH 099/284] Add some release stuff to Makefile.

---
 .gitignore |  3 +++
 Makefile   | 13 ++++++++++---
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/.gitignore b/.gitignore
index 50e45cc8..e43b388c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,3 +8,6 @@
 jv_test
 jv_parse
 parsertest*~
+
+# Something delightfully recursive happens otherwise
+docs/content/2.download/source/*
\ No newline at end of file
diff --git a/Makefile b/Makefile
index 7348b292..807a4b21 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,7 @@
 CC=gcc -Wextra -Wall -Wno-missing-field-initializers -Wno-unused-parameter -std=gnu99 -ggdb -Wno-unused-function
 
-.PHONY: all clean
-all: parsertest
+.PHONY: all clean releasedep tarball
+all: jq
 
 clean:
 	make -Bnd | grep 'Must remake target' | \
@@ -28,9 +28,16 @@ jq_test: $(JQ_SRC) jq_test.c
 	$(CC) -DJQ_DEBUG=1 -o $@ $^
 
 jq: $(JQ_SRC) main.c
-	$(CC) -DJQ_DEBUG=0 -o $@ $^
+	$(CC) -O -DJQ_DEBUG=0 -o $@ $^
 
 
 test: jq_test
 	valgrind --error-exitcode=1 -q --leak-check=full ./jq_test >/dev/null
 
+
+releasedep: lexer.gen.c parser.gen.c jv_utf8_tables.gen.h
+
+docs/content/2.download/source/jq.tgz: jq
+	tar -czvf $@ `git ls-files; ls *.gen.*`
+
+tarball: docs/content/2.download/source/jq.tgz
\ No newline at end of file

From 26c7132237b990a29a9e77139037199d43923264 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 19 Sep 2012 00:36:37 +0100
Subject: [PATCH 100/284] Ensure 'make tarball' creates the required
 directories.

---
 Makefile | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Makefile b/Makefile
index 807a4b21..aac341f8 100644
--- a/Makefile
+++ b/Makefile
@@ -38,6 +38,7 @@ test: jq_test
 releasedep: lexer.gen.c parser.gen.c jv_utf8_tables.gen.h
 
 docs/content/2.download/source/jq.tgz: jq
+	mkdir -p `dirname $@`
 	tar -czvf $@ `git ls-files; ls *.gen.*`
 
 tarball: docs/content/2.download/source/jq.tgz
\ No newline at end of file

From 040604b7dbe2fcfb8cc69bc31dcb8bd80afcb4dc Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 19 Sep 2012 01:00:25 +0100
Subject: [PATCH 101/284] Use a theme from Bootswatch for docs.

---
 docs/public/bootstrap/css/bootstrap.css | 3004 +++++++++--------------
 docs/public/css/base.scss               |    4 +
 docs/site.yml                           |    6 +-
 3 files changed, 1235 insertions(+), 1779 deletions(-)

diff --git a/docs/public/bootstrap/css/bootstrap.css b/docs/public/bootstrap/css/bootstrap.css
index 9fa6f766..d6a835ce 100644
--- a/docs/public/bootstrap/css/bootstrap.css
+++ b/docs/public/bootstrap/css/bootstrap.css
@@ -1,3 +1,4 @@
+@import url('http://fonts.googleapis.com/css?family=Muli');
 /*!
  * Bootstrap v2.1.1
  *
@@ -7,7 +8,6 @@
  *
  * Designed and built with all the love in the world @twitter by @mdo and @fat.
  */
-
 article,
 aside,
 details,
@@ -20,7 +20,6 @@ nav,
 section {
   display: block;
 }
-
 audio,
 canvas,
 video {
@@ -28,28 +27,23 @@ video {
   *display: inline;
   *zoom: 1;
 }
-
 audio:not([controls]) {
   display: none;
 }
-
 html {
   font-size: 100%;
   -webkit-text-size-adjust: 100%;
-      -ms-text-size-adjust: 100%;
+  -ms-text-size-adjust: 100%;
 }
-
 a:focus {
   outline: thin dotted #333;
   outline: 5px auto -webkit-focus-ring-color;
   outline-offset: -2px;
 }
-
 a:hover,
 a:active {
   outline: 0;
 }
-
 sub,
 sup {
   position: relative;
@@ -57,28 +51,31 @@ sup {
   line-height: 0;
   vertical-align: baseline;
 }
-
 sup {
   top: -0.5em;
 }
-
 sub {
   bottom: -0.25em;
 }
-
 img {
-  width: auto\9;
-  height: auto;
+  /* Responsive images (ensure images don't scale beyond their parents) */
+
   max-width: 100%;
+  /* Part 1: Set a maxium relative to the parent */
+
+  width: auto\9;
+  /* IE7-8 need help adjusting responsive images */
+
+  height: auto;
+  /* Part 2: Scale the height according to the width, otherwise you get stretching */
+
   vertical-align: middle;
   border: 0;
   -ms-interpolation-mode: bicubic;
 }
-
 #map_canvas img {
   max-width: none;
 }
-
 button,
 input,
 select,
@@ -87,19 +84,16 @@ textarea {
   font-size: 100%;
   vertical-align: middle;
 }
-
 button,
 input {
   *overflow: visible;
   line-height: normal;
 }
-
 button::-moz-focus-inner,
 input::-moz-focus-inner {
   padding: 0;
   border: 0;
 }
-
 button,
 input[type="button"],
 input[type="reset"],
@@ -107,39 +101,32 @@ input[type="submit"] {
   cursor: pointer;
   -webkit-appearance: button;
 }
-
 input[type="search"] {
   -webkit-box-sizing: content-box;
-     -moz-box-sizing: content-box;
-          box-sizing: content-box;
+  -moz-box-sizing: content-box;
+  box-sizing: content-box;
   -webkit-appearance: textfield;
 }
-
 input[type="search"]::-webkit-search-decoration,
 input[type="search"]::-webkit-search-cancel-button {
   -webkit-appearance: none;
 }
-
 textarea {
   overflow: auto;
   vertical-align: top;
 }
-
 .clearfix {
   *zoom: 1;
 }
-
 .clearfix:before,
 .clearfix:after {
   display: table;
-  line-height: 0;
   content: "";
+  line-height: 0;
 }
-
 .clearfix:after {
   clear: both;
 }
-
 .hide-text {
   font: 0/0 a;
   color: transparent;
@@ -147,499 +134,401 @@ textarea {
   background-color: transparent;
   border: 0;
 }
-
 .input-block-level {
   display: block;
   width: 100%;
   min-height: 30px;
   -webkit-box-sizing: border-box;
-     -moz-box-sizing: border-box;
-          box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
 }
-
 body {
   margin: 0;
-  font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+  font-family: "Muli", "Helvetica Neue", Helvetica, Arial, sans-serif;
   font-size: 14px;
-  line-height: 20px;
-  color: #333333;
+  line-height: 21px;
+  color: #2d2d2d;
   background-color: #ffffff;
 }
-
 a {
-  color: #0088cc;
+  color: #558bc4;
   text-decoration: none;
 }
-
 a:hover {
-  color: #005580;
+  color: #558bc4;
   text-decoration: underline;
 }
-
 .img-rounded {
   -webkit-border-radius: 6px;
-     -moz-border-radius: 6px;
-          border-radius: 6px;
+  -moz-border-radius: 6px;
+  border-radius: 6px;
 }
-
 .img-polaroid {
   padding: 4px;
   background-color: #fff;
   border: 1px solid #ccc;
   border: 1px solid rgba(0, 0, 0, 0.2);
   -webkit-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
-     -moz-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
-          box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+  -moz-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
 }
-
 .img-circle {
   -webkit-border-radius: 500px;
-     -moz-border-radius: 500px;
-          border-radius: 500px;
+  -moz-border-radius: 500px;
+  border-radius: 500px;
 }
-
 .row {
   margin-left: -20px;
   *zoom: 1;
 }
-
 .row:before,
 .row:after {
   display: table;
-  line-height: 0;
   content: "";
+  line-height: 0;
 }
-
 .row:after {
   clear: both;
 }
-
 [class*="span"] {
   float: left;
   min-height: 1px;
   margin-left: 20px;
 }
-
 .container,
 .navbar-static-top .container,
 .navbar-fixed-top .container,
 .navbar-fixed-bottom .container {
   width: 940px;
 }
-
 .span12 {
   width: 940px;
 }
-
 .span11 {
   width: 860px;
 }
-
 .span10 {
   width: 780px;
 }
-
 .span9 {
   width: 700px;
 }
-
 .span8 {
   width: 620px;
 }
-
 .span7 {
   width: 540px;
 }
-
 .span6 {
   width: 460px;
 }
-
 .span5 {
   width: 380px;
 }
-
 .span4 {
   width: 300px;
 }
-
 .span3 {
   width: 220px;
 }
-
 .span2 {
   width: 140px;
 }
-
 .span1 {
   width: 60px;
 }
-
 .offset12 {
   margin-left: 980px;
 }
-
 .offset11 {
   margin-left: 900px;
 }
-
 .offset10 {
   margin-left: 820px;
 }
-
 .offset9 {
   margin-left: 740px;
 }
-
 .offset8 {
   margin-left: 660px;
 }
-
 .offset7 {
   margin-left: 580px;
 }
-
 .offset6 {
   margin-left: 500px;
 }
-
 .offset5 {
   margin-left: 420px;
 }
-
 .offset4 {
   margin-left: 340px;
 }
-
 .offset3 {
   margin-left: 260px;
 }
-
 .offset2 {
   margin-left: 180px;
 }
-
 .offset1 {
   margin-left: 100px;
 }
-
 .row-fluid {
   width: 100%;
   *zoom: 1;
 }
-
 .row-fluid:before,
 .row-fluid:after {
   display: table;
-  line-height: 0;
   content: "";
+  line-height: 0;
 }
-
 .row-fluid:after {
   clear: both;
 }
-
 .row-fluid [class*="span"] {
   display: block;
-  float: left;
   width: 100%;
   min-height: 30px;
+  -webkit-box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+  float: left;
   margin-left: 2.127659574468085%;
   *margin-left: 2.074468085106383%;
-  -webkit-box-sizing: border-box;
-     -moz-box-sizing: border-box;
-          box-sizing: border-box;
 }
-
 .row-fluid [class*="span"]:first-child {
   margin-left: 0;
 }
-
 .row-fluid .span12 {
   width: 100%;
   *width: 99.94680851063829%;
 }
-
 .row-fluid .span11 {
   width: 91.48936170212765%;
   *width: 91.43617021276594%;
 }
-
 .row-fluid .span10 {
   width: 82.97872340425532%;
   *width: 82.92553191489361%;
 }
-
 .row-fluid .span9 {
   width: 74.46808510638297%;
   *width: 74.41489361702126%;
 }
-
 .row-fluid .span8 {
   width: 65.95744680851064%;
   *width: 65.90425531914893%;
 }
-
 .row-fluid .span7 {
   width: 57.44680851063829%;
   *width: 57.39361702127659%;
 }
-
 .row-fluid .span6 {
   width: 48.93617021276595%;
   *width: 48.88297872340425%;
 }
-
 .row-fluid .span5 {
   width: 40.42553191489362%;
   *width: 40.37234042553192%;
 }
-
 .row-fluid .span4 {
   width: 31.914893617021278%;
   *width: 31.861702127659576%;
 }
-
 .row-fluid .span3 {
   width: 23.404255319148934%;
   *width: 23.351063829787233%;
 }
-
 .row-fluid .span2 {
   width: 14.893617021276595%;
   *width: 14.840425531914894%;
 }
-
 .row-fluid .span1 {
   width: 6.382978723404255%;
   *width: 6.329787234042553%;
 }
-
 .row-fluid .offset12 {
   margin-left: 104.25531914893617%;
   *margin-left: 104.14893617021275%;
 }
-
 .row-fluid .offset12:first-child {
   margin-left: 102.12765957446808%;
   *margin-left: 102.02127659574467%;
 }
-
 .row-fluid .offset11 {
   margin-left: 95.74468085106382%;
   *margin-left: 95.6382978723404%;
 }
-
 .row-fluid .offset11:first-child {
   margin-left: 93.61702127659574%;
   *margin-left: 93.51063829787232%;
 }
-
 .row-fluid .offset10 {
   margin-left: 87.23404255319149%;
   *margin-left: 87.12765957446807%;
 }
-
 .row-fluid .offset10:first-child {
   margin-left: 85.1063829787234%;
   *margin-left: 84.99999999999999%;
 }
-
 .row-fluid .offset9 {
   margin-left: 78.72340425531914%;
   *margin-left: 78.61702127659572%;
 }
-
 .row-fluid .offset9:first-child {
   margin-left: 76.59574468085106%;
   *margin-left: 76.48936170212764%;
 }
-
 .row-fluid .offset8 {
   margin-left: 70.2127659574468%;
   *margin-left: 70.10638297872339%;
 }
-
 .row-fluid .offset8:first-child {
   margin-left: 68.08510638297872%;
   *margin-left: 67.9787234042553%;
 }
-
 .row-fluid .offset7 {
   margin-left: 61.70212765957446%;
   *margin-left: 61.59574468085106%;
 }
-
 .row-fluid .offset7:first-child {
   margin-left: 59.574468085106375%;
   *margin-left: 59.46808510638297%;
 }
-
 .row-fluid .offset6 {
   margin-left: 53.191489361702125%;
   *margin-left: 53.085106382978715%;
 }
-
 .row-fluid .offset6:first-child {
   margin-left: 51.063829787234035%;
   *margin-left: 50.95744680851063%;
 }
-
 .row-fluid .offset5 {
   margin-left: 44.68085106382979%;
   *margin-left: 44.57446808510638%;
 }
-
 .row-fluid .offset5:first-child {
   margin-left: 42.5531914893617%;
   *margin-left: 42.4468085106383%;
 }
-
 .row-fluid .offset4 {
   margin-left: 36.170212765957444%;
   *margin-left: 36.06382978723405%;
 }
-
 .row-fluid .offset4:first-child {
   margin-left: 34.04255319148936%;
   *margin-left: 33.93617021276596%;
 }
-
 .row-fluid .offset3 {
   margin-left: 27.659574468085104%;
   *margin-left: 27.5531914893617%;
 }
-
 .row-fluid .offset3:first-child {
   margin-left: 25.53191489361702%;
   *margin-left: 25.425531914893618%;
 }
-
 .row-fluid .offset2 {
   margin-left: 19.148936170212764%;
   *margin-left: 19.04255319148936%;
 }
-
 .row-fluid .offset2:first-child {
   margin-left: 17.02127659574468%;
   *margin-left: 16.914893617021278%;
 }
-
 .row-fluid .offset1 {
   margin-left: 10.638297872340425%;
   *margin-left: 10.53191489361702%;
 }
-
 .row-fluid .offset1:first-child {
   margin-left: 8.51063829787234%;
   *margin-left: 8.404255319148938%;
 }
-
 [class*="span"].hide,
 .row-fluid [class*="span"].hide {
   display: none;
 }
-
 [class*="span"].pull-right,
 .row-fluid [class*="span"].pull-right {
   float: right;
 }
-
 .container {
   margin-right: auto;
   margin-left: auto;
   *zoom: 1;
 }
-
 .container:before,
 .container:after {
   display: table;
-  line-height: 0;
   content: "";
+  line-height: 0;
 }
-
 .container:after {
   clear: both;
 }
-
 .container-fluid {
   padding-right: 20px;
   padding-left: 20px;
   *zoom: 1;
 }
-
 .container-fluid:before,
 .container-fluid:after {
   display: table;
-  line-height: 0;
   content: "";
+  line-height: 0;
 }
-
 .container-fluid:after {
   clear: both;
 }
-
 p {
-  margin: 0 0 10px;
+  margin: 0 0 10.5px;
 }
-
 .lead {
-  margin-bottom: 20px;
+  margin-bottom: 21px;
   font-size: 21px;
   font-weight: 200;
-  line-height: 30px;
+  line-height: 31.5px;
 }
-
 small {
   font-size: 85%;
 }
-
 strong {
   font-weight: bold;
 }
-
 em {
   font-style: italic;
 }
-
 cite {
   font-style: normal;
 }
-
 .muted {
-  color: #999999;
+  color: #bbbbbb;
 }
-
 .text-warning {
-  color: #c09853;
+  color: #ffffff;
 }
-
 .text-error {
-  color: #b94a48;
+  color: #ffffff;
 }
-
 .text-info {
-  color: #3a87ad;
+  color: #ffffff;
 }
-
 .text-success {
-  color: #468847;
+  color: #ffffff;
 }
-
 h1,
 h2,
 h3,
 h4,
 h5,
 h6 {
-  margin: 10px 0;
+  margin: 10.5px 0;
   font-family: inherit;
-  font-weight: bold;
+  font-weight: normal;
   line-height: 1;
   color: inherit;
   text-rendering: optimizelegibility;
 }
-
 h1 small,
 h2 small,
 h3 small,
@@ -648,170 +537,138 @@ h5 small,
 h6 small {
   font-weight: normal;
   line-height: 1;
-  color: #999999;
+  color: #bbbbbb;
 }
-
 h1 {
   font-size: 36px;
   line-height: 40px;
 }
-
 h2 {
   font-size: 30px;
   line-height: 40px;
 }
-
 h3 {
   font-size: 24px;
   line-height: 40px;
 }
-
 h4 {
   font-size: 18px;
   line-height: 20px;
 }
-
 h5 {
   font-size: 14px;
   line-height: 20px;
 }
-
 h6 {
   font-size: 12px;
   line-height: 20px;
 }
-
 h1 small {
   font-size: 24px;
 }
-
 h2 small {
   font-size: 18px;
 }
-
 h3 small {
   font-size: 14px;
 }
-
 h4 small {
   font-size: 14px;
 }
-
 .page-header {
-  padding-bottom: 9px;
-  margin: 20px 0 30px;
+  padding-bottom: 9.5px;
+  margin: 21px 0 31.5px;
   border-bottom: 1px solid #eeeeee;
 }
-
 ul,
 ol {
   padding: 0;
-  margin: 0 0 10px 25px;
+  margin: 0 0 10.5px 25px;
 }
-
 ul ul,
 ul ol,
 ol ol,
 ol ul {
   margin-bottom: 0;
 }
-
 li {
-  line-height: 20px;
+  line-height: 21px;
 }
-
 ul.unstyled,
 ol.unstyled {
   margin-left: 0;
   list-style: none;
 }
-
 dl {
-  margin-bottom: 20px;
+  margin-bottom: 21px;
 }
-
 dt,
 dd {
-  line-height: 20px;
+  line-height: 21px;
 }
-
 dt {
   font-weight: bold;
 }
-
 dd {
-  margin-left: 10px;
+  margin-left: 10.5px;
 }
-
 .dl-horizontal {
   *zoom: 1;
 }
-
 .dl-horizontal:before,
 .dl-horizontal:after {
   display: table;
-  line-height: 0;
   content: "";
+  line-height: 0;
 }
-
 .dl-horizontal:after {
   clear: both;
 }
-
 .dl-horizontal dt {
   float: left;
   width: 160px;
-  overflow: hidden;
   clear: left;
   text-align: right;
+  overflow: hidden;
   text-overflow: ellipsis;
   white-space: nowrap;
 }
-
 .dl-horizontal dd {
   margin-left: 180px;
 }
-
 hr {
-  margin: 20px 0;
+  margin: 21px 0;
   border: 0;
   border-top: 1px solid #eeeeee;
   border-bottom: 1px solid #ffffff;
 }
-
 abbr[title] {
   cursor: help;
-  border-bottom: 1px dotted #999999;
+  border-bottom: 1px dotted #bbbbbb;
 }
-
 abbr.initialism {
   font-size: 90%;
   text-transform: uppercase;
 }
-
 blockquote {
   padding: 0 0 0 15px;
-  margin: 0 0 20px;
+  margin: 0 0 21px;
   border-left: 5px solid #eeeeee;
 }
-
 blockquote p {
   margin-bottom: 0;
   font-size: 16px;
   font-weight: 300;
-  line-height: 25px;
+  line-height: 26.25px;
 }
-
 blockquote small {
   display: block;
-  line-height: 20px;
-  color: #999999;
+  line-height: 21px;
+  color: #bbbbbb;
 }
-
 blockquote small:before {
   content: '\2014 \00A0';
 }
-
 blockquote.pull-right {
   float: right;
   padding-right: 15px;
@@ -819,58 +676,50 @@ blockquote.pull-right {
   border-right: 5px solid #eeeeee;
   border-left: 0;
 }
-
 blockquote.pull-right p,
 blockquote.pull-right small {
   text-align: right;
 }
-
 blockquote.pull-right small:before {
   content: '';
 }
-
 blockquote.pull-right small:after {
   content: '\00A0 \2014';
 }
-
 q:before,
 q:after,
 blockquote:before,
 blockquote:after {
   content: "";
 }
-
 address {
   display: block;
-  margin-bottom: 20px;
+  margin-bottom: 21px;
   font-style: normal;
-  line-height: 20px;
+  line-height: 21px;
 }
-
 code,
 pre {
   padding: 0 3px 2px;
-  font-family: Monaco, Menlo, Consolas, "Courier New", monospace;
+  font-family: Menlo, Monaco, Consolas, "Courier New", monospace;
   font-size: 12px;
   color: #333333;
   -webkit-border-radius: 3px;
-     -moz-border-radius: 3px;
-          border-radius: 3px;
+  -moz-border-radius: 3px;
+  border-radius: 3px;
 }
-
 code {
   padding: 2px 4px;
   color: #d14;
   background-color: #f7f7f9;
   border: 1px solid #e1e1e8;
 }
-
 pre {
   display: block;
-  padding: 9.5px;
-  margin: 0 0 10px;
+  padding: 10px;
+  margin: 0 0 10.5px;
   font-size: 13px;
-  line-height: 20px;
+  line-height: 21px;
   word-break: break-all;
   word-wrap: break-word;
   white-space: pre;
@@ -879,53 +728,45 @@ pre {
   border: 1px solid #ccc;
   border: 1px solid rgba(0, 0, 0, 0.15);
   -webkit-border-radius: 4px;
-     -moz-border-radius: 4px;
-          border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
 }
-
 pre.prettyprint {
-  margin-bottom: 20px;
+  margin-bottom: 21px;
 }
-
 pre code {
   padding: 0;
   color: inherit;
   background-color: transparent;
   border: 0;
 }
-
 .pre-scrollable {
   max-height: 340px;
   overflow-y: scroll;
 }
-
 form {
-  margin: 0 0 20px;
+  margin: 0 0 21px;
 }
-
 fieldset {
   padding: 0;
   margin: 0;
   border: 0;
 }
-
 legend {
   display: block;
   width: 100%;
   padding: 0;
-  margin-bottom: 20px;
+  margin-bottom: 21px;
   font-size: 21px;
-  line-height: 40px;
+  line-height: 42px;
   color: #333333;
   border: 0;
   border-bottom: 1px solid #e5e5e5;
 }
-
 legend small {
-  font-size: 15px;
-  color: #999999;
+  font-size: 15.75px;
+  color: #bbbbbb;
 }
-
 label,
 input,
 button,
@@ -933,21 +774,18 @@ select,
 textarea {
   font-size: 14px;
   font-weight: normal;
-  line-height: 20px;
+  line-height: 21px;
 }
-
 input,
 button,
 select,
 textarea {
-  font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+  font-family: "Muli", "Helvetica Neue", Helvetica, Arial, sans-serif;
 }
-
 label {
   display: block;
   margin-bottom: 5px;
 }
-
 select,
 textarea,
 input[type="text"],
@@ -966,27 +804,24 @@ input[type="tel"],
 input[type="color"],
 .uneditable-input {
   display: inline-block;
-  height: 20px;
+  height: 21px;
   padding: 4px 6px;
   margin-bottom: 9px;
   font-size: 14px;
-  line-height: 20px;
-  color: #555555;
+  line-height: 21px;
+  color: #777777;
   -webkit-border-radius: 3px;
-     -moz-border-radius: 3px;
-          border-radius: 3px;
+  -moz-border-radius: 3px;
+  border-radius: 3px;
 }
-
 input,
 textarea,
 .uneditable-input {
   width: 206px;
 }
-
 textarea {
   height: auto;
 }
-
 textarea,
 input[type="text"],
 input[type="password"],
@@ -1006,14 +841,13 @@ input[type="color"],
   background-color: #ffffff;
   border: 1px solid #cccccc;
   -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
-     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
-          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
-  -webkit-transition: border linear 0.2s, box-shadow linear 0.2s;
-     -moz-transition: border linear 0.2s, box-shadow linear 0.2s;
-       -o-transition: border linear 0.2s, box-shadow linear 0.2s;
-          transition: border linear 0.2s, box-shadow linear 0.2s;
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  -webkit-transition: border linear .2s, box-shadow linear .2s;
+  -moz-transition: border linear .2s, box-shadow linear .2s;
+  -o-transition: border linear .2s, box-shadow linear .2s;
+  transition: border linear .2s, box-shadow linear .2s;
 }
-
 textarea:focus,
 input[type="text"]:focus,
 input[type="password"]:focus,
@@ -1036,19 +870,21 @@ input[type="color"]:focus,
   /* IE6-9 */
 
   -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 8px rgba(82, 168, 236, 0.6);
-     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 8px rgba(82, 168, 236, 0.6);
-          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 8px rgba(82, 168, 236, 0.6);
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 8px rgba(82, 168, 236, 0.6);
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 8px rgba(82, 168, 236, 0.6);
 }
-
 input[type="radio"],
 input[type="checkbox"] {
   margin: 4px 0 0;
-  margin-top: 1px \9;
   *margin-top: 0;
+  /* IE7 */
+
+  margin-top: 1px \9;
+  /* IE8-9 */
+
   line-height: normal;
   cursor: pointer;
 }
-
 input[type="file"],
 input[type="image"],
 input[type="submit"],
@@ -1058,7 +894,6 @@ input[type="radio"],
 input[type="checkbox"] {
   width: auto;
 }
-
 select,
 input[type="file"] {
   height: 30px;
@@ -1069,18 +904,15 @@ input[type="file"] {
 
   line-height: 30px;
 }
-
 select {
   width: 220px;
-  background-color: #ffffff;
   border: 1px solid #cccccc;
+  background-color: #ffffff;
 }
-
 select[multiple],
 select[size] {
   height: auto;
 }
-
 select:focus,
 input[type="file"]:focus,
 input[type="radio"]:focus,
@@ -1089,60 +921,50 @@ input[type="checkbox"]:focus {
   outline: 5px auto -webkit-focus-ring-color;
   outline-offset: -2px;
 }
-
 .uneditable-input,
 .uneditable-textarea {
-  color: #999999;
-  cursor: not-allowed;
+  color: #bbbbbb;
   background-color: #fcfcfc;
   border-color: #cccccc;
   -webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.025);
-     -moz-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.025);
-          box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.025);
+  -moz-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.025);
+  box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.025);
+  cursor: not-allowed;
 }
-
 .uneditable-input {
   overflow: hidden;
   white-space: nowrap;
 }
-
 .uneditable-textarea {
   width: auto;
   height: auto;
 }
-
 input:-moz-placeholder,
 textarea:-moz-placeholder {
-  color: #999999;
+  color: #bbbbbb;
 }
-
 input:-ms-input-placeholder,
 textarea:-ms-input-placeholder {
-  color: #999999;
+  color: #bbbbbb;
 }
-
 input::-webkit-input-placeholder,
 textarea::-webkit-input-placeholder {
-  color: #999999;
+  color: #bbbbbb;
 }
-
 .radio,
 .checkbox {
   min-height: 18px;
   padding-left: 18px;
 }
-
 .radio input[type="radio"],
 .checkbox input[type="checkbox"] {
   float: left;
   margin-left: -18px;
 }
-
 .controls > .radio:first-child,
 .controls > .checkbox:first-child {
   padding-top: 5px;
 }
-
 .radio.inline,
 .checkbox.inline {
   display: inline-block;
@@ -1150,36 +972,28 @@ textarea::-webkit-input-placeholder {
   margin-bottom: 0;
   vertical-align: middle;
 }
-
 .radio.inline + .radio.inline,
 .checkbox.inline + .checkbox.inline {
   margin-left: 10px;
 }
-
 .input-mini {
   width: 60px;
 }
-
 .input-small {
   width: 90px;
 }
-
 .input-medium {
   width: 150px;
 }
-
 .input-large {
   width: 210px;
 }
-
 .input-xlarge {
   width: 270px;
 }
-
 .input-xxlarge {
   width: 530px;
 }
-
 input[class*="span"],
 select[class*="span"],
 textarea[class*="span"],
@@ -1191,7 +1005,6 @@ textarea[class*="span"],
   float: none;
   margin-left: 0;
 }
-
 .input-append input[class*="span"],
 .input-append .uneditable-input[class*="span"],
 .input-prepend input[class*="span"],
@@ -1204,108 +1017,65 @@ textarea[class*="span"],
 .row-fluid .input-append [class*="span"] {
   display: inline-block;
 }
-
 input,
 textarea,
 .uneditable-input {
   margin-left: 0;
 }
-
 .controls-row [class*="span"] + [class*="span"] {
   margin-left: 20px;
 }
-
-input.span12,
-textarea.span12,
-.uneditable-input.span12 {
+input.span12, textarea.span12, .uneditable-input.span12 {
   width: 926px;
 }
-
-input.span11,
-textarea.span11,
-.uneditable-input.span11 {
+input.span11, textarea.span11, .uneditable-input.span11 {
   width: 846px;
 }
-
-input.span10,
-textarea.span10,
-.uneditable-input.span10 {
+input.span10, textarea.span10, .uneditable-input.span10 {
   width: 766px;
 }
-
-input.span9,
-textarea.span9,
-.uneditable-input.span9 {
+input.span9, textarea.span9, .uneditable-input.span9 {
   width: 686px;
 }
-
-input.span8,
-textarea.span8,
-.uneditable-input.span8 {
+input.span8, textarea.span8, .uneditable-input.span8 {
   width: 606px;
 }
-
-input.span7,
-textarea.span7,
-.uneditable-input.span7 {
+input.span7, textarea.span7, .uneditable-input.span7 {
   width: 526px;
 }
-
-input.span6,
-textarea.span6,
-.uneditable-input.span6 {
+input.span6, textarea.span6, .uneditable-input.span6 {
   width: 446px;
 }
-
-input.span5,
-textarea.span5,
-.uneditable-input.span5 {
+input.span5, textarea.span5, .uneditable-input.span5 {
   width: 366px;
 }
-
-input.span4,
-textarea.span4,
-.uneditable-input.span4 {
+input.span4, textarea.span4, .uneditable-input.span4 {
   width: 286px;
 }
-
-input.span3,
-textarea.span3,
-.uneditable-input.span3 {
+input.span3, textarea.span3, .uneditable-input.span3 {
   width: 206px;
 }
-
-input.span2,
-textarea.span2,
-.uneditable-input.span2 {
+input.span2, textarea.span2, .uneditable-input.span2 {
   width: 126px;
 }
-
-input.span1,
-textarea.span1,
-.uneditable-input.span1 {
+input.span1, textarea.span1, .uneditable-input.span1 {
   width: 46px;
 }
-
 .controls-row {
   *zoom: 1;
 }
-
 .controls-row:before,
 .controls-row:after {
   display: table;
-  line-height: 0;
   content: "";
+  line-height: 0;
 }
-
 .controls-row:after {
   clear: both;
 }
-
 .controls-row [class*="span"] {
   float: left;
 }
-
 input[disabled],
 select[disabled],
 textarea[disabled],
@@ -1315,231 +1085,202 @@ textarea[readonly] {
   cursor: not-allowed;
   background-color: #eeeeee;
 }
-
 input[type="radio"][disabled],
 input[type="checkbox"][disabled],
 input[type="radio"][readonly],
 input[type="checkbox"][readonly] {
   background-color: transparent;
 }
-
 .control-group.warning > label,
 .control-group.warning .help-block,
 .control-group.warning .help-inline {
-  color: #c09853;
+  color: #ffffff;
 }
-
 .control-group.warning .checkbox,
 .control-group.warning .radio,
 .control-group.warning input,
 .control-group.warning select,
 .control-group.warning textarea {
-  color: #c09853;
+  color: #ffffff;
 }
-
 .control-group.warning input,
 .control-group.warning select,
 .control-group.warning textarea {
-  border-color: #c09853;
+  border-color: #ffffff;
   -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
-     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
-          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
 }
-
 .control-group.warning input:focus,
 .control-group.warning select:focus,
 .control-group.warning textarea:focus {
-  border-color: #a47e3c;
-  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #dbc59e;
-     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #dbc59e;
-          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #dbc59e;
+  border-color: #e6e6e6;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #ffffff;
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #ffffff;
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #ffffff;
 }
-
 .control-group.warning .input-prepend .add-on,
 .control-group.warning .input-append .add-on {
-  color: #c09853;
-  background-color: #fcf8e3;
-  border-color: #c09853;
+  color: #ffffff;
+  background-color: #d47500;
+  border-color: #ffffff;
 }
-
 .control-group.error > label,
 .control-group.error .help-block,
 .control-group.error .help-inline {
-  color: #b94a48;
+  color: #ffffff;
 }
-
 .control-group.error .checkbox,
 .control-group.error .radio,
 .control-group.error input,
 .control-group.error select,
 .control-group.error textarea {
-  color: #b94a48;
+  color: #ffffff;
 }
-
 .control-group.error input,
 .control-group.error select,
 .control-group.error textarea {
-  border-color: #b94a48;
+  border-color: #ffffff;
   -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
-     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
-          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
 }
-
 .control-group.error input:focus,
 .control-group.error select:focus,
 .control-group.error textarea:focus {
-  border-color: #953b39;
-  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #d59392;
-     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #d59392;
-          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #d59392;
+  border-color: #e6e6e6;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #ffffff;
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #ffffff;
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #ffffff;
 }
-
 .control-group.error .input-prepend .add-on,
 .control-group.error .input-append .add-on {
-  color: #b94a48;
-  background-color: #f2dede;
-  border-color: #b94a48;
+  color: #ffffff;
+  background-color: #cd0200;
+  border-color: #ffffff;
 }
-
 .control-group.success > label,
 .control-group.success .help-block,
 .control-group.success .help-inline {
-  color: #468847;
+  color: #ffffff;
 }
-
 .control-group.success .checkbox,
 .control-group.success .radio,
 .control-group.success input,
 .control-group.success select,
 .control-group.success textarea {
-  color: #468847;
+  color: #ffffff;
 }
-
 .control-group.success input,
 .control-group.success select,
 .control-group.success textarea {
-  border-color: #468847;
+  border-color: #ffffff;
   -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
-     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
-          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
 }
-
 .control-group.success input:focus,
 .control-group.success select:focus,
 .control-group.success textarea:focus {
-  border-color: #356635;
-  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #7aba7b;
-     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #7aba7b;
-          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #7aba7b;
+  border-color: #e6e6e6;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #ffffff;
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #ffffff;
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #ffffff;
 }
-
 .control-group.success .input-prepend .add-on,
 .control-group.success .input-append .add-on {
-  color: #468847;
-  background-color: #dff0d8;
-  border-color: #468847;
+  color: #ffffff;
+  background-color: #819e37;
+  border-color: #ffffff;
 }
-
 .control-group.info > label,
 .control-group.info .help-block,
 .control-group.info .help-inline {
-  color: #3a87ad;
+  color: #ffffff;
 }
-
 .control-group.info .checkbox,
 .control-group.info .radio,
 .control-group.info input,
 .control-group.info select,
 .control-group.info textarea {
-  color: #3a87ad;
+  color: #ffffff;
 }
-
 .control-group.info input,
 .control-group.info select,
 .control-group.info textarea {
-  border-color: #3a87ad;
+  border-color: #ffffff;
   -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
-     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
-          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
 }
-
 .control-group.info input:focus,
 .control-group.info select:focus,
 .control-group.info textarea:focus {
-  border-color: #2d6987;
-  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #7ab5d3;
-     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #7ab5d3;
-          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #7ab5d3;
+  border-color: #e6e6e6;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #ffffff;
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #ffffff;
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #ffffff;
 }
-
 .control-group.info .input-prepend .add-on,
 .control-group.info .input-append .add-on {
-  color: #3a87ad;
-  background-color: #d9edf7;
-  border-color: #3a87ad;
+  color: #ffffff;
+  background-color: #3399f3;
+  border-color: #ffffff;
 }
-
 input:focus:required:invalid,
 textarea:focus:required:invalid,
 select:focus:required:invalid {
   color: #b94a48;
   border-color: #ee5f5b;
 }
-
 input:focus:required:invalid:focus,
 textarea:focus:required:invalid:focus,
 select:focus:required:invalid:focus {
   border-color: #e9322d;
   -webkit-box-shadow: 0 0 6px #f8b9b7;
-     -moz-box-shadow: 0 0 6px #f8b9b7;
-          box-shadow: 0 0 6px #f8b9b7;
+  -moz-box-shadow: 0 0 6px #f8b9b7;
+  box-shadow: 0 0 6px #f8b9b7;
 }
-
 .form-actions {
-  padding: 19px 20px 20px;
-  margin-top: 20px;
-  margin-bottom: 20px;
+  padding: 20px 20px 21px;
+  margin-top: 21px;
+  margin-bottom: 21px;
   background-color: #f5f5f5;
   border-top: 1px solid #e5e5e5;
   *zoom: 1;
 }
-
 .form-actions:before,
 .form-actions:after {
   display: table;
-  line-height: 0;
   content: "";
+  line-height: 0;
 }
-
 .form-actions:after {
   clear: both;
 }
-
 .help-block,
 .help-inline {
-  color: #595959;
+  color: #535353;
 }
-
 .help-block {
   display: block;
-  margin-bottom: 10px;
+  margin-bottom: 10.5px;
 }
-
 .help-inline {
   display: inline-block;
   *display: inline;
-  padding-left: 5px;
-  vertical-align: middle;
-  *zoom: 1;
-}
+  /* IE7 inline-block hack */
 
+  *zoom: 1;
+  vertical-align: middle;
+  padding-left: 5px;
+}
 .input-append,
 .input-prepend {
   margin-bottom: 5px;
   font-size: 0;
   white-space: nowrap;
 }
-
 .input-append input,
 .input-prepend input,
 .input-append select,
@@ -1552,10 +1293,9 @@ select:focus:required:invalid:focus {
   font-size: 14px;
   vertical-align: top;
   -webkit-border-radius: 0 3px 3px 0;
-     -moz-border-radius: 0 3px 3px 0;
-          border-radius: 0 3px 3px 0;
+  -moz-border-radius: 0 3px 3px 0;
+  border-radius: 0 3px 3px 0;
 }
-
 .input-append input:focus,
 .input-prepend input:focus,
 .input-append select:focus,
@@ -1564,95 +1304,83 @@ select:focus:required:invalid:focus {
 .input-prepend .uneditable-input:focus {
   z-index: 2;
 }
-
 .input-append .add-on,
 .input-prepend .add-on {
   display: inline-block;
   width: auto;
-  height: 20px;
+  height: 21px;
   min-width: 16px;
   padding: 4px 5px;
   font-size: 14px;
   font-weight: normal;
-  line-height: 20px;
+  line-height: 21px;
   text-align: center;
   text-shadow: 0 1px 0 #ffffff;
   background-color: #eeeeee;
   border: 1px solid #ccc;
 }
-
 .input-append .add-on,
 .input-prepend .add-on,
 .input-append .btn,
 .input-prepend .btn {
   vertical-align: top;
   -webkit-border-radius: 0;
-     -moz-border-radius: 0;
-          border-radius: 0;
+  -moz-border-radius: 0;
+  border-radius: 0;
 }
-
 .input-append .active,
 .input-prepend .active {
-  background-color: #a9dba9;
-  border-color: #46a546;
+  background-color: #c6da94;
+  border-color: #819e37;
 }
-
 .input-prepend .add-on,
 .input-prepend .btn {
   margin-right: -1px;
 }
-
 .input-prepend .add-on:first-child,
 .input-prepend .btn:first-child {
   -webkit-border-radius: 3px 0 0 3px;
-     -moz-border-radius: 3px 0 0 3px;
-          border-radius: 3px 0 0 3px;
+  -moz-border-radius: 3px 0 0 3px;
+  border-radius: 3px 0 0 3px;
 }
-
 .input-append input,
 .input-append select,
 .input-append .uneditable-input {
   -webkit-border-radius: 3px 0 0 3px;
-     -moz-border-radius: 3px 0 0 3px;
-          border-radius: 3px 0 0 3px;
+  -moz-border-radius: 3px 0 0 3px;
+  border-radius: 3px 0 0 3px;
 }
-
 .input-append .add-on,
 .input-append .btn {
   margin-left: -1px;
 }
-
 .input-append .add-on:last-child,
 .input-append .btn:last-child {
   -webkit-border-radius: 0 3px 3px 0;
-     -moz-border-radius: 0 3px 3px 0;
-          border-radius: 0 3px 3px 0;
+  -moz-border-radius: 0 3px 3px 0;
+  border-radius: 0 3px 3px 0;
 }
-
 .input-prepend.input-append input,
 .input-prepend.input-append select,
 .input-prepend.input-append .uneditable-input {
   -webkit-border-radius: 0;
-     -moz-border-radius: 0;
-          border-radius: 0;
+  -moz-border-radius: 0;
+  border-radius: 0;
 }
-
 .input-prepend.input-append .add-on:first-child,
 .input-prepend.input-append .btn:first-child {
   margin-right: -1px;
   -webkit-border-radius: 3px 0 0 3px;
-     -moz-border-radius: 3px 0 0 3px;
-          border-radius: 3px 0 0 3px;
+  -moz-border-radius: 3px 0 0 3px;
+  border-radius: 3px 0 0 3px;
 }
-
 .input-prepend.input-append .add-on:last-child,
 .input-prepend.input-append .btn:last-child {
   margin-left: -1px;
   -webkit-border-radius: 0 3px 3px 0;
-     -moz-border-radius: 0 3px 3px 0;
-          border-radius: 0 3px 3px 0;
+  -moz-border-radius: 0 3px 3px 0;
+  border-radius: 0 3px 3px 0;
 }
-
 input.search-query {
   padding-right: 14px;
   padding-right: 4px \9;
@@ -1662,43 +1390,36 @@ input.search-query {
 
   margin-bottom: 0;
   -webkit-border-radius: 15px;
-     -moz-border-radius: 15px;
-          border-radius: 15px;
+  -moz-border-radius: 15px;
+  border-radius: 15px;
 }
-
 /* Allow for input prepend/append in search forms */
-
 .form-search .input-append .search-query,
 .form-search .input-prepend .search-query {
   -webkit-border-radius: 0;
-     -moz-border-radius: 0;
-          border-radius: 0;
+  -moz-border-radius: 0;
+  border-radius: 0;
 }
-
 .form-search .input-append .search-query {
   -webkit-border-radius: 14px 0 0 14px;
-     -moz-border-radius: 14px 0 0 14px;
-          border-radius: 14px 0 0 14px;
+  -moz-border-radius: 14px 0 0 14px;
+  border-radius: 14px 0 0 14px;
 }
-
 .form-search .input-append .btn {
   -webkit-border-radius: 0 14px 14px 0;
-     -moz-border-radius: 0 14px 14px 0;
-          border-radius: 0 14px 14px 0;
+  -moz-border-radius: 0 14px 14px 0;
+  border-radius: 0 14px 14px 0;
 }
-
 .form-search .input-prepend .search-query {
   -webkit-border-radius: 0 14px 14px 0;
-     -moz-border-radius: 0 14px 14px 0;
-          border-radius: 0 14px 14px 0;
+  -moz-border-radius: 0 14px 14px 0;
+  border-radius: 0 14px 14px 0;
 }
-
 .form-search .input-prepend .btn {
   -webkit-border-radius: 14px 0 0 14px;
-     -moz-border-radius: 14px 0 0 14px;
-          border-radius: 14px 0 0 14px;
+  -moz-border-radius: 14px 0 0 14px;
+  border-radius: 14px 0 0 14px;
 }
-
 .form-search input,
 .form-inline input,
 .form-horizontal input,
@@ -1722,31 +1443,29 @@ input.search-query {
 .form-horizontal .input-append {
   display: inline-block;
   *display: inline;
+  /* IE7 inline-block hack */
+
+  *zoom: 1;
   margin-bottom: 0;
   vertical-align: middle;
-  *zoom: 1;
 }
-
 .form-search .hide,
 .form-inline .hide,
 .form-horizontal .hide {
   display: none;
 }
-
 .form-search label,
 .form-inline label,
 .form-search .btn-group,
 .form-inline .btn-group {
   display: inline-block;
 }
-
 .form-search .input-append,
 .form-inline .input-append,
 .form-search .input-prepend,
 .form-inline .input-prepend {
   margin-bottom: 0;
 }
-
 .form-search .radio,
 .form-search .checkbox,
 .form-inline .radio,
@@ -1755,7 +1474,6 @@ input.search-query {
   margin-bottom: 0;
   vertical-align: middle;
 }
-
 .form-search .radio input[type="radio"],
 .form-search .checkbox input[type="checkbox"],
 .form-inline .radio input[type="radio"],
@@ -1764,93 +1482,76 @@ input.search-query {
   margin-right: 3px;
   margin-left: 0;
 }
-
 .control-group {
-  margin-bottom: 10px;
+  margin-bottom: 10.5px;
 }
-
 legend + .control-group {
-  margin-top: 20px;
+  margin-top: 21px;
   -webkit-margin-top-collapse: separate;
 }
-
 .form-horizontal .control-group {
-  margin-bottom: 20px;
+  margin-bottom: 21px;
   *zoom: 1;
 }
-
 .form-horizontal .control-group:before,
 .form-horizontal .control-group:after {
   display: table;
-  line-height: 0;
   content: "";
+  line-height: 0;
 }
-
 .form-horizontal .control-group:after {
   clear: both;
 }
-
 .form-horizontal .control-label {
   float: left;
   width: 160px;
   padding-top: 5px;
   text-align: right;
 }
-
 .form-horizontal .controls {
   *display: inline-block;
   *padding-left: 20px;
   margin-left: 180px;
   *margin-left: 0;
 }
-
 .form-horizontal .controls:first-child {
   *padding-left: 180px;
 }
-
 .form-horizontal .help-block {
   margin-bottom: 0;
 }
-
 .form-horizontal input + .help-block,
 .form-horizontal select + .help-block,
 .form-horizontal textarea + .help-block {
-  margin-top: 10px;
+  margin-top: 10.5px;
 }
-
 .form-horizontal .form-actions {
   padding-left: 180px;
 }
-
 table {
   max-width: 100%;
   background-color: transparent;
   border-collapse: collapse;
   border-spacing: 0;
 }
-
 .table {
   width: 100%;
-  margin-bottom: 20px;
+  margin-bottom: 21px;
 }
-
 .table th,
 .table td {
   padding: 8px;
-  line-height: 20px;
+  line-height: 21px;
   text-align: left;
   vertical-align: top;
   border-top: 1px solid #dddddd;
 }
-
 .table th {
   font-weight: bold;
 }
-
 .table thead th {
   vertical-align: bottom;
 }
-
 .table caption + thead tr:first-child th,
 .table caption + thead tr:first-child td,
 .table colgroup + thead tr:first-child th,
@@ -1859,31 +1560,26 @@ table {
 .table thead:first-child tr:first-child td {
   border-top: 0;
 }
-
 .table tbody + tbody {
   border-top: 2px solid #dddddd;
 }
-
 .table-condensed th,
 .table-condensed td {
   padding: 4px 5px;
 }
-
 .table-bordered {
   border: 1px solid #dddddd;
   border-collapse: separate;
   *border-collapse: collapse;
   border-left: 0;
   -webkit-border-radius: 4px;
-     -moz-border-radius: 4px;
-          border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
 }
-
 .table-bordered th,
 .table-bordered td {
   border-left: 1px solid #dddddd;
 }
-
 .table-bordered caption + thead tr:first-child th,
 .table-bordered caption + tbody tr:first-child th,
 .table-bordered caption + tbody tr:first-child td,
@@ -1895,267 +1591,223 @@ table {
 .table-bordered tbody:first-child tr:first-child td {
   border-top: 0;
 }
-
 .table-bordered thead:first-child tr:first-child th:first-child,
 .table-bordered tbody:first-child tr:first-child td:first-child {
   -webkit-border-top-left-radius: 4px;
-          border-top-left-radius: 4px;
+  border-top-left-radius: 4px;
   -moz-border-radius-topleft: 4px;
 }
-
 .table-bordered thead:first-child tr:first-child th:last-child,
 .table-bordered tbody:first-child tr:first-child td:last-child {
   -webkit-border-top-right-radius: 4px;
-          border-top-right-radius: 4px;
+  border-top-right-radius: 4px;
   -moz-border-radius-topright: 4px;
 }
-
 .table-bordered thead:last-child tr:last-child th:first-child,
 .table-bordered tbody:last-child tr:last-child td:first-child,
 .table-bordered tfoot:last-child tr:last-child td:first-child {
   -webkit-border-radius: 0 0 0 4px;
-     -moz-border-radius: 0 0 0 4px;
-          border-radius: 0 0 0 4px;
+  -moz-border-radius: 0 0 0 4px;
+  border-radius: 0 0 0 4px;
   -webkit-border-bottom-left-radius: 4px;
-          border-bottom-left-radius: 4px;
+  border-bottom-left-radius: 4px;
   -moz-border-radius-bottomleft: 4px;
 }
-
 .table-bordered thead:last-child tr:last-child th:last-child,
 .table-bordered tbody:last-child tr:last-child td:last-child,
 .table-bordered tfoot:last-child tr:last-child td:last-child {
   -webkit-border-bottom-right-radius: 4px;
-          border-bottom-right-radius: 4px;
+  border-bottom-right-radius: 4px;
   -moz-border-radius-bottomright: 4px;
 }
-
 .table-bordered caption + thead tr:first-child th:first-child,
 .table-bordered caption + tbody tr:first-child td:first-child,
 .table-bordered colgroup + thead tr:first-child th:first-child,
 .table-bordered colgroup + tbody tr:first-child td:first-child {
   -webkit-border-top-left-radius: 4px;
-          border-top-left-radius: 4px;
+  border-top-left-radius: 4px;
   -moz-border-radius-topleft: 4px;
 }
-
 .table-bordered caption + thead tr:first-child th:last-child,
 .table-bordered caption + tbody tr:first-child td:last-child,
 .table-bordered colgroup + thead tr:first-child th:last-child,
 .table-bordered colgroup + tbody tr:first-child td:last-child {
   -webkit-border-top-right-radius: 4px;
-          border-top-right-radius: 4px;
+  border-top-right-radius: 4px;
   -moz-border-radius-topleft: 4px;
 }
-
 .table-striped tbody tr:nth-child(odd) td,
 .table-striped tbody tr:nth-child(odd) th {
   background-color: #f9f9f9;
 }
-
 .table-hover tbody tr:hover td,
 .table-hover tbody tr:hover th {
   background-color: #f5f5f5;
 }
-
 table [class*=span],
 .row-fluid table [class*=span] {
   display: table-cell;
   float: none;
   margin-left: 0;
 }
-
 .table .span1 {
   float: none;
   width: 44px;
   margin-left: 0;
 }
-
 .table .span2 {
   float: none;
   width: 124px;
   margin-left: 0;
 }
-
 .table .span3 {
   float: none;
   width: 204px;
   margin-left: 0;
 }
-
 .table .span4 {
   float: none;
   width: 284px;
   margin-left: 0;
 }
-
 .table .span5 {
   float: none;
   width: 364px;
   margin-left: 0;
 }
-
 .table .span6 {
   float: none;
   width: 444px;
   margin-left: 0;
 }
-
 .table .span7 {
   float: none;
   width: 524px;
   margin-left: 0;
 }
-
 .table .span8 {
   float: none;
   width: 604px;
   margin-left: 0;
 }
-
 .table .span9 {
   float: none;
   width: 684px;
   margin-left: 0;
 }
-
 .table .span10 {
   float: none;
   width: 764px;
   margin-left: 0;
 }
-
 .table .span11 {
   float: none;
   width: 844px;
   margin-left: 0;
 }
-
 .table .span12 {
   float: none;
   width: 924px;
   margin-left: 0;
 }
-
 .table .span13 {
   float: none;
   width: 1004px;
   margin-left: 0;
 }
-
 .table .span14 {
   float: none;
   width: 1084px;
   margin-left: 0;
 }
-
 .table .span15 {
   float: none;
   width: 1164px;
   margin-left: 0;
 }
-
 .table .span16 {
   float: none;
   width: 1244px;
   margin-left: 0;
 }
-
 .table .span17 {
   float: none;
   width: 1324px;
   margin-left: 0;
 }
-
 .table .span18 {
   float: none;
   width: 1404px;
   margin-left: 0;
 }
-
 .table .span19 {
   float: none;
   width: 1484px;
   margin-left: 0;
 }
-
 .table .span20 {
   float: none;
   width: 1564px;
   margin-left: 0;
 }
-
 .table .span21 {
   float: none;
   width: 1644px;
   margin-left: 0;
 }
-
 .table .span22 {
   float: none;
   width: 1724px;
   margin-left: 0;
 }
-
 .table .span23 {
   float: none;
   width: 1804px;
   margin-left: 0;
 }
-
 .table .span24 {
   float: none;
   width: 1884px;
   margin-left: 0;
 }
-
 .table tbody tr.success td {
-  background-color: #dff0d8;
+  background-color: #819e37;
 }
-
 .table tbody tr.error td {
-  background-color: #f2dede;
+  background-color: #cd0200;
 }
-
 .table tbody tr.warning td {
-  background-color: #fcf8e3;
+  background-color: #d47500;
 }
-
 .table tbody tr.info td {
-  background-color: #d9edf7;
+  background-color: #3399f3;
 }
-
 .table-hover tbody tr.success:hover td {
-  background-color: #d0e9c6;
+  background-color: #728b30;
 }
-
 .table-hover tbody tr.error:hover td {
-  background-color: #ebcccc;
+  background-color: #b40200;
 }
-
 .table-hover tbody tr.warning:hover td {
-  background-color: #faf2cc;
+  background-color: #bb6700;
 }
-
 .table-hover tbody tr.info:hover td {
-  background-color: #c4e3f3;
+  background-color: #1b8df2;
 }
-
 [class^="icon-"],
 [class*=" icon-"] {
   display: inline-block;
   width: 14px;
   height: 14px;
-  margin-top: 1px;
   *margin-right: .3em;
   line-height: 14px;
   vertical-align: text-top;
   background-image: url("../img/glyphicons-halflings.png");
   background-position: 14px 14px;
   background-repeat: no-repeat;
+  margin-top: 1px;
 }
-
 /* White icons with optional class, or on hover/active states of certain elements */
-
 .icon-white,
 .nav-tabs > .active > a > [class^="icon-"],
 .nav-tabs > .active > a > [class*=" icon-"],
@@ -2171,583 +1823,439 @@ table [class*=span],
 .dropdown-menu > .active > a > [class*=" icon-"] {
   background-image: url("../img/glyphicons-halflings-white.png");
 }
-
 .icon-glass {
   background-position: 0      0;
 }
-
 .icon-music {
   background-position: -24px 0;
 }
-
 .icon-search {
   background-position: -48px 0;
 }
-
 .icon-envelope {
   background-position: -72px 0;
 }
-
 .icon-heart {
   background-position: -96px 0;
 }
-
 .icon-star {
   background-position: -120px 0;
 }
-
 .icon-star-empty {
   background-position: -144px 0;
 }
-
 .icon-user {
   background-position: -168px 0;
 }
-
 .icon-film {
   background-position: -192px 0;
 }
-
 .icon-th-large {
   background-position: -216px 0;
 }
-
 .icon-th {
   background-position: -240px 0;
 }
-
 .icon-th-list {
   background-position: -264px 0;
 }
-
 .icon-ok {
   background-position: -288px 0;
 }
-
 .icon-remove {
   background-position: -312px 0;
 }
-
 .icon-zoom-in {
   background-position: -336px 0;
 }
-
 .icon-zoom-out {
   background-position: -360px 0;
 }
-
 .icon-off {
   background-position: -384px 0;
 }
-
 .icon-signal {
   background-position: -408px 0;
 }
-
 .icon-cog {
   background-position: -432px 0;
 }
-
 .icon-trash {
   background-position: -456px 0;
 }
-
 .icon-home {
   background-position: 0 -24px;
 }
-
 .icon-file {
   background-position: -24px -24px;
 }
-
 .icon-time {
   background-position: -48px -24px;
 }
-
 .icon-road {
   background-position: -72px -24px;
 }
-
 .icon-download-alt {
   background-position: -96px -24px;
 }
-
 .icon-download {
   background-position: -120px -24px;
 }
-
 .icon-upload {
   background-position: -144px -24px;
 }
-
 .icon-inbox {
   background-position: -168px -24px;
 }
-
 .icon-play-circle {
   background-position: -192px -24px;
 }
-
 .icon-repeat {
   background-position: -216px -24px;
 }
-
 .icon-refresh {
   background-position: -240px -24px;
 }
-
 .icon-list-alt {
   background-position: -264px -24px;
 }
-
 .icon-lock {
   background-position: -287px -24px;
 }
-
 .icon-flag {
   background-position: -312px -24px;
 }
-
 .icon-headphones {
   background-position: -336px -24px;
 }
-
 .icon-volume-off {
   background-position: -360px -24px;
 }
-
 .icon-volume-down {
   background-position: -384px -24px;
 }
-
 .icon-volume-up {
   background-position: -408px -24px;
 }
-
 .icon-qrcode {
   background-position: -432px -24px;
 }
-
 .icon-barcode {
   background-position: -456px -24px;
 }
-
 .icon-tag {
   background-position: 0 -48px;
 }
-
 .icon-tags {
   background-position: -25px -48px;
 }
-
 .icon-book {
   background-position: -48px -48px;
 }
-
 .icon-bookmark {
   background-position: -72px -48px;
 }
-
 .icon-print {
   background-position: -96px -48px;
 }
-
 .icon-camera {
   background-position: -120px -48px;
 }
-
 .icon-font {
   background-position: -144px -48px;
 }
-
 .icon-bold {
   background-position: -167px -48px;
 }
-
 .icon-italic {
   background-position: -192px -48px;
 }
-
 .icon-text-height {
   background-position: -216px -48px;
 }
-
 .icon-text-width {
   background-position: -240px -48px;
 }
-
 .icon-align-left {
   background-position: -264px -48px;
 }
-
 .icon-align-center {
   background-position: -288px -48px;
 }
-
 .icon-align-right {
   background-position: -312px -48px;
 }
-
 .icon-align-justify {
   background-position: -336px -48px;
 }
-
 .icon-list {
   background-position: -360px -48px;
 }
-
 .icon-indent-left {
   background-position: -384px -48px;
 }
-
 .icon-indent-right {
   background-position: -408px -48px;
 }
-
 .icon-facetime-video {
   background-position: -432px -48px;
 }
-
 .icon-picture {
   background-position: -456px -48px;
 }
-
 .icon-pencil {
   background-position: 0 -72px;
 }
-
 .icon-map-marker {
   background-position: -24px -72px;
 }
-
 .icon-adjust {
   background-position: -48px -72px;
 }
-
 .icon-tint {
   background-position: -72px -72px;
 }
-
 .icon-edit {
   background-position: -96px -72px;
 }
-
 .icon-share {
   background-position: -120px -72px;
 }
-
 .icon-check {
   background-position: -144px -72px;
 }
-
 .icon-move {
   background-position: -168px -72px;
 }
-
 .icon-step-backward {
   background-position: -192px -72px;
 }
-
 .icon-fast-backward {
   background-position: -216px -72px;
 }
-
 .icon-backward {
   background-position: -240px -72px;
 }
-
 .icon-play {
   background-position: -264px -72px;
 }
-
 .icon-pause {
   background-position: -288px -72px;
 }
-
 .icon-stop {
   background-position: -312px -72px;
 }
-
 .icon-forward {
   background-position: -336px -72px;
 }
-
 .icon-fast-forward {
   background-position: -360px -72px;
 }
-
 .icon-step-forward {
   background-position: -384px -72px;
 }
-
 .icon-eject {
   background-position: -408px -72px;
 }
-
 .icon-chevron-left {
   background-position: -432px -72px;
 }
-
 .icon-chevron-right {
   background-position: -456px -72px;
 }
-
 .icon-plus-sign {
   background-position: 0 -96px;
 }
-
 .icon-minus-sign {
   background-position: -24px -96px;
 }
-
 .icon-remove-sign {
   background-position: -48px -96px;
 }
-
 .icon-ok-sign {
   background-position: -72px -96px;
 }
-
 .icon-question-sign {
   background-position: -96px -96px;
 }
-
 .icon-info-sign {
   background-position: -120px -96px;
 }
-
 .icon-screenshot {
   background-position: -144px -96px;
 }
-
 .icon-remove-circle {
   background-position: -168px -96px;
 }
-
 .icon-ok-circle {
   background-position: -192px -96px;
 }
-
 .icon-ban-circle {
   background-position: -216px -96px;
 }
-
 .icon-arrow-left {
   background-position: -240px -96px;
 }
-
 .icon-arrow-right {
   background-position: -264px -96px;
 }
-
 .icon-arrow-up {
   background-position: -289px -96px;
 }
-
 .icon-arrow-down {
   background-position: -312px -96px;
 }
-
 .icon-share-alt {
   background-position: -336px -96px;
 }
-
 .icon-resize-full {
   background-position: -360px -96px;
 }
-
 .icon-resize-small {
   background-position: -384px -96px;
 }
-
 .icon-plus {
   background-position: -408px -96px;
 }
-
 .icon-minus {
   background-position: -433px -96px;
 }
-
 .icon-asterisk {
   background-position: -456px -96px;
 }
-
 .icon-exclamation-sign {
   background-position: 0 -120px;
 }
-
 .icon-gift {
   background-position: -24px -120px;
 }
-
 .icon-leaf {
   background-position: -48px -120px;
 }
-
 .icon-fire {
   background-position: -72px -120px;
 }
-
 .icon-eye-open {
   background-position: -96px -120px;
 }
-
 .icon-eye-close {
   background-position: -120px -120px;
 }
-
 .icon-warning-sign {
   background-position: -144px -120px;
 }
-
 .icon-plane {
   background-position: -168px -120px;
 }
-
 .icon-calendar {
   background-position: -192px -120px;
 }
-
 .icon-random {
-  width: 16px;
   background-position: -216px -120px;
+  width: 16px;
 }
-
 .icon-comment {
   background-position: -240px -120px;
 }
-
 .icon-magnet {
   background-position: -264px -120px;
 }
-
 .icon-chevron-up {
   background-position: -288px -120px;
 }
-
 .icon-chevron-down {
   background-position: -313px -119px;
 }
-
 .icon-retweet {
   background-position: -336px -120px;
 }
-
 .icon-shopping-cart {
   background-position: -360px -120px;
 }
-
 .icon-folder-close {
   background-position: -384px -120px;
 }
-
 .icon-folder-open {
-  width: 16px;
   background-position: -408px -120px;
+  width: 16px;
 }
-
 .icon-resize-vertical {
   background-position: -432px -119px;
 }
-
 .icon-resize-horizontal {
   background-position: -456px -118px;
 }
-
 .icon-hdd {
   background-position: 0 -144px;
 }
-
 .icon-bullhorn {
   background-position: -24px -144px;
 }
-
 .icon-bell {
   background-position: -48px -144px;
 }
-
 .icon-certificate {
   background-position: -72px -144px;
 }
-
 .icon-thumbs-up {
   background-position: -96px -144px;
 }
-
 .icon-thumbs-down {
   background-position: -120px -144px;
 }
-
 .icon-hand-right {
   background-position: -144px -144px;
 }
-
 .icon-hand-left {
   background-position: -168px -144px;
 }
-
 .icon-hand-up {
   background-position: -192px -144px;
 }
-
 .icon-hand-down {
   background-position: -216px -144px;
 }
-
 .icon-circle-arrow-right {
   background-position: -240px -144px;
 }
-
 .icon-circle-arrow-left {
   background-position: -264px -144px;
 }
-
 .icon-circle-arrow-up {
   background-position: -288px -144px;
 }
-
 .icon-circle-arrow-down {
   background-position: -312px -144px;
 }
-
 .icon-globe {
   background-position: -336px -144px;
 }
-
 .icon-wrench {
   background-position: -360px -144px;
 }
-
 .icon-tasks {
   background-position: -384px -144px;
 }
-
 .icon-filter {
   background-position: -408px -144px;
 }
-
 .icon-briefcase {
   background-position: -432px -144px;
 }
-
 .icon-fullscreen {
   background-position: -456px -144px;
 }
-
 .dropup,
 .dropdown {
   position: relative;
 }
-
 .dropdown-toggle {
   *margin-bottom: -3px;
 }
-
 .dropdown-toggle:active,
 .open .dropdown-toggle {
   outline: 0;
 }
-
 .caret {
   display: inline-block;
   width: 0;
@@ -2758,12 +2266,10 @@ table [class*=span],
   border-left: 4px solid transparent;
   content: "";
 }
-
 .dropdown .caret {
   margin-top: 8px;
   margin-left: 2px;
 }
-
 .dropdown-menu {
   position: absolute;
   top: 100%;
@@ -2781,159 +2287,139 @@ table [class*=span],
   *border-right-width: 2px;
   *border-bottom-width: 2px;
   -webkit-border-radius: 6px;
-     -moz-border-radius: 6px;
-          border-radius: 6px;
+  -moz-border-radius: 6px;
+  border-radius: 6px;
   -webkit-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
-     -moz-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
-          box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
+  -moz-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
+  box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
   -webkit-background-clip: padding-box;
-     -moz-background-clip: padding;
-          background-clip: padding-box;
+  -moz-background-clip: padding;
+  background-clip: padding-box;
 }
-
 .dropdown-menu.pull-right {
   right: 0;
   left: auto;
 }
-
 .dropdown-menu .divider {
   *width: 100%;
   height: 1px;
-  margin: 9px 1px;
+  margin: 9.5px 1px;
   *margin: -5px 0 5px;
   overflow: hidden;
   background-color: #e5e5e5;
   border-bottom: 1px solid #ffffff;
 }
-
 .dropdown-menu a {
   display: block;
   padding: 3px 20px;
   clear: both;
   font-weight: normal;
-  line-height: 20px;
-  color: #333333;
+  line-height: 21px;
+  color: #2d2d2d;
   white-space: nowrap;
 }
-
 .dropdown-menu li > a:hover,
 .dropdown-menu li > a:focus,
 .dropdown-submenu:hover > a {
-  color: #ffffff;
   text-decoration: none;
-  background-color: #0088cc;
-  background-color: #0081c2;
-  background-image: -moz-linear-gradient(top, #0088cc, #0077b3);
-  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#0088cc), to(#0077b3));
-  background-image: -webkit-linear-gradient(top, #0088cc, #0077b3);
-  background-image: -o-linear-gradient(top, #0088cc, #0077b3);
-  background-image: linear-gradient(to bottom, #0088cc, #0077b3);
+  color: #ffffff;
+  background-color: #558bc4;
+  background-color: #4d86c1;
+  background-image: -moz-linear-gradient(top, #558bc4, #427ebd);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#558bc4), to(#427ebd));
+  background-image: -webkit-linear-gradient(top, #558bc4, #427ebd);
+  background-image: -o-linear-gradient(top, #558bc4, #427ebd);
+  background-image: linear-gradient(to bottom, #558bc4, #427ebd);
   background-repeat: repeat-x;
-  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff0088cc', endColorstr='#ff0077b3', GradientType=0);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff558bc4', endColorstr='#ff427ebd', GradientType=0);
 }
-
 .dropdown-menu .active > a,
 .dropdown-menu .active > a:hover {
   color: #ffffff;
   text-decoration: none;
-  background-color: #0088cc;
-  background-color: #0081c2;
-  background-image: linear-gradient(to bottom, #0088cc, #0077b3);
-  background-image: -moz-linear-gradient(top, #0088cc, #0077b3);
-  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#0088cc), to(#0077b3));
-  background-image: -webkit-linear-gradient(top, #0088cc, #0077b3);
-  background-image: -o-linear-gradient(top, #0088cc, #0077b3);
-  background-repeat: repeat-x;
   outline: 0;
-  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff0088cc', endColorstr='#ff0077b3', GradientType=0);
+  background-color: #558bc4;
+  background-color: #4d86c1;
+  background-image: -moz-linear-gradient(top, #558bc4, #427ebd);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#558bc4), to(#427ebd));
+  background-image: -webkit-linear-gradient(top, #558bc4, #427ebd);
+  background-image: -o-linear-gradient(top, #558bc4, #427ebd);
+  background-image: linear-gradient(to bottom, #558bc4, #427ebd);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff558bc4', endColorstr='#ff427ebd', GradientType=0);
 }
-
 .dropdown-menu .disabled > a,
 .dropdown-menu .disabled > a:hover {
-  color: #999999;
+  color: #bbbbbb;
 }
-
 .dropdown-menu .disabled > a:hover {
   text-decoration: none;
-  cursor: default;
   background-color: transparent;
+  cursor: default;
 }
-
 .open {
   *z-index: 1000;
 }
-
-.open > .dropdown-menu {
+.open  > .dropdown-menu {
   display: block;
 }
-
 .pull-right > .dropdown-menu {
   right: 0;
   left: auto;
 }
-
 .dropup .caret,
 .navbar-fixed-bottom .dropdown .caret {
   border-top: 0;
   border-bottom: 4px solid #000000;
   content: "";
 }
-
 .dropup .dropdown-menu,
 .navbar-fixed-bottom .dropdown .dropdown-menu {
   top: auto;
   bottom: 100%;
   margin-bottom: 1px;
 }
-
 .dropdown-submenu {
   position: relative;
 }
-
 .dropdown-submenu > .dropdown-menu {
   top: 0;
   left: 100%;
   margin-top: -6px;
   margin-left: -1px;
   -webkit-border-radius: 0 6px 6px 6px;
-     -moz-border-radius: 0 6px 6px 6px;
-          border-radius: 0 6px 6px 6px;
+  -moz-border-radius: 0 6px 6px 6px;
+  border-radius: 0 6px 6px 6px;
 }
-
 .dropdown-submenu:hover > .dropdown-menu {
   display: block;
 }
-
 .dropdown-submenu > a:after {
   display: block;
+  content: " ";
   float: right;
   width: 0;
   height: 0;
-  margin-top: 5px;
-  margin-right: -10px;
   border-color: transparent;
-  border-left-color: #cccccc;
   border-style: solid;
   border-width: 5px 0 5px 5px;
-  content: " ";
+  border-left-color: #cccccc;
+  margin-top: 5px;
+  margin-right: -10px;
 }
-
 .dropdown-submenu:hover > a:after {
   border-left-color: #ffffff;
 }
-
 .dropdown .dropdown-menu .nav-header {
-  padding-right: 20px;
   padding-left: 20px;
+  padding-right: 20px;
 }
-
 .typeahead {
   margin-top: 2px;
   -webkit-border-radius: 4px;
-     -moz-border-radius: 4px;
-          border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
 }
-
 .well {
   min-height: 20px;
   padding: 19px;
@@ -2941,69 +2427,60 @@ table [class*=span],
   background-color: #f5f5f5;
   border: 1px solid #e3e3e3;
   -webkit-border-radius: 4px;
-     -moz-border-radius: 4px;
-          border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
   -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05);
-     -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05);
-          box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05);
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05);
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05);
 }
-
 .well blockquote {
   border-color: #ddd;
   border-color: rgba(0, 0, 0, 0.15);
 }
-
 .well-large {
   padding: 24px;
   -webkit-border-radius: 6px;
-     -moz-border-radius: 6px;
-          border-radius: 6px;
+  -moz-border-radius: 6px;
+  border-radius: 6px;
 }
-
 .well-small {
   padding: 9px;
   -webkit-border-radius: 3px;
-     -moz-border-radius: 3px;
-          border-radius: 3px;
+  -moz-border-radius: 3px;
+  border-radius: 3px;
 }
-
 .fade {
   opacity: 0;
   -webkit-transition: opacity 0.15s linear;
-     -moz-transition: opacity 0.15s linear;
-       -o-transition: opacity 0.15s linear;
-          transition: opacity 0.15s linear;
+  -moz-transition: opacity 0.15s linear;
+  -o-transition: opacity 0.15s linear;
+  transition: opacity 0.15s linear;
 }
-
 .fade.in {
   opacity: 1;
 }
-
 .collapse {
   position: relative;
   height: 0;
   overflow: hidden;
   -webkit-transition: height 0.35s ease;
-     -moz-transition: height 0.35s ease;
-       -o-transition: height 0.35s ease;
-          transition: height 0.35s ease;
+  -moz-transition: height 0.35s ease;
+  -o-transition: height 0.35s ease;
+  transition: height 0.35s ease;
 }
-
 .collapse.in {
   height: auto;
 }
-
 .close {
   float: right;
   font-size: 20px;
   font-weight: bold;
-  line-height: 20px;
+  line-height: 21px;
   color: #000000;
   text-shadow: 0 1px 0 #ffffff;
   opacity: 0.2;
   filter: alpha(opacity=20);
 }
-
 .close:hover {
   color: #000000;
   text-decoration: none;
@@ -3011,7 +2488,6 @@ table [class*=span],
   opacity: 0.4;
   filter: alpha(opacity=40);
 }
-
 button.close {
   padding: 0;
   cursor: pointer;
@@ -3019,64 +2495,63 @@ button.close {
   border: 0;
   -webkit-appearance: none;
 }
-
 .btn {
   display: inline-block;
   *display: inline;
+  /* IE7 inline-block hack */
+
+  *zoom: 1;
   padding: 4px 14px;
   margin-bottom: 0;
-  *margin-left: .3em;
   font-size: 14px;
-  line-height: 20px;
-  *line-height: 20px;
-  color: #333333;
+  line-height: 21px;
+  *line-height: 21px;
   text-align: center;
-  text-shadow: 0 1px 1px rgba(255, 255, 255, 0.75);
   vertical-align: middle;
   cursor: pointer;
-  background-color: #f5f5f5;
-  *background-color: #e6e6e6;
-  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#ffffff), to(#e6e6e6));
-  background-image: -webkit-linear-gradient(top, #ffffff, #e6e6e6);
-  background-image: -o-linear-gradient(top, #ffffff, #e6e6e6);
-  background-image: linear-gradient(to bottom, #ffffff, #e6e6e6);
-  background-image: -moz-linear-gradient(top, #ffffff, #e6e6e6);
+  color: #333333;
+  text-shadow: 0 1px 1px rgba(255, 255, 255, 0.75);
+  background-color: #f8f8f8;
+  background-image: -moz-linear-gradient(top, #ffffff, #eeeeee);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#ffffff), to(#eeeeee));
+  background-image: -webkit-linear-gradient(top, #ffffff, #eeeeee);
+  background-image: -o-linear-gradient(top, #ffffff, #eeeeee);
+  background-image: linear-gradient(to bottom, #ffffff, #eeeeee);
   background-repeat: repeat-x;
-  border: 1px solid #bbbbbb;
-  *border: 0;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff', endColorstr='#ffeeeeee', GradientType=0);
+  border-color: #eeeeee #eeeeee #c8c8c8;
   border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
-  border-color: #e6e6e6 #e6e6e6 #bfbfbf;
-  border-bottom-color: #a2a2a2;
-  -webkit-border-radius: 4px;
-     -moz-border-radius: 4px;
-          border-radius: 4px;
-  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ffffffff', endColorstr='#ffe6e6e6', GradientType=0);
-  filter: progid:dximagetransform.microsoft.gradient(enabled=false);
-  *zoom: 1;
-  -webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
-     -moz-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
-          box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
-}
+  *background-color: #eeeeee;
+  /* Darken IE7 buttons by default so they stand out more given they won't have borders */
 
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+  border: 1px solid #cccccc;
+  *border: 0;
+  border-bottom-color: #b3b3b3;
+  -webkit-border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
+  *margin-left: .3em;
+  -webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
+  -moz-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
+}
 .btn:hover,
 .btn:active,
 .btn.active,
 .btn.disabled,
 .btn[disabled] {
   color: #333333;
-  background-color: #e6e6e6;
-  *background-color: #d9d9d9;
+  background-color: #eeeeee;
+  *background-color: #e1e1e1;
 }
-
 .btn:active,
 .btn.active {
-  background-color: #cccccc \9;
+  background-color: #d5d5d5 \9;
 }
-
 .btn:first-child {
   *margin-left: 0;
 }
-
 .btn:hover {
   color: #333333;
   text-decoration: none;
@@ -3086,17 +2561,15 @@ button.close {
 
   background-position: 0 -15px;
   -webkit-transition: background-position 0.1s linear;
-     -moz-transition: background-position 0.1s linear;
-       -o-transition: background-position 0.1s linear;
-          transition: background-position 0.1s linear;
+  -moz-transition: background-position 0.1s linear;
+  -o-transition: background-position 0.1s linear;
+  transition: background-position 0.1s linear;
 }
-
 .btn:focus {
   outline: thin dotted #333;
   outline: 5px auto -webkit-focus-ring-color;
   outline-offset: -2px;
 }
-
 .btn.active,
 .btn:active {
   background-color: #e6e6e6;
@@ -3104,10 +2577,9 @@ button.close {
   background-image: none;
   outline: 0;
   -webkit-box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05);
-     -moz-box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05);
-          box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05);
+  -moz-box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05);
+  box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05);
 }
-
 .btn.disabled,
 .btn[disabled] {
   cursor: default;
@@ -3116,59 +2588,50 @@ button.close {
   opacity: 0.65;
   filter: alpha(opacity=65);
   -webkit-box-shadow: none;
-     -moz-box-shadow: none;
-          box-shadow: none;
+  -moz-box-shadow: none;
+  box-shadow: none;
 }
-
 .btn-large {
   padding: 9px 14px;
   font-size: 16px;
   line-height: normal;
   -webkit-border-radius: 5px;
-     -moz-border-radius: 5px;
-          border-radius: 5px;
+  -moz-border-radius: 5px;
+  border-radius: 5px;
 }
-
 .btn-large [class^="icon-"] {
   margin-top: 2px;
 }
-
 .btn-small {
   padding: 3px 9px;
   font-size: 12px;
-  line-height: 18px;
+  line-height: 19px;
 }
-
 .btn-small [class^="icon-"] {
   margin-top: 0;
 }
-
 .btn-mini {
   padding: 2px 6px;
   font-size: 11px;
-  line-height: 17px;
+  line-height: 18px;
 }
-
 .btn-block {
   display: block;
   width: 100%;
-  padding-right: 0;
   padding-left: 0;
+  padding-right: 0;
   -webkit-box-sizing: border-box;
-     -moz-box-sizing: border-box;
-          box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
 }
-
 .btn-block + .btn-block {
   margin-top: 5px;
 }
-
 input[type="submit"].btn-block,
 input[type="reset"].btn-block,
 input[type="button"].btn-block {
   width: 100%;
 }
-
 .btn-primary.active,
 .btn-warning.active,
 .btn-danger.active,
@@ -3177,286 +2640,265 @@ input[type="button"].btn-block {
 .btn-inverse.active {
   color: rgba(255, 255, 255, 0.75);
 }
-
 .btn {
   border-color: #c5c5c5;
   border-color: rgba(0, 0, 0, 0.15) rgba(0, 0, 0, 0.15) rgba(0, 0, 0, 0.25);
 }
-
 .btn-primary {
   color: #ffffff;
   text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
-  background-color: #006dcc;
-  *background-color: #0044cc;
-  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#0088cc), to(#0044cc));
-  background-image: -webkit-linear-gradient(top, #0088cc, #0044cc);
-  background-image: -o-linear-gradient(top, #0088cc, #0044cc);
-  background-image: linear-gradient(to bottom, #0088cc, #0044cc);
-  background-image: -moz-linear-gradient(top, #0088cc, #0044cc);
+  background-color: #77a2d0;
+  background-image: -moz-linear-gradient(top, #8eb2d8, #558bc4);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#8eb2d8), to(#558bc4));
+  background-image: -webkit-linear-gradient(top, #8eb2d8, #558bc4);
+  background-image: -o-linear-gradient(top, #8eb2d8, #558bc4);
+  background-image: linear-gradient(to bottom, #8eb2d8, #558bc4);
   background-repeat: repeat-x;
-  border-color: #0044cc #0044cc #002a80;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff8eb2d8', endColorstr='#ff558bc4', GradientType=0);
+  border-color: #558bc4 #558bc4 #356598;
   border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
-  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff0088cc', endColorstr='#ff0044cc', GradientType=0);
-  filter: progid:dximagetransform.microsoft.gradient(enabled=false);
-}
+  *background-color: #558bc4;
+  /* Darken IE7 buttons by default so they stand out more given they won't have borders */
 
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+}
 .btn-primary:hover,
 .btn-primary:active,
 .btn-primary.active,
 .btn-primary.disabled,
 .btn-primary[disabled] {
   color: #ffffff;
-  background-color: #0044cc;
-  *background-color: #003bb3;
+  background-color: #558bc4;
+  *background-color: #427ebd;
 }
-
 .btn-primary:active,
 .btn-primary.active {
-  background-color: #003399 \9;
+  background-color: #3b71ab \9;
 }
-
 .btn-warning {
   color: #ffffff;
   text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
-  background-color: #faa732;
-  *background-color: #f89406;
-  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#fbb450), to(#f89406));
-  background-image: -webkit-linear-gradient(top, #fbb450, #f89406);
-  background-image: -o-linear-gradient(top, #fbb450, #f89406);
-  background-image: linear-gradient(to bottom, #fbb450, #f89406);
-  background-image: -moz-linear-gradient(top, #fbb450, #f89406);
+  background-color: #ee8c14;
+  background-image: -moz-linear-gradient(top, #ff9c21, #d47500);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#ff9c21), to(#d47500));
+  background-image: -webkit-linear-gradient(top, #ff9c21, #d47500);
+  background-image: -o-linear-gradient(top, #ff9c21, #d47500);
+  background-image: linear-gradient(to bottom, #ff9c21, #d47500);
   background-repeat: repeat-x;
-  border-color: #f89406 #f89406 #ad6704;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffff9c21', endColorstr='#ffd47500', GradientType=0);
+  border-color: #d47500 #d47500 #884b00;
   border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
-  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#fffbb450', endColorstr='#fff89406', GradientType=0);
-  filter: progid:dximagetransform.microsoft.gradient(enabled=false);
-}
+  *background-color: #d47500;
+  /* Darken IE7 buttons by default so they stand out more given they won't have borders */
 
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+}
 .btn-warning:hover,
 .btn-warning:active,
 .btn-warning.active,
 .btn-warning.disabled,
 .btn-warning[disabled] {
   color: #ffffff;
-  background-color: #f89406;
-  *background-color: #df8505;
+  background-color: #d47500;
+  *background-color: #bb6700;
 }
-
 .btn-warning:active,
 .btn-warning.active {
-  background-color: #c67605 \9;
+  background-color: #a15900 \9;
 }
-
 .btn-danger {
   color: #ffffff;
   text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
-  background-color: #da4f49;
-  *background-color: #bd362f;
-  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#ee5f5b), to(#bd362f));
-  background-image: -webkit-linear-gradient(top, #ee5f5b, #bd362f);
-  background-image: -o-linear-gradient(top, #ee5f5b, #bd362f);
-  background-image: linear-gradient(to bottom, #ee5f5b, #bd362f);
-  background-image: -moz-linear-gradient(top, #ee5f5b, #bd362f);
+  background-color: #eb1210;
+  background-image: -moz-linear-gradient(top, #ff1d1b, #cd0200);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#ff1d1b), to(#cd0200));
+  background-image: -webkit-linear-gradient(top, #ff1d1b, #cd0200);
+  background-image: -o-linear-gradient(top, #ff1d1b, #cd0200);
+  background-image: linear-gradient(to bottom, #ff1d1b, #cd0200);
   background-repeat: repeat-x;
-  border-color: #bd362f #bd362f #802420;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffff1d1b', endColorstr='#ffcd0200', GradientType=0);
+  border-color: #cd0200 #cd0200 #810100;
   border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
-  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ffee5f5b', endColorstr='#ffbd362f', GradientType=0);
-  filter: progid:dximagetransform.microsoft.gradient(enabled=false);
-}
+  *background-color: #cd0200;
+  /* Darken IE7 buttons by default so they stand out more given they won't have borders */
 
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+}
 .btn-danger:hover,
 .btn-danger:active,
 .btn-danger.active,
 .btn-danger.disabled,
 .btn-danger[disabled] {
   color: #ffffff;
-  background-color: #bd362f;
-  *background-color: #a9302a;
+  background-color: #cd0200;
+  *background-color: #b40200;
 }
-
 .btn-danger:active,
 .btn-danger.active {
-  background-color: #942a25 \9;
+  background-color: #9a0200 \9;
 }
-
 .btn-success {
   color: #ffffff;
   text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
-  background-color: #5bb75b;
-  *background-color: #51a351;
-  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#62c462), to(#51a351));
-  background-image: -webkit-linear-gradient(top, #62c462, #51a351);
-  background-image: -o-linear-gradient(top, #62c462, #51a351);
-  background-image: linear-gradient(to bottom, #62c462, #51a351);
-  background-image: -moz-linear-gradient(top, #62c462, #51a351);
+  background-color: #98b64d;
+  background-image: -moz-linear-gradient(top, #a8c65b, #819e37);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#a8c65b), to(#819e37));
+  background-image: -webkit-linear-gradient(top, #a8c65b, #819e37);
+  background-image: -o-linear-gradient(top, #a8c65b, #819e37);
+  background-image: linear-gradient(to bottom, #a8c65b, #819e37);
   background-repeat: repeat-x;
-  border-color: #51a351 #51a351 #387038;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffa8c65b', endColorstr='#ff819e37', GradientType=0);
+  border-color: #819e37 #819e37 #536523;
   border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
-  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff62c462', endColorstr='#ff51a351', GradientType=0);
-  filter: progid:dximagetransform.microsoft.gradient(enabled=false);
-}
+  *background-color: #819e37;
+  /* Darken IE7 buttons by default so they stand out more given they won't have borders */
 
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+}
 .btn-success:hover,
 .btn-success:active,
 .btn-success.active,
 .btn-success.disabled,
 .btn-success[disabled] {
   color: #ffffff;
-  background-color: #51a351;
-  *background-color: #499249;
+  background-color: #819e37;
+  *background-color: #728b30;
 }
-
 .btn-success:active,
 .btn-success.active {
-  background-color: #408140 \9;
+  background-color: #62782a \9;
 }
-
 .btn-info {
   color: #ffffff;
   text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
-  background-color: #49afcd;
-  *background-color: #2f96b4;
-  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#5bc0de), to(#2f96b4));
-  background-image: -webkit-linear-gradient(top, #5bc0de, #2f96b4);
-  background-image: -o-linear-gradient(top, #5bc0de, #2f96b4);
-  background-image: linear-gradient(to bottom, #5bc0de, #2f96b4);
-  background-image: -moz-linear-gradient(top, #5bc0de, #2f96b4);
+  background-color: #d2d2d2;
+  background-image: -moz-linear-gradient(top, #e1e1e1, #bbbbbb);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#e1e1e1), to(#bbbbbb));
+  background-image: -webkit-linear-gradient(top, #e1e1e1, #bbbbbb);
+  background-image: -o-linear-gradient(top, #e1e1e1, #bbbbbb);
+  background-image: linear-gradient(to bottom, #e1e1e1, #bbbbbb);
   background-repeat: repeat-x;
-  border-color: #2f96b4 #2f96b4 #1f6377;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffe1e1e1', endColorstr='#ffbbbbbb', GradientType=0);
+  border-color: #bbbbbb #bbbbbb #959595;
   border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
-  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff5bc0de', endColorstr='#ff2f96b4', GradientType=0);
-  filter: progid:dximagetransform.microsoft.gradient(enabled=false);
-}
+  *background-color: #bbbbbb;
+  /* Darken IE7 buttons by default so they stand out more given they won't have borders */
 
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+}
 .btn-info:hover,
 .btn-info:active,
 .btn-info.active,
 .btn-info.disabled,
 .btn-info[disabled] {
   color: #ffffff;
-  background-color: #2f96b4;
-  *background-color: #2a85a0;
+  background-color: #bbbbbb;
+  *background-color: #aeaeae;
 }
-
 .btn-info:active,
 .btn-info.active {
-  background-color: #24748c \9;
+  background-color: #a2a2a2 \9;
 }
-
 .btn-inverse {
   color: #ffffff;
   text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
-  background-color: #363636;
-  *background-color: #222222;
-  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#444444), to(#222222));
-  background-image: -webkit-linear-gradient(top, #444444, #222222);
-  background-image: -o-linear-gradient(top, #444444, #222222);
-  background-image: linear-gradient(to bottom, #444444, #222222);
-  background-image: -moz-linear-gradient(top, #444444, #222222);
+  background-color: #848a94;
+  background-image: -moz-linear-gradient(top, #949aa3, #6c737e);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#949aa3), to(#6c737e));
+  background-image: -webkit-linear-gradient(top, #949aa3, #6c737e);
+  background-image: -o-linear-gradient(top, #949aa3, #6c737e);
+  background-image: linear-gradient(to bottom, #949aa3, #6c737e);
   background-repeat: repeat-x;
-  border-color: #222222 #222222 #000000;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff949aa3', endColorstr='#ff6c737e', GradientType=0);
+  border-color: #6c737e #6c737e #494d55;
   border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
-  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff444444', endColorstr='#ff222222', GradientType=0);
-  filter: progid:dximagetransform.microsoft.gradient(enabled=false);
-}
+  *background-color: #6c737e;
+  /* Darken IE7 buttons by default so they stand out more given they won't have borders */
 
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+}
 .btn-inverse:hover,
 .btn-inverse:active,
 .btn-inverse.active,
 .btn-inverse.disabled,
 .btn-inverse[disabled] {
   color: #ffffff;
-  background-color: #222222;
-  *background-color: #151515;
+  background-color: #6c737e;
+  *background-color: #606670;
 }
-
 .btn-inverse:active,
 .btn-inverse.active {
-  background-color: #080808 \9;
+  background-color: #545a63 \9;
 }
-
 button.btn,
 input[type="submit"].btn {
   *padding-top: 3px;
   *padding-bottom: 3px;
 }
-
 button.btn::-moz-focus-inner,
 input[type="submit"].btn::-moz-focus-inner {
   padding: 0;
   border: 0;
 }
-
 button.btn.btn-large,
 input[type="submit"].btn.btn-large {
   *padding-top: 7px;
   *padding-bottom: 7px;
 }
-
 button.btn.btn-small,
 input[type="submit"].btn.btn-small {
   *padding-top: 3px;
   *padding-bottom: 3px;
 }
-
 button.btn.btn-mini,
 input[type="submit"].btn.btn-mini {
   *padding-top: 1px;
   *padding-bottom: 1px;
 }
-
 .btn-link,
 .btn-link:active,
 .btn-link[disabled] {
   background-color: transparent;
   background-image: none;
   -webkit-box-shadow: none;
-     -moz-box-shadow: none;
-          box-shadow: none;
+  -moz-box-shadow: none;
+  box-shadow: none;
 }
-
 .btn-link {
-  color: #0088cc;
-  cursor: pointer;
   border-color: transparent;
+  cursor: pointer;
+  color: #558bc4;
   -webkit-border-radius: 0;
-     -moz-border-radius: 0;
-          border-radius: 0;
+  -moz-border-radius: 0;
+  border-radius: 0;
 }
-
 .btn-link:hover {
-  color: #005580;
+  color: #558bc4;
   text-decoration: underline;
   background-color: transparent;
 }
-
 .btn-link[disabled]:hover {
   color: #333333;
   text-decoration: none;
 }
-
 .btn-group {
   position: relative;
-  *margin-left: .3em;
   font-size: 0;
-  white-space: nowrap;
   vertical-align: middle;
+  white-space: nowrap;
+  *margin-left: .3em;
 }
-
 .btn-group:first-child {
   *margin-left: 0;
 }
-
 .btn-group + .btn-group {
   margin-left: 5px;
 }
-
 .btn-toolbar {
-  margin-top: 10px;
-  margin-bottom: 10px;
   font-size: 0;
+  margin-top: 10.5px;
+  margin-bottom: 10.5px;
 }
-
 .btn-toolbar .btn-group {
   display: inline-block;
   *display: inline;
@@ -3464,179 +2906,149 @@ input[type="submit"].btn.btn-mini {
 
   *zoom: 1;
 }
-
 .btn-toolbar .btn + .btn,
 .btn-toolbar .btn-group + .btn,
 .btn-toolbar .btn + .btn-group {
   margin-left: 5px;
 }
-
 .btn-group > .btn {
   position: relative;
   -webkit-border-radius: 0;
-     -moz-border-radius: 0;
-          border-radius: 0;
+  -moz-border-radius: 0;
+  border-radius: 0;
 }
-
 .btn-group > .btn + .btn {
   margin-left: -1px;
 }
-
 .btn-group > .btn,
 .btn-group > .dropdown-menu {
   font-size: 14px;
 }
-
 .btn-group > .btn-mini {
   font-size: 11px;
 }
-
 .btn-group > .btn-small {
   font-size: 12px;
 }
-
 .btn-group > .btn-large {
   font-size: 16px;
 }
-
 .btn-group > .btn:first-child {
   margin-left: 0;
-  -webkit-border-bottom-left-radius: 4px;
-          border-bottom-left-radius: 4px;
   -webkit-border-top-left-radius: 4px;
-          border-top-left-radius: 4px;
-  -moz-border-radius-bottomleft: 4px;
   -moz-border-radius-topleft: 4px;
+  border-top-left-radius: 4px;
+  -webkit-border-bottom-left-radius: 4px;
+  -moz-border-radius-bottomleft: 4px;
+  border-bottom-left-radius: 4px;
 }
-
 .btn-group > .btn:last-child,
 .btn-group > .dropdown-toggle {
   -webkit-border-top-right-radius: 4px;
-          border-top-right-radius: 4px;
-  -webkit-border-bottom-right-radius: 4px;
-          border-bottom-right-radius: 4px;
   -moz-border-radius-topright: 4px;
+  border-top-right-radius: 4px;
+  -webkit-border-bottom-right-radius: 4px;
   -moz-border-radius-bottomright: 4px;
+  border-bottom-right-radius: 4px;
 }
-
 .btn-group > .btn.large:first-child {
   margin-left: 0;
-  -webkit-border-bottom-left-radius: 6px;
-          border-bottom-left-radius: 6px;
   -webkit-border-top-left-radius: 6px;
-          border-top-left-radius: 6px;
-  -moz-border-radius-bottomleft: 6px;
   -moz-border-radius-topleft: 6px;
+  border-top-left-radius: 6px;
+  -webkit-border-bottom-left-radius: 6px;
+  -moz-border-radius-bottomleft: 6px;
+  border-bottom-left-radius: 6px;
 }
-
 .btn-group > .btn.large:last-child,
 .btn-group > .large.dropdown-toggle {
   -webkit-border-top-right-radius: 6px;
-          border-top-right-radius: 6px;
-  -webkit-border-bottom-right-radius: 6px;
-          border-bottom-right-radius: 6px;
   -moz-border-radius-topright: 6px;
+  border-top-right-radius: 6px;
+  -webkit-border-bottom-right-radius: 6px;
   -moz-border-radius-bottomright: 6px;
+  border-bottom-right-radius: 6px;
 }
-
 .btn-group > .btn:hover,
 .btn-group > .btn:focus,
 .btn-group > .btn:active,
 .btn-group > .btn.active {
   z-index: 2;
 }
-
 .btn-group .dropdown-toggle:active,
 .btn-group.open .dropdown-toggle {
   outline: 0;
 }
-
 .btn-group > .btn + .dropdown-toggle {
-  *padding-top: 5px;
-  padding-right: 8px;
-  *padding-bottom: 5px;
   padding-left: 8px;
+  padding-right: 8px;
   -webkit-box-shadow: inset 1px 0 0 rgba(255, 255, 255, 0.125), inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
-     -moz-box-shadow: inset 1px 0 0 rgba(255, 255, 255, 0.125), inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
-          box-shadow: inset 1px 0 0 rgba(255, 255, 255, 0.125), inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
+  -moz-box-shadow: inset 1px 0 0 rgba(255, 255, 255, 0.125), inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
+  box-shadow: inset 1px 0 0 rgba(255, 255, 255, 0.125), inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
+  *padding-top: 5px;
+  *padding-bottom: 5px;
 }
-
 .btn-group > .btn-mini + .dropdown-toggle {
-  *padding-top: 2px;
-  padding-right: 5px;
-  *padding-bottom: 2px;
   padding-left: 5px;
+  padding-right: 5px;
+  *padding-top: 2px;
+  *padding-bottom: 2px;
 }
-
 .btn-group > .btn-small + .dropdown-toggle {
   *padding-top: 5px;
   *padding-bottom: 4px;
 }
-
 .btn-group > .btn-large + .dropdown-toggle {
-  *padding-top: 7px;
-  padding-right: 12px;
-  *padding-bottom: 7px;
   padding-left: 12px;
+  padding-right: 12px;
+  *padding-top: 7px;
+  *padding-bottom: 7px;
 }
-
 .btn-group.open .dropdown-toggle {
   background-image: none;
   -webkit-box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05);
-     -moz-box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05);
-          box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05);
+  -moz-box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05);
+  box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05);
 }
-
 .btn-group.open .btn.dropdown-toggle {
-  background-color: #e6e6e6;
+  background-color: #eeeeee;
 }
-
 .btn-group.open .btn-primary.dropdown-toggle {
-  background-color: #0044cc;
+  background-color: #558bc4;
 }
-
 .btn-group.open .btn-warning.dropdown-toggle {
-  background-color: #f89406;
+  background-color: #d47500;
 }
-
 .btn-group.open .btn-danger.dropdown-toggle {
-  background-color: #bd362f;
+  background-color: #cd0200;
 }
-
 .btn-group.open .btn-success.dropdown-toggle {
-  background-color: #51a351;
+  background-color: #819e37;
 }
-
 .btn-group.open .btn-info.dropdown-toggle {
-  background-color: #2f96b4;
+  background-color: #bbbbbb;
 }
-
 .btn-group.open .btn-inverse.dropdown-toggle {
-  background-color: #222222;
+  background-color: #6c737e;
 }
-
 .btn .caret {
   margin-top: 8px;
   margin-left: 0;
 }
-
 .btn-mini .caret,
 .btn-small .caret,
 .btn-large .caret {
   margin-top: 6px;
 }
-
 .btn-large .caret {
-  border-top-width: 5px;
-  border-right-width: 5px;
   border-left-width: 5px;
+  border-right-width: 5px;
+  border-top-width: 5px;
 }
-
 .dropup .btn-large .caret {
-  border-top: 0;
   border-bottom: 5px solid #000000;
+  border-top: 0;
 }
-
 .btn-primary .caret,
 .btn-warning .caret,
 .btn-danger .caret,
@@ -3646,7 +3058,6 @@ input[type="submit"].btn.btn-mini {
   border-top-color: #ffffff;
   border-bottom-color: #ffffff;
 }
-
 .btn-group-vertical {
   display: inline-block;
   *display: inline;
@@ -3654,197 +3065,165 @@ input[type="submit"].btn.btn-mini {
 
   *zoom: 1;
 }
-
 .btn-group-vertical .btn {
   display: block;
   float: none;
   width: 100%;
   -webkit-border-radius: 0;
-     -moz-border-radius: 0;
-          border-radius: 0;
+  -moz-border-radius: 0;
+  border-radius: 0;
 }
-
 .btn-group-vertical .btn + .btn {
-  margin-top: -1px;
   margin-left: 0;
+  margin-top: -1px;
 }
-
 .btn-group-vertical .btn:first-child {
   -webkit-border-radius: 4px 4px 0 0;
-     -moz-border-radius: 4px 4px 0 0;
-          border-radius: 4px 4px 0 0;
+  -moz-border-radius: 4px 4px 0 0;
+  border-radius: 4px 4px 0 0;
 }
-
 .btn-group-vertical .btn:last-child {
   -webkit-border-radius: 0 0 4px 4px;
-     -moz-border-radius: 0 0 4px 4px;
-          border-radius: 0 0 4px 4px;
+  -moz-border-radius: 0 0 4px 4px;
+  border-radius: 0 0 4px 4px;
 }
-
 .btn-group-vertical .btn-large:first-child {
   -webkit-border-radius: 6px 6px 0 0;
-     -moz-border-radius: 6px 6px 0 0;
-          border-radius: 6px 6px 0 0;
+  -moz-border-radius: 6px 6px 0 0;
+  border-radius: 6px 6px 0 0;
 }
-
 .btn-group-vertical .btn-large:last-child {
   -webkit-border-radius: 0 0 6px 6px;
-     -moz-border-radius: 0 0 6px 6px;
-          border-radius: 0 0 6px 6px;
+  -moz-border-radius: 0 0 6px 6px;
+  border-radius: 0 0 6px 6px;
 }
-
 .alert {
   padding: 8px 35px 8px 14px;
-  margin-bottom: 20px;
-  color: #c09853;
+  margin-bottom: 21px;
   text-shadow: 0 1px 0 rgba(255, 255, 255, 0.5);
-  background-color: #fcf8e3;
-  border: 1px solid #fbeed5;
+  background-color: #d47500;
+  border: 1px solid #c54c00;
   -webkit-border-radius: 4px;
-     -moz-border-radius: 4px;
-          border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
+  color: #ffffff;
 }
-
 .alert h4 {
   margin: 0;
 }
-
 .alert .close {
   position: relative;
   top: -2px;
   right: -21px;
-  line-height: 20px;
+  line-height: 21px;
 }
-
 .alert-success {
-  color: #468847;
-  background-color: #dff0d8;
-  border-color: #d6e9c6;
+  background-color: #819e37;
+  border-color: #818b30;
+  color: #ffffff;
 }
-
 .alert-danger,
 .alert-error {
-  color: #b94a48;
-  background-color: #f2dede;
-  border-color: #eed3d7;
+  background-color: #cd0200;
+  border-color: #be001e;
+  color: #ffffff;
 }
-
 .alert-info {
-  color: #3a87ad;
-  background-color: #d9edf7;
-  border-color: #bce8f1;
+  background-color: #3399f3;
+  border-color: #11adf1;
+  color: #ffffff;
 }
-
 .alert-block {
   padding-top: 14px;
   padding-bottom: 14px;
 }
-
 .alert-block > p,
 .alert-block > ul {
   margin-bottom: 0;
 }
-
 .alert-block p + p {
   margin-top: 5px;
 }
-
 .nav {
-  margin-bottom: 20px;
   margin-left: 0;
+  margin-bottom: 21px;
   list-style: none;
 }
-
 .nav > li > a {
   display: block;
 }
-
 .nav > li > a:hover {
   text-decoration: none;
   background-color: #eeeeee;
 }
-
 .nav > .pull-right {
   float: right;
 }
-
 .nav-header {
   display: block;
   padding: 3px 15px;
   font-size: 11px;
   font-weight: bold;
-  line-height: 20px;
-  color: #999999;
+  line-height: 21px;
+  color: #bbbbbb;
   text-shadow: 0 1px 0 rgba(255, 255, 255, 0.5);
   text-transform: uppercase;
 }
-
 .nav li + .nav-header {
   margin-top: 9px;
 }
-
 .nav-list {
-  padding-right: 15px;
   padding-left: 15px;
+  padding-right: 15px;
   margin-bottom: 0;
 }
-
 .nav-list > li > a,
 .nav-list .nav-header {
-  margin-right: -15px;
   margin-left: -15px;
+  margin-right: -15px;
   text-shadow: 0 1px 0 rgba(255, 255, 255, 0.5);
 }
-
 .nav-list > li > a {
   padding: 3px 15px;
 }
-
 .nav-list > .active > a,
 .nav-list > .active > a:hover {
   color: #ffffff;
   text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.2);
-  background-color: #0088cc;
+  background-color: #558bc4;
 }
-
 .nav-list [class^="icon-"] {
   margin-right: 2px;
 }
-
 .nav-list .divider {
   *width: 100%;
   height: 1px;
-  margin: 9px 1px;
+  margin: 9.5px 1px;
   *margin: -5px 0 5px;
   overflow: hidden;
   background-color: #e5e5e5;
   border-bottom: 1px solid #ffffff;
 }
-
 .nav-tabs,
 .nav-pills {
   *zoom: 1;
 }
-
 .nav-tabs:before,
 .nav-pills:before,
 .nav-tabs:after,
 .nav-pills:after {
   display: table;
-  line-height: 0;
   content: "";
+  line-height: 0;
 }
-
 .nav-tabs:after,
 .nav-pills:after {
   clear: both;
 }
-
 .nav-tabs > li,
 .nav-pills > li {
   float: left;
 }
-
 .nav-tabs > li > a,
 .nav-pills > li > a {
   padding-right: 12px;
@@ -3852,155 +3231,128 @@ input[type="submit"].btn.btn-mini {
   margin-right: 2px;
   line-height: 14px;
 }
-
 .nav-tabs {
   border-bottom: 1px solid #ddd;
 }
-
 .nav-tabs > li {
   margin-bottom: -1px;
 }
-
 .nav-tabs > li > a {
   padding-top: 8px;
   padding-bottom: 8px;
-  line-height: 20px;
+  line-height: 21px;
   border: 1px solid transparent;
   -webkit-border-radius: 4px 4px 0 0;
-     -moz-border-radius: 4px 4px 0 0;
-          border-radius: 4px 4px 0 0;
+  -moz-border-radius: 4px 4px 0 0;
+  border-radius: 4px 4px 0 0;
 }
-
 .nav-tabs > li > a:hover {
   border-color: #eeeeee #eeeeee #dddddd;
 }
-
 .nav-tabs > .active > a,
 .nav-tabs > .active > a:hover {
-  color: #555555;
-  cursor: default;
+  color: #777777;
   background-color: #ffffff;
   border: 1px solid #ddd;
   border-bottom-color: transparent;
+  cursor: default;
 }
-
 .nav-pills > li > a {
   padding-top: 8px;
   padding-bottom: 8px;
   margin-top: 2px;
   margin-bottom: 2px;
   -webkit-border-radius: 5px;
-     -moz-border-radius: 5px;
-          border-radius: 5px;
+  -moz-border-radius: 5px;
+  border-radius: 5px;
 }
-
 .nav-pills > .active > a,
 .nav-pills > .active > a:hover {
   color: #ffffff;
-  background-color: #0088cc;
+  background-color: #558bc4;
 }
-
 .nav-stacked > li {
   float: none;
 }
-
 .nav-stacked > li > a {
   margin-right: 0;
 }
-
 .nav-tabs.nav-stacked {
   border-bottom: 0;
 }
-
 .nav-tabs.nav-stacked > li > a {
   border: 1px solid #ddd;
   -webkit-border-radius: 0;
-     -moz-border-radius: 0;
-          border-radius: 0;
+  -moz-border-radius: 0;
+  border-radius: 0;
 }
-
 .nav-tabs.nav-stacked > li:first-child > a {
   -webkit-border-top-right-radius: 4px;
-          border-top-right-radius: 4px;
-  -webkit-border-top-left-radius: 4px;
-          border-top-left-radius: 4px;
   -moz-border-radius-topright: 4px;
+  border-top-right-radius: 4px;
+  -webkit-border-top-left-radius: 4px;
   -moz-border-radius-topleft: 4px;
+  border-top-left-radius: 4px;
 }
-
 .nav-tabs.nav-stacked > li:last-child > a {
   -webkit-border-bottom-right-radius: 4px;
-          border-bottom-right-radius: 4px;
-  -webkit-border-bottom-left-radius: 4px;
-          border-bottom-left-radius: 4px;
   -moz-border-radius-bottomright: 4px;
+  border-bottom-right-radius: 4px;
+  -webkit-border-bottom-left-radius: 4px;
   -moz-border-radius-bottomleft: 4px;
+  border-bottom-left-radius: 4px;
 }
-
 .nav-tabs.nav-stacked > li > a:hover {
-  z-index: 2;
   border-color: #ddd;
+  z-index: 2;
 }
-
 .nav-pills.nav-stacked > li > a {
   margin-bottom: 3px;
 }
-
 .nav-pills.nav-stacked > li:last-child > a {
   margin-bottom: 1px;
 }
-
 .nav-tabs .dropdown-menu {
   -webkit-border-radius: 0 0 6px 6px;
-     -moz-border-radius: 0 0 6px 6px;
-          border-radius: 0 0 6px 6px;
+  -moz-border-radius: 0 0 6px 6px;
+  border-radius: 0 0 6px 6px;
 }
-
 .nav-pills .dropdown-menu {
   -webkit-border-radius: 6px;
-     -moz-border-radius: 6px;
-          border-radius: 6px;
+  -moz-border-radius: 6px;
+  border-radius: 6px;
 }
-
 .nav .dropdown-toggle .caret {
+  border-top-color: #558bc4;
+  border-bottom-color: #558bc4;
   margin-top: 6px;
-  border-top-color: #0088cc;
-  border-bottom-color: #0088cc;
 }
-
 .nav .dropdown-toggle:hover .caret {
-  border-top-color: #005580;
-  border-bottom-color: #005580;
+  border-top-color: #558bc4;
+  border-bottom-color: #558bc4;
 }
-
 /* move down carets for tabs */
-
 .nav-tabs .dropdown-toggle .caret {
   margin-top: 8px;
 }
-
 .nav .active .dropdown-toggle .caret {
   border-top-color: #fff;
   border-bottom-color: #fff;
 }
-
 .nav-tabs .active .dropdown-toggle .caret {
-  border-top-color: #555555;
-  border-bottom-color: #555555;
+  border-top-color: #777777;
+  border-bottom-color: #777777;
 }
-
 .nav > .dropdown.active > a:hover {
   cursor: pointer;
 }
-
 .nav-tabs .open .dropdown-toggle,
 .nav-pills .open .dropdown-toggle,
 .nav > li.dropdown.open.active > a:hover {
   color: #ffffff;
-  background-color: #999999;
-  border-color: #999999;
+  background-color: #bbbbbb;
+  border-color: #bbbbbb;
 }
-
 .nav li.dropdown.open .caret,
 .nav li.dropdown.open.active .caret,
 .nav li.dropdown.open a:hover .caret {
@@ -4009,312 +3361,260 @@ input[type="submit"].btn.btn-mini {
   opacity: 1;
   filter: alpha(opacity=100);
 }
-
 .tabs-stacked .open > a:hover {
-  border-color: #999999;
+  border-color: #bbbbbb;
 }
-
 .tabbable {
   *zoom: 1;
 }
-
 .tabbable:before,
 .tabbable:after {
   display: table;
-  line-height: 0;
   content: "";
+  line-height: 0;
 }
-
 .tabbable:after {
   clear: both;
 }
-
 .tab-content {
   overflow: auto;
 }
-
 .tabs-below > .nav-tabs,
 .tabs-right > .nav-tabs,
 .tabs-left > .nav-tabs {
   border-bottom: 0;
 }
-
 .tab-content > .tab-pane,
 .pill-content > .pill-pane {
   display: none;
 }
-
 .tab-content > .active,
 .pill-content > .active {
   display: block;
 }
-
 .tabs-below > .nav-tabs {
   border-top: 1px solid #ddd;
 }
-
 .tabs-below > .nav-tabs > li {
   margin-top: -1px;
   margin-bottom: 0;
 }
-
 .tabs-below > .nav-tabs > li > a {
   -webkit-border-radius: 0 0 4px 4px;
-     -moz-border-radius: 0 0 4px 4px;
-          border-radius: 0 0 4px 4px;
+  -moz-border-radius: 0 0 4px 4px;
+  border-radius: 0 0 4px 4px;
 }
-
 .tabs-below > .nav-tabs > li > a:hover {
-  border-top-color: #ddd;
   border-bottom-color: transparent;
+  border-top-color: #ddd;
 }
-
 .tabs-below > .nav-tabs > .active > a,
 .tabs-below > .nav-tabs > .active > a:hover {
   border-color: transparent #ddd #ddd #ddd;
 }
-
 .tabs-left > .nav-tabs > li,
 .tabs-right > .nav-tabs > li {
   float: none;
 }
-
 .tabs-left > .nav-tabs > li > a,
 .tabs-right > .nav-tabs > li > a {
   min-width: 74px;
   margin-right: 0;
   margin-bottom: 3px;
 }
-
 .tabs-left > .nav-tabs {
   float: left;
   margin-right: 19px;
   border-right: 1px solid #ddd;
 }
-
 .tabs-left > .nav-tabs > li > a {
   margin-right: -1px;
   -webkit-border-radius: 4px 0 0 4px;
-     -moz-border-radius: 4px 0 0 4px;
-          border-radius: 4px 0 0 4px;
+  -moz-border-radius: 4px 0 0 4px;
+  border-radius: 4px 0 0 4px;
 }
-
 .tabs-left > .nav-tabs > li > a:hover {
   border-color: #eeeeee #dddddd #eeeeee #eeeeee;
 }
-
 .tabs-left > .nav-tabs .active > a,
 .tabs-left > .nav-tabs .active > a:hover {
   border-color: #ddd transparent #ddd #ddd;
   *border-right-color: #ffffff;
 }
-
 .tabs-right > .nav-tabs {
   float: right;
   margin-left: 19px;
   border-left: 1px solid #ddd;
 }
-
 .tabs-right > .nav-tabs > li > a {
   margin-left: -1px;
   -webkit-border-radius: 0 4px 4px 0;
-     -moz-border-radius: 0 4px 4px 0;
-          border-radius: 0 4px 4px 0;
+  -moz-border-radius: 0 4px 4px 0;
+  border-radius: 0 4px 4px 0;
 }
-
 .tabs-right > .nav-tabs > li > a:hover {
   border-color: #eeeeee #eeeeee #eeeeee #dddddd;
 }
-
 .tabs-right > .nav-tabs .active > a,
 .tabs-right > .nav-tabs .active > a:hover {
   border-color: #ddd #ddd #ddd transparent;
   *border-left-color: #ffffff;
 }
-
 .nav > .disabled > a {
-  color: #999999;
+  color: #bbbbbb;
 }
-
 .nav > .disabled > a:hover {
   text-decoration: none;
-  cursor: default;
   background-color: transparent;
+  cursor: default;
 }
-
 .navbar {
+  overflow: visible;
+  margin-bottom: 21px;
+  color: #2d2d2d;
   *position: relative;
   *z-index: 2;
-  margin-bottom: 20px;
-  overflow: visible;
-  color: #777777;
 }
-
 .navbar-inner {
   min-height: 40px;
-  padding-right: 20px;
   padding-left: 20px;
-  background-color: #fafafa;
-  background-image: -moz-linear-gradient(top, #ffffff, #f2f2f2);
-  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#ffffff), to(#f2f2f2));
-  background-image: -webkit-linear-gradient(top, #ffffff, #f2f2f2);
-  background-image: -o-linear-gradient(top, #ffffff, #f2f2f2);
-  background-image: linear-gradient(to bottom, #ffffff, #f2f2f2);
+  padding-right: 20px;
+  background-color: #dadada;
+  background-image: -moz-linear-gradient(top, #eeeeee, #bbbbbb);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#eeeeee), to(#bbbbbb));
+  background-image: -webkit-linear-gradient(top, #eeeeee, #bbbbbb);
+  background-image: -o-linear-gradient(top, #eeeeee, #bbbbbb);
+  background-image: linear-gradient(to bottom, #eeeeee, #bbbbbb);
   background-repeat: repeat-x;
-  border: 1px solid #d4d4d4;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffeeeeee', endColorstr='#ffbbbbbb', GradientType=0);
+  border: 1px solid #aeaeae;
   -webkit-border-radius: 4px;
-     -moz-border-radius: 4px;
-          border-radius: 4px;
-  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ffffffff', endColorstr='#fff2f2f2', GradientType=0);
-  *zoom: 1;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
   -webkit-box-shadow: 0 1px 4px rgba(0, 0, 0, 0.065);
-     -moz-box-shadow: 0 1px 4px rgba(0, 0, 0, 0.065);
-          box-shadow: 0 1px 4px rgba(0, 0, 0, 0.065);
+  -moz-box-shadow: 0 1px 4px rgba(0, 0, 0, 0.065);
+  box-shadow: 0 1px 4px rgba(0, 0, 0, 0.065);
+  *zoom: 1;
 }
-
 .navbar-inner:before,
 .navbar-inner:after {
   display: table;
-  line-height: 0;
   content: "";
+  line-height: 0;
 }
-
 .navbar-inner:after {
   clear: both;
 }
-
 .navbar .container {
   width: auto;
 }
-
 .nav-collapse.collapse {
   height: auto;
 }
-
 .navbar .brand {
-  display: block;
   float: left;
-  padding: 10px 20px 10px;
+  display: block;
+  padding: 9.5px 20px 9.5px;
   margin-left: -20px;
   font-size: 20px;
   font-weight: 200;
-  color: #777777;
-  text-shadow: 0 1px 0 #ffffff;
+  color: #333333;
+  text-shadow: 0 1px 0 #eeeeee;
 }
-
 .navbar .brand:hover {
   text-decoration: none;
 }
-
 .navbar-text {
   margin-bottom: 0;
   line-height: 40px;
 }
-
 .navbar-link {
-  color: #777777;
+  color: #2d2d2d;
 }
-
 .navbar-link:hover {
-  color: #333333;
+  color: #558bc4;
 }
-
 .navbar .divider-vertical {
   height: 40px;
   margin: 0 9px;
-  border-right: 1px solid #ffffff;
-  border-left: 1px solid #f2f2f2;
+  border-left: 1px solid #bbbbbb;
+  border-right: 1px solid #eeeeee;
 }
-
 .navbar .btn,
 .navbar .btn-group {
   margin-top: 5px;
 }
-
 .navbar .btn-group .btn,
 .navbar .input-prepend .btn,
 .navbar .input-append .btn {
   margin-top: 0;
 }
-
 .navbar-form {
   margin-bottom: 0;
   *zoom: 1;
 }
-
 .navbar-form:before,
 .navbar-form:after {
   display: table;
-  line-height: 0;
   content: "";
+  line-height: 0;
 }
-
 .navbar-form:after {
   clear: both;
 }
-
 .navbar-form input,
 .navbar-form select,
 .navbar-form .radio,
 .navbar-form .checkbox {
   margin-top: 5px;
 }
-
 .navbar-form input,
 .navbar-form select,
 .navbar-form .btn {
   display: inline-block;
   margin-bottom: 0;
 }
-
 .navbar-form input[type="image"],
 .navbar-form input[type="checkbox"],
 .navbar-form input[type="radio"] {
   margin-top: 3px;
 }
-
 .navbar-form .input-append,
 .navbar-form .input-prepend {
   margin-top: 6px;
   white-space: nowrap;
 }
-
 .navbar-form .input-append input,
 .navbar-form .input-prepend input {
   margin-top: 0;
 }
-
 .navbar-search {
   position: relative;
   float: left;
   margin-top: 5px;
   margin-bottom: 0;
 }
-
 .navbar-search .search-query {
-  padding: 4px 14px;
   margin-bottom: 0;
-  font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+  padding: 4px 14px;
+  font-family: "Muli", "Helvetica Neue", Helvetica, Arial, sans-serif;
   font-size: 13px;
   font-weight: normal;
   line-height: 1;
   -webkit-border-radius: 15px;
-     -moz-border-radius: 15px;
-          border-radius: 15px;
+  -moz-border-radius: 15px;
+  border-radius: 15px;
 }
-
 .navbar-static-top {
   position: static;
   width: 100%;
   margin-bottom: 0;
 }
-
 .navbar-static-top .navbar-inner {
   -webkit-border-radius: 0;
-     -moz-border-radius: 0;
-          border-radius: 0;
+  -moz-border-radius: 0;
+  border-radius: 0;
 }
-
 .navbar-fixed-top,
 .navbar-fixed-bottom {
   position: fixed;
@@ -4323,52 +3623,43 @@ input[type="submit"].btn.btn-mini {
   z-index: 1030;
   margin-bottom: 0;
 }
-
 .navbar-fixed-top .navbar-inner,
 .navbar-static-top .navbar-inner {
   border-width: 0 0 1px;
 }
-
 .navbar-fixed-bottom .navbar-inner {
   border-width: 1px 0 0;
 }
-
 .navbar-fixed-top .navbar-inner,
 .navbar-fixed-bottom .navbar-inner {
-  padding-right: 0;
   padding-left: 0;
+  padding-right: 0;
   -webkit-border-radius: 0;
-     -moz-border-radius: 0;
-          border-radius: 0;
+  -moz-border-radius: 0;
+  border-radius: 0;
 }
-
 .navbar-static-top .container,
 .navbar-fixed-top .container,
 .navbar-fixed-bottom .container {
   width: 940px;
 }
-
 .navbar-fixed-top {
   top: 0;
 }
-
 .navbar-fixed-top .navbar-inner,
 .navbar-static-top .navbar-inner {
   -webkit-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.1), 0 1px 10px rgba(0, 0, 0, 0.1);
-     -moz-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.1), 0 1px 10px rgba(0, 0, 0, 0.1);
-          box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.1), 0 1px 10px rgba(0, 0, 0, 0.1);
+  -moz-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.1), 0 1px 10px rgba(0, 0, 0, 0.1);
+  box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.1), 0 1px 10px rgba(0, 0, 0, 0.1);
 }
-
 .navbar-fixed-bottom {
   bottom: 0;
 }
-
 .navbar-fixed-bottom .navbar-inner {
   -webkit-box-shadow: inset 0 1px 0 rgba(0, 0, 0, 0.1), 0 -1px 10px rgba(0, 0, 0, 0.1);
-     -moz-box-shadow: inset 0 1px 0 rgba(0, 0, 0, 0.1), 0 -1px 10px rgba(0, 0, 0, 0.1);
-          box-shadow: inset 0 1px 0 rgba(0, 0, 0, 0.1), 0 -1px 10px rgba(0, 0, 0, 0.1);
+  -moz-box-shadow: inset 0 1px 0 rgba(0, 0, 0, 0.1), 0 -1px 10px rgba(0, 0, 0, 0.1);
+  box-shadow: inset 0 1px 0 rgba(0, 0, 0, 0.1), 0 -1px 10px rgba(0, 0, 0, 0.1);
 }
-
 .navbar .nav {
   position: relative;
   left: 0;
@@ -4376,286 +3667,249 @@ input[type="submit"].btn.btn-mini {
   float: left;
   margin: 0 10px 0 0;
 }
-
 .navbar .nav.pull-right {
   float: right;
   margin-right: 0;
 }
-
 .navbar .nav > li {
   float: left;
 }
-
 .navbar .nav > li > a {
   float: none;
-  padding: 10px 15px 10px;
-  color: #777777;
+  padding: 9.5px 15px 9.5px;
+  color: #2d2d2d;
   text-decoration: none;
-  text-shadow: 0 1px 0 #ffffff;
+  text-shadow: 0 1px 0 #eeeeee;
 }
-
 .navbar .nav .dropdown-toggle .caret {
   margin-top: 8px;
 }
-
 .navbar .nav > li > a:focus,
 .navbar .nav > li > a:hover {
-  color: #333333;
-  text-decoration: none;
   background-color: transparent;
+  color: #558bc4;
+  text-decoration: none;
 }
-
 .navbar .nav > .active > a,
 .navbar .nav > .active > a:hover,
 .navbar .nav > .active > a:focus {
-  color: #555555;
+  color: #2d2d2d;
   text-decoration: none;
-  background-color: #e5e5e5;
+  background-color: transparent;
   -webkit-box-shadow: inset 0 3px 8px rgba(0, 0, 0, 0.125);
-     -moz-box-shadow: inset 0 3px 8px rgba(0, 0, 0, 0.125);
-          box-shadow: inset 0 3px 8px rgba(0, 0, 0, 0.125);
+  -moz-box-shadow: inset 0 3px 8px rgba(0, 0, 0, 0.125);
+  box-shadow: inset 0 3px 8px rgba(0, 0, 0, 0.125);
 }
-
 .navbar .btn-navbar {
   display: none;
   float: right;
   padding: 7px 10px;
-  margin-right: 5px;
   margin-left: 5px;
+  margin-right: 5px;
   color: #ffffff;
   text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
-  background-color: #ededed;
-  *background-color: #e5e5e5;
-  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#f2f2f2), to(#e5e5e5));
-  background-image: -webkit-linear-gradient(top, #f2f2f2, #e5e5e5);
-  background-image: -o-linear-gradient(top, #f2f2f2, #e5e5e5);
-  background-image: linear-gradient(to bottom, #f2f2f2, #e5e5e5);
-  background-image: -moz-linear-gradient(top, #f2f2f2, #e5e5e5);
+  background-color: #cdcdcd;
+  background-image: -moz-linear-gradient(top, #e1e1e1, #aeaeae);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#e1e1e1), to(#aeaeae));
+  background-image: -webkit-linear-gradient(top, #e1e1e1, #aeaeae);
+  background-image: -o-linear-gradient(top, #e1e1e1, #aeaeae);
+  background-image: linear-gradient(to bottom, #e1e1e1, #aeaeae);
   background-repeat: repeat-x;
-  border-color: #e5e5e5 #e5e5e5 #bfbfbf;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffe1e1e1', endColorstr='#ffaeaeae', GradientType=0);
+  border-color: #aeaeae #aeaeae #888888;
   border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
-  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#fff2f2f2', endColorstr='#ffe5e5e5', GradientType=0);
-  filter: progid:dximagetransform.microsoft.gradient(enabled=false);
-  -webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.1), 0 1px 0 rgba(255, 255, 255, 0.075);
-     -moz-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.1), 0 1px 0 rgba(255, 255, 255, 0.075);
-          box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.1), 0 1px 0 rgba(255, 255, 255, 0.075);
-}
+  *background-color: #aeaeae;
+  /* Darken IE7 buttons by default so they stand out more given they won't have borders */
 
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+  -webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.1), 0 1px 0 rgba(255, 255, 255, 0.075);
+  -moz-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.1), 0 1px 0 rgba(255, 255, 255, 0.075);
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.1), 0 1px 0 rgba(255, 255, 255, 0.075);
+}
 .navbar .btn-navbar:hover,
 .navbar .btn-navbar:active,
 .navbar .btn-navbar.active,
 .navbar .btn-navbar.disabled,
 .navbar .btn-navbar[disabled] {
   color: #ffffff;
-  background-color: #e5e5e5;
-  *background-color: #d9d9d9;
+  background-color: #aeaeae;
+  *background-color: #a1a1a1;
 }
-
 .navbar .btn-navbar:active,
 .navbar .btn-navbar.active {
-  background-color: #cccccc \9;
+  background-color: #959595 \9;
 }
-
 .navbar .btn-navbar .icon-bar {
   display: block;
   width: 18px;
   height: 2px;
   background-color: #f5f5f5;
   -webkit-border-radius: 1px;
-     -moz-border-radius: 1px;
-          border-radius: 1px;
+  -moz-border-radius: 1px;
+  border-radius: 1px;
   -webkit-box-shadow: 0 1px 0 rgba(0, 0, 0, 0.25);
-     -moz-box-shadow: 0 1px 0 rgba(0, 0, 0, 0.25);
-          box-shadow: 0 1px 0 rgba(0, 0, 0, 0.25);
+  -moz-box-shadow: 0 1px 0 rgba(0, 0, 0, 0.25);
+  box-shadow: 0 1px 0 rgba(0, 0, 0, 0.25);
 }
-
 .btn-navbar .icon-bar + .icon-bar {
   margin-top: 3px;
 }
-
 .navbar .nav > li > .dropdown-menu:before {
+  content: '';
+  display: inline-block;
+  border-left: 7px solid transparent;
+  border-right: 7px solid transparent;
+  border-bottom: 7px solid #ccc;
+  border-bottom-color: rgba(0, 0, 0, 0.2);
   position: absolute;
   top: -7px;
   left: 9px;
-  display: inline-block;
-  border-right: 7px solid transparent;
-  border-bottom: 7px solid #ccc;
-  border-left: 7px solid transparent;
-  border-bottom-color: rgba(0, 0, 0, 0.2);
-  content: '';
 }
-
 .navbar .nav > li > .dropdown-menu:after {
+  content: '';
+  display: inline-block;
+  border-left: 6px solid transparent;
+  border-right: 6px solid transparent;
+  border-bottom: 6px solid #ffffff;
   position: absolute;
   top: -6px;
   left: 10px;
-  display: inline-block;
-  border-right: 6px solid transparent;
-  border-bottom: 6px solid #ffffff;
-  border-left: 6px solid transparent;
-  content: '';
 }
-
 .navbar-fixed-bottom .nav > li > .dropdown-menu:before {
-  top: auto;
-  bottom: -7px;
   border-top: 7px solid #ccc;
-  border-bottom: 0;
   border-top-color: rgba(0, 0, 0, 0.2);
-}
-
-.navbar-fixed-bottom .nav > li > .dropdown-menu:after {
+  border-bottom: 0;
+  bottom: -7px;
   top: auto;
-  bottom: -6px;
+}
+.navbar-fixed-bottom .nav > li > .dropdown-menu:after {
   border-top: 6px solid #ffffff;
   border-bottom: 0;
+  bottom: -6px;
+  top: auto;
 }
-
 .navbar .nav li.dropdown.open > .dropdown-toggle,
 .navbar .nav li.dropdown.active > .dropdown-toggle,
 .navbar .nav li.dropdown.open.active > .dropdown-toggle {
-  color: #555555;
-  background-color: #e5e5e5;
+  background-color: transparent;
+  color: #2d2d2d;
 }
-
 .navbar .nav li.dropdown > .dropdown-toggle .caret {
-  border-top-color: #777777;
-  border-bottom-color: #777777;
+  border-top-color: #2d2d2d;
+  border-bottom-color: #2d2d2d;
 }
-
 .navbar .nav li.dropdown.open > .dropdown-toggle .caret,
 .navbar .nav li.dropdown.active > .dropdown-toggle .caret,
 .navbar .nav li.dropdown.open.active > .dropdown-toggle .caret {
-  border-top-color: #555555;
-  border-bottom-color: #555555;
+  border-top-color: #2d2d2d;
+  border-bottom-color: #2d2d2d;
 }
-
 .navbar .pull-right > li > .dropdown-menu,
 .navbar .nav > li > .dropdown-menu.pull-right {
-  right: 0;
   left: auto;
+  right: 0;
 }
-
 .navbar .pull-right > li > .dropdown-menu:before,
 .navbar .nav > li > .dropdown-menu.pull-right:before {
-  right: 12px;
   left: auto;
+  right: 12px;
 }
-
 .navbar .pull-right > li > .dropdown-menu:after,
 .navbar .nav > li > .dropdown-menu.pull-right:after {
-  right: 13px;
   left: auto;
+  right: 13px;
 }
-
 .navbar .pull-right > li > .dropdown-menu .dropdown-menu,
 .navbar .nav > li > .dropdown-menu.pull-right .dropdown-menu {
-  right: 100%;
   left: auto;
-  margin-right: -1px;
+  right: 100%;
   margin-left: 0;
+  margin-right: -1px;
   -webkit-border-radius: 6px 0 6px 6px;
-     -moz-border-radius: 6px 0 6px 6px;
-          border-radius: 6px 0 6px 6px;
+  -moz-border-radius: 6px 0 6px 6px;
+  border-radius: 6px 0 6px 6px;
 }
-
 .navbar-inverse {
-  color: #999999;
+  color: #eeeeee;
 }
-
 .navbar-inverse .navbar-inner {
-  background-color: #1b1b1b;
-  background-image: -moz-linear-gradient(top, #222222, #111111);
-  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#222222), to(#111111));
-  background-image: -webkit-linear-gradient(top, #222222, #111111);
-  background-image: -o-linear-gradient(top, #222222, #111111);
-  background-image: linear-gradient(to bottom, #222222, #111111);
+  background-color: #949aa2;
+  background-image: -moz-linear-gradient(top, #afb3ba, #6c737e);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#afb3ba), to(#6c737e));
+  background-image: -webkit-linear-gradient(top, #afb3ba, #6c737e);
+  background-image: -o-linear-gradient(top, #afb3ba, #6c737e);
+  background-image: linear-gradient(to bottom, #afb3ba, #6c737e);
   background-repeat: repeat-x;
-  border-color: #252525;
-  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff222222', endColorstr='#ff111111', GradientType=0);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffafb3ba', endColorstr='#ff6c737e', GradientType=0);
+  border-color: #606670;
 }
-
 .navbar-inverse .brand,
 .navbar-inverse .nav > li > a {
-  color: #999999;
+  color: #eeeeee;
   text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
 }
-
 .navbar-inverse .brand:hover,
 .navbar-inverse .nav > li > a:hover {
   color: #ffffff;
 }
-
 .navbar-inverse .nav > li > a:focus,
 .navbar-inverse .nav > li > a:hover {
-  color: #ffffff;
   background-color: transparent;
+  color: #ffffff;
 }
-
 .navbar-inverse .nav .active > a,
 .navbar-inverse .nav .active > a:hover,
 .navbar-inverse .nav .active > a:focus {
   color: #ffffff;
-  background-color: #111111;
+  background-color: #6c737e;
 }
-
 .navbar-inverse .navbar-link {
-  color: #999999;
+  color: #eeeeee;
 }
-
 .navbar-inverse .navbar-link:hover {
   color: #ffffff;
 }
-
 .navbar-inverse .divider-vertical {
-  border-right-color: #222222;
-  border-left-color: #111111;
+  border-left-color: #6c737e;
+  border-right-color: #afb3ba;
 }
-
 .navbar-inverse .nav li.dropdown.open > .dropdown-toggle,
 .navbar-inverse .nav li.dropdown.active > .dropdown-toggle,
 .navbar-inverse .nav li.dropdown.open.active > .dropdown-toggle {
+  background-color: #6c737e;
   color: #ffffff;
-  background-color: #111111;
 }
-
 .navbar-inverse .nav li.dropdown > .dropdown-toggle .caret {
-  border-top-color: #999999;
-  border-bottom-color: #999999;
+  border-top-color: #eeeeee;
+  border-bottom-color: #eeeeee;
 }
-
 .navbar-inverse .nav li.dropdown.open > .dropdown-toggle .caret,
 .navbar-inverse .nav li.dropdown.active > .dropdown-toggle .caret,
 .navbar-inverse .nav li.dropdown.open.active > .dropdown-toggle .caret {
   border-top-color: #ffffff;
   border-bottom-color: #ffffff;
 }
-
 .navbar-inverse .navbar-search .search-query {
   color: #ffffff;
-  background-color: #515151;
-  border-color: #111111;
+  background-color: #afb3ba;
+  border-color: #6c737e;
   -webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1), 0 1px 0 rgba(255, 255, 255, 0.15);
-     -moz-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1), 0 1px 0 rgba(255, 255, 255, 0.15);
-          box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1), 0 1px 0 rgba(255, 255, 255, 0.15);
+  -moz-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1), 0 1px 0 rgba(255, 255, 255, 0.15);
+  box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1), 0 1px 0 rgba(255, 255, 255, 0.15);
   -webkit-transition: none;
-     -moz-transition: none;
-       -o-transition: none;
-          transition: none;
+  -moz-transition: none;
+  -o-transition: none;
+  transition: none;
 }
-
 .navbar-inverse .navbar-search .search-query:-moz-placeholder {
-  color: #cccccc;
+  color: #eeeeee;
 }
-
 .navbar-inverse .navbar-search .search-query:-ms-input-placeholder {
-  color: #cccccc;
+  color: #eeeeee;
 }
-
 .navbar-inverse .navbar-search .search-query::-webkit-input-placeholder {
-  color: #cccccc;
+  color: #eeeeee;
 }
-
 .navbar-inverse .navbar-search .search-query:focus,
 .navbar-inverse .navbar-search .search-query.focused {
   padding: 5px 15px;
@@ -4663,169 +3917,152 @@ input[type="submit"].btn.btn-mini {
   text-shadow: 0 1px 0 #ffffff;
   background-color: #ffffff;
   border: 0;
-  outline: 0;
   -webkit-box-shadow: 0 0 3px rgba(0, 0, 0, 0.15);
-     -moz-box-shadow: 0 0 3px rgba(0, 0, 0, 0.15);
-          box-shadow: 0 0 3px rgba(0, 0, 0, 0.15);
+  -moz-box-shadow: 0 0 3px rgba(0, 0, 0, 0.15);
+  box-shadow: 0 0 3px rgba(0, 0, 0, 0.15);
+  outline: 0;
 }
-
 .navbar-inverse .btn-navbar {
   color: #ffffff;
   text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
-  background-color: #0e0e0e;
-  *background-color: #040404;
-  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#151515), to(#040404));
-  background-image: -webkit-linear-gradient(top, #151515, #040404);
-  background-image: -o-linear-gradient(top, #151515, #040404);
-  background-image: linear-gradient(to bottom, #151515, #040404);
-  background-image: -moz-linear-gradient(top, #151515, #040404);
+  background-color: #878d96;
+  background-image: -moz-linear-gradient(top, #a1a7af, #606670);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#a1a7af), to(#606670));
+  background-image: -webkit-linear-gradient(top, #a1a7af, #606670);
+  background-image: -o-linear-gradient(top, #a1a7af, #606670);
+  background-image: linear-gradient(to bottom, #a1a7af, #606670);
   background-repeat: repeat-x;
-  border-color: #040404 #040404 #000000;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffa1a7af', endColorstr='#ff606670', GradientType=0);
+  border-color: #606670 #606670 #3d4147;
   border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
-  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff151515', endColorstr='#ff040404', GradientType=0);
-  filter: progid:dximagetransform.microsoft.gradient(enabled=false);
-}
+  *background-color: #606670;
+  /* Darken IE7 buttons by default so they stand out more given they won't have borders */
 
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+}
 .navbar-inverse .btn-navbar:hover,
 .navbar-inverse .btn-navbar:active,
 .navbar-inverse .btn-navbar.active,
 .navbar-inverse .btn-navbar.disabled,
 .navbar-inverse .btn-navbar[disabled] {
   color: #ffffff;
-  background-color: #040404;
-  *background-color: #000000;
+  background-color: #606670;
+  *background-color: #545a63;
 }
-
 .navbar-inverse .btn-navbar:active,
 .navbar-inverse .btn-navbar.active {
-  background-color: #000000 \9;
+  background-color: #494d55 \9;
 }
-
 .breadcrumb {
   padding: 8px 15px;
-  margin: 0 0 20px;
+  margin: 0 0 21px;
   list-style: none;
   background-color: #f5f5f5;
   -webkit-border-radius: 4px;
-     -moz-border-radius: 4px;
-          border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
 }
-
 .breadcrumb li {
   display: inline-block;
   *display: inline;
-  text-shadow: 0 1px 0 #ffffff;
-  *zoom: 1;
-}
+  /* IE7 inline-block hack */
 
+  *zoom: 1;
+  text-shadow: 0 1px 0 #ffffff;
+}
 .breadcrumb .divider {
   padding: 0 5px;
   color: #ccc;
 }
-
 .breadcrumb .active {
-  color: #999999;
+  color: #bbbbbb;
 }
-
 .pagination {
-  height: 40px;
-  margin: 20px 0;
+  height: 42px;
+  margin: 21px 0;
 }
-
 .pagination ul {
   display: inline-block;
   *display: inline;
-  margin-bottom: 0;
-  margin-left: 0;
-  -webkit-border-radius: 3px;
-     -moz-border-radius: 3px;
-          border-radius: 3px;
-  *zoom: 1;
-  -webkit-box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
-     -moz-box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
-          box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
-}
+  /* IE7 inline-block hack */
 
+  *zoom: 1;
+  margin-left: 0;
+  margin-bottom: 0;
+  -webkit-border-radius: 3px;
+  -moz-border-radius: 3px;
+  border-radius: 3px;
+  -webkit-box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+  -moz-box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+}
 .pagination ul > li {
   display: inline;
 }
-
 .pagination ul > li > a,
 .pagination ul > li > span {
   float: left;
   padding: 0 14px;
-  line-height: 38px;
+  line-height: 40px;
   text-decoration: none;
   background-color: #ffffff;
   border: 1px solid #dddddd;
   border-left-width: 0;
 }
-
 .pagination ul > li > a:hover,
 .pagination ul > .active > a,
 .pagination ul > .active > span {
   background-color: #f5f5f5;
 }
-
 .pagination ul > .active > a,
 .pagination ul > .active > span {
-  color: #999999;
+  color: #bbbbbb;
   cursor: default;
 }
-
 .pagination ul > .disabled > span,
 .pagination ul > .disabled > a,
 .pagination ul > .disabled > a:hover {
-  color: #999999;
-  cursor: default;
+  color: #bbbbbb;
   background-color: transparent;
+  cursor: default;
 }
-
 .pagination ul > li:first-child > a,
 .pagination ul > li:first-child > span {
   border-left-width: 1px;
   -webkit-border-radius: 3px 0 0 3px;
-     -moz-border-radius: 3px 0 0 3px;
-          border-radius: 3px 0 0 3px;
+  -moz-border-radius: 3px 0 0 3px;
+  border-radius: 3px 0 0 3px;
 }
-
 .pagination ul > li:last-child > a,
 .pagination ul > li:last-child > span {
   -webkit-border-radius: 0 3px 3px 0;
-     -moz-border-radius: 0 3px 3px 0;
-          border-radius: 0 3px 3px 0;
+  -moz-border-radius: 0 3px 3px 0;
+  border-radius: 0 3px 3px 0;
 }
-
 .pagination-centered {
   text-align: center;
 }
-
 .pagination-right {
   text-align: right;
 }
-
 .pager {
-  margin: 20px 0;
-  text-align: center;
+  margin: 21px 0;
   list-style: none;
+  text-align: center;
   *zoom: 1;
 }
-
 .pager:before,
 .pager:after {
   display: table;
-  line-height: 0;
   content: "";
+  line-height: 0;
 }
-
 .pager:after {
   clear: both;
 }
-
 .pager li {
   display: inline;
 }
-
 .pager a,
 .pager span {
   display: inline-block;
@@ -4833,48 +4070,39 @@ input[type="submit"].btn.btn-mini {
   background-color: #fff;
   border: 1px solid #ddd;
   -webkit-border-radius: 15px;
-     -moz-border-radius: 15px;
-          border-radius: 15px;
+  -moz-border-radius: 15px;
+  border-radius: 15px;
 }
-
 .pager a:hover {
   text-decoration: none;
   background-color: #f5f5f5;
 }
-
 .pager .next a,
 .pager .next span {
   float: right;
 }
-
 .pager .previous a {
   float: left;
 }
-
 .pager .disabled a,
 .pager .disabled a:hover,
 .pager .disabled span {
-  color: #999999;
-  cursor: default;
+  color: #bbbbbb;
   background-color: #fff;
+  cursor: default;
 }
-
 .modal-open .modal .dropdown-menu {
   z-index: 2050;
 }
-
 .modal-open .modal .dropdown.open {
   *z-index: 2050;
 }
-
 .modal-open .modal .popover {
   z-index: 2060;
 }
-
 .modal-open .modal .tooltip {
   z-index: 2080;
 }
-
 .modal-backdrop {
   position: fixed;
   top: 0;
@@ -4884,76 +4112,67 @@ input[type="submit"].btn.btn-mini {
   z-index: 1040;
   background-color: #000000;
 }
-
 .modal-backdrop.fade {
   opacity: 0;
 }
-
 .modal-backdrop,
 .modal-backdrop.fade.in {
   opacity: 0.8;
   filter: alpha(opacity=80);
 }
-
 .modal {
   position: fixed;
   top: 50%;
   left: 50%;
   z-index: 1050;
+  overflow: auto;
   width: 560px;
   margin: -250px 0 0 -280px;
-  overflow: auto;
   background-color: #ffffff;
   border: 1px solid #999;
   border: 1px solid rgba(0, 0, 0, 0.3);
   *border: 1px solid #999;
+  /* IE6-7 */
+
   -webkit-border-radius: 6px;
-     -moz-border-radius: 6px;
-          border-radius: 6px;
+  -moz-border-radius: 6px;
+  border-radius: 6px;
   -webkit-box-shadow: 0 3px 7px rgba(0, 0, 0, 0.3);
-     -moz-box-shadow: 0 3px 7px rgba(0, 0, 0, 0.3);
-          box-shadow: 0 3px 7px rgba(0, 0, 0, 0.3);
+  -moz-box-shadow: 0 3px 7px rgba(0, 0, 0, 0.3);
+  box-shadow: 0 3px 7px rgba(0, 0, 0, 0.3);
   -webkit-background-clip: padding-box;
-     -moz-background-clip: padding-box;
-          background-clip: padding-box;
+  -moz-background-clip: padding-box;
+  background-clip: padding-box;
 }
-
 .modal.fade {
+  -webkit-transition: opacity .3s linear, top .3s ease-out;
+  -moz-transition: opacity .3s linear, top .3s ease-out;
+  -o-transition: opacity .3s linear, top .3s ease-out;
+  transition: opacity .3s linear, top .3s ease-out;
   top: -25%;
-  -webkit-transition: opacity 0.3s linear, top 0.3s ease-out;
-     -moz-transition: opacity 0.3s linear, top 0.3s ease-out;
-       -o-transition: opacity 0.3s linear, top 0.3s ease-out;
-          transition: opacity 0.3s linear, top 0.3s ease-out;
 }
-
 .modal.fade.in {
   top: 50%;
 }
-
 .modal-header {
   padding: 9px 15px;
   border-bottom: 1px solid #eee;
 }
-
 .modal-header .close {
   margin-top: 2px;
 }
-
 .modal-header h3 {
   margin: 0;
   line-height: 30px;
 }
-
 .modal-body {
+  overflow-y: auto;
   max-height: 400px;
   padding: 15px;
-  overflow-y: auto;
 }
-
 .modal-form {
   margin-bottom: 0;
 }
-
 .modal-footer {
   padding: 14px 15px 15px;
   margin-bottom: 0;
@@ -4961,66 +4180,55 @@ input[type="submit"].btn.btn-mini {
   background-color: #f5f5f5;
   border-top: 1px solid #ddd;
   -webkit-border-radius: 0 0 6px 6px;
-     -moz-border-radius: 0 0 6px 6px;
-          border-radius: 0 0 6px 6px;
-  *zoom: 1;
+  -moz-border-radius: 0 0 6px 6px;
+  border-radius: 0 0 6px 6px;
   -webkit-box-shadow: inset 0 1px 0 #ffffff;
-     -moz-box-shadow: inset 0 1px 0 #ffffff;
-          box-shadow: inset 0 1px 0 #ffffff;
+  -moz-box-shadow: inset 0 1px 0 #ffffff;
+  box-shadow: inset 0 1px 0 #ffffff;
+  *zoom: 1;
 }
-
 .modal-footer:before,
 .modal-footer:after {
   display: table;
-  line-height: 0;
   content: "";
+  line-height: 0;
 }
-
 .modal-footer:after {
   clear: both;
 }
-
 .modal-footer .btn + .btn {
-  margin-bottom: 0;
   margin-left: 5px;
+  margin-bottom: 0;
 }
-
 .modal-footer .btn-group .btn + .btn {
   margin-left: -1px;
 }
-
 .tooltip {
   position: absolute;
   z-index: 1030;
   display: block;
+  visibility: visible;
   padding: 5px;
   font-size: 11px;
   opacity: 0;
   filter: alpha(opacity=0);
-  visibility: visible;
 }
-
 .tooltip.in {
   opacity: 0.8;
   filter: alpha(opacity=80);
 }
-
 .tooltip.top {
   margin-top: -3px;
 }
-
 .tooltip.right {
   margin-left: 3px;
 }
-
 .tooltip.bottom {
   margin-top: 3px;
 }
-
 .tooltip.left {
   margin-left: -3px;
 }
-
 .tooltip-inner {
   max-width: 200px;
   padding: 3px 8px;
@@ -5029,10 +4237,9 @@ input[type="submit"].btn.btn-mini {
   text-decoration: none;
   background-color: #000000;
   -webkit-border-radius: 4px;
-     -moz-border-radius: 4px;
-          border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
 }
-
 .tooltip-arrow {
   position: absolute;
   width: 0;
@@ -5040,39 +4247,34 @@ input[type="submit"].btn.btn-mini {
   border-color: transparent;
   border-style: solid;
 }
-
 .tooltip.top .tooltip-arrow {
   bottom: 0;
   left: 50%;
   margin-left: -5px;
-  border-top-color: #000000;
   border-width: 5px 5px 0;
+  border-top-color: #000000;
 }
-
 .tooltip.right .tooltip-arrow {
   top: 50%;
   left: 0;
   margin-top: -5px;
-  border-right-color: #000000;
   border-width: 5px 5px 5px 0;
+  border-right-color: #000000;
 }
-
 .tooltip.left .tooltip-arrow {
   top: 50%;
   right: 0;
   margin-top: -5px;
-  border-left-color: #000000;
   border-width: 5px 0 5px 5px;
+  border-left-color: #000000;
 }
-
 .tooltip.bottom .tooltip-arrow {
   top: 0;
   left: 50%;
   margin-left: -5px;
-  border-bottom-color: #000000;
   border-width: 0 5px 5px;
+  border-bottom-color: #000000;
 }
-
 .popover {
   position: absolute;
   top: 0;
@@ -5082,58 +4284,50 @@ input[type="submit"].btn.btn-mini {
   width: 236px;
   padding: 1px;
   background-color: #ffffff;
+  -webkit-background-clip: padding-box;
+  -moz-background-clip: padding;
+  background-clip: padding-box;
   border: 1px solid #ccc;
   border: 1px solid rgba(0, 0, 0, 0.2);
   -webkit-border-radius: 6px;
-     -moz-border-radius: 6px;
-          border-radius: 6px;
+  -moz-border-radius: 6px;
+  border-radius: 6px;
   -webkit-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
-     -moz-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
-          box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
-  -webkit-background-clip: padding-box;
-     -moz-background-clip: padding;
-          background-clip: padding-box;
+  -moz-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
+  box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
 }
-
 .popover.top {
   margin-bottom: 10px;
 }
-
 .popover.right {
   margin-left: 10px;
 }
-
 .popover.bottom {
   margin-top: 10px;
 }
-
 .popover.left {
   margin-right: 10px;
 }
-
 .popover-title {
-  padding: 8px 14px;
   margin: 0;
+  padding: 8px 14px;
   font-size: 14px;
   font-weight: normal;
   line-height: 18px;
   background-color: #f7f7f7;
   border-bottom: 1px solid #ebebeb;
   -webkit-border-radius: 5px 5px 0 0;
-     -moz-border-radius: 5px 5px 0 0;
-          border-radius: 5px 5px 0 0;
+  -moz-border-radius: 5px 5px 0 0;
+  border-radius: 5px 5px 0 0;
 }
-
 .popover-content {
   padding: 9px 14px;
 }
-
 .popover-content p,
 .popover-content ul,
 .popover-content ol {
   margin-bottom: 0;
 }
-
 .popover .arrow,
 .popover .arrow:after {
   position: absolute;
@@ -5143,229 +4337,194 @@ input[type="submit"].btn.btn-mini {
   border-color: transparent;
   border-style: solid;
 }
-
 .popover .arrow:after {
-  z-index: -1;
   content: "";
+  z-index: -1;
 }
-
 .popover.top .arrow {
   bottom: -10px;
   left: 50%;
   margin-left: -10px;
-  border-top-color: #ffffff;
   border-width: 10px 10px 0;
+  border-top-color: #ffffff;
 }
-
 .popover.top .arrow:after {
+  border-width: 11px 11px 0;
+  border-top-color: rgba(0, 0, 0, 0.25);
   bottom: -1px;
   left: -11px;
-  border-top-color: rgba(0, 0, 0, 0.25);
-  border-width: 11px 11px 0;
 }
-
 .popover.right .arrow {
   top: 50%;
   left: -10px;
   margin-top: -10px;
-  border-right-color: #ffffff;
   border-width: 10px 10px 10px 0;
+  border-right-color: #ffffff;
 }
-
 .popover.right .arrow:after {
+  border-width: 11px 11px 11px 0;
+  border-right-color: rgba(0, 0, 0, 0.25);
   bottom: -11px;
   left: -1px;
-  border-right-color: rgba(0, 0, 0, 0.25);
-  border-width: 11px 11px 11px 0;
 }
-
 .popover.bottom .arrow {
   top: -10px;
   left: 50%;
   margin-left: -10px;
-  border-bottom-color: #ffffff;
   border-width: 0 10px 10px;
+  border-bottom-color: #ffffff;
 }
-
 .popover.bottom .arrow:after {
+  border-width: 0 11px 11px;
+  border-bottom-color: rgba(0, 0, 0, 0.25);
   top: -1px;
   left: -11px;
-  border-bottom-color: rgba(0, 0, 0, 0.25);
-  border-width: 0 11px 11px;
 }
-
 .popover.left .arrow {
   top: 50%;
   right: -10px;
   margin-top: -10px;
-  border-left-color: #ffffff;
   border-width: 10px 0 10px 10px;
+  border-left-color: #ffffff;
 }
-
 .popover.left .arrow:after {
-  right: -1px;
-  bottom: -11px;
-  border-left-color: rgba(0, 0, 0, 0.25);
   border-width: 11px 0 11px 11px;
+  border-left-color: rgba(0, 0, 0, 0.25);
+  bottom: -11px;
+  right: -1px;
 }
-
 .thumbnails {
   margin-left: -20px;
   list-style: none;
   *zoom: 1;
 }
-
 .thumbnails:before,
 .thumbnails:after {
   display: table;
-  line-height: 0;
   content: "";
+  line-height: 0;
 }
-
 .thumbnails:after {
   clear: both;
 }
-
 .row-fluid .thumbnails {
   margin-left: 0;
 }
-
 .thumbnails > li {
   float: left;
-  margin-bottom: 20px;
+  margin-bottom: 21px;
   margin-left: 20px;
 }
-
 .thumbnail {
   display: block;
   padding: 4px;
-  line-height: 20px;
+  line-height: 21px;
   border: 1px solid #ddd;
   -webkit-border-radius: 4px;
-     -moz-border-radius: 4px;
-          border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
   -webkit-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.055);
-     -moz-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.055);
-          box-shadow: 0 1px 3px rgba(0, 0, 0, 0.055);
+  -moz-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.055);
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.055);
   -webkit-transition: all 0.2s ease-in-out;
-     -moz-transition: all 0.2s ease-in-out;
-       -o-transition: all 0.2s ease-in-out;
-          transition: all 0.2s ease-in-out;
+  -moz-transition: all 0.2s ease-in-out;
+  -o-transition: all 0.2s ease-in-out;
+  transition: all 0.2s ease-in-out;
 }
-
 a.thumbnail:hover {
-  border-color: #0088cc;
+  border-color: #558bc4;
   -webkit-box-shadow: 0 1px 4px rgba(0, 105, 214, 0.25);
-     -moz-box-shadow: 0 1px 4px rgba(0, 105, 214, 0.25);
-          box-shadow: 0 1px 4px rgba(0, 105, 214, 0.25);
+  -moz-box-shadow: 0 1px 4px rgba(0, 105, 214, 0.25);
+  box-shadow: 0 1px 4px rgba(0, 105, 214, 0.25);
 }
-
 .thumbnail > img {
   display: block;
   max-width: 100%;
-  margin-right: auto;
   margin-left: auto;
+  margin-right: auto;
 }
-
 .thumbnail .caption {
   padding: 9px;
-  color: #555555;
+  color: #777777;
 }
-
 .label,
 .badge {
   font-size: 11.844px;
   font-weight: bold;
   line-height: 14px;
   color: #ffffff;
-  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
-  white-space: nowrap;
   vertical-align: baseline;
-  background-color: #999999;
+  white-space: nowrap;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+  background-color: #bbbbbb;
 }
-
 .label {
   padding: 1px 4px 2px;
   -webkit-border-radius: 3px;
-     -moz-border-radius: 3px;
-          border-radius: 3px;
+  -moz-border-radius: 3px;
+  border-radius: 3px;
 }
-
 .badge {
   padding: 1px 9px 2px;
   -webkit-border-radius: 9px;
-     -moz-border-radius: 9px;
-          border-radius: 9px;
+  -moz-border-radius: 9px;
+  border-radius: 9px;
 }
-
 a.label:hover,
 a.badge:hover {
   color: #ffffff;
   text-decoration: none;
   cursor: pointer;
 }
-
 .label-important,
 .badge-important {
-  background-color: #b94a48;
+  background-color: #ffffff;
 }
-
 .label-important[href],
 .badge-important[href] {
-  background-color: #953b39;
+  background-color: #e6e6e6;
 }
-
 .label-warning,
 .badge-warning {
-  background-color: #f89406;
+  background-color: #d47500;
 }
-
 .label-warning[href],
 .badge-warning[href] {
-  background-color: #c67605;
+  background-color: #a15900;
 }
-
 .label-success,
 .badge-success {
-  background-color: #468847;
+  background-color: #ffffff;
 }
-
 .label-success[href],
 .badge-success[href] {
-  background-color: #356635;
+  background-color: #e6e6e6;
 }
-
 .label-info,
 .badge-info {
-  background-color: #3a87ad;
+  background-color: #ffffff;
 }
-
 .label-info[href],
 .badge-info[href] {
-  background-color: #2d6987;
+  background-color: #e6e6e6;
 }
-
 .label-inverse,
 .badge-inverse {
   background-color: #333333;
 }
-
 .label-inverse[href],
 .badge-inverse[href] {
   background-color: #1a1a1a;
 }
-
 .btn .label,
 .btn .badge {
   position: relative;
   top: -1px;
 }
-
 .btn-mini .label,
 .btn-mini .badge {
   top: 0;
 }
-
 @-webkit-keyframes progress-bar-stripes {
   from {
     background-position: 40px 0;
@@ -5374,7 +4533,6 @@ a.badge:hover {
     background-position: 0 0;
   }
 }
-
 @-moz-keyframes progress-bar-stripes {
   from {
     background-position: 40px 0;
@@ -5383,7 +4541,6 @@ a.badge:hover {
     background-position: 0 0;
   }
 }
-
 @-ms-keyframes progress-bar-stripes {
   from {
     background-position: 40px 0;
@@ -5392,7 +4549,6 @@ a.badge:hover {
     background-position: 0 0;
   }
 }
-
 @-o-keyframes progress-bar-stripes {
   from {
     background-position: 0 0;
@@ -5401,7 +4557,6 @@ a.badge:hover {
     background-position: 40px 0;
   }
 }
-
 @keyframes progress-bar-stripes {
   from {
     background-position: 40px 0;
@@ -5410,11 +4565,10 @@ a.badge:hover {
     background-position: 0 0;
   }
 }
-
 .progress {
-  height: 20px;
-  margin-bottom: 20px;
   overflow: hidden;
+  height: 21px;
+  margin-bottom: 21px;
   background-color: #f7f7f7;
   background-image: -moz-linear-gradient(top, #f5f5f5, #f9f9f9);
   background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#f5f5f5), to(#f9f9f9));
@@ -5422,21 +4576,20 @@ a.badge:hover {
   background-image: -o-linear-gradient(top, #f5f5f5, #f9f9f9);
   background-image: linear-gradient(to bottom, #f5f5f5, #f9f9f9);
   background-repeat: repeat-x;
-  -webkit-border-radius: 4px;
-     -moz-border-radius: 4px;
-          border-radius: 4px;
-  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#fff5f5f5', endColorstr='#fff9f9f9', GradientType=0);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff5f5f5', endColorstr='#fff9f9f9', GradientType=0);
   -webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
-     -moz-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
-          box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
+  -moz-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
+  box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
+  -webkit-border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
 }
-
 .progress .bar {
-  float: left;
-  width: 0;
+  width: 0%;
   height: 100%;
-  font-size: 12px;
   color: #ffffff;
+  float: left;
+  font-size: 12px;
   text-align: center;
   text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
   background-color: #0e90d2;
@@ -5446,25 +4599,23 @@ a.badge:hover {
   background-image: -o-linear-gradient(top, #149bdf, #0480be);
   background-image: linear-gradient(to bottom, #149bdf, #0480be);
   background-repeat: repeat-x;
-  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff149bdf', endColorstr='#ff0480be', GradientType=0);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff149bdf', endColorstr='#ff0480be', GradientType=0);
   -webkit-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
-     -moz-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
-          box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
+  -moz-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
+  box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
   -webkit-box-sizing: border-box;
-     -moz-box-sizing: border-box;
-          box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
   -webkit-transition: width 0.6s ease;
-     -moz-transition: width 0.6s ease;
-       -o-transition: width 0.6s ease;
-          transition: width 0.6s ease;
+  -moz-transition: width 0.6s ease;
+  -o-transition: width 0.6s ease;
+  transition: width 0.6s ease;
 }
-
 .progress .bar + .bar {
   -webkit-box-shadow: inset 1px 0 0 rgba(0, 0, 0, 0.15), inset 0 -1px 0 rgba(0, 0, 0, 0.15);
-     -moz-box-shadow: inset 1px 0 0 rgba(0, 0, 0, 0.15), inset 0 -1px 0 rgba(0, 0, 0, 0.15);
-          box-shadow: inset 1px 0 0 rgba(0, 0, 0, 0.15), inset 0 -1px 0 rgba(0, 0, 0, 0.15);
+  -moz-box-shadow: inset 1px 0 0 rgba(0, 0, 0, 0.15), inset 0 -1px 0 rgba(0, 0, 0, 0.15);
+  box-shadow: inset 1px 0 0 rgba(0, 0, 0, 0.15), inset 0 -1px 0 rgba(0, 0, 0, 0.15);
 }
-
 .progress-striped .bar {
   background-color: #149bdf;
   background-image: -webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));
@@ -5473,19 +4624,17 @@ a.badge:hover {
   background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
   background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
   -webkit-background-size: 40px 40px;
-     -moz-background-size: 40px 40px;
-       -o-background-size: 40px 40px;
-          background-size: 40px 40px;
+  -moz-background-size: 40px 40px;
+  -o-background-size: 40px 40px;
+  background-size: 40px 40px;
 }
-
 .progress.active .bar {
   -webkit-animation: progress-bar-stripes 2s linear infinite;
-     -moz-animation: progress-bar-stripes 2s linear infinite;
-      -ms-animation: progress-bar-stripes 2s linear infinite;
-       -o-animation: progress-bar-stripes 2s linear infinite;
-          animation: progress-bar-stripes 2s linear infinite;
+  -moz-animation: progress-bar-stripes 2s linear infinite;
+  -ms-animation: progress-bar-stripes 2s linear infinite;
+  -o-animation: progress-bar-stripes 2s linear infinite;
+  animation: progress-bar-stripes 2s linear infinite;
 }
-
 .progress-danger .bar,
 .progress .bar-danger {
   background-color: #dd514c;
@@ -5495,9 +4644,8 @@ a.badge:hover {
   background-image: -o-linear-gradient(top, #ee5f5b, #c43c35);
   background-image: linear-gradient(to bottom, #ee5f5b, #c43c35);
   background-repeat: repeat-x;
-  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ffee5f5b', endColorstr='#ffc43c35', GradientType=0);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffee5f5b', endColorstr='#ffc43c35', GradientType=0);
 }
-
 .progress-danger.progress-striped .bar,
 .progress-striped .bar-danger {
   background-color: #ee5f5b;
@@ -5507,7 +4655,6 @@ a.badge:hover {
   background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
   background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
 }
-
 .progress-success .bar,
 .progress .bar-success {
   background-color: #5eb95e;
@@ -5517,9 +4664,8 @@ a.badge:hover {
   background-image: -o-linear-gradient(top, #62c462, #57a957);
   background-image: linear-gradient(to bottom, #62c462, #57a957);
   background-repeat: repeat-x;
-  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff62c462', endColorstr='#ff57a957', GradientType=0);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff62c462', endColorstr='#ff57a957', GradientType=0);
 }
-
 .progress-success.progress-striped .bar,
 .progress-striped .bar-success {
   background-color: #62c462;
@@ -5529,7 +4675,6 @@ a.badge:hover {
   background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
   background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
 }
-
 .progress-info .bar,
 .progress .bar-info {
   background-color: #4bb1cf;
@@ -5539,9 +4684,8 @@ a.badge:hover {
   background-image: -o-linear-gradient(top, #5bc0de, #339bb9);
   background-image: linear-gradient(to bottom, #5bc0de, #339bb9);
   background-repeat: repeat-x;
-  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff5bc0de', endColorstr='#ff339bb9', GradientType=0);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5bc0de', endColorstr='#ff339bb9', GradientType=0);
 }
-
 .progress-info.progress-striped .bar,
 .progress-striped .bar-info {
   background-color: #5bc0de;
@@ -5551,123 +4695,102 @@ a.badge:hover {
   background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
   background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
 }
-
 .progress-warning .bar,
 .progress .bar-warning {
-  background-color: #faa732;
-  background-image: -moz-linear-gradient(top, #fbb450, #f89406);
-  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#fbb450), to(#f89406));
-  background-image: -webkit-linear-gradient(top, #fbb450, #f89406);
-  background-image: -o-linear-gradient(top, #fbb450, #f89406);
-  background-image: linear-gradient(to bottom, #fbb450, #f89406);
+  background-color: #ee8c14;
+  background-image: -moz-linear-gradient(top, #ff9c21, #d47500);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#ff9c21), to(#d47500));
+  background-image: -webkit-linear-gradient(top, #ff9c21, #d47500);
+  background-image: -o-linear-gradient(top, #ff9c21, #d47500);
+  background-image: linear-gradient(to bottom, #ff9c21, #d47500);
   background-repeat: repeat-x;
-  filter: progid:dximagetransform.microsoft.gradient(startColorstr='#fffbb450', endColorstr='#fff89406', GradientType=0);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffff9c21', endColorstr='#ffd47500', GradientType=0);
 }
-
 .progress-warning.progress-striped .bar,
 .progress-striped .bar-warning {
-  background-color: #fbb450;
+  background-color: #ff9c21;
   background-image: -webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));
   background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
   background-image: -moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
   background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
   background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
 }
-
 .accordion {
-  margin-bottom: 20px;
+  margin-bottom: 21px;
 }
-
 .accordion-group {
   margin-bottom: 2px;
   border: 1px solid #e5e5e5;
   -webkit-border-radius: 4px;
-     -moz-border-radius: 4px;
-          border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
 }
-
 .accordion-heading {
   border-bottom: 0;
 }
-
 .accordion-heading .accordion-toggle {
   display: block;
   padding: 8px 15px;
 }
-
 .accordion-toggle {
   cursor: pointer;
 }
-
 .accordion-inner {
   padding: 9px 15px;
   border-top: 1px solid #e5e5e5;
 }
-
 .carousel {
   position: relative;
-  margin-bottom: 20px;
+  margin-bottom: 21px;
   line-height: 1;
 }
-
 .carousel-inner {
-  position: relative;
-  width: 100%;
   overflow: hidden;
-}
-
-.carousel .item {
+  width: 100%;
   position: relative;
-  display: none;
-  -webkit-transition: 0.6s ease-in-out left;
-     -moz-transition: 0.6s ease-in-out left;
-       -o-transition: 0.6s ease-in-out left;
-          transition: 0.6s ease-in-out left;
 }
-
+.carousel .item {
+  display: none;
+  position: relative;
+  -webkit-transition: 0.6s ease-in-out left;
+  -moz-transition: 0.6s ease-in-out left;
+  -o-transition: 0.6s ease-in-out left;
+  transition: 0.6s ease-in-out left;
+}
 .carousel .item > img {
   display: block;
   line-height: 1;
 }
-
 .carousel .active,
 .carousel .next,
 .carousel .prev {
   display: block;
 }
-
 .carousel .active {
   left: 0;
 }
-
 .carousel .next,
 .carousel .prev {
   position: absolute;
   top: 0;
   width: 100%;
 }
-
 .carousel .next {
   left: 100%;
 }
-
 .carousel .prev {
   left: -100%;
 }
-
 .carousel .next.left,
 .carousel .prev.right {
   left: 0;
 }
-
 .carousel .active.left {
   left: -100%;
 }
-
 .carousel .active.right {
   left: 100%;
 }
-
 .carousel-control {
   position: absolute;
   top: 40%;
@@ -5680,95 +4803,422 @@ a.badge:hover {
   line-height: 30px;
   color: #ffffff;
   text-align: center;
-  background: #222222;
+  background: #2d2d2d;
   border: 3px solid #ffffff;
   -webkit-border-radius: 23px;
-     -moz-border-radius: 23px;
-          border-radius: 23px;
+  -moz-border-radius: 23px;
+  border-radius: 23px;
   opacity: 0.5;
   filter: alpha(opacity=50);
 }
-
 .carousel-control.right {
-  right: 15px;
   left: auto;
+  right: 15px;
 }
-
 .carousel-control:hover {
   color: #ffffff;
   text-decoration: none;
   opacity: 0.9;
   filter: alpha(opacity=90);
 }
-
 .carousel-caption {
   position: absolute;
+  left: 0;
   right: 0;
   bottom: 0;
-  left: 0;
   padding: 15px;
   background: #333333;
   background: rgba(0, 0, 0, 0.75);
 }
-
 .carousel-caption h4,
 .carousel-caption p {
-  line-height: 20px;
   color: #ffffff;
+  line-height: 21px;
 }
-
 .carousel-caption h4 {
   margin: 0 0 5px;
 }
-
 .carousel-caption p {
   margin-bottom: 0;
 }
-
 .hero-unit {
   padding: 60px;
   margin-bottom: 30px;
   background-color: #eeeeee;
   -webkit-border-radius: 6px;
-     -moz-border-radius: 6px;
-          border-radius: 6px;
+  -moz-border-radius: 6px;
+  border-radius: 6px;
 }
-
 .hero-unit h1 {
   margin-bottom: 0;
   font-size: 60px;
   line-height: 1;
-  letter-spacing: -1px;
   color: inherit;
+  letter-spacing: -1px;
 }
-
 .hero-unit p {
   font-size: 18px;
   font-weight: 200;
-  line-height: 30px;
+  line-height: 31.5px;
   color: inherit;
 }
-
 .pull-right {
   float: right;
 }
-
 .pull-left {
   float: left;
 }
-
 .hide {
   display: none;
 }
-
 .show {
   display: block;
 }
-
 .invisible {
   visibility: hidden;
 }
+.affix {
+  position: fixed;
+}
+.navbar .navbar-inner {
+  border-bottom: 1px solid #CACACA;
+  -webkit-box-shadow: 0 1px 0 rgba(255, 255, 255, 0.4) ,  0 0 10px rgba(0, 0, 0, 0.1);
+  -moz-box-shadow: 0 1px 0 rgba(255, 255, 255, 0.4) ,  0 0 10px rgba(0, 0, 0, 0.1);
+  box-shadow: 0 1px 0 rgba(255, 255, 255, 0.4) ,  0 0 10px rgba(0, 0, 0, 0.1);
+}
+.navbar .brand {
+  text-shadow: 0 1px 0 rgba(255, 255, 255, 0.3);
+}
+.navbar .brand:hover {
+  color: #558bc4;
+}
+.navbar .nav > li > a {
+  padding: 11px 10px 9px;
+  text-shadow: 0 1px 0 rgba(255, 255, 255, 0.3);
+}
+.navbar .navbar-text {
+  margin-top: 2px;
+  padding: 0 10px;
+  line-height: 38px;
+}
+.navbar .navbar-search .search-query,
+.navbar .navbar-search .search-query:hover {
+  margin-bottom: 0;
+  line-height: normal;
+  color: #bbbbbb;
+  -webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.5);
+  -moz-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.5);
+  box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.5);
+}
+.navbar .navbar-search .search-query:-moz-placeholder,
+.navbar .navbar-search .search-query:hover:-moz-placeholder {
+  color: #bbbbbb;
+}
+.navbar .navbar-search .search-query:-ms-input-placeholder,
+.navbar .navbar-search .search-query:hover:-ms-input-placeholder {
+  color: #bbbbbb;
+}
+.navbar .navbar-search .search-query::-webkit-input-placeholder,
+.navbar .navbar-search .search-query:hover::-webkit-input-placeholder {
+  color: #bbbbbb;
+}
+.navbar .navbar-search .search-query:focus,
+.navbar .navbar-search .search-query:hover:focus,
+.navbar .navbar-search .search-query.focused,
+.navbar .navbar-search .search-query:hover.focused {
+  -webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.5);
+  -moz-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.5);
+  box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.5);
+  color: #2d2d2d;
+}
+.navbar-inverse .brand {
+  text-shadow: -1px -1px 0 rgba(0, 0, 0, 0.3);
+}
+.navbar-inverse .brand:hover {
+  color: #ffffff;
+}
+.navbar-inverse .nav > li > a {
+  text-shadow: -1px -1px 0 rgba(0, 0, 0, 0.3);
+}
+.navbar-inverse .nav li.dropdown.open > .dropdown-toggle .caret,
+.navbar-inverse .nav li.dropdown:hover > .dropdown-toggle .caret,
+.navbar-inverse .nav li.dropdown.open:hover > .dropdown-toggle .caret {
+  border-top-color: #ffffff;
+}
+.navbar-inverse .navbar-search .search-query,
+.navbar-inverse .navbar-search .search-query:hover {
+  color: #ffffff;
+}
+.navbar-inverse .navbar-search .search-query:-moz-placeholder,
+.navbar-inverse .navbar-search .search-query:hover:-moz-placeholder {
+  color: #eeeeee;
+}
+.navbar-inverse .navbar-search .search-query:-ms-input-placeholder,
+.navbar-inverse .navbar-search .search-query:hover:-ms-input-placeholder {
+  color: #eeeeee;
+}
+.navbar-inverse .navbar-search .search-query::-webkit-input-placeholder,
+.navbar-inverse .navbar-search .search-query:hover::-webkit-input-placeholder {
+  color: #eeeeee;
+}
+@media (max-width: 979px) {
+  .navbar .nav-collapse .nav li > a:hover {
+    background-color: #558bc4;
+    color: #ffffff;
+    text-shadow: none;
+  }
+  .navbar .nav-collapse .navbar-search {
+    border-top: none;
+    border-bottom: none;
+  }
+  .navbar-inverse .nav-collapse .nav li > a {
+    color: #eeeeee;
+  }
+  .navbar-inverse .nav-collapse .nav li > a:hover {
+    background-color: #558bc4 !important;
+  }
+  .navbar-inverse .nav-collapse .nav-header {
+    color: #eeeeee;
+  }
+}
+div.subnav .nav > li > a {
+  color: #2d2d2d;
+}
+div.subnav .nav > li > a:hover {
+  color: #558bc4;
+}
+div.subnav .nav > li.active > a {
+  color: #2d2d2d;
+}
+div.subnav .nav > li.active > a:hover {
+  color: #2d2d2d;
+}
+div.subnav .nav > li.dropdown > .dropdown-toggle {
+  background-color: transparent;
+}
+div.subnav .nav > li.dropdown.open > .dropdown-toggle {
+  border-left: 1px solid whiteSmoke;
+  border-right: 1px solid #E5E5E5;
+  color: #2d2d2d;
+}
+div.subnav .nav > li.dropdown.open > .dropdown-toggle:hover {
+  color: #558bc4;
+}
+.nav > li.dropdown > .dropdown-toggle .caret,
+.nav > li.dropdown.active > .dropdown-toggle .caret,
+.nav > li.dropdown.open > .dropdown-toggle .caret,
+.nav > li.dropdown.open.active > .dropdown-toggle .caret {
+  border-top: 4px solid #2d2d2d;
+  border-top-color: #2d2d2d;
+  opacity: 1;
+}
+.nav > li.dropdown > .dropdown-toggle:hover .caret,
+.nav > li.dropdown.active > .dropdown-toggle:hover .caret,
+.nav > li.dropdown.open > .dropdown-toggle:hover .caret,
+.nav > li.dropdown.open.active > .dropdown-toggle:hover .caret {
+  border-top: 4px solid #558bc4;
+  border-top-color: #558bc4;
+}
+.btn-info,
+.btn-info:hover,
+.btn-info.disabled {
+  color: #2d2d2d;
+  text-shadow: 0 1px 0 rgba(255, 255, 255, 0.3);
+}
+.btn-info .caret,
+.btn-info:hover .caret,
+.btn-info.disabled .caret {
+  border-top-color: #2d2d2d;
+  border-bottom-color: #2d2d2d;
+}
+/*.btn {
+	.buttonBackground(#F4F4F4, #ECECEC);
+	color: @textColor;
+	text-shadow: none;
 
+
+	&:hover,
+	&:active,
+	&.active,
+	&.disabled,
+	&[disabled] {
+		color: @grayDark;
+	}
+}
+
+.btn-primary {
+	.buttonBackground(#909090, #3F3F3F);
+}
+
+.btn-warning {
+  .buttonBackground(lighten(@yellow, 15%), @yellow);
+}
+
+.btn-danger {
+  .buttonBackground(lighten(#DA2D2D, 15%), #DA2D2D);
+}
+
+.btn-success {
+  .buttonBackground(#8ADD6D, #60B044);
+}
+
+.btn-info {
+  .buttonBackground(lighten(#4488BB, 15%), #4488BB);
+}
+
+.btn-inverse {
+  .buttonBackground(lighten(@purple, 5%), @purple);
+}*/
+.control-group.warning > label,
+.control-group.warning .help-block,
+.control-group.warning .help-inline {
+  color: #e29235;
+}
+.control-group.warning .checkbox,
+.control-group.warning .radio,
+.control-group.warning input,
+.control-group.warning select,
+.control-group.warning textarea {
+  color: #e29235;
+}
+.control-group.warning input,
+.control-group.warning select,
+.control-group.warning textarea {
+  border-color: #e29235;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+}
+.control-group.warning input:focus,
+.control-group.warning select:focus,
+.control-group.warning textarea:focus {
+  border-color: #c7781d;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #efc28e;
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #efc28e;
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #efc28e;
+}
+.control-group.warning .input-prepend .add-on,
+.control-group.warning .input-append .add-on {
+  color: #e29235;
+  background-color: #d47500;
+  border-color: #e29235;
+}
+.control-group.error > label,
+.control-group.error .help-block,
+.control-group.error .help-inline {
+  color: #cc0000;
+}
+.control-group.error .checkbox,
+.control-group.error .radio,
+.control-group.error input,
+.control-group.error select,
+.control-group.error textarea {
+  color: #cc0000;
+}
+.control-group.error input,
+.control-group.error select,
+.control-group.error textarea {
+  border-color: #cc0000;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+}
+.control-group.error input:focus,
+.control-group.error select:focus,
+.control-group.error textarea:focus {
+  border-color: #990000;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #ff3333;
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #ff3333;
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #ff3333;
+}
+.control-group.error .input-prepend .add-on,
+.control-group.error .input-append .add-on {
+  color: #cc0000;
+  background-color: #cd0200;
+  border-color: #cc0000;
+}
+.control-group.success > label,
+.control-group.success .help-block,
+.control-group.success .help-inline {
+  color: #2ba949;
+}
+.control-group.success .checkbox,
+.control-group.success .radio,
+.control-group.success input,
+.control-group.success select,
+.control-group.success textarea {
+  color: #2ba949;
+}
+.control-group.success input,
+.control-group.success select,
+.control-group.success textarea {
+  border-color: #2ba949;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+}
+.control-group.success input:focus,
+.control-group.success select:focus,
+.control-group.success textarea:focus {
+  border-color: #218037;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #63d77e;
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #63d77e;
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #63d77e;
+}
+.control-group.success .input-prepend .add-on,
+.control-group.success .input-append .add-on {
+  color: #2ba949;
+  background-color: #819e37;
+  border-color: #2ba949;
+}
+.alert {
+  color: #ffffff;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+}
+.label,
+.badge {
+  padding-top: 4px;
+}
+.label-important,
+.badge-important {
+  background-color: #cd0200;
+}
+.label-warning,
+.badge-warning {
+  background-color: #d47500;
+}
+.label-success,
+.badge-success {
+  background-color: #819e37;
+}
+.label-info,
+.badge-info {
+  background-color: #3399f3;
+}
+.well {
+  background-color: #eeeeee;
+}
+.hero-unit {
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05);
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05);
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05);
+  border: 1px solid rgba(0, 0, 0, 0.05);
+}
+.pull-right {
+  float: right;
+}
+.pull-left {
+  float: left;
+}
+.hide {
+  display: none;
+}
+.show {
+  display: block;
+}
+.invisible {
+  visibility: hidden;
+}
 .affix {
   position: fixed;
 }
diff --git a/docs/public/css/base.scss b/docs/public/css/base.scss
index eafd7d02..260f8309 100644
--- a/docs/public/css/base.scss
+++ b/docs/public/css/base.scss
@@ -85,4 +85,8 @@ section {
 h3 code {
     border: 0;
     font-size: 20px;
+}
+
+footer {
+    text-align: center;
 }
\ No newline at end of file
diff --git a/docs/site.yml b/docs/site.yml
index 4c752db0..b0d760ef 100644
--- a/docs/site.yml
+++ b/docs/site.yml
@@ -5,7 +5,9 @@ jq_version: 1.0
 footer: |
   
   This website is made with [Bonsai](http://www.tinytree.info) and
-  [Twitter Boostrap](http://twitter.github.com/bootstrap/). jq is
-  licensed under the MIT license (code) and the
+  [Twitter Boostrap](http://twitter.github.com/bootstrap/), themed
+  with [Bootswatch](http://bootswatch.com).
+
+  jq is licensed under the MIT license (code) and the
   [CC-BY-3.0](http://creativecommons.org/licenses/by/3.0/) license
   (docs).
\ No newline at end of file

From 9887cb57b2e7ac99301310957934765f3288fd21 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 19 Sep 2012 01:03:05 +0100
Subject: [PATCH 102/284] Add a rake task to compile docs into static html.

---
 docs/Rakefile | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/docs/Rakefile b/docs/Rakefile
index b4e1d6d1..62b0139e 100644
--- a/docs/Rakefile
+++ b/docs/Rakefile
@@ -52,3 +52,8 @@ task :serve do
     exit
   end
 end
+
+task :build do
+  Bonsai.root_dir = Dir.pwd
+  Bonsai::Exporter.publish!
+end

From f51eca20f59ef3d9291b5df61ca357d7924872da Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 19 Sep 2012 01:10:47 +0100
Subject: [PATCH 103/284] Fix some issues with relative URLs on Github Pages.

---
 docs/content/2.download/default.yml  | 6 +++---
 docs/site.yml                        | 3 +++
 docs/templates/index.liquid          | 8 ++++----
 docs/templates/shared/_head.liquid   | 6 +++---
 docs/templates/shared/_header.liquid | 4 ++--
 5 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/docs/content/2.download/default.yml b/docs/content/2.download/default.yml
index 9d69780a..54f4d78b 100644
--- a/docs/content/2.download/default.yml
+++ b/docs/content/2.download/default.yml
@@ -7,9 +7,9 @@ body:
       possible to build it for nearly any platform. Prebuilt binaries are
       available for Linux (64-bit x86) and OS X.
     
-       * [Download binary for 64-bit Linux](/download/linux_x86_64/jq)
-       * [Download binary for OS X](/download/osx_64/jq)
-       * [Download source](/download/source/jq.tgz)
+       * [Download binary for 64-bit Linux](linux_x86_64/jq)
+       * [Download binary for OS X](osx_64/jq)
+       * [Download source](source/jq.tgz)
 
       The binaries should just run, but you may need to make them
       executable first using:
diff --git a/docs/site.yml b/docs/site.yml
index b0d760ef..b34a9faa 100644
--- a/docs/site.yml
+++ b/docs/site.yml
@@ -2,6 +2,9 @@
 
 
 jq_version: 1.0
+# Next line is needed for publishing to github pages
+# root: '/jq'
+root: ''
 footer: |
   
   This website is made with [Bonsai](http://www.tinytree.info) and
diff --git a/docs/templates/index.liquid b/docs/templates/index.liquid
index d2d06de5..aaff1c9f 100644
--- a/docs/templates/index.liquid
+++ b/docs/templates/index.liquid
@@ -7,7 +7,7 @@
     <div class="container">
       <div class="row">
         <div class="hero-unit">
-          <img src="/jq.png" style="width: 400px; height: 220px; float: left; margin-right: 60px">
+          <img src="{{root}}/jq.png" style="width: 400px; height: 220px; float: left; margin-right: 60px">
           <div id="blurb">
             {{blurb | markdownify}}
             <div class="btn-group" style="float:right">
@@ -16,9 +16,9 @@
                 <span class="caret"></span>
               </a>
               <ul class="dropdown-menu">
-                <li><a href="/download/linux_x86_64/jq">Linux (x86_64)</a></li>
-                <li><a href="/download/osx_64/jq">OS X (64-bit)</a></li>
-                <li><a href="/download">Other platforms and source</a></li>
+                <li><a href="{{root}}/download/linux_x86_64/jq">Linux (x86_64)</a></li>
+                <li><a href="{{root}}/download/osx_64/jq">OS X (64-bit)</a></li>
+                <li><a href="{{root}}/download">Other platforms and source</a></li>
               </ul>
             </div>
 
diff --git a/docs/templates/shared/_head.liquid b/docs/templates/shared/_head.liquid
index acc6dfe2..5f2b7da8 100644
--- a/docs/templates/shared/_head.liquid
+++ b/docs/templates/shared/_head.liquid
@@ -1,12 +1,12 @@
 <head>
   <meta charset=UTF-8>
   <title>{{headline}} | jq</title>
-  <link rel="stylesheet" href="/bootstrap/css/bootstrap.css" type="text/css">
-  <link rel="stylesheet" href="/css/base.css" type="text/css">
+  <link rel="stylesheet" href="{{root}}/bootstrap/css/bootstrap.css" type="text/css">
+  <link rel="stylesheet" href="{{root}}/css/base.css" type="text/css">
   <!--[if IE]>
     <script src="http://html5shiv.googlecode.com/svn/trunk/html5.js"></script>
   <![endif]-->
   <script src="//ajax.googleapis.com/ajax/libs/jquery/1.8.1/jquery.min.js"></script>
-  <script src="/bootstrap/js/bootstrap.js"></script>
+  <script src="{{root}}/bootstrap/js/bootstrap.js"></script>
 
 </head>
\ No newline at end of file
diff --git a/docs/templates/shared/_header.liquid b/docs/templates/shared/_header.liquid
index 82f778d7..020b130f 100644
--- a/docs/templates/shared/_header.liquid
+++ b/docs/templates/shared/_header.liquid
@@ -7,12 +7,12 @@
         <span class="icon-bar"></span>
         <span class="icon-bar"></span>
       </button>
-      <a class="brand" href="/">jq</a>
+      <a class="brand" href="{{root}}/">jq</a>
       <div class="nav-collapse collapse">
         <ul class="nav">
           {% for item in navigation %}
             <li {% if item.permalink == permalink %} class="active" {% endif %}>
-              <a href="{{item.permalink}}">{{item.name}}</a>
+              <a href="{{root}}{{item.permalink}}">{{item.name}}</a>
             </li>
           {% endfor %}
           <li><a href="https://github.com/stedolan/jq/issues">Issues</a></li>

From fc57cf702ce57fc53b8074e7f1fca6f88e0e2fe0 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 19 Sep 2012 01:12:33 +0100
Subject: [PATCH 104/284] No HTTPS for me, sadly.

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 8f7b240d..df9ac4dd 100644
--- a/README.md
+++ b/README.md
@@ -4,11 +4,11 @@ jq
 jq is a command-line JSON processor.
 
 If you want to learn to use jq, read the documentation at
-[https://stedolan.github.com/jq](https://stedolan.github.com/jq). This
+[http://stedolan.github.com/jq](http://stedolan.github.com/jq). This
 documentation is generated from the docs/ folder of this repository.
 
 If you want to hack on jq, feel free, but be warned that its internals
 are not well-documented at the moment. Bring a hard hat and a shovel.
 
 You can find some basic build instructions at
-[https://stedolan.github.com/jq/download](https://stedolan.github.com/jq/download)
+[http://stedolan.github.com/jq/download](http://stedolan.github.com/jq/download)

From 92ab1933693dd26056f60d022abd6f2e8d3a699f Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 19 Sep 2012 01:15:49 +0100
Subject: [PATCH 105/284] Make the <title>s of the doc pages less messy.

---
 docs/templates/shared/_head.liquid | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/templates/shared/_head.liquid b/docs/templates/shared/_head.liquid
index 5f2b7da8..01fd63c6 100644
--- a/docs/templates/shared/_head.liquid
+++ b/docs/templates/shared/_head.liquid
@@ -1,6 +1,6 @@
 <head>
   <meta charset=UTF-8>
-  <title>{{headline}} | jq</title>
+  <title>{{headline}}</title>
   <link rel="stylesheet" href="{{root}}/bootstrap/css/bootstrap.css" type="text/css">
   <link rel="stylesheet" href="{{root}}/css/base.css" type="text/css">
   <!--[if IE]>

From 1f4a5d8d9f37be6bd3956a1613e5c508ebffe145 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <stephen.dolan@swrve.com>
Date: Wed, 19 Sep 2012 10:48:23 +0100
Subject: [PATCH 106/284] Make URLs relative to not break on github-pages

---
 docs/content/index/index.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/content/index/index.yml b/docs/content/index/index.yml
index 03331f0a..cf713f25 100644
--- a/docs/content/index/index.yml
+++ b/docs/content/index/index.yml
@@ -23,5 +23,5 @@ body3: |
   shorter and simpler than you'd expect.
   
 tail: |
-  Go read the [tutorial](/tutorial) for more, or the [manual](/manual)
+  Go read the [tutorial](tutorial) for more, or the [manual](manual)
   for *way* more.
\ No newline at end of file

From fcd7cf4ddd1025157bc2f8a808082a71937c85e7 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <stephen.dolan@swrve.com>
Date: Wed, 19 Sep 2012 10:54:58 +0100
Subject: [PATCH 107/284] More broken links :(

---
 docs/content/1.tutorial/default.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/content/1.tutorial/default.yml b/docs/content/1.tutorial/default.yml
index f41e5aae..57902d9b 100644
--- a/docs/content/1.tutorial/default.yml
+++ b/docs/content/1.tutorial/default.yml
@@ -237,5 +237,5 @@ body:
       - - -
 
       Here endeth the tutorial! There's lots more to play with, go
-      read [the manual](/manual) if you're interested, and [download
-      jq](/download) if you haven't already.
\ No newline at end of file
+      read [the manual](../manual) if you're interested, and [download
+      jq](../download) if you haven't already.
\ No newline at end of file

From 359d5f33bde0df899985eac3d720f5c6a7f4d580 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 20 Sep 2012 19:31:14 +0100
Subject: [PATCH 108/284] Add a bunch of commandline options for controlling
 I/O format.

Also docs for the above. Closes #1.
---
 docs/content/3.manual/manual.yml |  54 +++++++++-
 main.c                           | 166 +++++++++++++++++++++++++------
 2 files changed, 190 insertions(+), 30 deletions(-)

diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 10998dce..50c63eca 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -28,7 +28,59 @@ body: |
   simpler:
   
 sections:
-  - title: Basics
+  - title: Invoking jq
+    body: |
+      
+      jq filters run on a stream of JSON data. The input to jq is
+      parsed as a sequence of whitespace-separated JSON values which
+      are passed through the provided filter one at a time. The
+      output(s) of the filter are written to standard out, again as a
+      sequence of whitespace-separated JSON data.
+
+      You can affect how jq reads and writes its input and output
+      using some command-line options:
+
+      * `--slurp`/`-s` 
+
+        Instead of running the filter for each JSON object in the
+        input, read the entire input stream into a large array and run
+        the filter just once.
+      
+      * `--raw-input`/`-R` 
+      
+        Don't parse the input as JSON. Instead, each line of text is
+        passed to the filter as a string. If combined with `--slurp`,
+        then the entire input is passed to the filter as a single long
+        string.
+
+      * `--null-input`/`-n`
+
+        Don't read any input at all! Instead, the filter is run once
+        using `null` as the input. This is useful when using jq as a
+        simple calculator or to construct JSON data from scratch.
+
+      * `--compact-output` / `-c`
+
+        By default, jq pretty-prints JSON output. Using this option
+        will result in more compact output by instead putting each
+        JSON object on a single line.
+
+      * `--ascii-output` / `-a`
+
+        jq usually outputs non-ASCII Unicode codepoints as UTF-8, even
+        if the input specified them as escape sequences (like
+        "\u03bc"). Using this option, you can force jq to produce pure
+        ASCII output with every non-ASCII character replaced with the
+        equivalent escape sequence.
+
+      * `--raw-output` / `-r`
+
+        With this option, if the filter's result is a string then it
+        will be written directly to standard output rather than being
+        formatted as a JSON string with quotes. This can be useful for
+        making jq filters talk to non-JSON-based systems.
+
+  - title: Basic filters
     entries:
       - title: "`.`"
         body: |
diff --git a/main.c b/main.c
index 92a7c652..48934cc4 100644
--- a/main.c
+++ b/main.c
@@ -1,5 +1,6 @@
 #include <stdio.h>
 #include <string.h>
+#include <ctype.h>
 #include "compile.h"
 #include "builtin.h"
 #include "jv.h"
@@ -12,17 +13,98 @@ static const char* progname;
 
 static void usage() {
   fprintf(stderr, "\njq - commandline JSON processor\n");
-  fprintf(stderr, "Usage: %s <jq filter>\n\n", progname);
-  fprintf(stderr, "For a description of how to write jq filters and\n");
-  fprintf(stderr, "why you might want to, see the jq documentation at\n");
-  fprintf(stderr, "http://stedolan.github.com/jq\n\n");
+  fprintf(stderr, "Usage: %s [options] <jq filter>\n\n", progname);
+  fprintf(stderr, "For a description of the command line options and\n");
+  fprintf(stderr, "how to write jq filters (and why you might want to)\n");
+  fprintf(stderr, "see the jq documentation at http://stedolan.github.com/jq\n\n");
   exit(1);
 }
 
+static void die() {
+  fprintf(stderr, "Use %s --help for help with command-line options,\n", progname);
+  fprintf(stderr, "or see the jq documentation at http://stedolan.github.com/jq\n");
+  exit(1);
+}
+
+
+
+
+static int isoptish(const char* text) {
+  return text[0] == '-' && (text[1] == '-' || isalpha(text[1]));
+}
+
+static int isoption(const char* text, char shortopt, const char* longopt) {
+  if (text[0] != '-') return 0;
+  if (strlen(text) == 2 && text[1] == shortopt) return 1;
+  if (text[1] == '-' && !strcmp(text+2, longopt)) return 1;
+  return 0;
+}
+
+enum {
+  SLURP = 1,
+  RAW_INPUT = 2,
+  PROVIDE_NULL = 4,
+
+  RAW_OUTPUT = 8,
+  COMPACT_OUTPUT = 16,
+  ASCII_OUTPUT = 32,
+};
+static int options = 0;
+static struct bytecode* bc;
+
+static void process(jv value) {
+  jq_init(bc, value);
+  jv result;
+  while (jv_is_valid(result = jq_next())) {
+    if ((options & RAW_OUTPUT) && jv_get_kind(result) == JV_KIND_STRING) {
+      fwrite(jv_string_value(result), 1, jv_string_length(jv_copy(result)), stdout);
+    } else {
+      int dumpopts = 0;
+      if (!(options & COMPACT_OUTPUT)) dumpopts |= JV_PRINT_PRETTY;
+      if (options & ASCII_OUTPUT) dumpopts |= JV_PRINT_ASCII;
+      jv_dump(result, dumpopts);
+    }
+    printf("\n");
+  }
+  jv_free(result);
+  jq_teardown();
+}
+
 int main(int argc, char* argv[]) {
   if (argc) progname = argv[0];
-  if (argc != 2 || !strcmp(argv[1], "--help") || !strcmp(argv[1], "--version")) usage();
-  struct bytecode* bc = jq_compile(argv[1]);
+
+  const char* program = 0;
+  for (int i=1; i<argc; i++) {
+    if (!isoptish(argv[i])) {
+      if (program) usage();
+      program = argv[i];
+    } else if (isoption(argv[i], 's', "slurp")) {
+      options |= SLURP;
+    } else if (isoption(argv[i], 'r', "raw-output")) {
+      options |= RAW_OUTPUT;
+    } else if (isoption(argv[i], 'c', "compact-output")) {
+      options |= COMPACT_OUTPUT;
+    } else if (isoption(argv[i], 'a', "ascii-output")) {
+      options |= ASCII_OUTPUT;
+    } else if (isoption(argv[i], 'R', "raw-input")) {
+      options |= RAW_INPUT;
+    } else if (isoption(argv[i], 'n', "null-input")) {
+      options |= PROVIDE_NULL;
+    } else if (isoption(argv[i], 'h', "help")) {
+      usage();
+    } else {
+      fprintf(stderr, "%s: Unknown option %s\n", progname, argv[i]);
+      die();
+    }
+  }
+  if (!program) usage();
+
+  if ((options & PROVIDE_NULL) && (options & (RAW_INPUT | SLURP))) {
+    fprintf(stderr, "%s: --null-input cannot be used with --raw-input or --slurp\n", program);
+    die();
+  }
+
+  bc = jq_compile(program);
   if (!bc) return 1;
 
 #if JQ_DEBUG
@@ -30,33 +112,59 @@ int main(int argc, char* argv[]) {
   printf("\n");
 #endif
 
-  struct jv_parser parser;
-  jv_parser_init(&parser);
-  while (!feof(stdin)) {
-    char buf[4096];
-    if (!fgets(buf, sizeof(buf), stdin)) buf[0] = 0;
-    jv_parser_set_buf(&parser, buf, strlen(buf), !feof(stdin));
-    jv value;
-    while (jv_is_valid((value = jv_parser_next(&parser)))) {
-      jq_init(bc, value);
-      jv result;
-      while (jv_is_valid(result = jq_next())) {
-        jv_dump(result, JV_PRINT_PRETTY);
-        printf("\n");
+  if (options & PROVIDE_NULL) {
+    process(jv_null());
+  } else {
+    jv slurped;
+    if (options & SLURP) slurped = jv_invalid();
+    int first = 1;
+    struct jv_parser parser;
+    jv_parser_init(&parser);
+    while (!feof(stdin)) {
+      char buf[4096];
+      if (!fgets(buf, sizeof(buf), stdin)) buf[0] = 0;
+      if (options & RAW_INPUT) {
+        int len = strlen(buf);
+        if (len > 0) {
+          if (options & SLURP) {
+            if (first) slurped = jv_string(buf);
+            else slurped = jv_string_concat(slurped, jv_string(buf));
+          } else {
+            if (buf[len-1] == '\n') buf[len-1] = 0;
+            process(jv_string(buf));
+          }
+        }
+      } else {
+        jv_parser_set_buf(&parser, buf, strlen(buf), !feof(stdin));
+        jv value;
+        while (jv_is_valid((value = jv_parser_next(&parser)))) {
+          if (options & SLURP) {
+            if (first) slurped = jv_array();
+            slurped = jv_array_append(slurped, value);
+          } else {
+            process(value);
+          }
+        }
+        if (jv_invalid_has_msg(jv_copy(value))) {
+          jv msg = jv_invalid_get_msg(value);
+          fprintf(stderr, "parse error: %s\n", jv_string_value(msg));
+          jv_free(msg);
+          break;
+        } else {
+          jv_free(value);
+        }
       }
-      jv_free(result);
-      jq_teardown();
+      first = 0;
     }
-    if (jv_invalid_has_msg(jv_copy(value))) {
-      jv msg = jv_invalid_get_msg(value);
-      fprintf(stderr, "parse error: %s\n", jv_string_value(msg));
-      jv_free(msg);
-      break;
-    } else {
-      jv_free(value);
+    jv_parser_free(&parser);
+    if (options & SLURP) {
+      if (jv_is_valid(slurped)) {
+        process(slurped);
+      } else {
+        jv_free(slurped);
+      }
     }
   }
-  jv_parser_free(&parser);
 
   bytecode_free(bc);
   return 0;

From a2643cc0d564033c49bffbd0de9a8e797281e73f Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sat, 22 Sep 2012 14:03:46 +0100
Subject: [PATCH 109/284] Allow underscores in IDENT tokens. Fixes #3.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

IDENT syntax now includes ASCII letters and underscores, so
'.foo_bar' now works. Non-ASCII letters won't work in IDENT
tokens (it's impossible to tell which non-ascii characters are
"letters" without full unicode tables), so '.données' is still
a syntax error (the workaround is '.["données"]', since you can
put anything you like in a string).
---
 lexer.l  | 2 +-
 testdata | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/lexer.l b/lexer.l
index e604adab..fe0049a9 100644
--- a/lexer.l
+++ b/lexer.l
@@ -107,7 +107,7 @@
 }
   
 
-[[:alnum:]]+  { yylval->literal = jv_string(yytext); return IDENT;}
+[a-zA-Z_][a-zA-Z_0-9]*  { yylval->literal = jv_string(yytext); return IDENT;}
 
 [ \n\t]+  {}
 
diff --git a/testdata b/testdata
index 8a289973..307eaa62 100644
--- a/testdata
+++ b/testdata
@@ -61,6 +61,10 @@ null
 {"foo": {"bar": 42}, "bar": "badvalue"}
 42
 
+.foo_bar
+{"foo_bar": 2}
+2
+
 .["foo"].bar
 {"foo": {"bar": 42}, "bar": "badvalue"}
 42

From 0618e61e0bd0a58cd222bb4905c51178fe332525 Mon Sep 17 00:00:00 2001
From: Stephen Roantree <stroantree@gmail.com>
Date: Sun, 7 Oct 2012 22:34:12 +0100
Subject: [PATCH 110/284] Add <,>,<=,>= binops

---
 builtin.c | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 lexer.l   |  4 +++-
 parser.y  | 23 +++++++++++++++++++++++
 testdata  |  9 +++++++++
 4 files changed, 81 insertions(+), 1 deletion(-)

diff --git a/builtin.c b/builtin.c
index 1eee5bb5..c6ff785d 100644
--- a/builtin.c
+++ b/builtin.c
@@ -4,6 +4,12 @@
 #include "parser.h"
 #include "locfile.h"
 
+enum {
+  CMP_OP_LESS,
+  CMP_OP_GREATER,
+  CMP_OP_LESSEQ,
+  CMP_OP_GREATEREQ
+} _cmp_op;
 
 static void f_plus(jv input[], jv output[]) {
   jv_free(input[0]);
@@ -114,6 +120,42 @@ static void f_equal(jv input[], jv output[]) {
   output[0] = jv_bool(jv_equal(input[2], input[1]));
 }
 
+static void order_cmp(jv input[], jv output[], int op) {
+  jv_free(input[0]);
+  jv a = input[2];
+  jv b = input[1];
+  if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
+    double da = jv_number_value(a);
+    double db = jv_number_value(b);
+    output[0] = jv_bool((op == CMP_OP_LESS && da < db) ||
+                        (op == CMP_OP_LESSEQ && da <= db) ||
+                        (op == CMP_OP_GREATEREQ && da >= db) ||
+                        (op == CMP_OP_GREATER && da > db));
+  } else {
+    output[0] = jv_invalid_with_msg(jv_string_fmt("Attempted to compare order of %s wrt %s",
+                                                  jv_kind_name(jv_get_kind(a)),
+                                                  jv_kind_name(jv_get_kind(b))));
+    jv_free(a);
+    jv_free(b);
+  }
+}
+
+static void f_less(jv input[], jv output[]) {
+  order_cmp(input, output, CMP_OP_LESS);
+}
+
+static void f_greater(jv input[], jv output[]) {
+  order_cmp(input, output, CMP_OP_GREATER);
+}
+
+static void f_lesseq(jv input[], jv output[]) {
+  order_cmp(input, output, CMP_OP_LESSEQ);
+}
+
+static void f_greatereq(jv input[], jv output[]) {
+  order_cmp(input, output, CMP_OP_GREATEREQ);
+}
+
 static void f_tonumber(jv input[], jv output[]) {
   if (jv_get_kind(input[0]) == JV_KIND_NUMBER) {
     output[0] = input[0];
@@ -202,6 +244,10 @@ static struct cfunction function_list[] = {
   {f_tonumber, "tonumber", CALL_BUILTIN_1_1},
   {f_tostring, "tostring", CALL_BUILTIN_1_1},
   {f_equal, "_equal", CALL_BUILTIN_3_1},
+  {f_less, "_less", CALL_BUILTIN_3_1},
+  {f_greater, "_greater", CALL_BUILTIN_3_1},
+  {f_lesseq, "_lesseq", CALL_BUILTIN_3_1},
+  {f_greatereq, "_greatereq", CALL_BUILTIN_3_1},
   {f_length, "length", CALL_BUILTIN_1_1},
   {f_type, "type", CALL_BUILTIN_1_1},
   {f_add, "add", CALL_BUILTIN_1_1},
diff --git a/lexer.l b/lexer.l
index fe0049a9..a353d89b 100644
--- a/lexer.l
+++ b/lexer.l
@@ -48,7 +48,9 @@
 "*=" { return SETMULT; }
 "/=" { return SETDIV; }
 "//=" { return SETDEFINEDOR; }
-"."|"="|";"|","|":"|"|"|"+"|"-"|"*"|"/"|"\$" { return yytext[0];}
+"<=" { return LESSEQ; }
+">=" { return GREATEREQ; }
+"."|"="|";"|","|":"|"|"|"+"|"-"|"*"|"/"|"\$"|"<"|">" { return yytext[0];}
 
 "["|"{"|"(" {
   return enter(yytext[0], YY_START, yyscanner);
diff --git a/parser.y b/parser.y
index 0fda65bd..94700aee 100644
--- a/parser.y
+++ b/parser.y
@@ -59,6 +59,8 @@
 %token SETMULT "*="
 %token SETDIV "/="
 %token SETDEFINEDOR "//="
+%token LESSEQ "<="
+%token GREATEREQ ">="
 
 %token QQSTRING_START
 %token <literal> QQSTRING_TEXT
@@ -77,6 +79,7 @@
 %nonassoc EQ
 %left '+' '-'
 %left '*' '/'
+%right '<' '>' LESSEQ GREATEREQ
 
 
 %type <blk> Exp Term MkDict MkDictPair ExpD ElseBody QQString FuncDef FuncDefs
@@ -137,6 +140,10 @@ static block gen_binop(block a, block b, int op) {
   case '*': funcname = "_multiply"; break;
   case '/': funcname = "_divide"; break;
   case EQ: funcname = "_equal"; break;
+  case '<': funcname = "_less"; break;
+  case '>': funcname = "_greater"; break;
+  case LESSEQ: funcname = "_lesseq"; break;
+  case GREATEREQ: funcname = "_greatereq"; break;
   }
   assert(funcname);
 
@@ -273,6 +280,22 @@ Exp "==" Exp {
   $$ = gen_binop($1, $3, EQ);
 } |
 
+Exp '<' Exp {
+  $$ = gen_binop($1, $3, '<');
+} |
+
+Exp '>' Exp {
+  $$ = gen_binop($1, $3, '>');
+} |
+
+Exp "<=" Exp {
+  $$ = gen_binop($1, $3, LESSEQ);
+} |
+
+Exp ">=" Exp {
+  $$ = gen_binop($1, $3, GREATEREQ);
+} |
+
 QQSTRING_START QQString QQSTRING_END {
   $$ = $2;
 } |
diff --git a/testdata b/testdata
index 307eaa62..c37dee93 100644
--- a/testdata
+++ b/testdata
@@ -348,3 +348,12 @@ def inc(x): x |= .+1; inc(.[].a)
 [.[] | not]
 [1,0,false,null,true,"hello"]
 [false,false,true,true,false,false]
+
+# Check numeric comparison binops
+[10 > 0, 10 > 10, 10 > 20, 10 < 0, 10 < 10, 10 < 20]
+{}
+[true,false,false,false,false,true]
+
+[10 >= 0, 10 >= 10, 10 >= 20, 10 <= 0, 10 <= 10, 10 <= 20]
+{}
+[true,true,false,false,true,true]
\ No newline at end of file

From b3557429eb478e7d7c8f32223ce108c5e91d5a03 Mon Sep 17 00:00:00 2001
From: Stephen Roantree <stroantree@gmail.com>
Date: Wed, 10 Oct 2012 22:44:17 +0100
Subject: [PATCH 111/284] Make comp binops nonassoc

---
 parser.y | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/parser.y b/parser.y
index 94700aee..8c4b4566 100644
--- a/parser.y
+++ b/parser.y
@@ -76,10 +76,9 @@
 %nonassoc '=' SETPIPE SETPLUS SETMINUS SETMULT SETDIV SETDEFINEDOR
 %left OR
 %left AND
-%nonassoc EQ
+%nonassoc EQ '<' '>' LESSEQ GREATEREQ
 %left '+' '-'
 %left '*' '/'
-%right '<' '>' LESSEQ GREATEREQ
 
 
 %type <blk> Exp Term MkDict MkDictPair ExpD ElseBody QQString FuncDef FuncDefs

From afec2544f1793d11c47356c32ef74ce8c4035263 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sat, 20 Oct 2012 00:09:20 +0100
Subject: [PATCH 112/284] A string interpolation syntax that I don't hate. Also
 tests.

You can interpolate values into strings using \(this syntax), e.g.

    "best \("str" + "ing") ever"
---
 lexer.l       | 24 +++++-------------------
 opcode_list.h |  1 +
 parser.y      | 18 ++++++++++--------
 testdata      | 14 +++++++++++++-
 4 files changed, 29 insertions(+), 28 deletions(-)

diff --git a/lexer.l b/lexer.l
index a353d89b..1921f380 100644
--- a/lexer.l
+++ b/lexer.l
@@ -61,45 +61,31 @@
 }
 
 
-\"(\\.|[^\\\"])*\" |
 -?[0-9.]+([eE][+-]?[0-9]+)? { 
    yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; 
 }
 
-\"(\\.|[^\\\"])* { 
-  yylval->literal = jv_invalid_with_msg(jv_string("Unterminated string"));
-  return LITERAL;
-}
-
-"@(" {
+"\"" {
   yy_push_state(IN_QQSTRING, yyscanner);
   return QQSTRING_START;
 }
 
 <IN_QQSTRING>{
-  "%(" {
+  "\\(" {
     return enter(QQSTRING_INTERP_START, YY_START, yyscanner);
   }
-  "%"[^(] {
-    return INVALID_CHARACTER;
-  }
-  ")" {
+  "\"" {
     yy_pop_state(yyscanner);
     return QQSTRING_END;
   }
-  "\\"[)%] {
-    char text[2] = {yytext[1], 0};
-    yylval->literal = jv_string(text);
-    return QQSTRING_TEXT;
-  }
-  (\\[^u)%]|\\u[a-zA-Z0-9]{0,4})+ {
+  (\\[^u(]|\\u[a-zA-Z0-9]{0,4})+ {
     /* pass escapes to the json parser */
     jv escapes = jv_string_fmt("\"%.*s\"", yyleng, yytext);
     yylval->literal = jv_parse_sized(jv_string_value(escapes), jv_string_length(jv_copy(escapes)));
     jv_free(escapes);
     return QQSTRING_TEXT;
   }
-  [^\\)%]+ {
+  [^\\\"]+ {
     yylval->literal = jv_string_sized(yytext, yyleng);
     return QQSTRING_TEXT;
   }
diff --git a/opcode_list.h b/opcode_list.h
index 30e7203d..306373fb 100644
--- a/opcode_list.h
+++ b/opcode_list.h
@@ -18,6 +18,7 @@ OP(INSERT, NONE,    4, 2)
 OP(ASSIGN, VARIABLE, 3, 0)
 
 OP(CALL_BUILTIN_1_1, CFUNC, 1, 1)
+OP(CALL_BUILTIN_2_1, CFUNC, 2, 1)
 OP(CALL_BUILTIN_3_1, CFUNC, 3, 1)
 
 OP(CALL_1_1, UFUNC, 1, 1)
diff --git a/parser.y b/parser.y
index 8c4b4566..0effe07c 100644
--- a/parser.y
+++ b/parser.y
@@ -81,7 +81,7 @@
 %left '*' '/'
 
 
-%type <blk> Exp Term MkDict MkDictPair ExpD ElseBody QQString FuncDef FuncDefs
+%type <blk> Exp Term MkDict MkDictPair ExpD ElseBody QQString FuncDef FuncDefs String
 %{
 #include "lexer.gen.h"
 #define FAIL(loc, msg)                                   \
@@ -295,14 +295,19 @@ Exp ">=" Exp {
   $$ = gen_binop($1, $3, GREATEREQ);
 } |
 
-QQSTRING_START QQString QQSTRING_END {
-  $$ = $2;
+String {
+  $$ = $1;
 } |
 
 Term { 
   $$ = $1; 
 }
 
+String:
+QQSTRING_START QQString QQSTRING_END {
+  $$ = $2;
+}
+
 FuncDef:
 "def" IDENT ':' Exp ';' {
   block body = block_join($4, gen_op_simple(RET));
@@ -416,11 +421,8 @@ MkDictPair
 : IDENT ':' ExpD { 
   $$ = gen_dictpair(gen_op_const(LOADK, $1), $3);
  }
-| LITERAL ':' ExpD {
-  if (jv_get_kind($1) != JV_KIND_STRING) {
-    FAIL(@1, "Object keys must be strings");
-  }
-  $$ = gen_dictpair(gen_op_const(LOADK, $1), $3);
+| String ':' ExpD {
+  $$ = gen_dictpair($1, $3);
   }
 | IDENT {
   $$ = gen_dictpair(gen_op_const(LOADK, jv_copy($1)),
diff --git a/testdata b/testdata
index c37dee93..ea0b1cc6 100644
--- a/testdata
+++ b/testdata
@@ -31,7 +31,19 @@ null
 null
 []
 
-# FIXME: string literals
+# We test escapes by matching them against Unicode codepoints
+# FIXME: more tests needed for weird unicode stuff (e.g. utf16 pairs)
+"Aa\r\n\t\b\f\u03bc"
+null
+"Aa\u000d\u000a\u0009\u0008\u000c\u03bc"
+
+.
+"Aa\r\n\t\b\f\u03bc"
+"Aa\u000d\u000a\u0009\u0008\u000c\u03bc"
+
+"inter\("pol" + "ation")"
+null
+"interpolation"
 
 #
 # Dictionary construction syntax

From 32e1b114df3067b000b26d11030fd265d2fee17a Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sat, 20 Oct 2012 00:26:37 +0100
Subject: [PATCH 113/284] Add a 'keys' function. Fixes #4.

---
 builtin.c | 34 ++++++++++++++++++++++++++++++++++
 testdata  |  4 ++++
 2 files changed, 38 insertions(+)

diff --git a/builtin.c b/builtin.c
index c6ff785d..c3d6af19 100644
--- a/builtin.c
+++ b/builtin.c
@@ -202,6 +202,39 @@ static void f_tostring(jv input[], jv output[]) {
   }
 }
 
+static int string_cmp(const void* pa, const void* pb){
+  const jv* a = pa;
+  const jv* b = pb;
+  int lena = jv_string_length(jv_copy(*a));
+  int lenb = jv_string_length(jv_copy(*b));
+  int minlen = lena < lenb ? lena : lenb;
+  int r = memcmp(jv_string_value(*a), jv_string_value(*b), minlen);
+  if (r == 0) r = lena - lenb;
+  return r;
+}
+
+static void f_keys(jv input[], jv output[]) {
+  if (jv_get_kind(input[0]) == JV_KIND_OBJECT) {
+    int nkeys = jv_object_length(jv_copy(input[0]));
+    jv* keys = malloc(sizeof(jv) * nkeys);
+    int kidx = 0;
+    jv_object_foreach(i, input[0]) {
+      keys[kidx++] = jv_object_iter_key(input[0], i);
+    }
+    qsort(keys, nkeys, sizeof(jv), string_cmp);
+    output[0] = jv_array_sized(nkeys);
+    for (int i = 0; i<nkeys; i++) {
+      output[0] = jv_array_append(output[0], keys[i]);
+    }
+    free(keys);
+    jv_free(input[0]);
+  } else {
+    output[0] = jv_invalid_with_msg(jv_string_fmt("'keys' only supports object, not %s",
+                                                  jv_kind_name(jv_get_kind(input[0]))));
+    jv_free(input[0]);
+  }
+}
+
 static void f_type(jv input[], jv output[]) {
   output[0] = jv_string(jv_kind_name(jv_get_kind(input[0])));
   jv_free(input[0]);
@@ -243,6 +276,7 @@ static struct cfunction function_list[] = {
   {f_divide, "_divide", CALL_BUILTIN_3_1},
   {f_tonumber, "tonumber", CALL_BUILTIN_1_1},
   {f_tostring, "tostring", CALL_BUILTIN_1_1},
+  {f_keys, "keys", CALL_BUILTIN_1_1},
   {f_equal, "_equal", CALL_BUILTIN_3_1},
   {f_less, "_less", CALL_BUILTIN_3_1},
   {f_greater, "_greater", CALL_BUILTIN_3_1},
diff --git a/testdata b/testdata
index ea0b1cc6..6f04a1d5 100644
--- a/testdata
+++ b/testdata
@@ -223,6 +223,10 @@ null
 [[], {}, [1,2], {"a":42}, "asdf"]
 [0, 0, 2, 1, 4]
 
+map(keys)
+[{}, {"abcd":1,"abc":2,"abcde":3}, {"x":1, "z": 3, "y":2}]
+[[], ["abc","abcd","abcde"], ["x","y","z"]]
+
 [1,2,empty,3,empty,4]
 null
 [1,2,3,4]

From 95a0074edf1b4d6bffb8592ae39f4715561fe67c Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 21 Oct 2012 19:52:16 +0100
Subject: [PATCH 114/284] Check in a bunch of autogenerated files.

These seem not to build with the version of bison, etc. on OS X.
This is a hack for now, I'll fix the OS X build when I get access
to a mac.
---
 jv_utf8_tables.gen.h |   35 +
 lexer.gen.c          | 2296 +++++++++++++++++++++++++++++
 lexer.gen.h          |  362 +++++
 parser.gen.c         | 2830 ++++++++++++++++++++++++++++++++++++
 parser.gen.h         |  130 ++
 parser.gen.info      | 3283 ++++++++++++++++++++++++++++++++++++++++++
 6 files changed, 8936 insertions(+)
 create mode 100644 jv_utf8_tables.gen.h
 create mode 100644 lexer.gen.c
 create mode 100644 lexer.gen.h
 create mode 100644 parser.gen.c
 create mode 100644 parser.gen.h
 create mode 100644 parser.gen.info

diff --git a/jv_utf8_tables.gen.h b/jv_utf8_tables.gen.h
new file mode 100644
index 00000000..24d9a63a
--- /dev/null
+++ b/jv_utf8_tables.gen.h
@@ -0,0 +1,35 @@
+#define UTF8_CONTINUATION_BYTE ((unsigned char)255)
+static const unsigned char utf8_coding_length[] =
+ {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+  0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+  0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+  0x04, 0x04, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+static const unsigned char utf8_coding_bits[] =
+ {0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+  0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
+  0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
+  0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
+  0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
+  0x00, 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
+  0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
+  0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+  0x07, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
diff --git a/lexer.gen.c b/lexer.gen.c
new file mode 100644
index 00000000..a2f55400
--- /dev/null
+++ b/lexer.gen.c
@@ -0,0 +1,2296 @@
+#line 2 "lexer.gen.c"
+
+#line 4 "lexer.gen.c"
+
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 5
+#define YY_FLEX_SUBMINOR_VERSION 35
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* end standard C headers. */
+
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types. 
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t; 
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+#ifdef __cplusplus
+
+/* The "const" storage-class-modifier is valid. */
+#define YY_USE_CONST
+
+#else	/* ! __cplusplus */
+
+/* C99 requires __STDC__ to be defined as 1. */
+#if defined (__STDC__)
+
+#define YY_USE_CONST
+
+#endif	/* defined (__STDC__) */
+#endif	/* ! __cplusplus */
+
+#ifdef YY_USE_CONST
+#define yyconst const
+#else
+#define yyconst
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an unsigned
+ * integer for use as an array index.  If the signed char is negative,
+ * we want to instead treat it as an 8-bit unsigned char, hence the
+ * double cast.
+ */
+#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void* yyscan_t;
+#endif
+
+/* For convenience, these vars (plus the bison vars far below)
+   are macros in the reentrant scanner. */
+#define yyin yyg->yyin_r
+#define yyout yyg->yyout_r
+#define yyextra yyg->yyextra_r
+#define yyleng yyg->yyleng_r
+#define yytext yyg->yytext_r
+#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
+#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
+#define yy_flex_debug yyg->yy_flex_debug_r
+
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN yyg->yy_start = 1 + 2 *
+
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START ((yyg->yy_start - 1) / 2)
+#define YYSTATE YY_START
+
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE jq_yyrestart(yyin ,yyscanner )
+
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+/* The state buf must be large enough to hold one state per character in the main buffer.
+ */
+#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+    #define YY_LESS_LINENO(n)
+    
+/* Return all but the first "n" matched characters back to the input stream. */
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		*yy_cp = yyg->yy_hold_char; \
+		YY_RESTORE_YY_MORE_OFFSET \
+		yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+		} \
+	while ( 0 )
+
+#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+	{
+	FILE *yy_input_file;
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	yy_size_t yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
+
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+    
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
+
+	int yy_buffer_status;
+
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+	/* When an EOF's been seen but there's still some text to process
+	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+	 * shouldn't try reading from the input source any more.  We might
+	 * still have a bunch of tokens to match, though, because of
+	 * possible backing-up.
+	 *
+	 * When we actually see the EOF, we change the status to "new"
+	 * (via jq_yyrestart()), so that the user can continue scanning by
+	 * just pointing yyin at a new input file.
+	 */
+#define YY_BUFFER_EOF_PENDING 2
+
+	};
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ *
+ * Returns the top of the stack, or NULL.
+ */
+#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
+                          ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
+                          : NULL)
+
+/* Same as previous macro, but useful when we know that the buffer stack is not
+ * NULL or when we need an lvalue. For internal use only.
+ */
+#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
+
+void jq_yyrestart (FILE *input_file ,yyscan_t yyscanner );
+void jq_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
+YY_BUFFER_STATE jq_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
+void jq_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
+void jq_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
+void jq_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
+void jq_yypop_buffer_state (yyscan_t yyscanner );
+
+static void jq_yyensure_buffer_stack (yyscan_t yyscanner );
+static void jq_yy_load_buffer_state (yyscan_t yyscanner );
+static void jq_yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
+
+#define YY_FLUSH_BUFFER jq_yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
+
+YY_BUFFER_STATE jq_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
+YY_BUFFER_STATE jq_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
+YY_BUFFER_STATE jq_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
+
+void *jq_yyalloc (yy_size_t ,yyscan_t yyscanner );
+void *jq_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
+void jq_yyfree (void * ,yyscan_t yyscanner );
+
+#define yy_new_buffer jq_yy_create_buffer
+
+#define yy_set_interactive(is_interactive) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){ \
+        jq_yyensure_buffer_stack (yyscanner); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            jq_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+	}
+
+#define yy_set_bol(at_bol) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){\
+        jq_yyensure_buffer_stack (yyscanner); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            jq_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+	}
+
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+/* Begin user sect3 */
+
+#define jq_yywrap(n) 1
+#define YY_SKIP_YYWRAP
+
+typedef unsigned char YY_CHAR;
+
+typedef int yy_state_type;
+
+#define yytext_ptr yytext_r
+
+static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
+static yy_state_type yy_try_NUL_trans (yy_state_type current_state  ,yyscan_t yyscanner);
+static int yy_get_next_buffer (yyscan_t yyscanner );
+static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+	yyg->yytext_ptr = yy_bp; \
+	yyleng = (size_t) (yy_cp - yy_bp); \
+	yyg->yy_hold_char = *yy_cp; \
+	*yy_cp = '\0'; \
+	yyg->yy_c_buf_p = yy_cp;
+
+#define YY_NUM_RULES 33
+#define YY_END_OF_BUFFER 34
+/* This struct is not used in this scanner,
+   but its presence is necessary. */
+struct yy_trans_info
+	{
+	flex_int32_t yy_verify;
+	flex_int32_t yy_nxt;
+	};
+static yyconst flex_int16_t yy_accept[84] =
+    {   0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,   34,   32,   31,   31,   24,   20,   21,   22,
+       20,   20,   20,   20,   20,   23,   20,   20,   20,   30,
+       30,   30,   30,   30,   30,   30,   20,   28,   28,   26,
+       29,   31,   15,   13,   23,   14,    0,   11,   16,   18,
+        1,   19,   30,   30,    2,   30,   30,   30,    4,    9,
+       30,   12,   28,   27,   25,   27,    0,   23,   17,    8,
+        3,   30,   30,   10,   30,    0,   27,    7,    6,    5,
+       27,   27,    0
+    } ;
+
+static yyconst flex_int32_t yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    2,    1,    4,    1,    5,    1,    1,    1,    6,
+        7,    8,    9,   10,   11,   12,   13,   14,   14,   14,
+       14,   14,   14,   14,   14,   14,   14,   15,   16,   17,
+       18,   19,    1,    1,   20,   20,   20,   20,   21,   20,
+       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
+       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
+       22,   23,   24,    1,   25,    1,   26,   20,   20,   27,
+
+       28,   29,   20,   30,   31,   20,   20,   32,   20,   33,
+       34,   20,   20,   35,   36,   37,   38,   20,   20,   20,
+       20,   20,   39,   40,   41,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1
+    } ;
+
+static yyconst flex_int32_t yy_meta[42] =
+    {   0,
+        1,    1,    1,    2,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    3,    1,    1,    1,    1,    1,    3,
+        3,    1,    4,    1,    5,    3,    3,    3,    3,    3,
+        3,    3,    3,    3,    3,    3,    3,    3,    1,    1,
+        1
+    } ;
+
+static yyconst flex_int16_t yy_base[92] =
+    {   0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+       39,   41,  132,  133,   44,   46,  133,  133,  133,  133,
+      113,   98,   38,   39,   41,   49,   96,   93,   85,    0,
+       22,   74,   33,   72,   65,   69,   80,    0,    0,  133,
+       51,   66,  133,  133,   59,  133,   65,   79,  133,  133,
+      133,  133,    0,   69,    0,   66,   47,   67,    0,    0,
+       65,  133,    0,   69,  133,   68,   76,   74,  133,    0,
+        0,   57,   57,    0,   51,   66,   59,    0,    0,    0,
+       58,   52,  133,  104,  107,  112,  117,  120,  122,  124,
+      126
+
+    } ;
+
+static yyconst flex_int16_t yy_def[92] =
+    {   0,
+       83,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+       84,   84,   83,   83,   83,   83,   83,   83,   83,   83,
+       83,   83,   83,   83,   83,   83,   83,   83,   83,   85,
+       85,   85,   85,   85,   85,   85,   83,   86,   86,   83,
+       87,   83,   83,   83,   83,   83,   83,   83,   83,   83,
+       83,   83,   85,   85,   85,   85,   85,   85,   85,   85,
+       85,   83,   86,   83,   83,   88,   83,   83,   83,   85,
+       85,   85,   85,   85,   85,   87,   89,   85,   85,   85,
+       90,   91,    0,   83,   83,   83,   83,   83,   83,   83,
+       83
+
+    } ;
+
+static yyconst flex_int16_t yy_nxt[175] =
+    {   0,
+       14,   15,   16,   17,   18,   19,   20,   21,   22,   18,
+       23,   24,   25,   26,   18,   18,   27,   28,   29,   30,
+       30,   19,   14,   20,   30,   31,   32,   33,   30,   30,
+       34,   30,   30,   35,   30,   30,   36,   30,   19,   37,
+       20,   39,   40,   39,   40,   42,   42,   42,   42,   45,
+       45,   45,   45,   48,   54,   46,   65,   55,   49,   47,
+       45,   41,   45,   41,   57,   58,   47,   42,   42,   47,
+       45,   83,   45,   67,   76,   67,   47,   72,   68,   47,
+       76,   76,   73,   80,   79,   78,   47,   68,   66,   68,
+       76,   76,   75,   74,   71,   70,   69,   62,   61,   60,
+
+       59,   56,   52,   66,   38,   38,   38,   38,   38,   53,
+       51,   53,   63,   50,   63,   44,   63,   64,   64,   64,
+       64,   64,   77,   77,   81,   81,   82,   82,   64,   64,
+       43,   83,   13,   83,   83,   83,   83,   83,   83,   83,
+       83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
+       83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
+       83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
+       83,   83,   83,   83
+    } ;
+
+static yyconst flex_int16_t yy_chk[175] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,   11,   11,   12,   12,   15,   15,   16,   16,   23,
+       24,   23,   24,   25,   31,   23,   41,   31,   25,   24,
+       26,   11,   26,   12,   33,   33,   24,   42,   42,   26,
+       45,   76,   45,   47,   82,   47,   26,   57,   47,   45,
+       81,   77,   57,   75,   73,   72,   45,   68,   41,   67,
+       66,   64,   61,   58,   56,   54,   48,   37,   36,   35,
+
+       34,   32,   29,   76,   84,   84,   84,   84,   84,   85,
+       28,   85,   86,   27,   86,   22,   86,   87,   87,   87,
+       87,   87,   88,   88,   89,   89,   90,   90,   91,   91,
+       21,   13,   83,   83,   83,   83,   83,   83,   83,   83,
+       83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
+       83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
+       83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
+       83,   83,   83,   83
+    } ;
+
+/* The intent behind this definition is that it'll catch
+ * any uses of REJECT which flex missed.
+ */
+#define REJECT reject_used_but_not_detected
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
+#line 1 "lexer.l"
+#line 2 "lexer.l"
+#include "compile.h"
+#include "parser.gen.h"  /* Generated by bison. */
+
+#define YY_USER_ACTION                           \
+  do {                                           \
+    yylloc->start = jq_yyget_extra(yyscanner);      \
+    yylloc->end = yylloc->start + yyleng;        \
+    jq_yyset_extra(yylloc->end,yyscanner);         \
+  } while (0);
+
+
+
+
+
+
+#line 20 "lexer.l"
+  static int enter(int opening, int state, yyscan_t yyscanner);
+  static int try_exit(int closing, int state, yyscan_t yyscanner);
+#define YY_NO_INPUT 1
+#line 529 "lexer.gen.c"
+
+#define INITIAL 0
+#define IN_PAREN 1
+#define IN_BRACKET 2
+#define IN_BRACE 3
+#define IN_QQINTERP 4
+#define IN_QQSTRING 5
+
+#ifndef YY_NO_UNISTD_H
+/* Special case for "unistd.h", since it is non-ANSI. We include it way
+ * down here because we want the user's section 1 to have been scanned first.
+ * The user has a chance to override it with an option.
+ */
+#include <unistd.h>
+#endif
+
+#define YY_EXTRA_TYPE int
+
+/* Holds the entire state of the reentrant scanner. */
+struct yyguts_t
+    {
+
+    /* User-defined. Not touched by flex. */
+    YY_EXTRA_TYPE yyextra_r;
+
+    /* The rest are the same as the globals declared in the non-reentrant scanner. */
+    FILE *yyin_r, *yyout_r;
+    size_t yy_buffer_stack_top; /**< index of top of stack. */
+    size_t yy_buffer_stack_max; /**< capacity of stack. */
+    YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
+    char yy_hold_char;
+    int yy_n_chars;
+    int yyleng_r;
+    char *yy_c_buf_p;
+    int yy_init;
+    int yy_start;
+    int yy_did_buffer_switch_on_eof;
+    int yy_start_stack_ptr;
+    int yy_start_stack_depth;
+    int *yy_start_stack;
+    yy_state_type yy_last_accepting_state;
+    char* yy_last_accepting_cpos;
+
+    int yylineno_r;
+    int yy_flex_debug_r;
+
+    char *yytext_r;
+    int yy_more_flag;
+    int yy_more_len;
+
+    YYSTYPE * yylval_r;
+
+    YYLTYPE * yylloc_r;
+
+    }; /* end struct yyguts_t */
+
+static int yy_init_globals (yyscan_t yyscanner );
+
+    /* This must go here because YYSTYPE and YYLTYPE are included
+     * from bison output in section 1.*/
+    #    define yylval yyg->yylval_r
+    
+    #    define yylloc yyg->yylloc_r
+    
+int jq_yylex_init (yyscan_t* scanner);
+
+int jq_yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
+
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+int jq_yylex_destroy (yyscan_t yyscanner );
+
+int jq_yyget_debug (yyscan_t yyscanner );
+
+void jq_yyset_debug (int debug_flag ,yyscan_t yyscanner );
+
+YY_EXTRA_TYPE jq_yyget_extra (yyscan_t yyscanner );
+
+void jq_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
+
+FILE *jq_yyget_in (yyscan_t yyscanner );
+
+void jq_yyset_in  (FILE * in_str ,yyscan_t yyscanner );
+
+FILE *jq_yyget_out (yyscan_t yyscanner );
+
+void jq_yyset_out  (FILE * out_str ,yyscan_t yyscanner );
+
+int jq_yyget_leng (yyscan_t yyscanner );
+
+char *jq_yyget_text (yyscan_t yyscanner );
+
+int jq_yyget_lineno (yyscan_t yyscanner );
+
+void jq_yyset_lineno (int line_number ,yyscan_t yyscanner );
+
+YYSTYPE * jq_yyget_lval (yyscan_t yyscanner );
+
+void jq_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
+
+       YYLTYPE *jq_yyget_lloc (yyscan_t yyscanner );
+    
+        void jq_yyset_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner );
+    
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int jq_yywrap (yyscan_t yyscanner );
+#else
+extern int jq_yywrap (yyscan_t yyscanner );
+#endif
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
+#endif
+
+#ifndef YY_NO_INPUT
+
+#ifdef __cplusplus
+static int yyinput (yyscan_t yyscanner );
+#else
+static int input (yyscan_t yyscanner );
+#endif
+
+#endif
+
+    static void yy_push_state (int new_state ,yyscan_t yyscanner);
+    
+    static void yy_pop_state (yyscan_t yyscanner );
+    
+    static int yy_top_state (yyscan_t yyscanner );
+    
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+#ifndef ECHO
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
+#endif
+
+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
+		{ \
+		int c = '*'; \
+		size_t n; \
+		for ( n = 0; n < max_size && \
+			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+			buf[n] = (char) c; \
+		if ( c == '\n' ) \
+			buf[n++] = (char) c; \
+		if ( c == EOF && ferror( yyin ) ) \
+			YY_FATAL_ERROR( "input in flex scanner failed" ); \
+		result = n; \
+		} \
+	else \
+		{ \
+		errno=0; \
+		while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
+			{ \
+			if( errno != EINTR) \
+				{ \
+				YY_FATAL_ERROR( "input in flex scanner failed" ); \
+				break; \
+				} \
+			errno=0; \
+			clearerr(yyin); \
+			} \
+		}\
+\
+
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
+#endif
+
+/* end tables serialization structures and prototypes */
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+
+extern int jq_yylex \
+               (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner);
+
+#define YY_DECL int jq_yylex \
+               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
+#endif /* !YY_DECL */
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK break;
+#endif
+
+#define YY_RULE_SETUP \
+	YY_USER_ACTION
+
+/** The main scanner function which does all the work.
+ */
+YY_DECL
+{
+	register yy_state_type yy_current_state;
+	register char *yy_cp, *yy_bp;
+	register int yy_act;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+#line 32 "lexer.l"
+
+
+#line 785 "lexer.gen.c"
+
+    yylval = yylval_param;
+
+    yylloc = yylloc_param;
+
+	if ( !yyg->yy_init )
+		{
+		yyg->yy_init = 1;
+
+#ifdef YY_USER_INIT
+		YY_USER_INIT;
+#endif
+
+		if ( ! yyg->yy_start )
+			yyg->yy_start = 1;	/* first start state */
+
+		if ( ! yyin )
+			yyin = stdin;
+
+		if ( ! yyout )
+			yyout = stdout;
+
+		if ( ! YY_CURRENT_BUFFER ) {
+			jq_yyensure_buffer_stack (yyscanner);
+			YY_CURRENT_BUFFER_LVALUE =
+				jq_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
+		}
+
+		jq_yy_load_buffer_state(yyscanner );
+		}
+
+	while ( 1 )		/* loops until end-of-file is reached */
+		{
+		yy_cp = yyg->yy_c_buf_p;
+
+		/* Support of yytext. */
+		*yy_cp = yyg->yy_hold_char;
+
+		/* yy_bp points to the position in yy_ch_buf of the start of
+		 * the current run.
+		 */
+		yy_bp = yy_cp;
+
+		yy_current_state = yyg->yy_start;
+yy_match:
+		do
+			{
+			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
+			if ( yy_accept[yy_current_state] )
+				{
+				yyg->yy_last_accepting_state = yy_current_state;
+				yyg->yy_last_accepting_cpos = yy_cp;
+				}
+			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+				{
+				yy_current_state = (int) yy_def[yy_current_state];
+				if ( yy_current_state >= 84 )
+					yy_c = yy_meta[(unsigned int) yy_c];
+				}
+			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+			++yy_cp;
+			}
+		while ( yy_base[yy_current_state] != 133 );
+
+yy_find_action:
+		yy_act = yy_accept[yy_current_state];
+		if ( yy_act == 0 )
+			{ /* have to back up */
+			yy_cp = yyg->yy_last_accepting_cpos;
+			yy_current_state = yyg->yy_last_accepting_state;
+			yy_act = yy_accept[yy_current_state];
+			}
+
+		YY_DO_BEFORE_ACTION;
+
+do_action:	/* This label is used only to access EOF actions. */
+
+		switch ( yy_act )
+	{ /* beginning of action switch */
+			case 0: /* must back up */
+			/* undo the effects of YY_DO_BEFORE_ACTION */
+			*yy_cp = yyg->yy_hold_char;
+			yy_cp = yyg->yy_last_accepting_cpos;
+			yy_current_state = yyg->yy_last_accepting_state;
+			goto yy_find_action;
+
+case 1:
+YY_RULE_SETUP
+#line 34 "lexer.l"
+{ return EQ; }
+	YY_BREAK
+case 2:
+YY_RULE_SETUP
+#line 35 "lexer.l"
+{ return AS; }
+	YY_BREAK
+case 3:
+YY_RULE_SETUP
+#line 36 "lexer.l"
+{ return DEF; }
+	YY_BREAK
+case 4:
+YY_RULE_SETUP
+#line 37 "lexer.l"
+{ return IF; }
+	YY_BREAK
+case 5:
+YY_RULE_SETUP
+#line 38 "lexer.l"
+{ return THEN; }
+	YY_BREAK
+case 6:
+YY_RULE_SETUP
+#line 39 "lexer.l"
+{ return ELSE; }
+	YY_BREAK
+case 7:
+YY_RULE_SETUP
+#line 40 "lexer.l"
+{ return ELSE_IF; }
+	YY_BREAK
+case 8:
+YY_RULE_SETUP
+#line 41 "lexer.l"
+{ return AND; }
+	YY_BREAK
+case 9:
+YY_RULE_SETUP
+#line 42 "lexer.l"
+{ return OR; }
+	YY_BREAK
+case 10:
+YY_RULE_SETUP
+#line 43 "lexer.l"
+{ return END; }
+	YY_BREAK
+case 11:
+YY_RULE_SETUP
+#line 44 "lexer.l"
+{ return DEFINEDOR; }
+	YY_BREAK
+case 12:
+YY_RULE_SETUP
+#line 45 "lexer.l"
+{ return SETPIPE; }
+	YY_BREAK
+case 13:
+YY_RULE_SETUP
+#line 46 "lexer.l"
+{ return SETPLUS; }
+	YY_BREAK
+case 14:
+YY_RULE_SETUP
+#line 47 "lexer.l"
+{ return SETMINUS; }
+	YY_BREAK
+case 15:
+YY_RULE_SETUP
+#line 48 "lexer.l"
+{ return SETMULT; }
+	YY_BREAK
+case 16:
+YY_RULE_SETUP
+#line 49 "lexer.l"
+{ return SETDIV; }
+	YY_BREAK
+case 17:
+YY_RULE_SETUP
+#line 50 "lexer.l"
+{ return SETDEFINEDOR; }
+	YY_BREAK
+case 18:
+YY_RULE_SETUP
+#line 51 "lexer.l"
+{ return LESSEQ; }
+	YY_BREAK
+case 19:
+YY_RULE_SETUP
+#line 52 "lexer.l"
+{ return GREATEREQ; }
+	YY_BREAK
+case 20:
+YY_RULE_SETUP
+#line 53 "lexer.l"
+{ return yytext[0];}
+	YY_BREAK
+case 21:
+YY_RULE_SETUP
+#line 55 "lexer.l"
+{
+  return enter(yytext[0], YY_START, yyscanner);
+}
+	YY_BREAK
+case 22:
+YY_RULE_SETUP
+#line 59 "lexer.l"
+{
+  return try_exit(yytext[0], YY_START, yyscanner);
+}
+	YY_BREAK
+case 23:
+YY_RULE_SETUP
+#line 64 "lexer.l"
+{ 
+   yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; 
+}
+	YY_BREAK
+case 24:
+YY_RULE_SETUP
+#line 68 "lexer.l"
+{
+  yy_push_state(IN_QQSTRING, yyscanner);
+  return QQSTRING_START;
+}
+	YY_BREAK
+
+case 25:
+YY_RULE_SETUP
+#line 74 "lexer.l"
+{
+    return enter(QQSTRING_INTERP_START, YY_START, yyscanner);
+  }
+	YY_BREAK
+case 26:
+YY_RULE_SETUP
+#line 77 "lexer.l"
+{
+    yy_pop_state(yyscanner);
+    return QQSTRING_END;
+  }
+	YY_BREAK
+case 27:
+/* rule 27 can match eol */
+YY_RULE_SETUP
+#line 81 "lexer.l"
+{
+    /* pass escapes to the json parser */
+    jv escapes = jv_string_fmt("\"%.*s\"", yyleng, yytext);
+    yylval->literal = jv_parse_sized(jv_string_value(escapes), jv_string_length(jv_copy(escapes)));
+    jv_free(escapes);
+    return QQSTRING_TEXT;
+  }
+	YY_BREAK
+case 28:
+/* rule 28 can match eol */
+YY_RULE_SETUP
+#line 88 "lexer.l"
+{
+    yylval->literal = jv_string_sized(yytext, yyleng);
+    return QQSTRING_TEXT;
+  }
+	YY_BREAK
+case 29:
+YY_RULE_SETUP
+#line 92 "lexer.l"
+{
+    return INVALID_CHARACTER;
+  }
+	YY_BREAK
+
+case 30:
+YY_RULE_SETUP
+#line 98 "lexer.l"
+{ yylval->literal = jv_string(yytext); return IDENT;}
+	YY_BREAK
+case 31:
+/* rule 31 can match eol */
+YY_RULE_SETUP
+#line 100 "lexer.l"
+{}
+	YY_BREAK
+case 32:
+YY_RULE_SETUP
+#line 102 "lexer.l"
+{ return INVALID_CHARACTER; }
+	YY_BREAK
+case 33:
+YY_RULE_SETUP
+#line 104 "lexer.l"
+YY_FATAL_ERROR( "flex scanner jammed" );
+	YY_BREAK
+#line 1067 "lexer.gen.c"
+case YY_STATE_EOF(INITIAL):
+case YY_STATE_EOF(IN_PAREN):
+case YY_STATE_EOF(IN_BRACKET):
+case YY_STATE_EOF(IN_BRACE):
+case YY_STATE_EOF(IN_QQINTERP):
+case YY_STATE_EOF(IN_QQSTRING):
+	yyterminate();
+
+	case YY_END_OF_BUFFER:
+		{
+		/* Amount of text matched not including the EOB char. */
+		int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
+
+		/* Undo the effects of YY_DO_BEFORE_ACTION. */
+		*yy_cp = yyg->yy_hold_char;
+		YY_RESTORE_YY_MORE_OFFSET
+
+		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
+			{
+			/* We're scanning a new file or input source.  It's
+			 * possible that this happened because the user
+			 * just pointed yyin at a new source and called
+			 * jq_yylex().  If so, then we have to assure
+			 * consistency between YY_CURRENT_BUFFER and our
+			 * globals.  Here is the right place to do so, because
+			 * this is the first action (other than possibly a
+			 * back-up) that will match for the new input source.
+			 */
+			yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
+			}
+
+		/* Note that here we test for yy_c_buf_p "<=" to the position
+		 * of the first EOB in the buffer, since yy_c_buf_p will
+		 * already have been incremented past the NUL character
+		 * (since all states make transitions on EOB to the
+		 * end-of-buffer state).  Contrast this with the test
+		 * in input().
+		 */
+		if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
+			{ /* This was really a NUL. */
+			yy_state_type yy_next_state;
+
+			yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
+
+			yy_current_state = yy_get_previous_state( yyscanner );
+
+			/* Okay, we're now positioned to make the NUL
+			 * transition.  We couldn't have
+			 * yy_get_previous_state() go ahead and do it
+			 * for us because it doesn't know how to deal
+			 * with the possibility of jamming (and we don't
+			 * want to build jamming into it because then it
+			 * will run more slowly).
+			 */
+
+			yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
+
+			yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+
+			if ( yy_next_state )
+				{
+				/* Consume the NUL. */
+				yy_cp = ++yyg->yy_c_buf_p;
+				yy_current_state = yy_next_state;
+				goto yy_match;
+				}
+
+			else
+				{
+				yy_cp = yyg->yy_c_buf_p;
+				goto yy_find_action;
+				}
+			}
+
+		else switch ( yy_get_next_buffer( yyscanner ) )
+			{
+			case EOB_ACT_END_OF_FILE:
+				{
+				yyg->yy_did_buffer_switch_on_eof = 0;
+
+				if ( jq_yywrap(yyscanner ) )
+					{
+					/* Note: because we've taken care in
+					 * yy_get_next_buffer() to have set up
+					 * yytext, we can now set up
+					 * yy_c_buf_p so that if some total
+					 * hoser (like flex itself) wants to
+					 * call the scanner after we return the
+					 * YY_NULL, it'll still work - another
+					 * YY_NULL will get returned.
+					 */
+					yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
+
+					yy_act = YY_STATE_EOF(YY_START);
+					goto do_action;
+					}
+
+				else
+					{
+					if ( ! yyg->yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+					}
+				break;
+				}
+
+			case EOB_ACT_CONTINUE_SCAN:
+				yyg->yy_c_buf_p =
+					yyg->yytext_ptr + yy_amount_of_matched_text;
+
+				yy_current_state = yy_get_previous_state( yyscanner );
+
+				yy_cp = yyg->yy_c_buf_p;
+				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+				goto yy_match;
+
+			case EOB_ACT_LAST_MATCH:
+				yyg->yy_c_buf_p =
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
+
+				yy_current_state = yy_get_previous_state( yyscanner );
+
+				yy_cp = yyg->yy_c_buf_p;
+				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+				goto yy_find_action;
+			}
+		break;
+		}
+
+	default:
+		YY_FATAL_ERROR(
+			"fatal flex scanner internal error--no action found" );
+	} /* end of action switch */
+		} /* end of scanning one token */
+} /* end of jq_yylex */
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+ *	EOB_ACT_LAST_MATCH -
+ *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *	EOB_ACT_END_OF_FILE - end of file
+ */
+static int yy_get_next_buffer (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+	register char *source = yyg->yytext_ptr;
+	register int number_to_move, i;
+	int ret_val;
+
+	if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
+		YY_FATAL_ERROR(
+		"fatal flex scanner internal error--end of buffer missed" );
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
+		{ /* Don't try to fill the buffer, so this is an EOF. */
+		if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
+			{
+			/* We matched a single character, the EOB, so
+			 * treat this as a final EOF.
+			 */
+			return EOB_ACT_END_OF_FILE;
+			}
+
+		else
+			{
+			/* We matched some text prior to the EOB, first
+			 * process it.
+			 */
+			return EOB_ACT_LAST_MATCH;
+			}
+		}
+
+	/* Try to read more data. */
+
+	/* First move last chars to start of buffer. */
+	number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
+
+	for ( i = 0; i < number_to_move; ++i )
+		*(dest++) = *(source++);
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+		/* don't do the read, it's not guaranteed to return an EOF,
+		 * just force an EOF
+		 */
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
+
+	else
+		{
+			int num_to_read =
+			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
+
+		while ( num_to_read <= 0 )
+			{ /* Not enough room in the buffer - grow it. */
+
+			/* just a shorter name for the current buffer */
+			YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
+
+			int yy_c_buf_p_offset =
+				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);
+
+			if ( b->yy_is_our_buffer )
+				{
+				int new_size = b->yy_buf_size * 2;
+
+				if ( new_size <= 0 )
+					b->yy_buf_size += b->yy_buf_size / 8;
+				else
+					b->yy_buf_size *= 2;
+
+				b->yy_ch_buf = (char *)
+					/* Include room in for 2 EOB chars. */
+					jq_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
+				}
+			else
+				/* Can't grow it, we don't own it. */
+				b->yy_ch_buf = 0;
+
+			if ( ! b->yy_ch_buf )
+				YY_FATAL_ERROR(
+				"fatal error - scanner input buffer overflow" );
+
+			yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+						number_to_move - 1;
+
+			}
+
+		if ( num_to_read > YY_READ_BUF_SIZE )
+			num_to_read = YY_READ_BUF_SIZE;
+
+		/* Read in more data. */
+		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+			yyg->yy_n_chars, (size_t) num_to_read );
+
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+		}
+
+	if ( yyg->yy_n_chars == 0 )
+		{
+		if ( number_to_move == YY_MORE_ADJ )
+			{
+			ret_val = EOB_ACT_END_OF_FILE;
+			jq_yyrestart(yyin  ,yyscanner);
+			}
+
+		else
+			{
+			ret_val = EOB_ACT_LAST_MATCH;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
+				YY_BUFFER_EOF_PENDING;
+			}
+		}
+
+	else
+		ret_val = EOB_ACT_CONTINUE_SCAN;
+
+	if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+		/* Extend the array by 50%, plus the number we really need. */
+		yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
+		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) jq_yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
+		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+	}
+
+	yyg->yy_n_chars += number_to_move;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+
+	yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
+
+	return ret_val;
+}
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+    static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
+{
+	register yy_state_type yy_current_state;
+	register char *yy_cp;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	yy_current_state = yyg->yy_start;
+
+	for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
+		{
+		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+		if ( yy_accept[yy_current_state] )
+			{
+			yyg->yy_last_accepting_state = yy_current_state;
+			yyg->yy_last_accepting_cpos = yy_cp;
+			}
+		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+			{
+			yy_current_state = (int) yy_def[yy_current_state];
+			if ( yy_current_state >= 84 )
+				yy_c = yy_meta[(unsigned int) yy_c];
+			}
+		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+		}
+
+	return yy_current_state;
+}
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+ *	next_state = yy_try_NUL_trans( current_state );
+ */
+    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
+{
+	register int yy_is_jam;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
+	register char *yy_cp = yyg->yy_c_buf_p;
+
+	register YY_CHAR yy_c = 1;
+	if ( yy_accept[yy_current_state] )
+		{
+		yyg->yy_last_accepting_state = yy_current_state;
+		yyg->yy_last_accepting_cpos = yy_cp;
+		}
+	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+		{
+		yy_current_state = (int) yy_def[yy_current_state];
+		if ( yy_current_state >= 84 )
+			yy_c = yy_meta[(unsigned int) yy_c];
+		}
+	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+	yy_is_jam = (yy_current_state == 83);
+
+	return yy_is_jam ? 0 : yy_current_state;
+}
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+    static int yyinput (yyscan_t yyscanner)
+#else
+    static int input  (yyscan_t yyscanner)
+#endif
+
+{
+	int c;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	*yyg->yy_c_buf_p = yyg->yy_hold_char;
+
+	if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+		{
+		/* yy_c_buf_p now points to the character we want to return.
+		 * If this occurs *before* the EOB characters, then it's a
+		 * valid NUL; if not, then we've hit the end of the buffer.
+		 */
+		if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
+			/* This was really a NUL. */
+			*yyg->yy_c_buf_p = '\0';
+
+		else
+			{ /* need more input */
+			int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
+			++yyg->yy_c_buf_p;
+
+			switch ( yy_get_next_buffer( yyscanner ) )
+				{
+				case EOB_ACT_LAST_MATCH:
+					/* This happens because yy_g_n_b()
+					 * sees that we've accumulated a
+					 * token and flags that we need to
+					 * try matching the token before
+					 * proceeding.  But for input(),
+					 * there's no matching to consider.
+					 * So convert the EOB_ACT_LAST_MATCH
+					 * to EOB_ACT_END_OF_FILE.
+					 */
+
+					/* Reset buffer status. */
+					jq_yyrestart(yyin ,yyscanner);
+
+					/*FALLTHROUGH*/
+
+				case EOB_ACT_END_OF_FILE:
+					{
+					if ( jq_yywrap(yyscanner ) )
+						return EOF;
+
+					if ( ! yyg->yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+#ifdef __cplusplus
+					return yyinput(yyscanner);
+#else
+					return input(yyscanner);
+#endif
+					}
+
+				case EOB_ACT_CONTINUE_SCAN:
+					yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
+					break;
+				}
+			}
+		}
+
+	c = *(unsigned char *) yyg->yy_c_buf_p;	/* cast for 8-bit char's */
+	*yyg->yy_c_buf_p = '\0';	/* preserve yytext */
+	yyg->yy_hold_char = *++yyg->yy_c_buf_p;
+
+	return c;
+}
+#endif	/* ifndef YY_NO_INPUT */
+
+/** Immediately switch to a different input stream.
+ * @param input_file A readable stream.
+ * @param yyscanner The scanner object.
+ * @note This function does not reset the start condition to @c INITIAL .
+ */
+    void jq_yyrestart  (FILE * input_file , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if ( ! YY_CURRENT_BUFFER ){
+        jq_yyensure_buffer_stack (yyscanner);
+		YY_CURRENT_BUFFER_LVALUE =
+            jq_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
+	}
+
+	jq_yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
+	jq_yy_load_buffer_state(yyscanner );
+}
+
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ * @param yyscanner The scanner object.
+ */
+    void jq_yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	/* TODO. We should be able to replace this entire function body
+	 * with
+	 *		jq_yypop_buffer_state();
+	 *		jq_yypush_buffer_state(new_buffer);
+     */
+	jq_yyensure_buffer_stack (yyscanner);
+	if ( YY_CURRENT_BUFFER == new_buffer )
+		return;
+
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*yyg->yy_c_buf_p = yyg->yy_hold_char;
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+		}
+
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+	jq_yy_load_buffer_state(yyscanner );
+
+	/* We don't actually know whether we did this switch during
+	 * EOF (jq_yywrap()) processing, but the only time this flag
+	 * is looked at is after jq_yywrap() is called, so it's safe
+	 * to go ahead and always set it.
+	 */
+	yyg->yy_did_buffer_switch_on_eof = 1;
+}
+
+static void jq_yy_load_buffer_state  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+	yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+	yyg->yy_hold_char = *yyg->yy_c_buf_p;
+}
+
+/** Allocate and initialize an input buffer state.
+ * @param file A readable stream.
+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
+ * @param yyscanner The scanner object.
+ * @return the allocated buffer state.
+ */
+    YY_BUFFER_STATE jq_yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
+{
+	YY_BUFFER_STATE b;
+    
+	b = (YY_BUFFER_STATE) jq_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in jq_yy_create_buffer()" );
+
+	b->yy_buf_size = size;
+
+	/* yy_ch_buf has to be 2 characters longer than the size given because
+	 * we need to put in 2 end-of-buffer characters.
+	 */
+	b->yy_ch_buf = (char *) jq_yyalloc(b->yy_buf_size + 2 ,yyscanner );
+	if ( ! b->yy_ch_buf )
+		YY_FATAL_ERROR( "out of dynamic memory in jq_yy_create_buffer()" );
+
+	b->yy_is_our_buffer = 1;
+
+	jq_yy_init_buffer(b,file ,yyscanner);
+
+	return b;
+}
+
+/** Destroy the buffer.
+ * @param b a buffer created with jq_yy_create_buffer()
+ * @param yyscanner The scanner object.
+ */
+    void jq_yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if ( ! b )
+		return;
+
+	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
+		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
+
+	if ( b->yy_is_our_buffer )
+		jq_yyfree((void *) b->yy_ch_buf ,yyscanner );
+
+	jq_yyfree((void *) b ,yyscanner );
+}
+
+#ifndef __cplusplus
+extern int isatty (int );
+#endif /* __cplusplus */
+    
+/* Initializes or reinitializes a buffer.
+ * This function is sometimes called more than once on the same buffer,
+ * such as during a jq_yyrestart() or at EOF.
+ */
+    static void jq_yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
+
+{
+	int oerrno = errno;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	jq_yy_flush_buffer(b ,yyscanner);
+
+	b->yy_input_file = file;
+	b->yy_fill_buffer = 1;
+
+    /* If b is the current buffer, then jq_yy_init_buffer was _probably_
+     * called from jq_yyrestart() or through yy_get_next_buffer.
+     * In that case, we don't want to reset the lineno or column.
+     */
+    if (b != YY_CURRENT_BUFFER){
+        b->yy_bs_lineno = 1;
+        b->yy_bs_column = 0;
+    }
+
+        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+    
+	errno = oerrno;
+}
+
+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
+ * @param yyscanner The scanner object.
+ */
+    void jq_yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if ( ! b )
+		return;
+
+	b->yy_n_chars = 0;
+
+	/* We always need two end-of-buffer characters.  The first causes
+	 * a transition to the end-of-buffer state.  The second causes
+	 * a jam in that state.
+	 */
+	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+
+	b->yy_buf_pos = &b->yy_ch_buf[0];
+
+	b->yy_at_bol = 1;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	if ( b == YY_CURRENT_BUFFER )
+		jq_yy_load_buffer_state(yyscanner );
+}
+
+/** Pushes the new state onto the stack. The new state becomes
+ *  the current state. This function will allocate the stack
+ *  if necessary.
+ *  @param new_buffer The new state.
+ *  @param yyscanner The scanner object.
+ */
+void jq_yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if (new_buffer == NULL)
+		return;
+
+	jq_yyensure_buffer_stack(yyscanner);
+
+	/* This block is copied from jq_yy_switch_to_buffer. */
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*yyg->yy_c_buf_p = yyg->yy_hold_char;
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+		}
+
+	/* Only push if top exists. Otherwise, replace top. */
+	if (YY_CURRENT_BUFFER)
+		yyg->yy_buffer_stack_top++;
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+	/* copied from jq_yy_switch_to_buffer. */
+	jq_yy_load_buffer_state(yyscanner );
+	yyg->yy_did_buffer_switch_on_eof = 1;
+}
+
+/** Removes and deletes the top of the stack, if present.
+ *  The next element becomes the new top.
+ *  @param yyscanner The scanner object.
+ */
+void jq_yypop_buffer_state (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if (!YY_CURRENT_BUFFER)
+		return;
+
+	jq_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
+	YY_CURRENT_BUFFER_LVALUE = NULL;
+	if (yyg->yy_buffer_stack_top > 0)
+		--yyg->yy_buffer_stack_top;
+
+	if (YY_CURRENT_BUFFER) {
+		jq_yy_load_buffer_state(yyscanner );
+		yyg->yy_did_buffer_switch_on_eof = 1;
+	}
+}
+
+/* Allocates the stack if it does not exist.
+ *  Guarantees space for at least one push.
+ */
+static void jq_yyensure_buffer_stack (yyscan_t yyscanner)
+{
+	int num_to_alloc;
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+	if (!yyg->yy_buffer_stack) {
+
+		/* First allocation is just for 2 elements, since we don't know if this
+		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
+		 * immediate realloc on the next call.
+         */
+		num_to_alloc = 1;
+		yyg->yy_buffer_stack = (struct yy_buffer_state**)jq_yyalloc
+								(num_to_alloc * sizeof(struct yy_buffer_state*)
+								, yyscanner);
+		if ( ! yyg->yy_buffer_stack )
+			YY_FATAL_ERROR( "out of dynamic memory in jq_yyensure_buffer_stack()" );
+								  
+		memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+				
+		yyg->yy_buffer_stack_max = num_to_alloc;
+		yyg->yy_buffer_stack_top = 0;
+		return;
+	}
+
+	if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
+
+		/* Increase the buffer to prepare for a possible push. */
+		int grow_size = 8 /* arbitrary grow size */;
+
+		num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
+		yyg->yy_buffer_stack = (struct yy_buffer_state**)jq_yyrealloc
+								(yyg->yy_buffer_stack,
+								num_to_alloc * sizeof(struct yy_buffer_state*)
+								, yyscanner);
+		if ( ! yyg->yy_buffer_stack )
+			YY_FATAL_ERROR( "out of dynamic memory in jq_yyensure_buffer_stack()" );
+
+		/* zero only the new slots.*/
+		memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
+		yyg->yy_buffer_stack_max = num_to_alloc;
+	}
+}
+
+/** Setup the input buffer state to scan directly from a user-specified character buffer.
+ * @param base the character buffer
+ * @param size the size in bytes of the character buffer
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object. 
+ */
+YY_BUFFER_STATE jq_yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
+{
+	YY_BUFFER_STATE b;
+    
+	if ( size < 2 ||
+	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
+	     base[size-1] != YY_END_OF_BUFFER_CHAR )
+		/* They forgot to leave room for the EOB's. */
+		return 0;
+
+	b = (YY_BUFFER_STATE) jq_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in jq_yy_scan_buffer()" );
+
+	b->yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */
+	b->yy_buf_pos = b->yy_ch_buf = base;
+	b->yy_is_our_buffer = 0;
+	b->yy_input_file = 0;
+	b->yy_n_chars = b->yy_buf_size;
+	b->yy_is_interactive = 0;
+	b->yy_at_bol = 1;
+	b->yy_fill_buffer = 0;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	jq_yy_switch_to_buffer(b ,yyscanner );
+
+	return b;
+}
+
+/** Setup the input buffer state to scan a string. The next call to jq_yylex() will
+ * scan from a @e copy of @a str.
+ * @param yystr a NUL-terminated string to scan
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ * @note If you want to scan bytes that may contain NUL values, then use
+ *       jq_yy_scan_bytes() instead.
+ */
+YY_BUFFER_STATE jq_yy_scan_string (yyconst char * yystr , yyscan_t yyscanner)
+{
+    
+	return jq_yy_scan_bytes(yystr,strlen(yystr) ,yyscanner);
+}
+
+/** Setup the input buffer state to scan the given bytes. The next call to jq_yylex() will
+ * scan from a @e copy of @a bytes.
+ * @param yybytes the byte buffer to scan
+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE jq_yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
+{
+	YY_BUFFER_STATE b;
+	char *buf;
+	yy_size_t n;
+	int i;
+    
+	/* Get memory for full buffer, including space for trailing EOB's. */
+	n = _yybytes_len + 2;
+	buf = (char *) jq_yyalloc(n ,yyscanner );
+	if ( ! buf )
+		YY_FATAL_ERROR( "out of dynamic memory in jq_yy_scan_bytes()" );
+
+	for ( i = 0; i < _yybytes_len; ++i )
+		buf[i] = yybytes[i];
+
+	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
+
+	b = jq_yy_scan_buffer(buf,n ,yyscanner);
+	if ( ! b )
+		YY_FATAL_ERROR( "bad buffer in jq_yy_scan_bytes()" );
+
+	/* It's okay to grow etc. this buffer, and we should throw it
+	 * away when we're done.
+	 */
+	b->yy_is_our_buffer = 1;
+
+	return b;
+}
+
+    static void yy_push_state (int  new_state , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if ( yyg->yy_start_stack_ptr >= yyg->yy_start_stack_depth )
+		{
+		yy_size_t new_size;
+
+		yyg->yy_start_stack_depth += YY_START_STACK_INCR;
+		new_size = yyg->yy_start_stack_depth * sizeof( int );
+
+		if ( ! yyg->yy_start_stack )
+			yyg->yy_start_stack = (int *) jq_yyalloc(new_size ,yyscanner );
+
+		else
+			yyg->yy_start_stack = (int *) jq_yyrealloc((void *) yyg->yy_start_stack,new_size ,yyscanner );
+
+		if ( ! yyg->yy_start_stack )
+			YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
+		}
+
+	yyg->yy_start_stack[yyg->yy_start_stack_ptr++] = YY_START;
+
+	BEGIN(new_state);
+}
+
+    static void yy_pop_state  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	if ( --yyg->yy_start_stack_ptr < 0 )
+		YY_FATAL_ERROR( "start-condition stack underflow" );
+
+	BEGIN(yyg->yy_start_stack[yyg->yy_start_stack_ptr]);
+}
+
+    static int yy_top_state  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+	return yyg->yy_start_stack[yyg->yy_start_stack_ptr - 1];
+}
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
+{
+    	(void) fprintf( stderr, "%s\n", msg );
+	exit( YY_EXIT_FAILURE );
+}
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		yytext[yyleng] = yyg->yy_hold_char; \
+		yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
+		yyg->yy_hold_char = *yyg->yy_c_buf_p; \
+		*yyg->yy_c_buf_p = '\0'; \
+		yyleng = yyless_macro_arg; \
+		} \
+	while ( 0 )
+
+/* Accessor  methods (get/set functions) to struct members. */
+
+/** Get the user-defined data for this scanner.
+ * @param yyscanner The scanner object.
+ */
+YY_EXTRA_TYPE jq_yyget_extra  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyextra;
+}
+
+/** Get the current line number.
+ * @param yyscanner The scanner object.
+ */
+int jq_yyget_lineno  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    
+        if (! YY_CURRENT_BUFFER)
+            return 0;
+    
+    return yylineno;
+}
+
+/** Get the current column number.
+ * @param yyscanner The scanner object.
+ */
+int jq_yyget_column  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    
+        if (! YY_CURRENT_BUFFER)
+            return 0;
+    
+    return yycolumn;
+}
+
+/** Get the input stream.
+ * @param yyscanner The scanner object.
+ */
+FILE *jq_yyget_in  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyin;
+}
+
+/** Get the output stream.
+ * @param yyscanner The scanner object.
+ */
+FILE *jq_yyget_out  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyout;
+}
+
+/** Get the length of the current token.
+ * @param yyscanner The scanner object.
+ */
+int jq_yyget_leng  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yyleng;
+}
+
+/** Get the current token.
+ * @param yyscanner The scanner object.
+ */
+
+char *jq_yyget_text  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yytext;
+}
+
+/** Set the user-defined data. This data is never touched by the scanner.
+ * @param user_defined The data to be associated with this scanner.
+ * @param yyscanner The scanner object.
+ */
+void jq_yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yyextra = user_defined ;
+}
+
+/** Set the current line number.
+ * @param line_number
+ * @param yyscanner The scanner object.
+ */
+void jq_yyset_lineno (int  line_number , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        /* lineno is only valid if an input buffer exists. */
+        if (! YY_CURRENT_BUFFER )
+           yy_fatal_error( "jq_yyset_lineno called with no buffer" , yyscanner); 
+    
+    yylineno = line_number;
+}
+
+/** Set the current column.
+ * @param line_number
+ * @param yyscanner The scanner object.
+ */
+void jq_yyset_column (int  column_no , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+        /* column is only valid if an input buffer exists. */
+        if (! YY_CURRENT_BUFFER )
+           yy_fatal_error( "jq_yyset_column called with no buffer" , yyscanner); 
+    
+    yycolumn = column_no;
+}
+
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param in_str A readable stream.
+ * @param yyscanner The scanner object.
+ * @see jq_yy_switch_to_buffer
+ */
+void jq_yyset_in (FILE *  in_str , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yyin = in_str ;
+}
+
+void jq_yyset_out (FILE *  out_str , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yyout = out_str ;
+}
+
+int jq_yyget_debug  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yy_flex_debug;
+}
+
+void jq_yyset_debug (int  bdebug , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yy_flex_debug = bdebug ;
+}
+
+/* Accessor methods for yylval and yylloc */
+
+YYSTYPE * jq_yyget_lval  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yylval;
+}
+
+void jq_yyset_lval (YYSTYPE *  yylval_param , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yylval = yylval_param;
+}
+
+YYLTYPE *jq_yyget_lloc  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    return yylloc;
+}
+    
+void jq_yyset_lloc (YYLTYPE *  yylloc_param , yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    yylloc = yylloc_param;
+}
+    
+/* User-visible API */
+
+/* jq_yylex_init is special because it creates the scanner itself, so it is
+ * the ONLY reentrant function that doesn't take the scanner as the last argument.
+ * That's why we explicitly handle the declaration, instead of using our macros.
+ */
+
+int jq_yylex_init(yyscan_t* ptr_yy_globals)
+
+{
+    if (ptr_yy_globals == NULL){
+        errno = EINVAL;
+        return 1;
+    }
+
+    *ptr_yy_globals = (yyscan_t) jq_yyalloc ( sizeof( struct yyguts_t ), NULL );
+
+    if (*ptr_yy_globals == NULL){
+        errno = ENOMEM;
+        return 1;
+    }
+
+    /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
+    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+
+    return yy_init_globals ( *ptr_yy_globals );
+}
+
+/* jq_yylex_init_extra has the same functionality as jq_yylex_init, but follows the
+ * convention of taking the scanner as the last argument. Note however, that
+ * this is a *pointer* to a scanner, as it will be allocated by this call (and
+ * is the reason, too, why this function also must handle its own declaration).
+ * The user defined value in the first argument will be available to jq_yyalloc in
+ * the yyextra field.
+ */
+
+int jq_yylex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
+
+{
+    struct yyguts_t dummy_yyguts;
+
+    jq_yyset_extra (yy_user_defined, &dummy_yyguts);
+
+    if (ptr_yy_globals == NULL){
+        errno = EINVAL;
+        return 1;
+    }
+	
+    *ptr_yy_globals = (yyscan_t) jq_yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
+	
+    if (*ptr_yy_globals == NULL){
+        errno = ENOMEM;
+        return 1;
+    }
+    
+    /* By setting to 0xAA, we expose bugs in
+    yy_init_globals. Leave at 0x00 for releases. */
+    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+    
+    jq_yyset_extra (yy_user_defined, *ptr_yy_globals);
+    
+    return yy_init_globals ( *ptr_yy_globals );
+}
+
+static int yy_init_globals (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+    /* Initialization is the same as for the non-reentrant scanner.
+     * This function is called from jq_yylex_destroy(), so don't allocate here.
+     */
+
+    yyg->yy_buffer_stack = 0;
+    yyg->yy_buffer_stack_top = 0;
+    yyg->yy_buffer_stack_max = 0;
+    yyg->yy_c_buf_p = (char *) 0;
+    yyg->yy_init = 0;
+    yyg->yy_start = 0;
+
+    yyg->yy_start_stack_ptr = 0;
+    yyg->yy_start_stack_depth = 0;
+    yyg->yy_start_stack =  NULL;
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+    yyin = stdin;
+    yyout = stdout;
+#else
+    yyin = (FILE *) 0;
+    yyout = (FILE *) 0;
+#endif
+
+    /* For future reference: Set errno on error, since we are called by
+     * jq_yylex_init()
+     */
+    return 0;
+}
+
+/* jq_yylex_destroy is for both reentrant and non-reentrant scanners. */
+int jq_yylex_destroy  (yyscan_t yyscanner)
+{
+    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+    /* Pop the buffer stack, destroying each element. */
+	while(YY_CURRENT_BUFFER){
+		jq_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
+		YY_CURRENT_BUFFER_LVALUE = NULL;
+		jq_yypop_buffer_state(yyscanner);
+	}
+
+	/* Destroy the stack itself. */
+	jq_yyfree(yyg->yy_buffer_stack ,yyscanner);
+	yyg->yy_buffer_stack = NULL;
+
+    /* Destroy the start condition stack. */
+        jq_yyfree(yyg->yy_start_stack ,yyscanner );
+        yyg->yy_start_stack = NULL;
+
+    /* Reset the globals. This is important in a non-reentrant scanner so the next time
+     * jq_yylex() is called, initialization will occur. */
+    yy_init_globals( yyscanner);
+
+    /* Destroy the main struct (reentrant only). */
+    jq_yyfree ( yyscanner , yyscanner );
+    yyscanner = NULL;
+    return 0;
+}
+
+/*
+ * Internal utility routines.
+ */
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
+{
+	register int i;
+	for ( i = 0; i < n; ++i )
+		s1[i] = s2[i];
+}
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
+{
+	register int n;
+	for ( n = 0; s[n]; ++n )
+		;
+
+	return n;
+}
+#endif
+
+void *jq_yyalloc (yy_size_t  size , yyscan_t yyscanner)
+{
+	return (void *) malloc( size );
+}
+
+void *jq_yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
+{
+	/* The cast to (char *) in the following accommodates both
+	 * implementations that use char* generic pointers, and those
+	 * that use void* generic pointers.  It works with the latter
+	 * because both ANSI C and C++ allow castless assignment from
+	 * any pointer type to void*, and deal with argument conversions
+	 * as though doing an assignment.
+	 */
+	return (void *) realloc( (char *) ptr, size );
+}
+
+void jq_yyfree (void * ptr , yyscan_t yyscanner)
+{
+	free( (char *) ptr );	/* see jq_yyrealloc() for (char *) cast */
+}
+
+#define YYTABLES_NAME "yytables"
+
+#line 104 "lexer.l"
+
+
+/* perhaps these should be calls... */
+/*
+"true" { return TRUE; }
+"false" { return FALSE; }
+"null" { return NULL; }
+*/
+static int try_exit(int c, int state, yyscan_t yyscanner) {
+  char match = 0;
+  int ret;
+  switch (state) {
+  case IN_PAREN: match = ret = ')'; break;
+  case IN_BRACKET: match = ret = ']'; break;
+  case IN_BRACE: match = ret = '}'; break;
+
+  case IN_QQINTERP:
+    match = ')'; 
+    ret = QQSTRING_INTERP_END;
+    break;
+  }
+  assert(match);
+  if (match == c) {
+    yy_pop_state(yyscanner);
+    return ret;
+  } else {
+    // FIXME: should we pop? Give a better error at least
+    return INVALID_CHARACTER;
+  }
+}
+
+static int enter(int c, int currstate, yyscan_t yyscanner) {
+  int state = 0;
+  switch (c) {
+  case '(': state = IN_PAREN; break;
+  case '[': state = IN_BRACKET; break;
+  case '{': state = IN_BRACE; break;
+  case QQSTRING_INTERP_START: state = IN_QQINTERP; break;
+  }
+  assert(state);
+  yy_push_state(state, yyscanner);
+  return c;
+}
+
diff --git a/lexer.gen.h b/lexer.gen.h
new file mode 100644
index 00000000..5804e150
--- /dev/null
+++ b/lexer.gen.h
@@ -0,0 +1,362 @@
+#ifndef jq_yyHEADER_H
+#define jq_yyHEADER_H 1
+#define jq_yyIN_HEADER 1
+
+#line 6 "lexer.gen.h"
+
+#line 8 "lexer.gen.h"
+
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 5
+#define YY_FLEX_SUBMINOR_VERSION 35
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* end standard C headers. */
+
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types. 
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t; 
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+#ifdef __cplusplus
+
+/* The "const" storage-class-modifier is valid. */
+#define YY_USE_CONST
+
+#else	/* ! __cplusplus */
+
+/* C99 requires __STDC__ to be defined as 1. */
+#if defined (__STDC__)
+
+#define YY_USE_CONST
+
+#endif	/* defined (__STDC__) */
+#endif	/* ! __cplusplus */
+
+#ifdef YY_USE_CONST
+#define yyconst const
+#else
+#define yyconst
+#endif
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void* yyscan_t;
+#endif
+
+/* For convenience, these vars (plus the bison vars far below)
+   are macros in the reentrant scanner. */
+#define yyin yyg->yyin_r
+#define yyout yyg->yyout_r
+#define yyextra yyg->yyextra_r
+#define yyleng yyg->yyleng_r
+#define yytext yyg->yytext_r
+#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
+#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
+#define yy_flex_debug yyg->yy_flex_debug_r
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+	{
+	FILE *yy_input_file;
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	yy_size_t yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
+
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+    
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
+
+	int yy_buffer_status;
+
+	};
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+void jq_yyrestart (FILE *input_file ,yyscan_t yyscanner );
+void jq_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
+YY_BUFFER_STATE jq_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
+void jq_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
+void jq_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
+void jq_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
+void jq_yypop_buffer_state (yyscan_t yyscanner );
+
+YY_BUFFER_STATE jq_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
+YY_BUFFER_STATE jq_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
+YY_BUFFER_STATE jq_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
+
+void *jq_yyalloc (yy_size_t ,yyscan_t yyscanner );
+void *jq_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
+void jq_yyfree (void * ,yyscan_t yyscanner );
+
+/* Begin user sect3 */
+
+#define jq_yywrap(n) 1
+#define YY_SKIP_YYWRAP
+
+#define yytext_ptr yytext_r
+
+#ifdef YY_HEADER_EXPORT_START_CONDITIONS
+#define INITIAL 0
+#define IN_PAREN 1
+#define IN_BRACKET 2
+#define IN_BRACE 3
+#define IN_QQINTERP 4
+#define IN_QQSTRING 5
+
+#endif
+
+#ifndef YY_NO_UNISTD_H
+/* Special case for "unistd.h", since it is non-ANSI. We include it way
+ * down here because we want the user's section 1 to have been scanned first.
+ * The user has a chance to override it with an option.
+ */
+#include <unistd.h>
+#endif
+
+#define YY_EXTRA_TYPE int
+
+int jq_yylex_init (yyscan_t* scanner);
+
+int jq_yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
+
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+int jq_yylex_destroy (yyscan_t yyscanner );
+
+int jq_yyget_debug (yyscan_t yyscanner );
+
+void jq_yyset_debug (int debug_flag ,yyscan_t yyscanner );
+
+YY_EXTRA_TYPE jq_yyget_extra (yyscan_t yyscanner );
+
+void jq_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
+
+FILE *jq_yyget_in (yyscan_t yyscanner );
+
+void jq_yyset_in  (FILE * in_str ,yyscan_t yyscanner );
+
+FILE *jq_yyget_out (yyscan_t yyscanner );
+
+void jq_yyset_out  (FILE * out_str ,yyscan_t yyscanner );
+
+int jq_yyget_leng (yyscan_t yyscanner );
+
+char *jq_yyget_text (yyscan_t yyscanner );
+
+int jq_yyget_lineno (yyscan_t yyscanner );
+
+void jq_yyset_lineno (int line_number ,yyscan_t yyscanner );
+
+YYSTYPE * jq_yyget_lval (yyscan_t yyscanner );
+
+void jq_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
+
+       YYLTYPE *jq_yyget_lloc (yyscan_t yyscanner );
+    
+        void jq_yyset_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner );
+    
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int jq_yywrap (yyscan_t yyscanner );
+#else
+extern int jq_yywrap (yyscan_t yyscanner );
+#endif
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
+#endif
+
+#ifndef YY_NO_INPUT
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+
+extern int jq_yylex \
+               (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner);
+
+#define YY_DECL int jq_yylex \
+               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
+#endif /* !YY_DECL */
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+#undef YY_NEW_FILE
+#undef YY_FLUSH_BUFFER
+#undef yy_set_bol
+#undef yy_new_buffer
+#undef yy_set_interactive
+#undef YY_DO_BEFORE_ACTION
+
+#ifdef YY_DECL_IS_OURS
+#undef YY_DECL_IS_OURS
+#undef YY_DECL
+#endif
+
+#line 104 "lexer.l"
+
+
+#line 361 "lexer.gen.h"
+#undef jq_yyIN_HEADER
+#endif /* jq_yyHEADER_H */
diff --git a/parser.gen.c b/parser.gen.c
new file mode 100644
index 00000000..346a94b9
--- /dev/null
+++ b/parser.gen.c
@@ -0,0 +1,2830 @@
+/* A Bison parser, made by GNU Bison 2.5.  */
+
+/* Bison implementation for Yacc-like parsers in C
+   
+      Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
+   
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+   
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+   simplifying the original so-called "semantic" parser.  */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+   infringing on user name space.  This should be done even for local
+   variables, as they might otherwise be expanded by user macros.
+   There are some unavoidable exceptions within include files to
+   define necessary library symbols; they are noted "INFRINGES ON
+   USER NAME SPACE" below.  */
+
+/* Identify Bison output.  */
+#define YYBISON 1
+
+/* Bison version.  */
+#define YYBISON_VERSION "2.5"
+
+/* Skeleton name.  */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers.  */
+#define YYPURE 1
+
+/* Push parsers.  */
+#define YYPUSH 0
+
+/* Pull parsers.  */
+#define YYPULL 1
+
+/* Using locations.  */
+#define YYLSP_NEEDED 1
+
+
+
+/* Copy the first part of user declarations.  */
+
+/* Line 268 of yacc.c  */
+#line 1 "parser.y"
+
+#include <stdio.h>
+#include <string.h>
+#include "compile.h"
+
+
+/* Line 268 of yacc.c  */
+#line 78 "parser.gen.c"
+
+/* Enabling traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+
+/* Enabling verbose error messages.  */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 1
+#endif
+
+/* Enabling the token table.  */
+#ifndef YYTOKEN_TABLE
+# define YYTOKEN_TABLE 0
+#endif
+
+/* "%code requires" blocks.  */
+
+/* Line 288 of yacc.c  */
+#line 6 "parser.y"
+
+#include "locfile.h"
+#define YYLTYPE location
+#define YYLLOC_DEFAULT(Loc, Rhs, N)             \
+  do {                                          \
+    if (N) {                                    \
+      (Loc).start = YYRHSLOC(Rhs, 1).start;     \
+      (Loc).end = YYRHSLOC(Rhs, N).end;         \
+    } else {                                    \
+      (Loc).start = YYRHSLOC(Rhs, 0).end;       \
+      (Loc).end = YYRHSLOC(Rhs, 0).end;         \
+    }                                           \
+  } while (0)
+ 
+
+
+/* Line 288 of yacc.c  */
+#line 119 "parser.gen.c"
+
+/* Tokens.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+   /* Put the tokens into the symbol table, so that GDB and other debuggers
+      know about them.  */
+   enum yytokentype {
+     INVALID_CHARACTER = 258,
+     IDENT = 259,
+     LITERAL = 260,
+     EQ = 261,
+     DEFINEDOR = 262,
+     AS = 263,
+     DEF = 264,
+     IF = 265,
+     THEN = 266,
+     ELSE = 267,
+     ELSE_IF = 268,
+     END = 269,
+     AND = 270,
+     OR = 271,
+     SETPIPE = 272,
+     SETPLUS = 273,
+     SETMINUS = 274,
+     SETMULT = 275,
+     SETDIV = 276,
+     SETDEFINEDOR = 277,
+     LESSEQ = 278,
+     GREATEREQ = 279,
+     QQSTRING_START = 280,
+     QQSTRING_TEXT = 281,
+     QQSTRING_INTERP_START = 282,
+     QQSTRING_INTERP_END = 283,
+     QQSTRING_END = 284
+   };
+#endif
+
+
+
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef union YYSTYPE
+{
+
+/* Line 293 of yacc.c  */
+#line 24 "parser.y"
+
+  jv literal;
+  block blk;
+
+
+
+/* Line 293 of yacc.c  */
+#line 172 "parser.gen.c"
+} YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
+typedef struct YYLTYPE
+{
+  int first_line;
+  int first_column;
+  int last_line;
+  int last_column;
+} YYLTYPE;
+# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
+# define YYLTYPE_IS_DECLARED 1
+# define YYLTYPE_IS_TRIVIAL 1
+#endif
+
+
+/* Copy the second part of user declarations.  */
+
+/* Line 343 of yacc.c  */
+#line 85 "parser.y"
+
+#include "lexer.gen.h"
+#define FAIL(loc, msg)                                   \
+  do {                                                   \
+    location l = loc;                                    \
+    yyerror(&l, answer, errors, locations, lexer, msg);  \
+    /*YYERROR*/;                                         \
+  } while (0)
+
+void yyerror(YYLTYPE* loc, block* answer, int* errors, 
+             struct locfile* locations, yyscan_t lexer, const char *s){
+  (*errors)++;
+  locfile_locate(locations, *loc, "error: %s", s);
+}
+
+int yylex(YYSTYPE* yylval, YYLTYPE* yylloc, block* answer, int* errors, 
+          struct locfile* locations, yyscan_t lexer) {
+  while (1) {
+    int tok = jq_yylex(yylval, yylloc, lexer);
+    if (tok == INVALID_CHARACTER) {
+      FAIL(*yylloc, "Invalid character");
+    } else {
+      if ((tok == LITERAL || tok == QQSTRING_TEXT) && !jv_is_valid(yylval->literal)) {
+        jv msg = jv_invalid_get_msg(jv_copy(yylval->literal));
+        if (jv_get_kind(msg) == JV_KIND_STRING) {
+          FAIL(*yylloc, jv_string_value(msg));
+        } else {
+          FAIL(*yylloc, "Invalid literal");
+        }
+        jv_free(msg);
+        jv_free(yylval->literal);
+        yylval->literal = jv_null();
+      }
+      return tok;
+    }
+  }
+}
+
+static block gen_dictpair(block k, block v) {
+  block b = gen_subexp(k);
+  block_append(&b, gen_subexp(v));
+  block_append(&b, gen_op_simple(INSERT));
+  return b;
+}
+
+static block gen_index(block obj, block key) {
+  return block_join(obj, block_join(gen_subexp(key), gen_op_simple(INDEX)));
+}
+
+static block gen_binop(block a, block b, int op) {
+  const char* funcname = 0;
+  switch (op) {
+  case '+': funcname = "_plus"; break;
+  case '-': funcname = "_minus"; break;
+  case '*': funcname = "_multiply"; break;
+  case '/': funcname = "_divide"; break;
+  case EQ: funcname = "_equal"; break;
+  case '<': funcname = "_less"; break;
+  case '>': funcname = "_greater"; break;
+  case LESSEQ: funcname = "_lesseq"; break;
+  case GREATEREQ: funcname = "_greatereq"; break;
+  }
+  assert(funcname);
+
+  block c = gen_noop();
+  block_append(&c, gen_subexp(a));
+  block_append(&c, gen_subexp(b));
+  block_append(&c, gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, funcname)));
+  return c;
+}
+
+static block gen_format(block a) {
+  return block_join(a, gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, "tostring")));
+}
+ 
+static block gen_update(block a, block op, int optype) {
+  block assign = a;
+  block_append(&assign, gen_op_simple(DUP));
+  if (optype) {
+    op = gen_binop(gen_noop(), op, optype);
+  }
+  block_append(&assign, op);
+  return gen_assign(assign);
+}
+
+
+
+/* Line 343 of yacc.c  */
+#line 285 "parser.gen.c"
+
+#ifdef short
+# undef short
+#endif
+
+#ifdef YYTYPE_UINT8
+typedef YYTYPE_UINT8 yytype_uint8;
+#else
+typedef unsigned char yytype_uint8;
+#endif
+
+#ifdef YYTYPE_INT8
+typedef YYTYPE_INT8 yytype_int8;
+#elif (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+typedef signed char yytype_int8;
+#else
+typedef short int yytype_int8;
+#endif
+
+#ifdef YYTYPE_UINT16
+typedef YYTYPE_UINT16 yytype_uint16;
+#else
+typedef unsigned short int yytype_uint16;
+#endif
+
+#ifdef YYTYPE_INT16
+typedef YYTYPE_INT16 yytype_int16;
+#else
+typedef short int yytype_int16;
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+#  define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+#  define YYSIZE_T size_t
+# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYSIZE_T size_t
+# else
+#  define YYSIZE_T unsigned int
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
+
+#ifndef YY_
+# if defined YYENABLE_NLS && YYENABLE_NLS
+#  if ENABLE_NLS
+#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+#   define YY_(msgid) dgettext ("bison-runtime", msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(msgid) msgid
+# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E.  */
+#if ! defined lint || defined __GNUC__
+# define YYUSE(e) ((void) (e))
+#else
+# define YYUSE(e) /* empty */
+#endif
+
+/* Identity function, used to suppress warnings about constant conditions.  */
+#ifndef lint
+# define YYID(n) (n)
+#else
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static int
+YYID (int yyi)
+#else
+static int
+YYID (yyi)
+    int yyi;
+#endif
+{
+  return yyi;
+}
+#endif
+
+#if ! defined yyoverflow || YYERROR_VERBOSE
+
+/* The parser invokes alloca or malloc; define the necessary symbols.  */
+
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
+#   elif defined __BUILTIN_VA_ARG_INCR
+#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+#   elif defined _AIX
+#    define YYSTACK_ALLOC __alloca
+#   elif defined _MSC_VER
+#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+#    define alloca _alloca
+#   else
+#    define YYSTACK_ALLOC alloca
+#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#     ifndef EXIT_SUCCESS
+#      define EXIT_SUCCESS 0
+#     endif
+#    endif
+#   endif
+#  endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+   /* Pacify GCC's `empty if-body' warning.  */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+    /* The OS might guarantee only one guard page at the bottom of the stack,
+       and a page size can be as small as 4096 bytes.  So we cannot safely
+       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
+       to allow for a few compiler-allocated temporary stack slots.  */
+#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+#  endif
+# else
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+#  endif
+#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
+       && ! ((defined YYMALLOC || defined malloc) \
+	     && (defined YYFREE || defined free)))
+#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#   ifndef EXIT_SUCCESS
+#    define EXIT_SUCCESS 0
+#   endif
+#  endif
+#  ifndef YYMALLOC
+#   define YYMALLOC malloc
+#   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifndef YYFREE
+#   define YYFREE free
+#   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+# endif
+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
+
+
+#if (! defined yyoverflow \
+     && (! defined __cplusplus \
+	 || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
+	     && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member.  */
+union yyalloc
+{
+  yytype_int16 yyss_alloc;
+  YYSTYPE yyvs_alloc;
+  YYLTYPE yyls_alloc;
+};
+
+/* The size of the maximum gap between one aligned stack and the next.  */
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+   N elements.  */
+# define YYSTACK_BYTES(N) \
+     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
+      + 2 * YYSTACK_GAP_MAXIMUM)
+
+# define YYCOPY_NEEDED 1
+
+/* Relocate STACK from its old location to the new one.  The
+   local variables YYSIZE and YYSTACKSIZE give the old and new number of
+   elements in the stack, and YYPTR gives the new location of the
+   stack.  Advance YYPTR to a properly aligned location for the next
+   stack.  */
+# define YYSTACK_RELOCATE(Stack_alloc, Stack)				\
+    do									\
+      {									\
+	YYSIZE_T yynewbytes;						\
+	YYCOPY (&yyptr->Stack_alloc, Stack, yysize);			\
+	Stack = &yyptr->Stack_alloc;					\
+	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+	yyptr += yynewbytes / sizeof (*yyptr);				\
+      }									\
+    while (YYID (0))
+
+#endif
+
+#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
+/* Copy COUNT objects from FROM to TO.  The source and destination do
+   not overlap.  */
+# ifndef YYCOPY
+#  if defined __GNUC__ && 1 < __GNUC__
+#   define YYCOPY(To, From, Count) \
+      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
+#  else
+#   define YYCOPY(To, From, Count)		\
+      do					\
+	{					\
+	  YYSIZE_T yyi;				\
+	  for (yyi = 0; yyi < (Count); yyi++)	\
+	    (To)[yyi] = (From)[yyi];		\
+	}					\
+      while (YYID (0))
+#  endif
+# endif
+#endif /* !YYCOPY_NEEDED */
+
+/* YYFINAL -- State number of the termination state.  */
+#define YYFINAL  35
+/* YYLAST -- Last index in YYTABLE.  */
+#define YYLAST   808
+
+/* YYNTOKENS -- Number of terminals.  */
+#define YYNTOKENS  49
+/* YYNNTS -- Number of nonterminals.  */
+#define YYNNTS  12
+/* YYNRULES -- Number of rules.  */
+#define YYNRULES  68
+/* YYNRULES -- Number of states.  */
+#define YYNSTATES  147
+
+/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
+#define YYUNDEFTOK  2
+#define YYMAXUTOK   284
+
+#define YYTRANSLATE(YYX)						\
+  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+
+/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
+static const yytype_uint8 yytranslate[] =
+{
+       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,    40,     2,     2,     2,
+      42,    43,    38,    36,    32,    37,    44,    39,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,    41,    30,
+      34,    33,    35,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,    45,     2,    46,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,    47,    31,    48,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    26,    27,    28,    29
+};
+
+#if YYDEBUG
+/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
+   YYRHS.  */
+static const yytype_uint8 yyprhs[] =
+{
+       0,     0,     3,     5,     7,     8,    11,    14,    21,    27,
+      31,    35,    39,    43,    47,    51,    55,    59,    63,    67,
+      71,    75,    79,    83,    87,    91,    95,    99,   103,   107,
+     111,   115,   117,   119,   123,   129,   138,   139,   142,   147,
+     153,   157,   161,   163,   165,   169,   172,   177,   181,   183,
+     187,   191,   194,   198,   201,   203,   208,   212,   216,   221,
+     225,   226,   228,   232,   236,   240,   244,   246,   252
+};
+
+/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
+static const yytype_int8 yyrhs[] =
+{
+      50,     0,    -1,    52,    -1,    51,    -1,    -1,    54,    51,
+      -1,    54,    52,    -1,    58,     8,    40,     4,    31,    52,
+      -1,    10,    52,    11,    52,    56,    -1,    10,    52,     1,
+      -1,    52,    33,    52,    -1,    52,    16,    52,    -1,    52,
+      15,    52,    -1,    52,     7,    52,    -1,    52,    22,    52,
+      -1,    52,    17,    52,    -1,    52,    31,    52,    -1,    52,
+      32,    52,    -1,    52,    36,    52,    -1,    52,    18,    52,
+      -1,    52,    37,    52,    -1,    52,    19,    52,    -1,    52,
+      38,    52,    -1,    52,    20,    52,    -1,    52,    39,    52,
+      -1,    52,    21,    52,    -1,    52,     6,    52,    -1,    52,
+      34,    52,    -1,    52,    35,    52,    -1,    52,    23,    52,
+      -1,    52,    24,    52,    -1,    53,    -1,    58,    -1,    25,
+      55,    29,    -1,     9,     4,    41,    52,    30,    -1,     9,
+       4,    42,     4,    43,    41,    52,    30,    -1,    -1,    55,
+      26,    -1,    55,    27,    52,    28,    -1,    13,    52,    11,
+      52,    56,    -1,    12,    52,    14,    -1,    57,    31,    57,
+      -1,    58,    -1,    44,    -1,    58,    44,     4,    -1,    44,
+       4,    -1,    58,    45,    52,    46,    -1,    58,    45,    46,
+      -1,     5,    -1,    42,    52,    43,    -1,    45,    52,    46,
+      -1,    45,    46,    -1,    47,    59,    48,    -1,    40,     4,
+      -1,     4,    -1,     4,    42,    52,    43,    -1,    42,     1,
+      43,    -1,    45,     1,    46,    -1,    58,    45,     1,    46,
+      -1,    47,     1,    48,    -1,    -1,    60,    -1,    60,    32,
+      59,    -1,     1,    32,    59,    -1,     4,    41,    57,    -1,
+      53,    41,    57,    -1,     4,    -1,    42,    52,    43,    41,
+      57,    -1,    42,     1,    43,    41,    57,    -1
+};
+
+/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
+static const yytype_uint16 yyrline[] =
+{
+       0,   174,   174,   177,   182,   185,   190,   194,   201,   204,
+     209,   218,   222,   226,   230,   234,   238,   242,   246,   250,
+     254,   258,   262,   266,   270,   274,   278,   282,   286,   290,
+     294,   298,   302,   307,   312,   318,   326,   329,   332,   338,
+     341,   346,   350,   356,   359,   362,   366,   369,   372,   375,
+     378,   381,   384,   389,   393,   397,   407,   408,   409,   410,
+     413,   416,   417,   418,   421,   424,   427,   431,   434
+};
+#endif
+
+#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
+static const char *const yytname[] =
+{
+  "$end", "error", "$undefined", "INVALID_CHARACTER", "IDENT", "LITERAL",
+  "\"==\"", "\"//\"", "\"as\"", "\"def\"", "\"if\"", "\"then\"",
+  "\"else\"", "\"elif\"", "\"end\"", "\"and\"", "\"or\"", "\"|=\"",
+  "\"+=\"", "\"-=\"", "\"*=\"", "\"/=\"", "\"//=\"", "\"<=\"", "\">=\"",
+  "QQSTRING_START", "QQSTRING_TEXT", "QQSTRING_INTERP_START",
+  "QQSTRING_INTERP_END", "QQSTRING_END", "';'", "'|'", "','", "'='", "'<'",
+  "'>'", "'+'", "'-'", "'*'", "'/'", "'$'", "':'", "'('", "')'", "'.'",
+  "'['", "']'", "'{'", "'}'", "$accept", "TopLevel", "FuncDefs", "Exp",
+  "String", "FuncDef", "QQString", "ElseBody", "ExpD", "Term", "MkDict",
+  "MkDictPair", 0
+};
+#endif
+
+# ifdef YYPRINT
+/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
+   token YYLEX-NUM.  */
+static const yytype_uint16 yytoknum[] =
+{
+       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
+     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
+     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
+      59,   124,    44,    61,    60,    62,    43,    45,    42,    47,
+      36,    58,    40,    41,    46,    91,    93,   123,   125
+};
+# endif
+
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+static const yytype_uint8 yyr1[] =
+{
+       0,    49,    50,    50,    51,    51,    52,    52,    52,    52,
+      52,    52,    52,    52,    52,    52,    52,    52,    52,    52,
+      52,    52,    52,    52,    52,    52,    52,    52,    52,    52,
+      52,    52,    52,    53,    54,    54,    55,    55,    55,    56,
+      56,    57,    57,    58,    58,    58,    58,    58,    58,    58,
+      58,    58,    58,    58,    58,    58,    58,    58,    58,    58,
+      59,    59,    59,    59,    60,    60,    60,    60,    60
+};
+
+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
+static const yytype_uint8 yyr2[] =
+{
+       0,     2,     1,     1,     0,     2,     2,     6,     5,     3,
+       3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+       3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+       3,     1,     1,     3,     5,     8,     0,     2,     4,     5,
+       3,     3,     1,     1,     3,     2,     4,     3,     1,     3,
+       3,     2,     3,     2,     1,     4,     3,     3,     4,     3,
+       0,     1,     3,     3,     3,     3,     1,     5,     5
+};
+
+/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
+   Performed when YYTABLE doesn't specify something else to do.  Zero
+   means the default is an error.  */
+static const yytype_uint8 yydefact[] =
+{
+       4,    54,    48,     0,     0,    36,     0,     0,    43,     0,
+       0,     0,     3,     2,    31,     4,    32,     0,     0,     0,
+       0,     0,    53,     0,     0,    45,     0,    51,     0,     0,
+      66,     0,     0,     0,    61,     1,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     5,     6,     0,
+       0,     0,     0,     0,     0,     9,     0,    37,     0,    33,
+      56,    49,    57,    50,     0,    59,     0,     0,     0,     0,
+      52,     0,    26,    13,    12,    11,    15,    19,    21,    23,
+      25,    14,    29,    30,    16,    17,    10,    27,    28,    18,
+      20,    22,    24,     0,    44,     0,    47,     0,    55,     0,
+       0,     0,     0,     0,    63,    64,    42,     0,     0,    65,
+      62,     0,    58,    46,    34,     0,     0,     0,     8,    38,
+       0,     0,     0,     0,     0,     0,     0,    41,    68,    67,
+       7,     0,    40,     0,    35,     0,    39
+};
+
+/* YYDEFGOTO[NTERM-NUM].  */
+static const yytype_int16 yydefgoto[] =
+{
+      -1,    11,    12,    58,    14,    20,    21,   128,   115,    16,
+      33,    34
+};
+
+/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+   STATE-NUM.  */
+#define YYPACT_NINF -74
+static const yytype_int16 yypact[] =
+{
+     194,   -40,   -74,    10,   194,   -74,    16,   137,    18,    77,
+      63,    28,   -74,   651,   -74,   194,    54,   194,   -26,   311,
+     194,   -16,   -74,   -13,   345,   -74,   -17,   -74,   236,   -27,
+      -8,   150,    -7,    12,     3,   -74,   194,   194,   194,   194,
+     194,   194,   194,   194,   194,   194,   194,   194,   194,   194,
+     194,   194,   194,   194,   194,   194,   194,   -74,   651,    34,
+      71,   127,   379,   194,    73,   -74,   194,   -74,   194,   -74,
+     -74,   -74,   -74,   -74,    72,   -74,   181,   -11,   413,   181,
+     -74,    72,   177,   719,   763,   769,   744,   744,   744,   744,
+     744,   744,   177,   177,   685,   719,   744,   177,   177,   -14,
+     -14,   -74,   -74,    75,   -74,    37,   -74,   270,   -74,   481,
+      41,   447,   515,    48,   -74,    58,   -18,    44,    49,    58,
+     -74,    60,   -74,   -74,   -74,    51,   194,   194,   -74,   -74,
+     181,   181,   181,   194,   194,   549,   583,   -74,    58,    58,
+     685,   617,   -74,   194,   -74,   447,   -74
+};
+
+/* YYPGOTO[NTERM-NUM].  */
+static const yytype_int8 yypgoto[] =
+{
+     -74,   -74,    78,     0,    -9,     8,   -74,   -51,   -61,   -73,
+     -62,   -74
+};
+
+/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
+   positive, shift that token.  If negative, reduce the rule which
+   number is the opposite.  If YYTABLE_NINF, syntax error.  */
+#define YYTABLE_NINF -61
+static const yytype_int16 yytable[] =
+{
+      13,    32,    17,   116,    19,    74,   116,    24,    15,    28,
+      67,    68,   114,    69,    18,    63,    64,    62,   119,   120,
+      22,    75,    25,    15,    55,    56,    60,    61,    35,    72,
+      70,    78,   117,    76,    79,    81,    82,    83,    84,    85,
+      86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
+      96,    97,    98,    99,   100,   101,   102,   116,   116,   116,
+      80,   107,    59,   109,    29,    32,   111,    30,   112,   137,
+     138,   139,    32,   113,   103,   104,    30,   110,    26,   121,
+      74,     1,     2,   122,   125,   131,     3,     4,     5,   130,
+     132,   133,   134,    57,   146,     0,     0,     5,    60,    61,
+       0,     0,     5,     0,     0,    31,     0,     0,     0,     0,
+       0,   -60,     0,     0,    31,     0,     0,     6,     0,     7,
+     -60,     8,     9,    27,    10,     0,   135,   136,   105,     0,
+       0,     1,     2,   140,   141,     0,     3,     4,    23,     0,
+       0,     1,     2,   145,     0,     0,     3,     4,     0,     0,
+       0,    77,     5,     0,     1,     2,     0,     0,     0,     3,
+       4,     0,     5,     0,     0,     0,     0,     6,     0,     7,
+       0,     8,     9,   106,    10,     5,     0,     6,     0,     7,
+       0,     8,     9,   -61,    10,     1,     2,     0,     0,     0,
+       6,     0,     7,     0,     8,     9,     0,    10,     1,     2,
+     -61,   -61,     0,     3,     4,     0,     0,     0,     0,     0,
+       0,   -61,   -61,    53,    54,    55,    56,     0,     0,     5,
+       0,     6,     0,     7,     0,     8,     9,     0,    10,     0,
+       0,     0,     0,     0,     6,     0,     7,     0,     8,     9,
+       0,    10,    36,    37,     0,     0,     0,     0,     0,     0,
+       0,    38,    39,    40,    41,    42,    43,    44,    45,    46,
+      47,     0,     0,     0,     0,     0,     0,    48,    49,    50,
+      51,    52,    53,    54,    55,    56,    36,    37,     0,     0,
+       0,     0,    73,     0,     0,    38,    39,    40,    41,    42,
+      43,    44,    45,    46,    47,     0,     0,     0,     0,     0,
+       0,    48,    49,    50,    51,    52,    53,    54,    55,    56,
+       0,     0,    65,     0,     0,     0,   123,    36,    37,     0,
+       0,     0,    66,     0,     0,     0,    38,    39,    40,    41,
+      42,    43,    44,    45,    46,    47,     0,     0,     0,     0,
+       0,     0,    48,    49,    50,    51,    52,    53,    54,    55,
+      56,    36,    37,     0,     0,     0,     0,     0,     0,     0,
+      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+       0,     0,     0,     0,     0,     0,    48,    49,    50,    51,
+      52,    53,    54,    55,    56,    36,    37,     0,    71,     0,
+       0,     0,     0,     0,    38,    39,    40,    41,    42,    43,
+      44,    45,    46,    47,     0,     0,     0,     0,     0,     0,
+      48,    49,    50,    51,    52,    53,    54,    55,    56,    36,
+      37,     0,   108,     0,     0,     0,     0,     0,    38,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,     0,     0,
+       0,     0,     0,     0,    48,    49,    50,    51,    52,    53,
+      54,    55,    56,    36,    37,     0,   118,     0,     0,   126,
+     127,     0,    38,    39,    40,    41,    42,    43,    44,    45,
+      46,    47,     0,     0,     0,     0,     0,     0,    48,    49,
+      50,    51,    52,    53,    54,    55,    56,    36,    37,     0,
+       0,     0,     0,     0,     0,     0,    38,    39,    40,    41,
+      42,    43,    44,    45,    46,    47,     0,     0,     0,     0,
+       0,   124,    48,    49,    50,    51,    52,    53,    54,    55,
+      56,    36,    37,     0,     0,     0,     0,     0,     0,     0,
+      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+       0,     0,     0,   129,     0,     0,    48,    49,    50,    51,
+      52,    53,    54,    55,    56,    36,    37,     0,     0,     0,
+       0,     0,     0,   142,    38,    39,    40,    41,    42,    43,
+      44,    45,    46,    47,     0,     0,     0,     0,     0,     0,
+      48,    49,    50,    51,    52,    53,    54,    55,    56,    36,
+      37,     0,     0,     0,   143,     0,     0,     0,    38,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,     0,     0,
+       0,     0,     0,     0,    48,    49,    50,    51,    52,    53,
+      54,    55,    56,    36,    37,     0,     0,     0,     0,     0,
+       0,     0,    38,    39,    40,    41,    42,    43,    44,    45,
+      46,    47,     0,     0,     0,     0,     0,   144,    48,    49,
+      50,    51,    52,    53,    54,    55,    56,    36,    37,     0,
+       0,     0,     0,     0,     0,     0,    38,    39,    40,    41,
+      42,    43,    44,    45,    46,    47,     0,     0,     0,     0,
+       0,     0,    48,    49,    50,    51,    52,    53,    54,    55,
+      56,    36,    37,     0,     0,     0,     0,     0,     0,     0,
+      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+       0,     0,     0,     0,     0,     0,     0,    49,    50,    51,
+      52,    53,    54,    55,    56,    36,    37,     0,     0,     0,
+       0,     0,     0,     0,    38,    39,    40,    41,    42,    43,
+      44,    45,    46,    47,     0,     0,     0,     0,     0,     0,
+      36,     0,    50,    51,    52,    53,    54,    55,    56,    38,
+      39,   -61,   -61,   -61,   -61,   -61,   -61,    46,    47,    36,
+       0,     0,     0,     0,     0,    36,     0,   -61,    51,    52,
+      53,    54,    55,    56,    38,     0,    46,    47,     0,     0,
+       0,     0,    46,    47,     0,     0,     0,    51,    52,    53,
+      54,    55,    56,    51,    52,    53,    54,    55,    56
+};
+
+#define yypact_value_is_default(yystate) \
+  ((yystate) == (-74))
+
+#define yytable_value_is_error(yytable_value) \
+  ((yytable_value) == (-61))
+
+static const yytype_int16 yycheck[] =
+{
+       0,    10,    42,    76,     4,    32,    79,     7,     0,     9,
+      26,    27,    74,    29,     4,    41,    42,    17,    79,    81,
+       4,    48,     4,    15,    38,    39,    44,    45,     0,    46,
+      43,    31,    43,    41,    41,    32,    36,    37,    38,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+      50,    51,    52,    53,    54,    55,    56,   130,   131,   132,
+      48,    61,     8,    63,     1,    74,    66,     4,    68,   130,
+     131,   132,    81,     1,    40,     4,     4,     4,     1,     4,
+      32,     4,     5,    46,    43,    41,     9,    10,    25,    31,
+      41,    31,    41,    15,   145,    -1,    -1,    25,    44,    45,
+      -1,    -1,    25,    -1,    -1,    42,    -1,    -1,    -1,    -1,
+      -1,    48,    -1,    -1,    42,    -1,    -1,    40,    -1,    42,
+      48,    44,    45,    46,    47,    -1,   126,   127,     1,    -1,
+      -1,     4,     5,   133,   134,    -1,     9,    10,     1,    -1,
+      -1,     4,     5,   143,    -1,    -1,     9,    10,    -1,    -1,
+      -1,     1,    25,    -1,     4,     5,    -1,    -1,    -1,     9,
+      10,    -1,    25,    -1,    -1,    -1,    -1,    40,    -1,    42,
+      -1,    44,    45,    46,    47,    25,    -1,    40,    -1,    42,
+      -1,    44,    45,     6,    47,     4,     5,    -1,    -1,    -1,
+      40,    -1,    42,    -1,    44,    45,    -1,    47,     4,     5,
+      23,    24,    -1,     9,    10,    -1,    -1,    -1,    -1,    -1,
+      -1,    34,    35,    36,    37,    38,    39,    -1,    -1,    25,
+      -1,    40,    -1,    42,    -1,    44,    45,    -1,    47,    -1,
+      -1,    -1,    -1,    -1,    40,    -1,    42,    -1,    44,    45,
+      -1,    47,     6,     7,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    -1,    -1,    -1,    -1,    -1,    -1,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,     6,     7,    -1,    -1,
+      -1,    -1,    46,    -1,    -1,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
+      -1,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+      -1,    -1,     1,    -1,    -1,    -1,    46,     6,     7,    -1,
+      -1,    -1,    11,    -1,    -1,    -1,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
+      -1,    -1,    31,    32,    33,    34,    35,    36,    37,    38,
+      39,     6,     7,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      -1,    -1,    -1,    -1,    -1,    -1,    31,    32,    33,    34,
+      35,    36,    37,    38,    39,     6,     7,    -1,    43,    -1,
+      -1,    -1,    -1,    -1,    15,    16,    17,    18,    19,    20,
+      21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    -1,
+      31,    32,    33,    34,    35,    36,    37,    38,    39,     6,
+       7,    -1,    43,    -1,    -1,    -1,    -1,    -1,    15,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
+      -1,    -1,    -1,    -1,    31,    32,    33,    34,    35,    36,
+      37,    38,    39,     6,     7,    -1,    43,    -1,    -1,    12,
+      13,    -1,    15,    16,    17,    18,    19,    20,    21,    22,
+      23,    24,    -1,    -1,    -1,    -1,    -1,    -1,    31,    32,
+      33,    34,    35,    36,    37,    38,    39,     6,     7,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
+      -1,    30,    31,    32,    33,    34,    35,    36,    37,    38,
+      39,     6,     7,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      -1,    -1,    -1,    28,    -1,    -1,    31,    32,    33,    34,
+      35,    36,    37,    38,    39,     6,     7,    -1,    -1,    -1,
+      -1,    -1,    -1,    14,    15,    16,    17,    18,    19,    20,
+      21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    -1,
+      31,    32,    33,    34,    35,    36,    37,    38,    39,     6,
+       7,    -1,    -1,    -1,    11,    -1,    -1,    -1,    15,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
+      -1,    -1,    -1,    -1,    31,    32,    33,    34,    35,    36,
+      37,    38,    39,     6,     7,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    15,    16,    17,    18,    19,    20,    21,    22,
+      23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
+      33,    34,    35,    36,    37,    38,    39,     6,     7,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
+      -1,    -1,    31,    32,    33,    34,    35,    36,    37,    38,
+      39,     6,     7,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    32,    33,    34,
+      35,    36,    37,    38,    39,     6,     7,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    15,    16,    17,    18,    19,    20,
+      21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    -1,
+       6,    -1,    33,    34,    35,    36,    37,    38,    39,    15,
+      16,    17,    18,    19,    20,    21,    22,    23,    24,     6,
+      -1,    -1,    -1,    -1,    -1,     6,    -1,    33,    34,    35,
+      36,    37,    38,    39,    15,    -1,    23,    24,    -1,    -1,
+      -1,    -1,    23,    24,    -1,    -1,    -1,    34,    35,    36,
+      37,    38,    39,    34,    35,    36,    37,    38,    39
+};
+
+/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+   symbol of state STATE-NUM.  */
+static const yytype_uint8 yystos[] =
+{
+       0,     4,     5,     9,    10,    25,    40,    42,    44,    45,
+      47,    50,    51,    52,    53,    54,    58,    42,     4,    52,
+      54,    55,     4,     1,    52,     4,     1,    46,    52,     1,
+       4,    42,    53,    59,    60,     0,     6,     7,    15,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    31,    32,
+      33,    34,    35,    36,    37,    38,    39,    51,    52,     8,
+      44,    45,    52,    41,    42,     1,    11,    26,    27,    29,
+      43,    43,    46,    46,    32,    48,    41,     1,    52,    41,
+      48,    32,    52,    52,    52,    52,    52,    52,    52,    52,
+      52,    52,    52,    52,    52,    52,    52,    52,    52,    52,
+      52,    52,    52,    40,     4,     1,    46,    52,    43,    52,
+       4,    52,    52,     1,    59,    57,    58,    43,    43,    57,
+      59,     4,    46,    46,    30,    43,    12,    13,    56,    28,
+      31,    41,    41,    31,    41,    52,    52,    57,    57,    57,
+      52,    52,    14,    11,    30,    52,    56
+};
+
+#define yyerrok		(yyerrstatus = 0)
+#define yyclearin	(yychar = YYEMPTY)
+#define YYEMPTY		(-2)
+#define YYEOF		0
+
+#define YYACCEPT	goto yyacceptlab
+#define YYABORT		goto yyabortlab
+#define YYERROR		goto yyerrorlab
+
+
+/* Like YYERROR except do call yyerror.  This remains here temporarily
+   to ease the transition to the new meaning of YYERROR, for GCC.
+   Once GCC version 2 has supplanted version 1, this can go.  However,
+   YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
+   in Bison 2.4.2's NEWS entry, where a plan to phase it out is
+   discussed.  */
+
+#define YYFAIL		goto yyerrlab
+#if defined YYFAIL
+  /* This is here to suppress warnings from the GCC cpp's
+     -Wunused-macros.  Normally we don't worry about that warning, but
+     some users do, and we want to make it easy for users to remove
+     YYFAIL uses, which will produce warnings from Bison 2.5.  */
+#endif
+
+#define YYRECOVERING()  (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value)					\
+do								\
+  if (yychar == YYEMPTY && yylen == 1)				\
+    {								\
+      yychar = (Token);						\
+      yylval = (Value);						\
+      YYPOPSTACK (1);						\
+      goto yybackup;						\
+    }								\
+  else								\
+    {								\
+      yyerror (&yylloc, answer, errors, locations, lexer, YY_("syntax error: cannot back up")); \
+      YYERROR;							\
+    }								\
+while (YYID (0))
+
+
+#define YYTERROR	1
+#define YYERRCODE	256
+
+
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
+   If N is 0, then set CURRENT to the empty location which ends
+   the previous symbol: RHS[0] (always defined).  */
+
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])
+#ifndef YYLLOC_DEFAULT
+# define YYLLOC_DEFAULT(Current, Rhs, N)				\
+    do									\
+      if (YYID (N))                                                    \
+	{								\
+	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
+	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
+	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
+	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
+	}								\
+      else								\
+	{								\
+	  (Current).first_line   = (Current).last_line   =		\
+	    YYRHSLOC (Rhs, 0).last_line;				\
+	  (Current).first_column = (Current).last_column =		\
+	    YYRHSLOC (Rhs, 0).last_column;				\
+	}								\
+    while (YYID (0))
+#endif
+
+
+/* YY_LOCATION_PRINT -- Print the location on the stream.
+   This macro was not mandated originally: define only if we know
+   we won't break user code: when these are the locations we know.  */
+
+#ifndef YY_LOCATION_PRINT
+# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
+#  define YY_LOCATION_PRINT(File, Loc)			\
+     fprintf (File, "%d.%d-%d.%d",			\
+	      (Loc).first_line, (Loc).first_column,	\
+	      (Loc).last_line,  (Loc).last_column)
+# else
+#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+# endif
+#endif
+
+
+/* YYLEX -- calling `yylex' with the right arguments.  */
+
+#ifdef YYLEX_PARAM
+# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
+#else
+# define YYLEX yylex (&yylval, &yylloc, answer, errors, locations, lexer)
+#endif
+
+/* Enable debugging if requested.  */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args)			\
+do {						\
+  if (yydebug)					\
+    YYFPRINTF Args;				\
+} while (YYID (0))
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)			  \
+do {									  \
+  if (yydebug)								  \
+    {									  \
+      YYFPRINTF (stderr, "%s ", Title);					  \
+      yy_symbol_print (stderr,						  \
+		  Type, Value, Location, answer, errors, locations, lexer); \
+      YYFPRINTF (stderr, "\n");						  \
+    }									  \
+} while (YYID (0))
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
+
+/*ARGSUSED*/
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, block* answer, int* errors, struct locfile* locations, yyscan_t lexer)
+#else
+static void
+yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors, locations, lexer)
+    FILE *yyoutput;
+    int yytype;
+    YYSTYPE const * const yyvaluep;
+    YYLTYPE const * const yylocationp;
+    block* answer;
+    int* errors;
+    struct locfile* locations;
+    yyscan_t lexer;
+#endif
+{
+  if (!yyvaluep)
+    return;
+  YYUSE (yylocationp);
+  YYUSE (answer);
+  YYUSE (errors);
+  YYUSE (locations);
+  YYUSE (lexer);
+# ifdef YYPRINT
+  if (yytype < YYNTOKENS)
+    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# else
+  YYUSE (yyoutput);
+# endif
+  switch (yytype)
+    {
+      default:
+	break;
+    }
+}
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
+
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, block* answer, int* errors, struct locfile* locations, yyscan_t lexer)
+#else
+static void
+yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors, locations, lexer)
+    FILE *yyoutput;
+    int yytype;
+    YYSTYPE const * const yyvaluep;
+    YYLTYPE const * const yylocationp;
+    block* answer;
+    int* errors;
+    struct locfile* locations;
+    yyscan_t lexer;
+#endif
+{
+  if (yytype < YYNTOKENS)
+    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
+  else
+    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
+
+  YY_LOCATION_PRINT (yyoutput, *yylocationp);
+  YYFPRINTF (yyoutput, ": ");
+  yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors, locations, lexer);
+  YYFPRINTF (yyoutput, ")");
+}
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included).                                                   |
+`------------------------------------------------------------------*/
+
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
+#else
+static void
+yy_stack_print (yybottom, yytop)
+    yytype_int16 *yybottom;
+    yytype_int16 *yytop;
+#endif
+{
+  YYFPRINTF (stderr, "Stack now");
+  for (; yybottom <= yytop; yybottom++)
+    {
+      int yybot = *yybottom;
+      YYFPRINTF (stderr, " %d", yybot);
+    }
+  YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top)				\
+do {								\
+  if (yydebug)							\
+    yy_stack_print ((Bottom), (Top));				\
+} while (YYID (0))
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced.  |
+`------------------------------------------------*/
+
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, block* answer, int* errors, struct locfile* locations, yyscan_t lexer)
+#else
+static void
+yy_reduce_print (yyvsp, yylsp, yyrule, answer, errors, locations, lexer)
+    YYSTYPE *yyvsp;
+    YYLTYPE *yylsp;
+    int yyrule;
+    block* answer;
+    int* errors;
+    struct locfile* locations;
+    yyscan_t lexer;
+#endif
+{
+  int yynrhs = yyr2[yyrule];
+  int yyi;
+  unsigned long int yylno = yyrline[yyrule];
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+	     yyrule - 1, yylno);
+  /* The symbols being reduced.  */
+  for (yyi = 0; yyi < yynrhs; yyi++)
+    {
+      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
+      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
+		       &(yyvsp[(yyi + 1) - (yynrhs)])
+		       , &(yylsp[(yyi + 1) - (yynrhs)])		       , answer, errors, locations, lexer);
+      YYFPRINTF (stderr, "\n");
+    }
+}
+
+# define YY_REDUCE_PRINT(Rule)		\
+do {					\
+  if (yydebug)				\
+    yy_reduce_print (yyvsp, yylsp, Rule, answer, errors, locations, lexer); \
+} while (YYID (0))
+
+/* Nonzero means print parse trace.  It is left uninitialized so that
+   multiple parsers can coexist.  */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks.  */
+#ifndef	YYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+   if the built-in stack extension method is used).
+
+   Do not make this value too large; the results are undefined if
+   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+   evaluated with infinite-precision integer arithmetic.  */
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+
+
+#if YYERROR_VERBOSE
+
+# ifndef yystrlen
+#  if defined __GLIBC__ && defined _STRING_H
+#   define yystrlen strlen
+#  else
+/* Return the length of YYSTR.  */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static YYSIZE_T
+yystrlen (const char *yystr)
+#else
+static YYSIZE_T
+yystrlen (yystr)
+    const char *yystr;
+#endif
+{
+  YYSIZE_T yylen;
+  for (yylen = 0; yystr[yylen]; yylen++)
+    continue;
+  return yylen;
+}
+#  endif
+# endif
+
+# ifndef yystpcpy
+#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
+#   define yystpcpy stpcpy
+#  else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+   YYDEST.  */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static char *
+yystpcpy (char *yydest, const char *yysrc)
+#else
+static char *
+yystpcpy (yydest, yysrc)
+    char *yydest;
+    const char *yysrc;
+#endif
+{
+  char *yyd = yydest;
+  const char *yys = yysrc;
+
+  while ((*yyd++ = *yys++) != '\0')
+    continue;
+
+  return yyd - 1;
+}
+#  endif
+# endif
+
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+   quotes and backslashes, so that it's suitable for yyerror.  The
+   heuristic is that double-quoting is unnecessary unless the string
+   contains an apostrophe, a comma, or backslash (other than
+   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
+   null, do not copy; instead, return the length of what the result
+   would have been.  */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+  if (*yystr == '"')
+    {
+      YYSIZE_T yyn = 0;
+      char const *yyp = yystr;
+
+      for (;;)
+	switch (*++yyp)
+	  {
+	  case '\'':
+	  case ',':
+	    goto do_not_strip_quotes;
+
+	  case '\\':
+	    if (*++yyp != '\\')
+	      goto do_not_strip_quotes;
+	    /* Fall through.  */
+	  default:
+	    if (yyres)
+	      yyres[yyn] = *yyp;
+	    yyn++;
+	    break;
+
+	  case '"':
+	    if (yyres)
+	      yyres[yyn] = '\0';
+	    return yyn;
+	  }
+    do_not_strip_quotes: ;
+    }
+
+  if (! yyres)
+    return yystrlen (yystr);
+
+  return yystpcpy (yyres, yystr) - yyres;
+}
+# endif
+
+/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
+   about the unexpected token YYTOKEN for the state stack whose top is
+   YYSSP.
+
+   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
+   not large enough to hold the message.  In that case, also set
+   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
+   required number of bytes is too large to store.  */
+static int
+yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
+                yytype_int16 *yyssp, int yytoken)
+{
+  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
+  YYSIZE_T yysize = yysize0;
+  YYSIZE_T yysize1;
+  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+  /* Internationalized format string. */
+  const char *yyformat = 0;
+  /* Arguments of yyformat. */
+  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+  /* Number of reported tokens (one for the "unexpected", one per
+     "expected"). */
+  int yycount = 0;
+
+  /* There are many possibilities here to consider:
+     - Assume YYFAIL is not used.  It's too flawed to consider.  See
+       <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
+       for details.  YYERROR is fine as it does not invoke this
+       function.
+     - If this state is a consistent state with a default action, then
+       the only way this function was invoked is if the default action
+       is an error action.  In that case, don't check for expected
+       tokens because there are none.
+     - The only way there can be no lookahead present (in yychar) is if
+       this state is a consistent state with a default action.  Thus,
+       detecting the absence of a lookahead is sufficient to determine
+       that there is no unexpected or expected token to report.  In that
+       case, just report a simple "syntax error".
+     - Don't assume there isn't a lookahead just because this state is a
+       consistent state with a default action.  There might have been a
+       previous inconsistent state, consistent state with a non-default
+       action, or user semantic action that manipulated yychar.
+     - Of course, the expected token list depends on states to have
+       correct lookahead information, and it depends on the parser not
+       to perform extra reductions after fetching a lookahead from the
+       scanner and before detecting a syntax error.  Thus, state merging
+       (from LALR or IELR) and default reductions corrupt the expected
+       token list.  However, the list is correct for canonical LR with
+       one exception: it will still contain any token that will not be
+       accepted due to an error action in a later state.
+  */
+  if (yytoken != YYEMPTY)
+    {
+      int yyn = yypact[*yyssp];
+      yyarg[yycount++] = yytname[yytoken];
+      if (!yypact_value_is_default (yyn))
+        {
+          /* Start YYX at -YYN if negative to avoid negative indexes in
+             YYCHECK.  In other words, skip the first -YYN actions for
+             this state because they are default actions.  */
+          int yyxbegin = yyn < 0 ? -yyn : 0;
+          /* Stay within bounds of both yycheck and yytname.  */
+          int yychecklim = YYLAST - yyn + 1;
+          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+          int yyx;
+
+          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
+                && !yytable_value_is_error (yytable[yyx + yyn]))
+              {
+                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+                  {
+                    yycount = 1;
+                    yysize = yysize0;
+                    break;
+                  }
+                yyarg[yycount++] = yytname[yyx];
+                yysize1 = yysize + yytnamerr (0, yytname[yyx]);
+                if (! (yysize <= yysize1
+                       && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+                  return 2;
+                yysize = yysize1;
+              }
+        }
+    }
+
+  switch (yycount)
+    {
+# define YYCASE_(N, S)                      \
+      case N:                               \
+        yyformat = S;                       \
+      break
+      YYCASE_(0, YY_("syntax error"));
+      YYCASE_(1, YY_("syntax error, unexpected %s"));
+      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
+      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
+# undef YYCASE_
+    }
+
+  yysize1 = yysize + yystrlen (yyformat);
+  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+    return 2;
+  yysize = yysize1;
+
+  if (*yymsg_alloc < yysize)
+    {
+      *yymsg_alloc = 2 * yysize;
+      if (! (yysize <= *yymsg_alloc
+             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
+        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
+      return 1;
+    }
+
+  /* Avoid sprintf, as that infringes on the user's name space.
+     Don't have undefined behavior even if the translation
+     produced a string with the wrong number of "%s"s.  */
+  {
+    char *yyp = *yymsg;
+    int yyi = 0;
+    while ((*yyp = *yyformat) != '\0')
+      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
+        {
+          yyp += yytnamerr (yyp, yyarg[yyi++]);
+          yyformat += 2;
+        }
+      else
+        {
+          yyp++;
+          yyformat++;
+        }
+  }
+  return 0;
+}
+#endif /* YYERROR_VERBOSE */
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol.  |
+`-----------------------------------------------*/
+
+/*ARGSUSED*/
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, block* answer, int* errors, struct locfile* locations, yyscan_t lexer)
+#else
+static void
+yydestruct (yymsg, yytype, yyvaluep, yylocationp, answer, errors, locations, lexer)
+    const char *yymsg;
+    int yytype;
+    YYSTYPE *yyvaluep;
+    YYLTYPE *yylocationp;
+    block* answer;
+    int* errors;
+    struct locfile* locations;
+    yyscan_t lexer;
+#endif
+{
+  YYUSE (yyvaluep);
+  YYUSE (yylocationp);
+  YYUSE (answer);
+  YYUSE (errors);
+  YYUSE (locations);
+  YYUSE (lexer);
+
+  if (!yymsg)
+    yymsg = "Deleting";
+  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+
+  switch (yytype)
+    {
+      case 4: /* "IDENT" */
+
+/* Line 1391 of yacc.c  */
+#line 29 "parser.y"
+	{ jv_free((yyvaluep->literal)); };
+
+/* Line 1391 of yacc.c  */
+#line 1511 "parser.gen.c"
+	break;
+      case 5: /* "LITERAL" */
+
+/* Line 1391 of yacc.c  */
+#line 29 "parser.y"
+	{ jv_free((yyvaluep->literal)); };
+
+/* Line 1391 of yacc.c  */
+#line 1520 "parser.gen.c"
+	break;
+      case 26: /* "QQSTRING_TEXT" */
+
+/* Line 1391 of yacc.c  */
+#line 29 "parser.y"
+	{ jv_free((yyvaluep->literal)); };
+
+/* Line 1391 of yacc.c  */
+#line 1529 "parser.gen.c"
+	break;
+      case 51: /* "FuncDefs" */
+
+/* Line 1391 of yacc.c  */
+#line 30 "parser.y"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1538 "parser.gen.c"
+	break;
+      case 52: /* "Exp" */
+
+/* Line 1391 of yacc.c  */
+#line 30 "parser.y"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1547 "parser.gen.c"
+	break;
+      case 53: /* "String" */
+
+/* Line 1391 of yacc.c  */
+#line 30 "parser.y"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1556 "parser.gen.c"
+	break;
+      case 54: /* "FuncDef" */
+
+/* Line 1391 of yacc.c  */
+#line 30 "parser.y"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1565 "parser.gen.c"
+	break;
+      case 55: /* "QQString" */
+
+/* Line 1391 of yacc.c  */
+#line 30 "parser.y"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1574 "parser.gen.c"
+	break;
+      case 56: /* "ElseBody" */
+
+/* Line 1391 of yacc.c  */
+#line 30 "parser.y"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1583 "parser.gen.c"
+	break;
+      case 57: /* "ExpD" */
+
+/* Line 1391 of yacc.c  */
+#line 30 "parser.y"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1592 "parser.gen.c"
+	break;
+      case 58: /* "Term" */
+
+/* Line 1391 of yacc.c  */
+#line 30 "parser.y"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1601 "parser.gen.c"
+	break;
+      case 59: /* "MkDict" */
+
+/* Line 1391 of yacc.c  */
+#line 30 "parser.y"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1610 "parser.gen.c"
+	break;
+      case 60: /* "MkDictPair" */
+
+/* Line 1391 of yacc.c  */
+#line 30 "parser.y"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1619 "parser.gen.c"
+	break;
+
+      default:
+	break;
+    }
+}
+
+
+/* Prevent warnings from -Wmissing-prototypes.  */
+#ifdef YYPARSE_PARAM
+#if defined __STDC__ || defined __cplusplus
+int yyparse (void *YYPARSE_PARAM);
+#else
+int yyparse ();
+#endif
+#else /* ! YYPARSE_PARAM */
+#if defined __STDC__ || defined __cplusplus
+int yyparse (block* answer, int* errors, struct locfile* locations, yyscan_t lexer);
+#else
+int yyparse ();
+#endif
+#endif /* ! YYPARSE_PARAM */
+
+
+/*----------.
+| yyparse.  |
+`----------*/
+
+#ifdef YYPARSE_PARAM
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+int
+yyparse (void *YYPARSE_PARAM)
+#else
+int
+yyparse (YYPARSE_PARAM)
+    void *YYPARSE_PARAM;
+#endif
+#else /* ! YYPARSE_PARAM */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+int
+yyparse (block* answer, int* errors, struct locfile* locations, yyscan_t lexer)
+#else
+int
+yyparse (answer, errors, locations, lexer)
+    block* answer;
+    int* errors;
+    struct locfile* locations;
+    yyscan_t lexer;
+#endif
+#endif
+{
+/* The lookahead symbol.  */
+int yychar;
+
+/* The semantic value of the lookahead symbol.  */
+YYSTYPE yylval;
+
+/* Location data for the lookahead symbol.  */
+YYLTYPE yylloc;
+
+    /* Number of syntax errors so far.  */
+    int yynerrs;
+
+    int yystate;
+    /* Number of tokens to shift before error messages enabled.  */
+    int yyerrstatus;
+
+    /* The stacks and their tools:
+       `yyss': related to states.
+       `yyvs': related to semantic values.
+       `yyls': related to locations.
+
+       Refer to the stacks thru separate pointers, to allow yyoverflow
+       to reallocate them elsewhere.  */
+
+    /* The state stack.  */
+    yytype_int16 yyssa[YYINITDEPTH];
+    yytype_int16 *yyss;
+    yytype_int16 *yyssp;
+
+    /* The semantic value stack.  */
+    YYSTYPE yyvsa[YYINITDEPTH];
+    YYSTYPE *yyvs;
+    YYSTYPE *yyvsp;
+
+    /* The location stack.  */
+    YYLTYPE yylsa[YYINITDEPTH];
+    YYLTYPE *yyls;
+    YYLTYPE *yylsp;
+
+    /* The locations where the error started and ended.  */
+    YYLTYPE yyerror_range[3];
+
+    YYSIZE_T yystacksize;
+
+  int yyn;
+  int yyresult;
+  /* Lookahead token as an internal (translated) token number.  */
+  int yytoken;
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;
+  YYLTYPE yyloc;
+
+#if YYERROR_VERBOSE
+  /* Buffer for error messages, and its allocated size.  */
+  char yymsgbuf[128];
+  char *yymsg = yymsgbuf;
+  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
+#endif
+
+#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
+
+  /* The number of symbols on the RHS of the reduced rule.
+     Keep to zero when no symbol should be popped.  */
+  int yylen = 0;
+
+  yytoken = 0;
+  yyss = yyssa;
+  yyvs = yyvsa;
+  yyls = yylsa;
+  yystacksize = YYINITDEPTH;
+
+  YYDPRINTF ((stderr, "Starting parse\n"));
+
+  yystate = 0;
+  yyerrstatus = 0;
+  yynerrs = 0;
+  yychar = YYEMPTY; /* Cause a token to be read.  */
+
+  /* Initialize stack pointers.
+     Waste one element of value and location stack
+     so that they stay on the same level as the state stack.
+     The wasted elements are never initialized.  */
+  yyssp = yyss;
+  yyvsp = yyvs;
+  yylsp = yyls;
+
+#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
+  /* Initialize the default location before parsing starts.  */
+  yylloc.first_line   = yylloc.last_line   = 1;
+  yylloc.first_column = yylloc.last_column = 1;
+#endif
+
+  goto yysetstate;
+
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate.  |
+`------------------------------------------------------------*/
+ yynewstate:
+  /* In all cases, when you get here, the value and location stacks
+     have just been pushed.  So pushing a state here evens the stacks.  */
+  yyssp++;
+
+ yysetstate:
+  *yyssp = yystate;
+
+  if (yyss + yystacksize - 1 <= yyssp)
+    {
+      /* Get the current used size of the three stacks, in elements.  */
+      YYSIZE_T yysize = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+      {
+	/* Give user a chance to reallocate the stack.  Use copies of
+	   these so that the &'s don't force the real ones into
+	   memory.  */
+	YYSTYPE *yyvs1 = yyvs;
+	yytype_int16 *yyss1 = yyss;
+	YYLTYPE *yyls1 = yyls;
+
+	/* Each stack pointer address is followed by the size of the
+	   data in use in that stack, in bytes.  This used to be a
+	   conditional around just the two extra args, but that might
+	   be undefined if yyoverflow is a macro.  */
+	yyoverflow (YY_("memory exhausted"),
+		    &yyss1, yysize * sizeof (*yyssp),
+		    &yyvs1, yysize * sizeof (*yyvsp),
+		    &yyls1, yysize * sizeof (*yylsp),
+		    &yystacksize);
+
+	yyls = yyls1;
+	yyss = yyss1;
+	yyvs = yyvs1;
+      }
+#else /* no yyoverflow */
+# ifndef YYSTACK_RELOCATE
+      goto yyexhaustedlab;
+# else
+      /* Extend the stack our own way.  */
+      if (YYMAXDEPTH <= yystacksize)
+	goto yyexhaustedlab;
+      yystacksize *= 2;
+      if (YYMAXDEPTH < yystacksize)
+	yystacksize = YYMAXDEPTH;
+
+      {
+	yytype_int16 *yyss1 = yyss;
+	union yyalloc *yyptr =
+	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+	if (! yyptr)
+	  goto yyexhaustedlab;
+	YYSTACK_RELOCATE (yyss_alloc, yyss);
+	YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+	YYSTACK_RELOCATE (yyls_alloc, yyls);
+#  undef YYSTACK_RELOCATE
+	if (yyss1 != yyssa)
+	  YYSTACK_FREE (yyss1);
+      }
+# endif
+#endif /* no yyoverflow */
+
+      yyssp = yyss + yysize - 1;
+      yyvsp = yyvs + yysize - 1;
+      yylsp = yyls + yysize - 1;
+
+      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+		  (unsigned long int) yystacksize));
+
+      if (yyss + yystacksize - 1 <= yyssp)
+	YYABORT;
+    }
+
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+
+  if (yystate == YYFINAL)
+    YYACCEPT;
+
+  goto yybackup;
+
+/*-----------.
+| yybackup.  |
+`-----------*/
+yybackup:
+
+  /* Do appropriate processing given the current state.  Read a
+     lookahead token if we need one and don't already have one.  */
+
+  /* First try to decide what to do without reference to lookahead token.  */
+  yyn = yypact[yystate];
+  if (yypact_value_is_default (yyn))
+    goto yydefault;
+
+  /* Not known => get a lookahead token if don't already have one.  */
+
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
+  if (yychar == YYEMPTY)
+    {
+      YYDPRINTF ((stderr, "Reading a token: "));
+      yychar = YYLEX;
+    }
+
+  if (yychar <= YYEOF)
+    {
+      yychar = yytoken = YYEOF;
+      YYDPRINTF ((stderr, "Now at end of input.\n"));
+    }
+  else
+    {
+      yytoken = YYTRANSLATE (yychar);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+    }
+
+  /* If the proper action on seeing token YYTOKEN is to reduce or to
+     detect an error, take that action.  */
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+    goto yydefault;
+  yyn = yytable[yyn];
+  if (yyn <= 0)
+    {
+      if (yytable_value_is_error (yyn))
+        goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+
+  /* Count tokens shifted since error; after three, turn off error
+     status.  */
+  if (yyerrstatus)
+    yyerrstatus--;
+
+  /* Shift the lookahead token.  */
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+
+  /* Discard the shifted token.  */
+  yychar = YYEMPTY;
+
+  yystate = yyn;
+  *++yyvsp = yylval;
+  *++yylsp = yylloc;
+  goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state.  |
+`-----------------------------------------------------------*/
+yydefault:
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+  goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- Do a reduction.  |
+`-----------------------------*/
+yyreduce:
+  /* yyn is the number of a rule to reduce with.  */
+  yylen = yyr2[yyn];
+
+  /* If YYLEN is nonzero, implement the default value of the action:
+     `$$ = $1'.
+
+     Otherwise, the following line sets YYVAL to garbage.
+     This behavior is undocumented and Bison
+     users should not rely upon it.  Assigning to YYVAL
+     unconditionally makes the parser a bit smaller, and it avoids a
+     GCC warning that YYVAL may be used uninitialized.  */
+  yyval = yyvsp[1-yylen];
+
+  /* Default location.  */
+  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
+  YY_REDUCE_PRINT (yyn);
+  switch (yyn)
+    {
+        case 2:
+
+/* Line 1806 of yacc.c  */
+#line 174 "parser.y"
+    {
+  *answer = (yyvsp[(1) - (1)].blk);
+}
+    break;
+
+  case 3:
+
+/* Line 1806 of yacc.c  */
+#line 177 "parser.y"
+    {
+  *answer = (yyvsp[(1) - (1)].blk);
+}
+    break;
+
+  case 4:
+
+/* Line 1806 of yacc.c  */
+#line 182 "parser.y"
+    {
+  (yyval.blk) = gen_noop();
+}
+    break;
+
+  case 5:
+
+/* Line 1806 of yacc.c  */
+#line 185 "parser.y"
+    {
+  (yyval.blk) = block_join((yyvsp[(1) - (2)].blk), (yyvsp[(2) - (2)].blk));
+}
+    break;
+
+  case 6:
+
+/* Line 1806 of yacc.c  */
+#line 190 "parser.y"
+    {
+  (yyval.blk) = block_bind((yyvsp[(1) - (2)].blk), (yyvsp[(2) - (2)].blk), OP_IS_CALL_PSEUDO);
+}
+    break;
+
+  case 7:
+
+/* Line 1806 of yacc.c  */
+#line 194 "parser.y"
+    {
+  (yyval.blk) = gen_op_simple(DUP);
+  block_append(&(yyval.blk), (yyvsp[(1) - (6)].blk));
+  block_append(&(yyval.blk), block_bind(gen_op_var_unbound(STOREV, jv_string_value((yyvsp[(4) - (6)].literal))), (yyvsp[(6) - (6)].blk), OP_HAS_VARIABLE));
+  jv_free((yyvsp[(4) - (6)].literal));
+}
+    break;
+
+  case 8:
+
+/* Line 1806 of yacc.c  */
+#line 201 "parser.y"
+    {
+  (yyval.blk) = gen_cond((yyvsp[(2) - (5)].blk), (yyvsp[(4) - (5)].blk), (yyvsp[(5) - (5)].blk));
+}
+    break;
+
+  case 9:
+
+/* Line 1806 of yacc.c  */
+#line 204 "parser.y"
+    {
+  FAIL((yyloc), "Possibly unterminated 'if' statment");
+  (yyval.blk) = (yyvsp[(2) - (3)].blk);
+}
+    break;
+
+  case 10:
+
+/* Line 1806 of yacc.c  */
+#line 209 "parser.y"
+    {
+  block assign = gen_op_simple(DUP);
+  block_append(&assign, (yyvsp[(3) - (3)].blk));
+  block_append(&assign, gen_op_simple(SWAP));
+  block_append(&assign, (yyvsp[(1) - (3)].blk));
+  block_append(&assign, gen_op_simple(SWAP));
+  (yyval.blk) = gen_assign(assign);
+}
+    break;
+
+  case 11:
+
+/* Line 1806 of yacc.c  */
+#line 218 "parser.y"
+    {
+  (yyval.blk) = gen_or((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
+}
+    break;
+
+  case 12:
+
+/* Line 1806 of yacc.c  */
+#line 222 "parser.y"
+    {
+  (yyval.blk) = gen_and((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
+}
+    break;
+
+  case 13:
+
+/* Line 1806 of yacc.c  */
+#line 226 "parser.y"
+    {
+  (yyval.blk) = gen_definedor((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
+}
+    break;
+
+  case 14:
+
+/* Line 1806 of yacc.c  */
+#line 230 "parser.y"
+    {
+  (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), gen_definedor(gen_noop(), (yyvsp[(3) - (3)].blk)), 0);
+}
+    break;
+
+  case 15:
+
+/* Line 1806 of yacc.c  */
+#line 234 "parser.y"
+    {
+  (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), 0);
+}
+    break;
+
+  case 16:
+
+/* Line 1806 of yacc.c  */
+#line 238 "parser.y"
+    { 
+  (yyval.blk) = block_join((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk)); 
+}
+    break;
+
+  case 17:
+
+/* Line 1806 of yacc.c  */
+#line 242 "parser.y"
+    { 
+  (yyval.blk) = gen_both((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk)); 
+}
+    break;
+
+  case 18:
+
+/* Line 1806 of yacc.c  */
+#line 246 "parser.y"
+    {
+  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '+');
+}
+    break;
+
+  case 19:
+
+/* Line 1806 of yacc.c  */
+#line 250 "parser.y"
+    {
+  (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '+');
+}
+    break;
+
+  case 20:
+
+/* Line 1806 of yacc.c  */
+#line 254 "parser.y"
+    {
+  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '-');
+}
+    break;
+
+  case 21:
+
+/* Line 1806 of yacc.c  */
+#line 258 "parser.y"
+    {
+  (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '-');
+}
+    break;
+
+  case 22:
+
+/* Line 1806 of yacc.c  */
+#line 262 "parser.y"
+    {
+  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '*');
+}
+    break;
+
+  case 23:
+
+/* Line 1806 of yacc.c  */
+#line 266 "parser.y"
+    {
+  (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '*');
+}
+    break;
+
+  case 24:
+
+/* Line 1806 of yacc.c  */
+#line 270 "parser.y"
+    {
+  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '/');
+}
+    break;
+
+  case 25:
+
+/* Line 1806 of yacc.c  */
+#line 274 "parser.y"
+    {
+  (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '/');
+}
+    break;
+
+  case 26:
+
+/* Line 1806 of yacc.c  */
+#line 278 "parser.y"
+    {
+  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), EQ);
+}
+    break;
+
+  case 27:
+
+/* Line 1806 of yacc.c  */
+#line 282 "parser.y"
+    {
+  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '<');
+}
+    break;
+
+  case 28:
+
+/* Line 1806 of yacc.c  */
+#line 286 "parser.y"
+    {
+  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '>');
+}
+    break;
+
+  case 29:
+
+/* Line 1806 of yacc.c  */
+#line 290 "parser.y"
+    {
+  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), LESSEQ);
+}
+    break;
+
+  case 30:
+
+/* Line 1806 of yacc.c  */
+#line 294 "parser.y"
+    {
+  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), GREATEREQ);
+}
+    break;
+
+  case 31:
+
+/* Line 1806 of yacc.c  */
+#line 298 "parser.y"
+    {
+  (yyval.blk) = (yyvsp[(1) - (1)].blk);
+}
+    break;
+
+  case 32:
+
+/* Line 1806 of yacc.c  */
+#line 302 "parser.y"
+    { 
+  (yyval.blk) = (yyvsp[(1) - (1)].blk); 
+}
+    break;
+
+  case 33:
+
+/* Line 1806 of yacc.c  */
+#line 307 "parser.y"
+    {
+  (yyval.blk) = (yyvsp[(2) - (3)].blk);
+}
+    break;
+
+  case 34:
+
+/* Line 1806 of yacc.c  */
+#line 312 "parser.y"
+    {
+  block body = block_join((yyvsp[(4) - (5)].blk), gen_op_simple(RET));
+  (yyval.blk) = gen_op_block_defn_rec(CLOSURE_CREATE, jv_string_value((yyvsp[(2) - (5)].literal)), body);
+  jv_free((yyvsp[(2) - (5)].literal));
+}
+    break;
+
+  case 35:
+
+/* Line 1806 of yacc.c  */
+#line 318 "parser.y"
+    {
+  block body = block_bind(gen_op_block_unbound(CLOSURE_PARAM, jv_string_value((yyvsp[(4) - (8)].literal))), block_join((yyvsp[(7) - (8)].blk), gen_op_simple(RET)), OP_IS_CALL_PSEUDO);
+  (yyval.blk) = gen_op_block_defn_rec(CLOSURE_CREATE, jv_string_value((yyvsp[(2) - (8)].literal)), body);
+  jv_free((yyvsp[(2) - (8)].literal));
+  jv_free((yyvsp[(4) - (8)].literal));
+}
+    break;
+
+  case 36:
+
+/* Line 1806 of yacc.c  */
+#line 326 "parser.y"
+    {
+  (yyval.blk) = gen_op_const(LOADK, jv_string(""));
+}
+    break;
+
+  case 37:
+
+/* Line 1806 of yacc.c  */
+#line 329 "parser.y"
+    {
+  (yyval.blk) = gen_binop((yyvsp[(1) - (2)].blk), gen_op_const(LOADK, (yyvsp[(2) - (2)].literal)), '+');
+}
+    break;
+
+  case 38:
+
+/* Line 1806 of yacc.c  */
+#line 332 "parser.y"
+    {
+  (yyval.blk) = gen_binop((yyvsp[(1) - (4)].blk), gen_format((yyvsp[(3) - (4)].blk)), '+');
+}
+    break;
+
+  case 39:
+
+/* Line 1806 of yacc.c  */
+#line 338 "parser.y"
+    {
+  (yyval.blk) = gen_cond((yyvsp[(2) - (5)].blk), (yyvsp[(4) - (5)].blk), (yyvsp[(5) - (5)].blk));
+}
+    break;
+
+  case 40:
+
+/* Line 1806 of yacc.c  */
+#line 341 "parser.y"
+    {
+  (yyval.blk) = (yyvsp[(2) - (3)].blk);
+}
+    break;
+
+  case 41:
+
+/* Line 1806 of yacc.c  */
+#line 346 "parser.y"
+    { 
+  (yyval.blk) = block_join((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
+}
+    break;
+
+  case 42:
+
+/* Line 1806 of yacc.c  */
+#line 350 "parser.y"
+    {
+  (yyval.blk) = (yyvsp[(1) - (1)].blk);
+}
+    break;
+
+  case 43:
+
+/* Line 1806 of yacc.c  */
+#line 356 "parser.y"
+    {
+  (yyval.blk) = gen_noop(); 
+}
+    break;
+
+  case 44:
+
+/* Line 1806 of yacc.c  */
+#line 359 "parser.y"
+    {
+  (yyval.blk) = gen_index((yyvsp[(1) - (3)].blk), gen_op_const(LOADK, (yyvsp[(3) - (3)].literal))); 
+}
+    break;
+
+  case 45:
+
+/* Line 1806 of yacc.c  */
+#line 362 "parser.y"
+    { 
+  (yyval.blk) = gen_index(gen_noop(), gen_op_const(LOADK, (yyvsp[(2) - (2)].literal))); 
+}
+    break;
+
+  case 46:
+
+/* Line 1806 of yacc.c  */
+#line 366 "parser.y"
+    {
+  (yyval.blk) = gen_index((yyvsp[(1) - (4)].blk), (yyvsp[(3) - (4)].blk)); 
+}
+    break;
+
+  case 47:
+
+/* Line 1806 of yacc.c  */
+#line 369 "parser.y"
+    {
+  (yyval.blk) = block_join((yyvsp[(1) - (3)].blk), gen_op_simple(EACH)); 
+}
+    break;
+
+  case 48:
+
+/* Line 1806 of yacc.c  */
+#line 372 "parser.y"
+    {
+  (yyval.blk) = gen_op_const(LOADK, (yyvsp[(1) - (1)].literal)); 
+}
+    break;
+
+  case 49:
+
+/* Line 1806 of yacc.c  */
+#line 375 "parser.y"
+    { 
+  (yyval.blk) = (yyvsp[(2) - (3)].blk); 
+}
+    break;
+
+  case 50:
+
+/* Line 1806 of yacc.c  */
+#line 378 "parser.y"
+    { 
+  (yyval.blk) = gen_collect((yyvsp[(2) - (3)].blk)); 
+}
+    break;
+
+  case 51:
+
+/* Line 1806 of yacc.c  */
+#line 381 "parser.y"
+    { 
+  (yyval.blk) = gen_op_const(LOADK, jv_array()); 
+}
+    break;
+
+  case 52:
+
+/* Line 1806 of yacc.c  */
+#line 384 "parser.y"
+    { 
+  (yyval.blk) = gen_subexp(gen_op_const(LOADK, jv_object()));
+  block_append(&(yyval.blk), (yyvsp[(2) - (3)].blk));
+  block_append(&(yyval.blk), gen_op_simple(POP));
+}
+    break;
+
+  case 53:
+
+/* Line 1806 of yacc.c  */
+#line 389 "parser.y"
+    {
+  (yyval.blk) = gen_location((yyloc), gen_op_var_unbound(LOADV, jv_string_value((yyvsp[(2) - (2)].literal))));
+  jv_free((yyvsp[(2) - (2)].literal));
+}
+    break;
+
+  case 54:
+
+/* Line 1806 of yacc.c  */
+#line 393 "parser.y"
+    {
+  (yyval.blk) = gen_location((yyloc), gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, jv_string_value((yyvsp[(1) - (1)].literal)))));
+  jv_free((yyvsp[(1) - (1)].literal));
+}
+    break;
+
+  case 55:
+
+/* Line 1806 of yacc.c  */
+#line 397 "parser.y"
+    {
+  (yyval.blk) = gen_op_call(CALL_1_1, 
+                   block_join(gen_op_block_unbound(CLOSURE_REF, jv_string_value((yyvsp[(1) - (4)].literal))),
+                              block_bind(gen_op_block_defn(CLOSURE_CREATE,
+                                                "lambda",
+                                                           block_join((yyvsp[(3) - (4)].blk), gen_op_simple(RET))),
+                                         gen_noop(), OP_IS_CALL_PSEUDO)));
+  (yyval.blk) = gen_location((yylsp[(1) - (4)]), (yyval.blk));
+  jv_free((yyvsp[(1) - (4)].literal));
+}
+    break;
+
+  case 56:
+
+/* Line 1806 of yacc.c  */
+#line 407 "parser.y"
+    { (yyval.blk) = gen_noop(); }
+    break;
+
+  case 57:
+
+/* Line 1806 of yacc.c  */
+#line 408 "parser.y"
+    { (yyval.blk) = gen_noop(); }
+    break;
+
+  case 58:
+
+/* Line 1806 of yacc.c  */
+#line 409 "parser.y"
+    { (yyval.blk) = (yyvsp[(1) - (4)].blk); }
+    break;
+
+  case 59:
+
+/* Line 1806 of yacc.c  */
+#line 410 "parser.y"
+    { (yyval.blk) = gen_noop(); }
+    break;
+
+  case 60:
+
+/* Line 1806 of yacc.c  */
+#line 413 "parser.y"
+    { 
+  (yyval.blk)=gen_noop(); 
+}
+    break;
+
+  case 61:
+
+/* Line 1806 of yacc.c  */
+#line 416 "parser.y"
+    { (yyval.blk) = (yyvsp[(1) - (1)].blk); }
+    break;
+
+  case 62:
+
+/* Line 1806 of yacc.c  */
+#line 417 "parser.y"
+    { (yyval.blk)=block_join((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk)); }
+    break;
+
+  case 63:
+
+/* Line 1806 of yacc.c  */
+#line 418 "parser.y"
+    { (yyval.blk) = (yyvsp[(3) - (3)].blk); }
+    break;
+
+  case 64:
+
+/* Line 1806 of yacc.c  */
+#line 421 "parser.y"
+    { 
+  (yyval.blk) = gen_dictpair(gen_op_const(LOADK, (yyvsp[(1) - (3)].literal)), (yyvsp[(3) - (3)].blk));
+ }
+    break;
+
+  case 65:
+
+/* Line 1806 of yacc.c  */
+#line 424 "parser.y"
+    {
+  (yyval.blk) = gen_dictpair((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
+  }
+    break;
+
+  case 66:
+
+/* Line 1806 of yacc.c  */
+#line 427 "parser.y"
+    {
+  (yyval.blk) = gen_dictpair(gen_op_const(LOADK, jv_copy((yyvsp[(1) - (1)].literal))),
+                    gen_index(gen_noop(), gen_op_const(LOADK, (yyvsp[(1) - (1)].literal))));
+  }
+    break;
+
+  case 67:
+
+/* Line 1806 of yacc.c  */
+#line 431 "parser.y"
+    {
+  (yyval.blk) = gen_dictpair((yyvsp[(2) - (5)].blk), (yyvsp[(5) - (5)].blk));
+  }
+    break;
+
+  case 68:
+
+/* Line 1806 of yacc.c  */
+#line 434 "parser.y"
+    { (yyval.blk) = (yyvsp[(5) - (5)].blk); }
+    break;
+
+
+
+/* Line 1806 of yacc.c  */
+#line 2564 "parser.gen.c"
+      default: break;
+    }
+  /* User semantic actions sometimes alter yychar, and that requires
+     that yytoken be updated with the new translation.  We take the
+     approach of translating immediately before every use of yytoken.
+     One alternative is translating here after every semantic action,
+     but that translation would be missed if the semantic action invokes
+     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
+     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
+     incorrect destructor might then be invoked immediately.  In the
+     case of YYERROR or YYBACKUP, subsequent parser actions might lead
+     to an incorrect destructor call or verbose syntax error message
+     before the lookahead is translated.  */
+  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
+
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+
+  *++yyvsp = yyval;
+  *++yylsp = yyloc;
+
+  /* Now `shift' the result of the reduction.  Determine what state
+     that goes to, based on the state we popped back to and the rule
+     number reduced by.  */
+
+  yyn = yyr1[yyn];
+
+  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
+  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+    yystate = yytable[yystate];
+  else
+    yystate = yydefgoto[yyn - YYNTOKENS];
+
+  goto yynewstate;
+
+
+/*------------------------------------.
+| yyerrlab -- here on detecting error |
+`------------------------------------*/
+yyerrlab:
+  /* Make sure we have latest lookahead translation.  See comments at
+     user semantic actions for why this is necessary.  */
+  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
+
+  /* If not already recovering from an error, report this error.  */
+  if (!yyerrstatus)
+    {
+      ++yynerrs;
+#if ! YYERROR_VERBOSE
+      yyerror (&yylloc, answer, errors, locations, lexer, YY_("syntax error"));
+#else
+# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
+                                        yyssp, yytoken)
+      {
+        char const *yymsgp = YY_("syntax error");
+        int yysyntax_error_status;
+        yysyntax_error_status = YYSYNTAX_ERROR;
+        if (yysyntax_error_status == 0)
+          yymsgp = yymsg;
+        else if (yysyntax_error_status == 1)
+          {
+            if (yymsg != yymsgbuf)
+              YYSTACK_FREE (yymsg);
+            yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
+            if (!yymsg)
+              {
+                yymsg = yymsgbuf;
+                yymsg_alloc = sizeof yymsgbuf;
+                yysyntax_error_status = 2;
+              }
+            else
+              {
+                yysyntax_error_status = YYSYNTAX_ERROR;
+                yymsgp = yymsg;
+              }
+          }
+        yyerror (&yylloc, answer, errors, locations, lexer, yymsgp);
+        if (yysyntax_error_status == 2)
+          goto yyexhaustedlab;
+      }
+# undef YYSYNTAX_ERROR
+#endif
+    }
+
+  yyerror_range[1] = yylloc;
+
+  if (yyerrstatus == 3)
+    {
+      /* If just tried and failed to reuse lookahead token after an
+	 error, discard it.  */
+
+      if (yychar <= YYEOF)
+	{
+	  /* Return failure if at end of input.  */
+	  if (yychar == YYEOF)
+	    YYABORT;
+	}
+      else
+	{
+	  yydestruct ("Error: discarding",
+		      yytoken, &yylval, &yylloc, answer, errors, locations, lexer);
+	  yychar = YYEMPTY;
+	}
+    }
+
+  /* Else will try to reuse lookahead token after shifting the error
+     token.  */
+  goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
+
+  /* Pacify compilers like GCC when the user code never invokes
+     YYERROR and the label yyerrorlab therefore never appears in user
+     code.  */
+  if (/*CONSTCOND*/ 0)
+     goto yyerrorlab;
+
+  yyerror_range[1] = yylsp[1-yylen];
+  /* Do not reclaim the symbols of the rule which action triggered
+     this YYERROR.  */
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+  yystate = *yyssp;
+  goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
+yyerrlab1:
+  yyerrstatus = 3;	/* Each real token shifted decrements this.  */
+
+  for (;;)
+    {
+      yyn = yypact[yystate];
+      if (!yypact_value_is_default (yyn))
+	{
+	  yyn += YYTERROR;
+	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+	    {
+	      yyn = yytable[yyn];
+	      if (0 < yyn)
+		break;
+	    }
+	}
+
+      /* Pop the current state because it cannot handle the error token.  */
+      if (yyssp == yyss)
+	YYABORT;
+
+      yyerror_range[1] = *yylsp;
+      yydestruct ("Error: popping",
+		  yystos[yystate], yyvsp, yylsp, answer, errors, locations, lexer);
+      YYPOPSTACK (1);
+      yystate = *yyssp;
+      YY_STACK_PRINT (yyss, yyssp);
+    }
+
+  *++yyvsp = yylval;
+
+  yyerror_range[2] = yylloc;
+  /* Using YYLLOC is tempting, but would change the location of
+     the lookahead.  YYLOC is available though.  */
+  YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
+  *++yylsp = yyloc;
+
+  /* Shift the error token.  */
+  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
+
+  yystate = yyn;
+  goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here.  |
+`-------------------------------------*/
+yyacceptlab:
+  yyresult = 0;
+  goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here.  |
+`-----------------------------------*/
+yyabortlab:
+  yyresult = 1;
+  goto yyreturn;
+
+#if !defined(yyoverflow) || YYERROR_VERBOSE
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here.  |
+`-------------------------------------------------*/
+yyexhaustedlab:
+  yyerror (&yylloc, answer, errors, locations, lexer, YY_("memory exhausted"));
+  yyresult = 2;
+  /* Fall through.  */
+#endif
+
+yyreturn:
+  if (yychar != YYEMPTY)
+    {
+      /* Make sure we have latest lookahead translation.  See comments at
+         user semantic actions for why this is necessary.  */
+      yytoken = YYTRANSLATE (yychar);
+      yydestruct ("Cleanup: discarding lookahead",
+                  yytoken, &yylval, &yylloc, answer, errors, locations, lexer);
+    }
+  /* Do not reclaim the symbols of the rule which action triggered
+     this YYABORT or YYACCEPT.  */
+  YYPOPSTACK (yylen);
+  YY_STACK_PRINT (yyss, yyssp);
+  while (yyssp != yyss)
+    {
+      yydestruct ("Cleanup: popping",
+		  yystos[*yyssp], yyvsp, yylsp, answer, errors, locations, lexer);
+      YYPOPSTACK (1);
+    }
+#ifndef yyoverflow
+  if (yyss != yyssa)
+    YYSTACK_FREE (yyss);
+#endif
+#if YYERROR_VERBOSE
+  if (yymsg != yymsgbuf)
+    YYSTACK_FREE (yymsg);
+#endif
+  /* Make sure YYID is used.  */
+  return YYID (yyresult);
+}
+
+
+
+/* Line 2067 of yacc.c  */
+#line 435 "parser.y"
+
+
+int jq_parse(struct locfile* locations, block* answer) {
+  yyscan_t scanner;
+  YY_BUFFER_STATE buf;
+  jq_yylex_init_extra(0, &scanner);
+  buf = jq_yy_scan_bytes(locations->data, locations->length, scanner);
+  int errors = 0;
+  *answer = gen_noop();
+  yyparse(answer, &errors, locations, scanner);
+  jq_yy_delete_buffer(buf, scanner);
+  jq_yylex_destroy(scanner);
+  if (errors > 0) {
+    block_free(*answer);
+    *answer = gen_noop();
+  }
+  return errors;
+}
+
+int jq_parse_library(struct locfile* locations, block* answer) {
+  int errs = jq_parse(locations, answer);
+  if (errs) return errs;
+  if (!block_has_only_binders(*answer, OP_IS_CALL_PSEUDO)) {
+    locfile_locate(locations, UNKNOWN_LOCATION, "error: library should only have function definitions, not a main expression");
+    return 1;
+  }
+  return 0;
+}
+
diff --git a/parser.gen.h b/parser.gen.h
new file mode 100644
index 00000000..49bf4cc7
--- /dev/null
+++ b/parser.gen.h
@@ -0,0 +1,130 @@
+/* A Bison parser, made by GNU Bison 2.5.  */
+
+/* Bison interface for Yacc-like parsers in C
+   
+      Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
+   
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+   
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* "%code requires" blocks.  */
+
+/* Line 2068 of yacc.c  */
+#line 6 "parser.y"
+
+#include "locfile.h"
+#define YYLTYPE location
+#define YYLLOC_DEFAULT(Loc, Rhs, N)             \
+  do {                                          \
+    if (N) {                                    \
+      (Loc).start = YYRHSLOC(Rhs, 1).start;     \
+      (Loc).end = YYRHSLOC(Rhs, N).end;         \
+    } else {                                    \
+      (Loc).start = YYRHSLOC(Rhs, 0).end;       \
+      (Loc).end = YYRHSLOC(Rhs, 0).end;         \
+    }                                           \
+  } while (0)
+ 
+
+
+/* Line 2068 of yacc.c  */
+#line 55 "parser.gen.h"
+
+/* Tokens.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+   /* Put the tokens into the symbol table, so that GDB and other debuggers
+      know about them.  */
+   enum yytokentype {
+     INVALID_CHARACTER = 258,
+     IDENT = 259,
+     LITERAL = 260,
+     EQ = 261,
+     DEFINEDOR = 262,
+     AS = 263,
+     DEF = 264,
+     IF = 265,
+     THEN = 266,
+     ELSE = 267,
+     ELSE_IF = 268,
+     END = 269,
+     AND = 270,
+     OR = 271,
+     SETPIPE = 272,
+     SETPLUS = 273,
+     SETMINUS = 274,
+     SETMULT = 275,
+     SETDIV = 276,
+     SETDEFINEDOR = 277,
+     LESSEQ = 278,
+     GREATEREQ = 279,
+     QQSTRING_START = 280,
+     QQSTRING_TEXT = 281,
+     QQSTRING_INTERP_START = 282,
+     QQSTRING_INTERP_END = 283,
+     QQSTRING_END = 284
+   };
+#endif
+
+
+
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef union YYSTYPE
+{
+
+/* Line 2068 of yacc.c  */
+#line 24 "parser.y"
+
+  jv literal;
+  block blk;
+
+
+
+/* Line 2068 of yacc.c  */
+#line 108 "parser.gen.h"
+} YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+
+
+#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
+typedef struct YYLTYPE
+{
+  int first_line;
+  int first_column;
+  int last_line;
+  int last_column;
+} YYLTYPE;
+# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
+# define YYLTYPE_IS_DECLARED 1
+# define YYLTYPE_IS_TRIVIAL 1
+#endif
+
+
+
diff --git a/parser.gen.info b/parser.gen.info
new file mode 100644
index 00000000..6c84d979
--- /dev/null
+++ b/parser.gen.info
@@ -0,0 +1,3283 @@
+Terminals unused in grammar
+
+   INVALID_CHARACTER
+
+
+Grammar
+
+    0 $accept: TopLevel $end
+
+    1 TopLevel: Exp
+    2         | FuncDefs
+
+    3 FuncDefs: /* empty */
+    4         | FuncDef FuncDefs
+
+    5 Exp: FuncDef Exp
+    6    | Term "as" '$' IDENT '|' Exp
+    7    | "if" Exp "then" Exp ElseBody
+    8    | "if" Exp error
+    9    | Exp '=' Exp
+   10    | Exp "or" Exp
+   11    | Exp "and" Exp
+   12    | Exp "//" Exp
+   13    | Exp "//=" Exp
+   14    | Exp "|=" Exp
+   15    | Exp '|' Exp
+   16    | Exp ',' Exp
+   17    | Exp '+' Exp
+   18    | Exp "+=" Exp
+   19    | Exp '-' Exp
+   20    | Exp "-=" Exp
+   21    | Exp '*' Exp
+   22    | Exp "*=" Exp
+   23    | Exp '/' Exp
+   24    | Exp "/=" Exp
+   25    | Exp "==" Exp
+   26    | Exp '<' Exp
+   27    | Exp '>' Exp
+   28    | Exp "<=" Exp
+   29    | Exp ">=" Exp
+   30    | String
+   31    | Term
+
+   32 String: QQSTRING_START QQString QQSTRING_END
+
+   33 FuncDef: "def" IDENT ':' Exp ';'
+   34        | "def" IDENT '(' IDENT ')' ':' Exp ';'
+
+   35 QQString: /* empty */
+   36         | QQString QQSTRING_TEXT
+   37         | QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END
+
+   38 ElseBody: "elif" Exp "then" Exp ElseBody
+   39         | "else" Exp "end"
+
+   40 ExpD: ExpD '|' ExpD
+   41     | Term
+
+   42 Term: '.'
+   43     | Term '.' IDENT
+   44     | '.' IDENT
+   45     | Term '[' Exp ']'
+   46     | Term '[' ']'
+   47     | LITERAL
+   48     | '(' Exp ')'
+   49     | '[' Exp ']'
+   50     | '[' ']'
+   51     | '{' MkDict '}'
+   52     | '$' IDENT
+   53     | IDENT
+   54     | IDENT '(' Exp ')'
+   55     | '(' error ')'
+   56     | '[' error ']'
+   57     | Term '[' error ']'
+   58     | '{' error '}'
+
+   59 MkDict: /* empty */
+   60       | MkDictPair
+   61       | MkDictPair ',' MkDict
+   62       | error ',' MkDict
+
+   63 MkDictPair: IDENT ':' ExpD
+   64           | String ':' ExpD
+   65           | IDENT
+   66           | '(' Exp ')' ':' ExpD
+   67           | '(' error ')' ':' ExpD
+
+
+Terminals, with rules where they appear
+
+$end (0) 0
+'$' (36) 6 52
+'(' (40) 34 48 54 55 66 67
+')' (41) 34 48 54 55 66 67
+'*' (42) 21
+'+' (43) 17
+',' (44) 16 61 62
+'-' (45) 19
+'.' (46) 42 43 44
+'/' (47) 23
+':' (58) 33 34 63 64 66 67
+';' (59) 33 34
+'<' (60) 26
+'=' (61) 9
+'>' (62) 27
+'[' (91) 45 46 49 50 56 57
+']' (93) 45 46 49 50 56 57
+'{' (123) 51 58
+'|' (124) 6 15 40
+'}' (125) 51 58
+error (256) 8 55 56 57 58 62 67
+INVALID_CHARACTER (258)
+IDENT (259) 6 33 34 43 44 52 53 54 63 65
+LITERAL (260) 47
+"==" (261) 25
+"//" (262) 12
+"as" (263) 6
+"def" (264) 33 34
+"if" (265) 7 8
+"then" (266) 7 38
+"else" (267) 39
+"elif" (268) 38
+"end" (269) 39
+"and" (270) 11
+"or" (271) 10
+"|=" (272) 14
+"+=" (273) 18
+"-=" (274) 20
+"*=" (275) 22
+"/=" (276) 24
+"//=" (277) 13
+"<=" (278) 28
+">=" (279) 29
+QQSTRING_START (280) 32
+QQSTRING_TEXT (281) 36
+QQSTRING_INTERP_START (282) 37
+QQSTRING_INTERP_END (283) 37
+QQSTRING_END (284) 32
+
+
+Nonterminals, with rules where they appear
+
+$accept (49)
+    on left: 0
+TopLevel (50)
+    on left: 1 2, on right: 0
+FuncDefs (51)
+    on left: 3 4, on right: 2 4
+Exp (52)
+    on left: 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
+    25 26 27 28 29 30 31, on right: 1 5 6 7 8 9 10 11 12 13 14 15 16
+    17 18 19 20 21 22 23 24 25 26 27 28 29 33 34 37 38 39 45 48 49
+    54 66
+String (53)
+    on left: 32, on right: 30 64
+FuncDef (54)
+    on left: 33 34, on right: 4 5
+QQString (55)
+    on left: 35 36 37, on right: 32 36 37
+ElseBody (56)
+    on left: 38 39, on right: 7 38
+ExpD (57)
+    on left: 40 41, on right: 40 63 64 66 67
+Term (58)
+    on left: 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58, on right:
+    6 31 41 43 45 46 57
+MkDict (59)
+    on left: 59 60 61 62, on right: 51 61 62
+MkDictPair (60)
+    on left: 63 64 65 66 67, on right: 60 61
+
+
+state 0
+
+    0 $accept: . TopLevel $end
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    $default  reduce using rule 3 (FuncDefs)
+
+    TopLevel  go to state 11
+    FuncDefs  go to state 12
+    Exp       go to state 13
+    String    go to state 14
+    FuncDef   go to state 15
+    Term      go to state 16
+
+
+state 1
+
+   53 Term: IDENT .
+   54     | IDENT . '(' Exp ')'
+
+    '('  shift, and go to state 17
+
+    $default  reduce using rule 53 (Term)
+
+
+state 2
+
+   47 Term: LITERAL .
+
+    $default  reduce using rule 47 (Term)
+
+
+state 3
+
+   33 FuncDef: "def" . IDENT ':' Exp ';'
+   34        | "def" . IDENT '(' IDENT ')' ':' Exp ';'
+
+    IDENT  shift, and go to state 18
+
+
+state 4
+
+    7 Exp: "if" . Exp "then" Exp ElseBody
+    8    | "if" . Exp error
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 19
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 5
+
+   32 String: QQSTRING_START . QQString QQSTRING_END
+
+    $default  reduce using rule 35 (QQString)
+
+    QQString  go to state 21
+
+
+state 6
+
+   52 Term: '$' . IDENT
+
+    IDENT  shift, and go to state 22
+
+
+state 7
+
+   48 Term: '(' . Exp ')'
+   55     | '(' . error ')'
+
+    error           shift, and go to state 23
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 24
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 8
+
+   42 Term: '.' .
+   44     | '.' . IDENT
+
+    IDENT  shift, and go to state 25
+
+    $default  reduce using rule 42 (Term)
+
+
+state 9
+
+   49 Term: '[' . Exp ']'
+   50     | '[' . ']'
+   56     | '[' . error ']'
+
+    error           shift, and go to state 26
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    ']'             shift, and go to state 27
+    '{'             shift, and go to state 10
+
+    Exp      go to state 28
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 10
+
+   51 Term: '{' . MkDict '}'
+   58     | '{' . error '}'
+
+    error           shift, and go to state 29
+    IDENT           shift, and go to state 30
+    QQSTRING_START  shift, and go to state 5
+    '('             shift, and go to state 31
+
+    '}'  reduce using rule 59 (MkDict)
+
+    String      go to state 32
+    MkDict      go to state 33
+    MkDictPair  go to state 34
+
+
+state 11
+
+    0 $accept: TopLevel . $end
+
+    $end  shift, and go to state 35
+
+
+state 12
+
+    2 TopLevel: FuncDefs .
+
+    $default  reduce using rule 2 (TopLevel)
+
+
+state 13
+
+    1 TopLevel: Exp .
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    "=="   shift, and go to state 36
+    "//"   shift, and go to state 37
+    "and"  shift, and go to state 38
+    "or"   shift, and go to state 39
+    "|="   shift, and go to state 40
+    "+="   shift, and go to state 41
+    "-="   shift, and go to state 42
+    "*="   shift, and go to state 43
+    "/="   shift, and go to state 44
+    "//="  shift, and go to state 45
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    '|'    shift, and go to state 48
+    ','    shift, and go to state 49
+    '='    shift, and go to state 50
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+
+    $default  reduce using rule 1 (TopLevel)
+
+
+state 14
+
+   30 Exp: String .
+
+    $default  reduce using rule 30 (Exp)
+
+
+state 15
+
+    4 FuncDefs: FuncDef . FuncDefs
+    5 Exp: FuncDef . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    $default  reduce using rule 3 (FuncDefs)
+
+    FuncDefs  go to state 57
+    Exp       go to state 58
+    String    go to state 14
+    FuncDef   go to state 15
+    Term      go to state 16
+
+
+state 16
+
+    6 Exp: Term . "as" '$' IDENT '|' Exp
+   31    | Term .
+   43 Term: Term . '.' IDENT
+   45     | Term . '[' Exp ']'
+   46     | Term . '[' ']'
+   57     | Term . '[' error ']'
+
+    "as"  shift, and go to state 59
+    '.'   shift, and go to state 60
+    '['   shift, and go to state 61
+
+    $default  reduce using rule 31 (Exp)
+
+
+state 17
+
+   54 Term: IDENT '(' . Exp ')'
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 62
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 18
+
+   33 FuncDef: "def" IDENT . ':' Exp ';'
+   34        | "def" IDENT . '(' IDENT ')' ':' Exp ';'
+
+    ':'  shift, and go to state 63
+    '('  shift, and go to state 64
+
+
+state 19
+
+    7 Exp: "if" Exp . "then" Exp ElseBody
+    8    | "if" Exp . error
+    9    | Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    error   shift, and go to state 65
+    "=="    shift, and go to state 36
+    "//"    shift, and go to state 37
+    "then"  shift, and go to state 66
+    "and"   shift, and go to state 38
+    "or"    shift, and go to state 39
+    "|="    shift, and go to state 40
+    "+="    shift, and go to state 41
+    "-="    shift, and go to state 42
+    "*="    shift, and go to state 43
+    "/="    shift, and go to state 44
+    "//="   shift, and go to state 45
+    "<="    shift, and go to state 46
+    ">="    shift, and go to state 47
+    '|'     shift, and go to state 48
+    ','     shift, and go to state 49
+    '='     shift, and go to state 50
+    '<'     shift, and go to state 51
+    '>'     shift, and go to state 52
+    '+'     shift, and go to state 53
+    '-'     shift, and go to state 54
+    '*'     shift, and go to state 55
+    '/'     shift, and go to state 56
+
+
+state 20
+
+    5 Exp: FuncDef . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 58
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 21
+
+   32 String: QQSTRING_START QQString . QQSTRING_END
+   36 QQString: QQString . QQSTRING_TEXT
+   37         | QQString . QQSTRING_INTERP_START Exp QQSTRING_INTERP_END
+
+    QQSTRING_TEXT          shift, and go to state 67
+    QQSTRING_INTERP_START  shift, and go to state 68
+    QQSTRING_END           shift, and go to state 69
+
+
+state 22
+
+   52 Term: '$' IDENT .
+
+    $default  reduce using rule 52 (Term)
+
+
+state 23
+
+   55 Term: '(' error . ')'
+
+    ')'  shift, and go to state 70
+
+
+state 24
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+   48 Term: '(' Exp . ')'
+
+    "=="   shift, and go to state 36
+    "//"   shift, and go to state 37
+    "and"  shift, and go to state 38
+    "or"   shift, and go to state 39
+    "|="   shift, and go to state 40
+    "+="   shift, and go to state 41
+    "-="   shift, and go to state 42
+    "*="   shift, and go to state 43
+    "/="   shift, and go to state 44
+    "//="  shift, and go to state 45
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    '|'    shift, and go to state 48
+    ','    shift, and go to state 49
+    '='    shift, and go to state 50
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+    ')'    shift, and go to state 71
+
+
+state 25
+
+   44 Term: '.' IDENT .
+
+    $default  reduce using rule 44 (Term)
+
+
+state 26
+
+   56 Term: '[' error . ']'
+
+    ']'  shift, and go to state 72
+
+
+state 27
+
+   50 Term: '[' ']' .
+
+    $default  reduce using rule 50 (Term)
+
+
+state 28
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+   49 Term: '[' Exp . ']'
+
+    "=="   shift, and go to state 36
+    "//"   shift, and go to state 37
+    "and"  shift, and go to state 38
+    "or"   shift, and go to state 39
+    "|="   shift, and go to state 40
+    "+="   shift, and go to state 41
+    "-="   shift, and go to state 42
+    "*="   shift, and go to state 43
+    "/="   shift, and go to state 44
+    "//="  shift, and go to state 45
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    '|'    shift, and go to state 48
+    ','    shift, and go to state 49
+    '='    shift, and go to state 50
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+    ']'    shift, and go to state 73
+
+
+state 29
+
+   58 Term: '{' error . '}'
+   62 MkDict: error . ',' MkDict
+
+    ','  shift, and go to state 74
+    '}'  shift, and go to state 75
+
+
+state 30
+
+   63 MkDictPair: IDENT . ':' ExpD
+   65           | IDENT .
+
+    ':'  shift, and go to state 76
+
+    $default  reduce using rule 65 (MkDictPair)
+
+
+state 31
+
+   66 MkDictPair: '(' . Exp ')' ':' ExpD
+   67           | '(' . error ')' ':' ExpD
+
+    error           shift, and go to state 77
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 78
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 32
+
+   64 MkDictPair: String . ':' ExpD
+
+    ':'  shift, and go to state 79
+
+
+state 33
+
+   51 Term: '{' MkDict . '}'
+
+    '}'  shift, and go to state 80
+
+
+state 34
+
+   60 MkDict: MkDictPair .
+   61       | MkDictPair . ',' MkDict
+
+    ','  shift, and go to state 81
+
+    $default  reduce using rule 60 (MkDict)
+
+
+state 35
+
+    0 $accept: TopLevel $end .
+
+    $default  accept
+
+
+state 36
+
+   25 Exp: Exp "==" . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 82
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 37
+
+   12 Exp: Exp "//" . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 83
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 38
+
+   11 Exp: Exp "and" . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 84
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 39
+
+   10 Exp: Exp "or" . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 85
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 40
+
+   14 Exp: Exp "|=" . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 86
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 41
+
+   18 Exp: Exp "+=" . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 87
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 42
+
+   20 Exp: Exp "-=" . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 88
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 43
+
+   22 Exp: Exp "*=" . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 89
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 44
+
+   24 Exp: Exp "/=" . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 90
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 45
+
+   13 Exp: Exp "//=" . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 91
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 46
+
+   28 Exp: Exp "<=" . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 92
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 47
+
+   29 Exp: Exp ">=" . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 93
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 48
+
+   15 Exp: Exp '|' . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 94
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 49
+
+   16 Exp: Exp ',' . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 95
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 50
+
+    9 Exp: Exp '=' . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 96
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 51
+
+   26 Exp: Exp '<' . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 97
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 52
+
+   27 Exp: Exp '>' . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 98
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 53
+
+   17 Exp: Exp '+' . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 99
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 54
+
+   19 Exp: Exp '-' . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 100
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 55
+
+   21 Exp: Exp '*' . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 101
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 56
+
+   23 Exp: Exp '/' . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 102
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 57
+
+    4 FuncDefs: FuncDef FuncDefs .
+
+    $default  reduce using rule 4 (FuncDefs)
+
+
+state 58
+
+    5 Exp: FuncDef Exp .
+    9    | Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    "=="   shift, and go to state 36
+    "//"   shift, and go to state 37
+    "and"  shift, and go to state 38
+    "or"   shift, and go to state 39
+    "|="   shift, and go to state 40
+    "+="   shift, and go to state 41
+    "-="   shift, and go to state 42
+    "*="   shift, and go to state 43
+    "/="   shift, and go to state 44
+    "//="  shift, and go to state 45
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    '|'    shift, and go to state 48
+    ','    shift, and go to state 49
+    '='    shift, and go to state 50
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+
+    $default  reduce using rule 5 (Exp)
+
+
+state 59
+
+    6 Exp: Term "as" . '$' IDENT '|' Exp
+
+    '$'  shift, and go to state 103
+
+
+state 60
+
+   43 Term: Term '.' . IDENT
+
+    IDENT  shift, and go to state 104
+
+
+state 61
+
+   45 Term: Term '[' . Exp ']'
+   46     | Term '[' . ']'
+   57     | Term '[' . error ']'
+
+    error           shift, and go to state 105
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    ']'             shift, and go to state 106
+    '{'             shift, and go to state 10
+
+    Exp      go to state 107
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 62
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+   54 Term: IDENT '(' Exp . ')'
+
+    "=="   shift, and go to state 36
+    "//"   shift, and go to state 37
+    "and"  shift, and go to state 38
+    "or"   shift, and go to state 39
+    "|="   shift, and go to state 40
+    "+="   shift, and go to state 41
+    "-="   shift, and go to state 42
+    "*="   shift, and go to state 43
+    "/="   shift, and go to state 44
+    "//="  shift, and go to state 45
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    '|'    shift, and go to state 48
+    ','    shift, and go to state 49
+    '='    shift, and go to state 50
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+    ')'    shift, and go to state 108
+
+
+state 63
+
+   33 FuncDef: "def" IDENT ':' . Exp ';'
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 109
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 64
+
+   34 FuncDef: "def" IDENT '(' . IDENT ')' ':' Exp ';'
+
+    IDENT  shift, and go to state 110
+
+
+state 65
+
+    8 Exp: "if" Exp error .
+
+    $default  reduce using rule 8 (Exp)
+
+
+state 66
+
+    7 Exp: "if" Exp "then" . Exp ElseBody
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 111
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 67
+
+   36 QQString: QQString QQSTRING_TEXT .
+
+    $default  reduce using rule 36 (QQString)
+
+
+state 68
+
+   37 QQString: QQString QQSTRING_INTERP_START . Exp QQSTRING_INTERP_END
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 112
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 69
+
+   32 String: QQSTRING_START QQString QQSTRING_END .
+
+    $default  reduce using rule 32 (String)
+
+
+state 70
+
+   55 Term: '(' error ')' .
+
+    $default  reduce using rule 55 (Term)
+
+
+state 71
+
+   48 Term: '(' Exp ')' .
+
+    $default  reduce using rule 48 (Term)
+
+
+state 72
+
+   56 Term: '[' error ']' .
+
+    $default  reduce using rule 56 (Term)
+
+
+state 73
+
+   49 Term: '[' Exp ']' .
+
+    $default  reduce using rule 49 (Term)
+
+
+state 74
+
+   62 MkDict: error ',' . MkDict
+
+    error           shift, and go to state 113
+    IDENT           shift, and go to state 30
+    QQSTRING_START  shift, and go to state 5
+    '('             shift, and go to state 31
+
+    '}'  reduce using rule 59 (MkDict)
+
+    String      go to state 32
+    MkDict      go to state 114
+    MkDictPair  go to state 34
+
+
+state 75
+
+   58 Term: '{' error '}' .
+
+    $default  reduce using rule 58 (Term)
+
+
+state 76
+
+   63 MkDictPair: IDENT ':' . ExpD
+
+    IDENT    shift, and go to state 1
+    LITERAL  shift, and go to state 2
+    '$'      shift, and go to state 6
+    '('      shift, and go to state 7
+    '.'      shift, and go to state 8
+    '['      shift, and go to state 9
+    '{'      shift, and go to state 10
+
+    ExpD  go to state 115
+    Term  go to state 116
+
+
+state 77
+
+   67 MkDictPair: '(' error . ')' ':' ExpD
+
+    ')'  shift, and go to state 117
+
+
+state 78
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+   66 MkDictPair: '(' Exp . ')' ':' ExpD
+
+    "=="   shift, and go to state 36
+    "//"   shift, and go to state 37
+    "and"  shift, and go to state 38
+    "or"   shift, and go to state 39
+    "|="   shift, and go to state 40
+    "+="   shift, and go to state 41
+    "-="   shift, and go to state 42
+    "*="   shift, and go to state 43
+    "/="   shift, and go to state 44
+    "//="  shift, and go to state 45
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    '|'    shift, and go to state 48
+    ','    shift, and go to state 49
+    '='    shift, and go to state 50
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+    ')'    shift, and go to state 118
+
+
+state 79
+
+   64 MkDictPair: String ':' . ExpD
+
+    IDENT    shift, and go to state 1
+    LITERAL  shift, and go to state 2
+    '$'      shift, and go to state 6
+    '('      shift, and go to state 7
+    '.'      shift, and go to state 8
+    '['      shift, and go to state 9
+    '{'      shift, and go to state 10
+
+    ExpD  go to state 119
+    Term  go to state 116
+
+
+state 80
+
+   51 Term: '{' MkDict '}' .
+
+    $default  reduce using rule 51 (Term)
+
+
+state 81
+
+   61 MkDict: MkDictPair ',' . MkDict
+
+    error           shift, and go to state 113
+    IDENT           shift, and go to state 30
+    QQSTRING_START  shift, and go to state 5
+    '('             shift, and go to state 31
+
+    '}'  reduce using rule 59 (MkDict)
+
+    String      go to state 32
+    MkDict      go to state 120
+    MkDictPair  go to state 34
+
+
+state 82
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   25    | Exp "==" Exp .
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    '+'  shift, and go to state 53
+    '-'  shift, and go to state 54
+    '*'  shift, and go to state 55
+    '/'  shift, and go to state 56
+
+    "=="  error (nonassociative)
+    "<="  error (nonassociative)
+    ">="  error (nonassociative)
+    '<'   error (nonassociative)
+    '>'   error (nonassociative)
+
+    $default  reduce using rule 25 (Exp)
+
+
+state 83
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   12    | Exp "//" Exp .
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    "=="   shift, and go to state 36
+    "//"   shift, and go to state 37
+    "and"  shift, and go to state 38
+    "or"   shift, and go to state 39
+    "|="   shift, and go to state 40
+    "+="   shift, and go to state 41
+    "-="   shift, and go to state 42
+    "*="   shift, and go to state 43
+    "/="   shift, and go to state 44
+    "//="  shift, and go to state 45
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    '='    shift, and go to state 50
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+
+    $default  reduce using rule 12 (Exp)
+
+
+state 84
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   11    | Exp "and" Exp .
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    "=="  shift, and go to state 36
+    "<="  shift, and go to state 46
+    ">="  shift, and go to state 47
+    '<'   shift, and go to state 51
+    '>'   shift, and go to state 52
+    '+'   shift, and go to state 53
+    '-'   shift, and go to state 54
+    '*'   shift, and go to state 55
+    '/'   shift, and go to state 56
+
+    $default  reduce using rule 11 (Exp)
+
+
+state 85
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   10    | Exp "or" Exp .
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    "=="   shift, and go to state 36
+    "and"  shift, and go to state 38
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+
+    $default  reduce using rule 10 (Exp)
+
+
+state 86
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   14    | Exp "|=" Exp .
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    "=="   shift, and go to state 36
+    "and"  shift, and go to state 38
+    "or"   shift, and go to state 39
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+
+    "|="   error (nonassociative)
+    "+="   error (nonassociative)
+    "-="   error (nonassociative)
+    "*="   error (nonassociative)
+    "/="   error (nonassociative)
+    "//="  error (nonassociative)
+    '='    error (nonassociative)
+
+    $default  reduce using rule 14 (Exp)
+
+
+state 87
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   18    | Exp "+=" Exp .
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    "=="   shift, and go to state 36
+    "and"  shift, and go to state 38
+    "or"   shift, and go to state 39
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+
+    "|="   error (nonassociative)
+    "+="   error (nonassociative)
+    "-="   error (nonassociative)
+    "*="   error (nonassociative)
+    "/="   error (nonassociative)
+    "//="  error (nonassociative)
+    '='    error (nonassociative)
+
+    $default  reduce using rule 18 (Exp)
+
+
+state 88
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   20    | Exp "-=" Exp .
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    "=="   shift, and go to state 36
+    "and"  shift, and go to state 38
+    "or"   shift, and go to state 39
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+
+    "|="   error (nonassociative)
+    "+="   error (nonassociative)
+    "-="   error (nonassociative)
+    "*="   error (nonassociative)
+    "/="   error (nonassociative)
+    "//="  error (nonassociative)
+    '='    error (nonassociative)
+
+    $default  reduce using rule 20 (Exp)
+
+
+state 89
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   22    | Exp "*=" Exp .
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    "=="   shift, and go to state 36
+    "and"  shift, and go to state 38
+    "or"   shift, and go to state 39
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+
+    "|="   error (nonassociative)
+    "+="   error (nonassociative)
+    "-="   error (nonassociative)
+    "*="   error (nonassociative)
+    "/="   error (nonassociative)
+    "//="  error (nonassociative)
+    '='    error (nonassociative)
+
+    $default  reduce using rule 22 (Exp)
+
+
+state 90
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   24    | Exp "/=" Exp .
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    "=="   shift, and go to state 36
+    "and"  shift, and go to state 38
+    "or"   shift, and go to state 39
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+
+    "|="   error (nonassociative)
+    "+="   error (nonassociative)
+    "-="   error (nonassociative)
+    "*="   error (nonassociative)
+    "/="   error (nonassociative)
+    "//="  error (nonassociative)
+    '='    error (nonassociative)
+
+    $default  reduce using rule 24 (Exp)
+
+
+state 91
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   13    | Exp "//=" Exp .
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    "=="   shift, and go to state 36
+    "and"  shift, and go to state 38
+    "or"   shift, and go to state 39
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+
+    "|="   error (nonassociative)
+    "+="   error (nonassociative)
+    "-="   error (nonassociative)
+    "*="   error (nonassociative)
+    "/="   error (nonassociative)
+    "//="  error (nonassociative)
+    '='    error (nonassociative)
+
+    $default  reduce using rule 13 (Exp)
+
+
+state 92
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   28    | Exp "<=" Exp .
+   29    | Exp . ">=" Exp
+
+    '+'  shift, and go to state 53
+    '-'  shift, and go to state 54
+    '*'  shift, and go to state 55
+    '/'  shift, and go to state 56
+
+    "=="  error (nonassociative)
+    "<="  error (nonassociative)
+    ">="  error (nonassociative)
+    '<'   error (nonassociative)
+    '>'   error (nonassociative)
+
+    $default  reduce using rule 28 (Exp)
+
+
+state 93
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+   29    | Exp ">=" Exp .
+
+    '+'  shift, and go to state 53
+    '-'  shift, and go to state 54
+    '*'  shift, and go to state 55
+    '/'  shift, and go to state 56
+
+    "=="  error (nonassociative)
+    "<="  error (nonassociative)
+    ">="  error (nonassociative)
+    '<'   error (nonassociative)
+    '>'   error (nonassociative)
+
+    $default  reduce using rule 29 (Exp)
+
+
+state 94
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   15    | Exp '|' Exp .
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    "=="   shift, and go to state 36
+    "//"   shift, and go to state 37
+    "and"  shift, and go to state 38
+    "or"   shift, and go to state 39
+    "|="   shift, and go to state 40
+    "+="   shift, and go to state 41
+    "-="   shift, and go to state 42
+    "*="   shift, and go to state 43
+    "/="   shift, and go to state 44
+    "//="  shift, and go to state 45
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    ','    shift, and go to state 49
+    '='    shift, and go to state 50
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+
+    $default  reduce using rule 15 (Exp)
+
+
+state 95
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   16    | Exp ',' Exp .
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    "=="   shift, and go to state 36
+    "//"   shift, and go to state 37
+    "and"  shift, and go to state 38
+    "or"   shift, and go to state 39
+    "|="   shift, and go to state 40
+    "+="   shift, and go to state 41
+    "-="   shift, and go to state 42
+    "*="   shift, and go to state 43
+    "/="   shift, and go to state 44
+    "//="  shift, and go to state 45
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    '='    shift, and go to state 50
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+
+    $default  reduce using rule 16 (Exp)
+
+
+state 96
+
+    9 Exp: Exp . '=' Exp
+    9    | Exp '=' Exp .
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    "=="   shift, and go to state 36
+    "and"  shift, and go to state 38
+    "or"   shift, and go to state 39
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+
+    "|="   error (nonassociative)
+    "+="   error (nonassociative)
+    "-="   error (nonassociative)
+    "*="   error (nonassociative)
+    "/="   error (nonassociative)
+    "//="  error (nonassociative)
+    '='    error (nonassociative)
+
+    $default  reduce using rule 9 (Exp)
+
+
+state 97
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   26    | Exp '<' Exp .
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    '+'  shift, and go to state 53
+    '-'  shift, and go to state 54
+    '*'  shift, and go to state 55
+    '/'  shift, and go to state 56
+
+    "=="  error (nonassociative)
+    "<="  error (nonassociative)
+    ">="  error (nonassociative)
+    '<'   error (nonassociative)
+    '>'   error (nonassociative)
+
+    $default  reduce using rule 26 (Exp)
+
+
+state 98
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   27    | Exp '>' Exp .
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    '+'  shift, and go to state 53
+    '-'  shift, and go to state 54
+    '*'  shift, and go to state 55
+    '/'  shift, and go to state 56
+
+    "=="  error (nonassociative)
+    "<="  error (nonassociative)
+    ">="  error (nonassociative)
+    '<'   error (nonassociative)
+    '>'   error (nonassociative)
+
+    $default  reduce using rule 27 (Exp)
+
+
+state 99
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   17    | Exp '+' Exp .
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    '*'  shift, and go to state 55
+    '/'  shift, and go to state 56
+
+    $default  reduce using rule 17 (Exp)
+
+
+state 100
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   19    | Exp '-' Exp .
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    '*'  shift, and go to state 55
+    '/'  shift, and go to state 56
+
+    $default  reduce using rule 19 (Exp)
+
+
+state 101
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   21    | Exp '*' Exp .
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    $default  reduce using rule 21 (Exp)
+
+
+state 102
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   23    | Exp '/' Exp .
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    $default  reduce using rule 23 (Exp)
+
+
+state 103
+
+    6 Exp: Term "as" '$' . IDENT '|' Exp
+
+    IDENT  shift, and go to state 121
+
+
+state 104
+
+   43 Term: Term '.' IDENT .
+
+    $default  reduce using rule 43 (Term)
+
+
+state 105
+
+   57 Term: Term '[' error . ']'
+
+    ']'  shift, and go to state 122
+
+
+state 106
+
+   46 Term: Term '[' ']' .
+
+    $default  reduce using rule 46 (Term)
+
+
+state 107
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+   45 Term: Term '[' Exp . ']'
+
+    "=="   shift, and go to state 36
+    "//"   shift, and go to state 37
+    "and"  shift, and go to state 38
+    "or"   shift, and go to state 39
+    "|="   shift, and go to state 40
+    "+="   shift, and go to state 41
+    "-="   shift, and go to state 42
+    "*="   shift, and go to state 43
+    "/="   shift, and go to state 44
+    "//="  shift, and go to state 45
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    '|'    shift, and go to state 48
+    ','    shift, and go to state 49
+    '='    shift, and go to state 50
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+    ']'    shift, and go to state 123
+
+
+state 108
+
+   54 Term: IDENT '(' Exp ')' .
+
+    $default  reduce using rule 54 (Term)
+
+
+state 109
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+   33 FuncDef: "def" IDENT ':' Exp . ';'
+
+    "=="   shift, and go to state 36
+    "//"   shift, and go to state 37
+    "and"  shift, and go to state 38
+    "or"   shift, and go to state 39
+    "|="   shift, and go to state 40
+    "+="   shift, and go to state 41
+    "-="   shift, and go to state 42
+    "*="   shift, and go to state 43
+    "/="   shift, and go to state 44
+    "//="  shift, and go to state 45
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    ';'    shift, and go to state 124
+    '|'    shift, and go to state 48
+    ','    shift, and go to state 49
+    '='    shift, and go to state 50
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+
+
+state 110
+
+   34 FuncDef: "def" IDENT '(' IDENT . ')' ':' Exp ';'
+
+    ')'  shift, and go to state 125
+
+
+state 111
+
+    7 Exp: "if" Exp "then" Exp . ElseBody
+    9    | Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    "=="    shift, and go to state 36
+    "//"    shift, and go to state 37
+    "else"  shift, and go to state 126
+    "elif"  shift, and go to state 127
+    "and"   shift, and go to state 38
+    "or"    shift, and go to state 39
+    "|="    shift, and go to state 40
+    "+="    shift, and go to state 41
+    "-="    shift, and go to state 42
+    "*="    shift, and go to state 43
+    "/="    shift, and go to state 44
+    "//="   shift, and go to state 45
+    "<="    shift, and go to state 46
+    ">="    shift, and go to state 47
+    '|'     shift, and go to state 48
+    ','     shift, and go to state 49
+    '='     shift, and go to state 50
+    '<'     shift, and go to state 51
+    '>'     shift, and go to state 52
+    '+'     shift, and go to state 53
+    '-'     shift, and go to state 54
+    '*'     shift, and go to state 55
+    '/'     shift, and go to state 56
+
+    ElseBody  go to state 128
+
+
+state 112
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+   37 QQString: QQString QQSTRING_INTERP_START Exp . QQSTRING_INTERP_END
+
+    "=="                 shift, and go to state 36
+    "//"                 shift, and go to state 37
+    "and"                shift, and go to state 38
+    "or"                 shift, and go to state 39
+    "|="                 shift, and go to state 40
+    "+="                 shift, and go to state 41
+    "-="                 shift, and go to state 42
+    "*="                 shift, and go to state 43
+    "/="                 shift, and go to state 44
+    "//="                shift, and go to state 45
+    "<="                 shift, and go to state 46
+    ">="                 shift, and go to state 47
+    QQSTRING_INTERP_END  shift, and go to state 129
+    '|'                  shift, and go to state 48
+    ','                  shift, and go to state 49
+    '='                  shift, and go to state 50
+    '<'                  shift, and go to state 51
+    '>'                  shift, and go to state 52
+    '+'                  shift, and go to state 53
+    '-'                  shift, and go to state 54
+    '*'                  shift, and go to state 55
+    '/'                  shift, and go to state 56
+
+
+state 113
+
+   62 MkDict: error . ',' MkDict
+
+    ','  shift, and go to state 74
+
+
+state 114
+
+   62 MkDict: error ',' MkDict .
+
+    $default  reduce using rule 62 (MkDict)
+
+
+state 115
+
+   40 ExpD: ExpD . '|' ExpD
+   63 MkDictPair: IDENT ':' ExpD .
+
+    '|'  shift, and go to state 130
+
+    $default  reduce using rule 63 (MkDictPair)
+
+
+state 116
+
+   41 ExpD: Term .
+   43 Term: Term . '.' IDENT
+   45     | Term . '[' Exp ']'
+   46     | Term . '[' ']'
+   57     | Term . '[' error ']'
+
+    '.'  shift, and go to state 60
+    '['  shift, and go to state 61
+
+    $default  reduce using rule 41 (ExpD)
+
+
+state 117
+
+   67 MkDictPair: '(' error ')' . ':' ExpD
+
+    ':'  shift, and go to state 131
+
+
+state 118
+
+   66 MkDictPair: '(' Exp ')' . ':' ExpD
+
+    ':'  shift, and go to state 132
+
+
+state 119
+
+   40 ExpD: ExpD . '|' ExpD
+   64 MkDictPair: String ':' ExpD .
+
+    '|'  shift, and go to state 130
+
+    $default  reduce using rule 64 (MkDictPair)
+
+
+state 120
+
+   61 MkDict: MkDictPair ',' MkDict .
+
+    $default  reduce using rule 61 (MkDict)
+
+
+state 121
+
+    6 Exp: Term "as" '$' IDENT . '|' Exp
+
+    '|'  shift, and go to state 133
+
+
+state 122
+
+   57 Term: Term '[' error ']' .
+
+    $default  reduce using rule 57 (Term)
+
+
+state 123
+
+   45 Term: Term '[' Exp ']' .
+
+    $default  reduce using rule 45 (Term)
+
+
+state 124
+
+   33 FuncDef: "def" IDENT ':' Exp ';' .
+
+    $default  reduce using rule 33 (FuncDef)
+
+
+state 125
+
+   34 FuncDef: "def" IDENT '(' IDENT ')' . ':' Exp ';'
+
+    ':'  shift, and go to state 134
+
+
+state 126
+
+   39 ElseBody: "else" . Exp "end"
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 135
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 127
+
+   38 ElseBody: "elif" . Exp "then" Exp ElseBody
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 136
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 128
+
+    7 Exp: "if" Exp "then" Exp ElseBody .
+
+    $default  reduce using rule 7 (Exp)
+
+
+state 129
+
+   37 QQString: QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END .
+
+    $default  reduce using rule 37 (QQString)
+
+
+state 130
+
+   40 ExpD: ExpD '|' . ExpD
+
+    IDENT    shift, and go to state 1
+    LITERAL  shift, and go to state 2
+    '$'      shift, and go to state 6
+    '('      shift, and go to state 7
+    '.'      shift, and go to state 8
+    '['      shift, and go to state 9
+    '{'      shift, and go to state 10
+
+    ExpD  go to state 137
+    Term  go to state 116
+
+
+state 131
+
+   67 MkDictPair: '(' error ')' ':' . ExpD
+
+    IDENT    shift, and go to state 1
+    LITERAL  shift, and go to state 2
+    '$'      shift, and go to state 6
+    '('      shift, and go to state 7
+    '.'      shift, and go to state 8
+    '['      shift, and go to state 9
+    '{'      shift, and go to state 10
+
+    ExpD  go to state 138
+    Term  go to state 116
+
+
+state 132
+
+   66 MkDictPair: '(' Exp ')' ':' . ExpD
+
+    IDENT    shift, and go to state 1
+    LITERAL  shift, and go to state 2
+    '$'      shift, and go to state 6
+    '('      shift, and go to state 7
+    '.'      shift, and go to state 8
+    '['      shift, and go to state 9
+    '{'      shift, and go to state 10
+
+    ExpD  go to state 139
+    Term  go to state 116
+
+
+state 133
+
+    6 Exp: Term "as" '$' IDENT '|' . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 140
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 134
+
+   34 FuncDef: "def" IDENT '(' IDENT ')' ':' . Exp ';'
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 141
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 135
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+   39 ElseBody: "else" Exp . "end"
+
+    "=="   shift, and go to state 36
+    "//"   shift, and go to state 37
+    "end"  shift, and go to state 142
+    "and"  shift, and go to state 38
+    "or"   shift, and go to state 39
+    "|="   shift, and go to state 40
+    "+="   shift, and go to state 41
+    "-="   shift, and go to state 42
+    "*="   shift, and go to state 43
+    "/="   shift, and go to state 44
+    "//="  shift, and go to state 45
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    '|'    shift, and go to state 48
+    ','    shift, and go to state 49
+    '='    shift, and go to state 50
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+
+
+state 136
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+   38 ElseBody: "elif" Exp . "then" Exp ElseBody
+
+    "=="    shift, and go to state 36
+    "//"    shift, and go to state 37
+    "then"  shift, and go to state 143
+    "and"   shift, and go to state 38
+    "or"    shift, and go to state 39
+    "|="    shift, and go to state 40
+    "+="    shift, and go to state 41
+    "-="    shift, and go to state 42
+    "*="    shift, and go to state 43
+    "/="    shift, and go to state 44
+    "//="   shift, and go to state 45
+    "<="    shift, and go to state 46
+    ">="    shift, and go to state 47
+    '|'     shift, and go to state 48
+    ','     shift, and go to state 49
+    '='     shift, and go to state 50
+    '<'     shift, and go to state 51
+    '>'     shift, and go to state 52
+    '+'     shift, and go to state 53
+    '-'     shift, and go to state 54
+    '*'     shift, and go to state 55
+    '/'     shift, and go to state 56
+
+
+state 137
+
+   40 ExpD: ExpD . '|' ExpD
+   40     | ExpD '|' ExpD .
+
+    $default  reduce using rule 40 (ExpD)
+
+
+state 138
+
+   40 ExpD: ExpD . '|' ExpD
+   67 MkDictPair: '(' error ')' ':' ExpD .
+
+    '|'  shift, and go to state 130
+
+    $default  reduce using rule 67 (MkDictPair)
+
+
+state 139
+
+   40 ExpD: ExpD . '|' ExpD
+   66 MkDictPair: '(' Exp ')' ':' ExpD .
+
+    '|'  shift, and go to state 130
+
+    $default  reduce using rule 66 (MkDictPair)
+
+
+state 140
+
+    6 Exp: Term "as" '$' IDENT '|' Exp .
+    9    | Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+
+    "=="   shift, and go to state 36
+    "//"   shift, and go to state 37
+    "and"  shift, and go to state 38
+    "or"   shift, and go to state 39
+    "|="   shift, and go to state 40
+    "+="   shift, and go to state 41
+    "-="   shift, and go to state 42
+    "*="   shift, and go to state 43
+    "/="   shift, and go to state 44
+    "//="  shift, and go to state 45
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    ','    shift, and go to state 49
+    '='    shift, and go to state 50
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+
+    $default  reduce using rule 6 (Exp)
+
+
+state 141
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+   34 FuncDef: "def" IDENT '(' IDENT ')' ':' Exp . ';'
+
+    "=="   shift, and go to state 36
+    "//"   shift, and go to state 37
+    "and"  shift, and go to state 38
+    "or"   shift, and go to state 39
+    "|="   shift, and go to state 40
+    "+="   shift, and go to state 41
+    "-="   shift, and go to state 42
+    "*="   shift, and go to state 43
+    "/="   shift, and go to state 44
+    "//="  shift, and go to state 45
+    "<="   shift, and go to state 46
+    ">="   shift, and go to state 47
+    ';'    shift, and go to state 144
+    '|'    shift, and go to state 48
+    ','    shift, and go to state 49
+    '='    shift, and go to state 50
+    '<'    shift, and go to state 51
+    '>'    shift, and go to state 52
+    '+'    shift, and go to state 53
+    '-'    shift, and go to state 54
+    '*'    shift, and go to state 55
+    '/'    shift, and go to state 56
+
+
+state 142
+
+   39 ElseBody: "else" Exp "end" .
+
+    $default  reduce using rule 39 (ElseBody)
+
+
+state 143
+
+   38 ElseBody: "elif" Exp "then" . Exp ElseBody
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 145
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 144
+
+   34 FuncDef: "def" IDENT '(' IDENT ')' ':' Exp ';' .
+
+    $default  reduce using rule 34 (FuncDef)
+
+
+state 145
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . '<' Exp
+   27    | Exp . '>' Exp
+   28    | Exp . "<=" Exp
+   29    | Exp . ">=" Exp
+   38 ElseBody: "elif" Exp "then" Exp . ElseBody
+
+    "=="    shift, and go to state 36
+    "//"    shift, and go to state 37
+    "else"  shift, and go to state 126
+    "elif"  shift, and go to state 127
+    "and"   shift, and go to state 38
+    "or"    shift, and go to state 39
+    "|="    shift, and go to state 40
+    "+="    shift, and go to state 41
+    "-="    shift, and go to state 42
+    "*="    shift, and go to state 43
+    "/="    shift, and go to state 44
+    "//="   shift, and go to state 45
+    "<="    shift, and go to state 46
+    ">="    shift, and go to state 47
+    '|'     shift, and go to state 48
+    ','     shift, and go to state 49
+    '='     shift, and go to state 50
+    '<'     shift, and go to state 51
+    '>'     shift, and go to state 52
+    '+'     shift, and go to state 53
+    '-'     shift, and go to state 54
+    '*'     shift, and go to state 55
+    '/'     shift, and go to state 56
+
+    ElseBody  go to state 146
+
+
+state 146
+
+   38 ElseBody: "elif" Exp "then" Exp ElseBody .
+
+    $default  reduce using rule 38 (ElseBody)

From 758da604cdb9183289526a9c087287ec83399216 Mon Sep 17 00:00:00 2001
From: Maxime Biais <maxime.biais@gmail.com>
Date: Sun, 21 Oct 2012 20:55:50 +0200
Subject: [PATCH 115/284] add install and uninstall rules in Makefile

---
 Makefile | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index aac341f8..ac55fd4a 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,5 @@
 CC=gcc -Wextra -Wall -Wno-missing-field-initializers -Wno-unused-parameter -std=gnu99 -ggdb -Wno-unused-function
+prefix=/usr/local
 
 .PHONY: all clean releasedep tarball
 all: jq
@@ -41,4 +42,14 @@ docs/content/2.download/source/jq.tgz: jq
 	mkdir -p `dirname $@`
 	tar -czvf $@ `git ls-files; ls *.gen.*`
 
-tarball: docs/content/2.download/source/jq.tgz
\ No newline at end of file
+tarball: docs/content/2.download/source/jq.tgz
+
+install: jq
+	install -d -m 0755 $(prefix)/bin
+	install -m 0755 jq $(prefix)/bin
+
+uninstall:
+	test -d $(prefix)/bin && \
+	cd $(prefix)/bin && \
+	rm -f jq
+

From 73e479e171bd959e9ee194732205a0ed49d029d9 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 21 Oct 2012 20:16:26 +0100
Subject: [PATCH 116/284] Update website: binaries + version bump.

---
 docs/content/2.download/linux_x86_64/jq | Bin 447776 -> 385542 bytes
 docs/content/2.download/osx_64/jq       | Bin 185432 -> 190556 bytes
 docs/site.yml                           |   8 ++++----
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/content/2.download/linux_x86_64/jq b/docs/content/2.download/linux_x86_64/jq
index 5a36b20225b33a60951fd05781a166fce908e17a..4395acc175d74f4dcd7b93b484cb999cb70c9ed5 100755
GIT binary patch
literal 385542
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
Biktud

literal 447776
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

diff --git a/docs/content/2.download/osx_64/jq b/docs/content/2.download/osx_64/jq
index 47a4f223805d908d3a3c766f58125109619f0ebd..c7b521ec27e91c90f110f32dc4b835b45d6cbc57 100755
GIT binary patch
delta 59995
zcma&P34Be*`#*lqNF-8m6A~hOWRW0}kdTm&kZ?l~dz9EBc0nX|g5;L#x}~NZRcl*C
zOHn1n7L=f^rA3w2)~XYswo+=j|MxR<gZA_J{JwuL=bV}6{XEY+^UOYH?#YD>Z~c7w
ztwko+M5g=4zr^>JH+OZ_=@d{)chFs@o8|i6^;R_#%M?i!G@UN7j5kqQ)zlr6<aEia
z(;ee;Ku$j{$$tb(_VnZYd!?0o;$2Bz<0r`!x98WYdhtZ&U+ZcOCX(o9GYWBFK70}L
zcTaSc*oMY7NyMuN$*Zg`WkaOzQfVA_s?yrcMh&$Qb%@&uk;zp8g8l`DB3`AE5znf)
z{Q15r4TIBdoRzvM{%_7;?rhgEc%Y3_+M?4@{7p^==&a8(?HaiyNqgtn%M=G9F5R%p
z&fi_v-iB7X6mf~(Q|x$kd+%zC3^ooPW#7J<N2-ju@!9r?b<<@;w??YgAx{7LE#nvM
z{rVvmiC83_!v$U5mJt{JFYCs18E=W8&I8cE0Zg|IMlRUHbf+8Xbbxf}Hn|&iIvrh~
zB5npx2)WjNTnW>)f3IsTKCf!1%P(u%j!a(AV(XUd`p+(XH|G>Dt-98ZY8O}o`8<cj
zs`oOPZk)3HjKi1J_$>EG-?WX2&QzxDK-K$m5&rcwm~L2^!Q9+napxucq<e@G!5_JY
zvg5nBU+vNDxBaZ>^at#c3ZLxEcilw}GgzFvBT)VhBD=%j{;-3EPoqkr0O>oQF&+Ht
zr=iBu1C$57;i)0(RGP(pL1X@X?O2xk3$I?s%W222if(9|!uY<2c~qUUCV%WybQMu)
zrt?sIm%_maI20pL7lFnUa6zCa1so74D&F3}BcA!53}d=fb8Ca8XDNiW+1nIEn;&pO
z!di`Oyx&+4uVr8{nBOv35|$&s`^ox}T7=)(%8NaHJ?nsKu*3x5Q3B^v*8C9Gx@_fl
zJ=1$W3MKJaaJ&U-WU1C-E1Y*RIqa6fY=7Yu*lizaaqfZ#cxr>E!h5LRFIlIv9tPtU
z!5Dd<KPCKf3xD4$qF}s@CX6lJ0{PirUjW`Wsb5lNQvaj@nTKI?m9K<(&UlnWNb|f9
z)>@K)B_T+{e{2UFE#c<~Yu<om`tnXiY$&|#U-+_aL4(4Vc6s)^jklloo_ji7g;U|n
zCIxR5zVysHZz%lQKl5<m(eDahR^v0g{n(;5e3f?y-|B5wRqt1X1o%ns+6C_LqQUe{
zs_A^H>917N^MaJ5*-z|1EXYMAX<6W#R9Jc*A$$GYIl?G=Uw|F5s?Rbg2d&qD#OJ+@
zd#n7RX_oM%==92Gfe%V*gD=m3Kph0~4M5u?I~Cao_)(xA0*M6>sOXMR5(PSd+n%_+
zK(QmHSOgdaA`s9~AOx<ejsS{Lk4Fg?Ryh+%Td-Ntfp5>3qUgRzq^zYJGnjgwPBYz1
zGriOrrs=>i<5-%>YA_wueoo3k-1L{hbXjvHNRp2x>2wEbLvNbt5AA6tB2>#r;5ka&
z#<Uhp1~asqd!B}`J>Dqmp^NHUt=8$dGI9CZo{@Mi_6=&3VSu1z#s$(B4<*J+c>$<s
z*IH8&Wd_svG}GT{ru#{z3tBi&_jS`dij*K=&cCWvWbp~U!~A2=JWxp&;-P)|x78~1
zXE0sVp48Rp66*55ecQ448@!EQLpI<hU-PFo+S-go+Vsc#{siwT+IPS4ZGK_3+uTA?
zS*scj{^}1Oq$w}aZ3JxP_x$|pSVgUL9)<cJS!yuv8wc~XVNdz^-+kD;+q{FHud6of
zHf3esWI)Kll;3#1e>dhH$dCK?QFigbfadzrU#;-8Wepyt!{z7sh=7P{;cg^l@4tnw
z4X8Cd6xNp+zXHQcs7W*LBayU*`$)uKHtwRBWuRk9)SZg19WB)(494U7qH`z^gV{o0
z8?*OD)5;CRZE-eVL-)2b+7Wf+$QP&!rU%-wr=-VH%DwA(h3_~`-Jf?-;j^82E3AiS
zKMO^NH)*jU>l<YJ!WlHQ!uSqK{%ph=T;N0MwMr97n0jn<Y-38^SUpYIOy;E)9`z_Q
zzK;+MS81ko!b;N)vZ8!2#)Y)3XUJg<q}EP<AZT(@;q#sPqP_f&dIJ?7-X*Yh!Q5ZS
zP&>yY<?E!`&#Bv;5S^O!Ez;dAOmyoIcPPJJnkC`oc}16m9=nUNRKGAx(ZRwehxJ9f
zF}nVBp~4NR^t((PJMA36QM49xLsqH5WE?0xav3Nk1WGz6yP-j62rD><Ldg&u)l*Z=
zJx;n9OiP|1PGRsaxhKMIClS<$%~+ahu|v#AS<I_#^F7K(DzQ5lb-cnKR7%5Oar+Lb
zpnyc_8N$#$O6?4P{bVpNAxD|hPVn3yH=j0URCwboQ1o-1^g3NR#x`9?i`{cjckz#d
zLfZ%Gjqa!w<(}kH^S%uTcQVZkMQ|B{NNx=tsiw~Upn8~BE<y|#rIBPB;Amd?J_rbL
zm*BdNsfA^ZX{LR<cvP@k4bx#mp^-`wL#45l_XrLN>hK@6FZGPoFnixJaJkgS=vVkc
z&sPOEa@w#CO^<wil%EauXY<$b$H6JA?K++i(web#d}fFzJM;-(9^zY@Qs`odE<hsW
zx6YR6d-{dP`N<GpmxncUx~NO#H}Ei6?C<IM^N@hnGpp+`=yi5XHP=ox&(u=Q6YrIW
zVHWf+TGFmraIZEt1wO<0uRB16sztWu{p$O(m(BUi`aT5<uY-<R23&kp`?8Nt*U4O!
z)Kqpchmv+-E~3-^!nlSeED9N%8=6yU?XDV3$w4j%obF_vc%eK6^;0IYtQBcA9z$+W
zHBRG^YHpTl?u8b&kBHhZC^*1$J)n9F@k%lo(OIaTcpBUnD!E%oZZIeQlQ{qYIvtUY
zc?YGVz3jttLhE$gk%e(C_q9i$Z{h{50JF1-e*dPXjsdkDx~6e4|LFj&AwL}&*4p(E
zWyL5RAnJYjLX6}8Ry98ss($<zwLG&5KND7qcMS7pO=NI-n4j{JpAK{5TM;^eP*Y_o
z#jD1{-R09MsI=nWgw?G|17x{D5bAJiSVWt-RI^Mc(2ucC(XT)HgS^{Lvss6dxL1D3
z5$;9*sng0@Qc0YttS1K3A<Zp@k82R<9&rUcb!5?FL`X9|)%x}18yYkWT73;E_I;%y
z@jq2qqWND90z)=jh6;D7LTiW_tgJRto2~k}CGo_DVeWm1^`EJ|(}T}!7{v}><=Ywt
zJH>CJj`*?G!--#Qn7~rvxL>0>Nw@E!UH5uUIqa`>GS9px23$0SaUYWtj%v?3LvQ7{
z`?8D3tif~zqc~;NxhbF2sD9O;7Rb;aylaGayC|!+8f9cK9Zog<*vULp)Z8@Fj#$*4
z1GGBP65~*;rlYB*b5f5s07X*S9v-Bb%C(tIc-8R8lt$14MuX`GRGorIVlt8%D3+SO
z5e#2LlWp>FOL$Ta-q%S}wI+O8c;lccZ!*#ZWZAzNi=+5=;dSb^5~fpWiuz1hG-C>0
zzJ$LBukXI9H-f`4P+}xTgF>&SRXpNxjYHiPw3G6NmB>{>I{(2ZHV$?Ex>;rBw2dwJ
z=ZyoslaZ4HG+=2RASEn6szrcU-qDT^+UXs(_aYdmS0Mji>58X$-#p~oaPX$Tp~^n$
zsR`-Xm`6mkF6cqrG)p4dj~(AAt&5mSRhZzrsK$g+fyg>LTiEoEI(rf`VN_#TgDf#0
zuA$ODq%{`>P7eJ?of{`gj1;EwDGfXe_WbmQ4Xt3qoAp%7gzi^WC=y2fvz@;h#HOH$
z!4u)|L}$1XZEn}=Hdk6+iqQv|=|XtjCxln_(EOdq`ffWgSx+_lqIudnSB=N=gOPPQ
zO+}feS$4S4z(RA(qgp8ZaR5EOPHT(~$wsUNVwzd7VVv*)cg0{d3dc_7R+ZI3i-_f|
zn$`)cEj9YT*7!Ayk{VCI44cL+;e2LO-zw!>6cnph8d}Ewrj-SOjJP%uo}e0yK0Fc+
zS*!a{Mod(zZS7++s!3)05Vcwj=YyKmVKc+|)Fxr9?ODFANoYYep___I`$LqkF%kAb
zvq3zl#cJmOz!e18Y%GKk(r^>xZNwZ9;R+#dHj;dK399sKZ|p*6U#iWO$<Tz_VCt|W
zR%k`=vX&#$A;hNA`&ByiUZ>+A(-8{HMv^b@j&%5{rmYKhkz33wGw^^ZROgdT(U^OS
zmSCEG!4B1CAc2;ckW)0j+Zi2&9(w@7N&5Y1HBMocBW6L$_XhJ0ngJNXP>DrIf1tK<
zX7*E>bQ&ynSOJI$(xd=G)<LNF3q$PC;5fIWd{-#%a8ykEyxW!Ex(6K=`?^S>js8Ht
zajVKN@Y&Ix1wI%*avhT}+M>DDGGvKKH1zcSR?#Kvcg8yw?xQKHPH#MZn>6gZK*m^h
zT&0J337M9RvEkdRRx3?s3ZbU(iIP_hDh_>smDY4*TJTzo>E!CTCwcZ-|D|Z4W>RHm
z)kZGmzA=$(<Oe)G#=Tml!X%y(6XvpfIfk&BzhMGa_?+pD8ebpd6Ep@ysBiwEZBa29
zHfZN?!+r^6g67v;i}96tbJ#DaHD71#{)t!f`wF3I2~7mG6E`SF7BaxlQY<#|u)2)N
z`i_=^30J`R<^np+ypA|iF{=)0gW`+CiZ0E(c>`!^rd!$!DC33AYAU6CX|teuU%oFg
z{2z{3F6j1w&W!)u%&#B<(M5GpQgq$InxiS6?QsporF(3(&VGm$4#IQqTdgZ`ZO3&S
z*ArZi!C&uz)f$T{4ObSf8Mstj+i-n@>jo|>uDa0E6jvu)!*H#@7`ozl0bGd4DO|n&
zv|8I@QZo(LZd{Z&VU!3llW_r{y^pKvUsh`duBo_)X9=F`as7sC=o72;BrZqrlMG$w
z-w2bgN}W!%(QjICv1e9mjIao^dcQ<&ZSEELpbmAAt&*sNH21u!<@!)RQ&yJpGs>KL
z*89OcA=abmFpWwv|0;?@Gh^~$FweNEeN<bgOE%~KoML=D)6-yXX)sT4)W(Dexle=n
zyx63GAA+%nF3q!xDy{ILR$q1$o<c=;@3u_r18nEFVncXoPE}qzuDQn+C)x!<zt+~#
zP&my+mtO;$Iv+VPo*h@uYn=ymKodd@=4p;;=4l@Lb&1pkUeq@E@{i(jYD7ZuJjL8L
z&0w<lTe)wG_>koHuu)}d=O~s0%k`+m?op*!q^9YU?<Ez^4ASLqFQ2C8vs(DEWGi3W
zq7jR=@>4BRym~BB(B7<h_JvQJ@=ww&G|7tI!vZ{_Wn*?}As>JTgci1}AEGU!WZJ`n
z6FguYEVTQ}P&nC9r!Sg@5yjj#x{493Keud4`UB$K3mTCVNE;ps)_WZj(XDG&!E7*7
z*g}~}Gk-n{g^*_2>`#1I$KbZ_zLD!-@ChFMPIL+G#n_-RSD&BP$kcW?dJhsdn7WU{
z-q<2+#q>d+gZ9*}@JWy9w7pmDyKcn(p6R%L=b1&cBDKWqL~}Ig4@9>!SmJAA8*%7K
z(Zj`0jw{RGr{8%{xd*{*=;gp<mt?RSMH&|8nUEVgJ3h(C9TI$cIsU&hfP|bMp_dqH
zwoAgsWj^}Fw!`(s&}Z&A&X#H9OXSvMro4;H@Tm#)$Z@L@BI$8Dp-x6%;geAP+^Fh0
zor#oAM8J?`H`|~bvtFIwHqz!CstxeRE8XROaLk*q>6on$!j4&wnT(CBymhOAO{i2-
z<FN2;j4lrS+kY>tVIoaReavxwrd6F9@1tnoo$5&_5W~0paVy_~<AUPW6-=2n6yX?G
z6v)uH9-UeKMg4)}R*Wz1{ozOb0k;l?e|I;Sw~MTsc90|TUEZh><riL{WR1t)AnA*~
zCK_^LEyb86i@t55>2&$o=LzV3bIppb44y<i%G!|(g`KjVSA?MX>$Kj03S;f`#ts;)
zu%NAEqz0yCnEC0}fpxM#O)?!xHjRo-G2TIm5f*9YPKk|rk~R!r;pkR~Ok+Gp8%^2|
zb-MBhkkQ6sb@`syF%mv4v?}@~hcNs-NU|O+-v)+c(-Raifnleq1kg&%iCN97R;k<#
zUVw%O_oOVw-epTHnb9AVvr2HR1Q!tK3y{w?ggEV@P0I3wS5XIwI@_Xbmm}|#6ro_(
z6?Z4T8TYsNFSu9d&TS%;8ax4aJs*R+Ghc~&RsJ3BF8l@Vt~|VLgi@1d;$DkeaChVT
zaChf-aIejMk|UHlyi@Y{%(_Ulz$dBjWoTYI-23W_YQh49rsdZW)BK9)q}eY$!IkeI
zX7v?8*cQ8Lq0Gjdz@ua#e28lE1H#%Oqav61<l=`e+$*I!Yh%yHrFa&2K}AUzc*Wjp
zkW>&t3T8+J^+>_(A`pnnbUN-tevY|g59@JL#~#MxQ^MfTqc4!G*n3YyX~Wx=1)^`Z
zqhx86*M5e)Aq&;6`#^Lvmb7Y$sbgA2Lvs~gtz9E_LC2f7Ywx>3^R9+|C1pdBsVX*K
zw^GMzPT7@YYUg53*~?e7i*mPZdR*3;p)cO$K_%1K$_osk?zW}PW$h`tkX_`Ma#upa
zLfiI0#c10Dv!Ho-m`_l5W$rl8Y&YAItW!*F({_0ibLmSkN4w3S{_Z|<fst#)ZK^IG
zF5>ql_}R}W)jrzK$L;lY)E<6|k}w_R2mHL;w;d!ei%n9j0g|yLIo3hpS1bGj*N9yf
z<YSS++-aG?loo^vZWpAveGU7lc+2<lnT9YvvR$nf`v#%{Ys1c?t2a_mIKVg@A>jk#
zI6;FOjCnHTCN;Ew!TmbKInZ2MbHBrL9tSy@+PdwkLfS8I-wq86>|Ot^EE{#MC>!Vb
zsO;@9il>&f!)AeK5x1XKGUZC9EEAXlz=YC0^$P4M!QTnA0~l3Wo`#1g;__h8itX3F
z;;s+w0#t_K#C{&A-cQFd4cURI$qiiYn1-a_%Ez@1*EwAFPcXy4m5pl&t|Pb};R?po
zq$e&Tt{u2;;Bv=|Bn8)0T<%aG4O3KHXK}frOB;+UeJD!&FMyZu9EV*A3e#rbmoVfM
zp8xIAfu{^gPvSa<>&@xq;<WmWZtSI*r@b#`^l297AH~Bx@*u^0On9+mu=un=7lt|N
zo?X0qTC&n(`?54&#wO0-yE=DpX)psUrYm@@;Mg~_+<OME*(KfS#B>Ol{?ZOj=cBu<
za;j&GdQRtV=~1<APJ>8U+fZ3t(*|nir}2#RZfwppzA4?a;Re9cNP2ygS)TKccv7$K
zre_A@<9v6md@8@6?iCaZJQZyWBdD`>U@CRn7>jfjXZNq6`hZuCpG@VET?<&)RKBgN
zPuN7T7)(_p|BETF_`iR}e;q^vT62r8y?N(u(Lrq<P@LYz9V<Y{;(i<tG^ttOlRZMl
z6#i+qMnMnmS29kPjB6!h<SRzUDg1G_!03jQf~jpN89{x{hpz+!q+qTT{AqG!3fm_0
zPTkXLp96seQxCrMCt<z8>{I9d_AT858Oxo>&-NT1H17{Gq9v@Y0l&jq6%SZ@G`~{U
zs(e1MR|MOU&)@6Sqt%r=#80`)rh>7!cLsk2W^O)51VWlRO2kfTs`5(Hr92+kyGOO}
z@*rWa-OJ;%ddIe`{z_~yx!U6XF{EKY2XIMu)kA2gcma&!G?*TynqE?MS(wKk_HM$q
zPvG@44*4~lAl?^u#=}@T(_t670bK=)DorxA57oZU<&J%tcsT)t8}gE9Ga&0_s%d(V
zhoP{HY4>w^&pu6p5-KQfl!L?MIE#A_EP^T1aw|>gp36V)v&Yk8QccrS!@+CzSiMdq
z`;}w#BGmrfdwka0QN4>~{@<TT(#hB%Ts|HPSK2ALthL4xxo}#dZf07FWhP6B`VFu3
zMuAbhhm{pM*>sJz!`wTQ8q<$ZK&!W2<GEvBgUiq3h*;TzPLAUP`_`-S**HZV7^HZ!
zx4z^b_iYl`8%*S)F2rn}7OS;;CFS2Ysefj9vvK@M-zHH%p<*SQULuR3U`Wj>OEuTf
z7sn@Qb<t&zlgxSOxh)CB-~&^YalCK8k-ps!(-x0Kp`;jp%X1}L6H<ky-?eFD`LF$w
zA~pE0Vs#RH`}m+^o*U9gR{j9nEzl!N%h#iD9v@_R6A$<!q`8dcJu(AW^UwIC%pkV*
z2fi}XFDCJC6kycjgLZi>Q?pL#i=z#Y?<?fBq8yR<ojh025(F(7Z#2i`@cWr=tkGod
z&_A-dJKQI{Dh#ZGnDFFvtvaMTWm!8~qFWoPG^Mq}a&(vSh5X|&Jg5IL#e+8=u#F{;
z=C=m4bDF-HI)*FSpQCt-fgR#9Cc>$BM~g=ZcIgmy?t-uuIg02BaT30VT3>>VM1qN=
zxsKxd2FAtx4mzY)5^R(H1z~OfNFiM&;h6;6q=}@h9?2sH88VC#_9mFNHK2SB!3k1&
zsDxjj!ITt9cpAaJ5^gWy%LE%Gyog}y2!3i%1Zy{P@!&z8)Lda;6JoMWgB*#e`v^X5
za4TjW!Tmq<;6DuR&uWd}2j{tMZ=dC*WH4%4mY68Clu9WFkhE^YM7H{Z4!9=4wp@2Z
zSZgZbcnLp5GpWoqku<kqyktludwba8!ETGQ4RJ#xUq|B0ml+5kzR^QPDk&0fMDRoj
zUq)E#G?dTI{wZz_H3Caa93GWMOhH(CJ6lL+N!XKMo9l_Bwan&xXgDj%UOYIB*BDmc
zbFO6Uj}}mpBa<m2#)2Wd%diM`bO@g{tdD1)<SIdBD;X}i{E6#Q7JoRbBda<D&g;Z2
z!;{&BEb=3NX-VRtBNEt^!6Le9QA@saL|(@CV}#WsM!(i`3M6g*AYnBJ9hvGtu+3^B
zX`>{ZC*g(!+Z;cN;Iu(}&d3;M8HBXDa;H&US@}Sb>?TtJ|6)|5jCxXVH)>9$`F<pL
zaezqnS5c#4mJ@8#dl6x6kA%OL@HB#LRuM^CF@QH2y^gIMz<(N@P~a<COw5cC;Cd!q
z<Oh<rs=r9XDwXsn__>6=2`-TERSCBy_=SX%2p%ZmgA(>9_@#tf5u5~A4kmobn4K9m
zHp6hRxnj^ji=w8ejmQ)><bn?Oh7oMb=Lm$g4ifGzVJCuZ`6QCoFq40rqt=^$4!tTJ
z{fVhBtm#>*#X<1Z@t>pp#POeWu*u^;-B4=#Y3P#2f7bQm3&;A_+ajuW%ufT6N+X$-
z9}(6Z`YF1UD7hWwnb>p3SyDqo^EW`zU;o|r^)aAjufUq{2y&^%13c%!^N(XdV+Et_
z7|{N{bPQ-fl#M2i0nLKMe?12Dv1msz-=PXr9s|0Bu=eb2N-$xCgufsd8}eksUV?vq
zd;5cNehL<XHFHDI^Ty?lXUqHWO}VjbU?2W_?yx$4Wk7*RtO;l;hT|TTxov#Ngod6+
zq*l8uXicFl2aB^4Iu$KAgKwNLnyH+Qh&W;So<<9Wt{?G)yyh&H^ND$F*pMyTOY%B0
zgS)=yF$TQCzw79WJ{JKGebJu?!0M)h$@rLDvf4xHzW|cPd(h~DqIBqBjt-^4HmoP_
zG|9*FmS}h}VI<I23WUKptwRr9H0gQ9SriTQ)j};SX(-_jAfZKf7f!k(>Q&62c$Dmx
z)$swsn!ALTO6hY1w~*4uNcwR%eqr)}0v`$YBlrg?T@xg2MmM4SC2T_42?YNpVK0LF
zOZbX}eF@ei{2U~$wS-G0Y(=Fjxh>&e2=<ro+5t)dX}?Oiv$X9z;floPNb!RNyGZx~
z!PmPA+p;A55y9@ZoDqCj!qY*A@<M{CfuNX|A*_8O;b0-%G-e3lF;d)#vSyTcRjECN
z;ARr8MexwBeE8JxI$OYnjoZ|+_6Af;-2oTewB=p-rm5kmkQb+>vVg8Ucv@%A@luaJ
znm|cUsV9f5OiJgLX|37hbbfMLU5IGY(pj5y-eUR;X6b?f(~W;OJ&}#+!u2yeJs-ls
z$jit+P_jifgeM?r=FYtBj250ZC0v`}of6)K7Nj-r%+(pOEWa~9GvhcmOg@}BC%m@4
z$Q$*#@Cj;e5(22OX~-kAXZ40S?OnlB<a4bkjdv*MUvQRMuO+6U7vOyoJ_C}56F{IR
z?2z!c1Y@yI(hmr}(^0^WL5K8af^FU59fY-$68=%b?-Fe54vC~~k#I&|r4EUYCH#A-
z{SVT<s3UJRE0yi*$W604u}?bk3$uLVT1it@_5|~4$=s0qu)l*a#ZSUB30@=NAkwwE
z1CN+JoNey#%I%g8!tE18Hxx4;4Yy>O6c|VPK2PO=bE4Uu)K>!ErOI+b3BcMDXnG~{
zrN9%Av<ibPCkam^_&o`Gz!*(6@aBar+4lw-T3xUN!5eqEcVmfZ(}$lc%wx~m1M9(8
z7j0rs+tIMQeUQ;lDVQ!QYfP<lXtYfkrhueHr-&RUfDU{9>;l;4{AiFgcM1DS_#DAD
z=MzbLoGhg4%d*)?u+7{IQvM@gz27WkfLq^*X09n@wjO5V{WiMVQgpS)SMnuu!`M5?
zWGeq$ZOQfXTCr0-c$azOn6WLW=hzo*1h~mGjrqu6!u<U#HHoO(UCo1)0+Xl&G5#pN
z%G|vJl9tq3*w;Y93c<EnRegf%Nw}dX^_c6afNhzt2a;Ar!qp{wm|$DxiKPA3N+@?v
zmo@Jb!fm;4N7|3H;?*pP>{%<=*_nS}>B9O^(2ZZl0%sD>c{h}OkwA@_*ISgvf8mbG
zL|%1aD65?yxIR}?xn*HGTbR$UfSM3*V;#!&wiFDj7M&_s*iMvN2#TpP;|oC2+P4t4
zrHkT=aUj@cI+3(c3A;*Z4aHRHml`BpO~N&$^l^f1eyK*%x8krwYE0*0`R(@-m{$vt
z!6}Qou<3EavX_<|mY&Ny^H6p&_EipFyz9W`jpx6E+6*uIMRBL{G4H3dE93Zq_d{7`
zbHU4&3}rtz6AUw#oGRFoB(m5p@pTqAfus$K5m_7uI%;lxf^AtOl4g)_l$3TP*jDt7
zNjglzO{8==O1d(OVI=JY*p|g_m!>#2C2mv78s4cW&CxPr11fG*4j-e2DqDEzJa^RF
zS!`Mx9=<G(ecV)d<NmS&cD4zceNSHY!F={G%I27s{G;X5Sx6L+9JVu(FZwW>O&Y=f
z`mi~x9cgn)%k2d#5?Mh4+>D%^ZT>prEkM#9H4+)W94p`*1lw|U2_)^jgs*@O>7@kQ
z3hz9^TCs#nB|M2>o7;$_EtBx^1X-yw2)9-0ze)R)M!e^0KNk80pSU{S@788|3sHk!
z#UH$i*;8~PULAi2B4(!A>PGy`YVZ165KXfLuOX`GNX1(;v%yi&PUc2Iw0iD@&ft{x
zw~@Q8iDF$g^Y&|+u%=`9v^6c`I?KY@M1|ugd%+YcoR<xR10p1BA=qES%?Q5IfZtuy
zo3&`j4Qod*-hgjk+nXI)%Bz1=7`a5$Z0C**p+Vo}gu(0{_z{BU7I4)&z)Xiwv_r#)
zG~={3HjE$msAIumArwPxsw7Az^drLBXQ9H52@<9@RT3cKe1gpq?jd1nQzi8zoJsI#
z3CBp7+EhuPgu4;k32^3N+GOCSkLxttyAfOX2FEx<b$!ut!RE6OB-%R&z~G#gHKDq}
zj1%Aq6E^a1J`VN}zi}|&tztqOuxY<w#tCrZM(+4YaJMcXnFN?ZI%vmK9JnuEDkr89
z(k45ysfV;Fl584Qzp_8q(T=FtGJA&oSnCE}@JVfUa|2gDX*9T8*4uYcT}m>g^kb^G
z_d|rcPDpqx!Tlv{CHQ;5wyn6{q`B}mwukITZ+M+=F7w@I0}o!;ao{GY=LqR(A@yt|
zJ;~6MS~%S|QkT~X**8kIRm6saP-qj*7m3YBT5}Y1l>LWP&uv*P14(-s%ulZiWTy4}
z(Ym(I$?Fwe!xob#V&^PwJx}?xSwWaod%hXuR!OyuNo`!P$mAgjAH$<^Go_4RPYI8b
z@G_GAKuYHj{47XFljC7jCK=UG!mb4W3|Q{t@xMRyWkWvYp6f@1h7G0j=w&H!e@)+p
zJ@Q-YAdG6!2HWlCwvKUatLF^^`G<A<^Y!&J-bRv8okc0*6dSo?D8kzHK#_7w2`3XA
zCE;{}4@-Eogp<%6R(fj;!Jh>31{=az&urdj!!q9)V8%Xp5{`T&hh0m{D(_&455;So
zG}Co0HIVB!c8WWVtig;&O`)izOy?X(T1Gu##x@C`Cm09R$jYY#$JOIYHpa0pKIW%4
zwr7u~@w%UN>~{=Y&~=8GZCN^tu$CSmbZwOImjv6gw4dN8z^`_GEeT(uAK34Pv^4Q9
z*K`>5dge#G^t0gVy#bk$TtKjV#P5F=%!Yo%Jw6X}f425@-So%80Sww&-s|(eiO>4t
zl~c+ZQ_3#9sM>&$qZIGm@T&@Q%2%e8Z^1VbqO`DMcsY|~Zs(X3*A5MvHqHQcTFdW$
z-ii74;fb4~J3BTJ+506D_S<S`HITGKKassSF_6WaqU?2+u8IUn3ji#$XKPJZy!%XF
z!w+qWV!H?ON1FoM4Ov6>S8r)>%&U&3))Uc|2AAnq5e^fO>~2m9tv<CuqI&f%j>o+2
zZmzE8{Wpiz-LV=jYG1vLIk~B$slAJqLQIx~%d7dC%>j{nUZXCAz6BK46oE_{pX2b2
zt)`9xdCY2le{*C;q0Dz=1Ttok8JkD><~}0dLnQ1<@VgQ=5u7JsAGiyZ;z8rrUh@S>
z>*>R%d=Xesy6RQY(J~IK_7)<gJI19~*Bh}+B2vj4q!E%d7o<3Yi{3a{#C;|qj(vTt
zH6>ey4R|4#M1r!nHe!>GbTzINY>jvUvgvD+tojd0!yA$)Mv{!Fl&mU~47Le==ly1q
z5ug^v62FhYV`rvET}p|1j8bp|0VA+I9<uk)^W|Ft3+|$GrjgisIH{#ysyRMr`f05%
z>9pAIT}i4bGZfp2m@R_eN6~L~Du11IJBrw222<U<Bdl{S2TA+Ni|7g8Nw_V+e@OTi
z!Al5!+mi5w#DfUGEAa}#Cra^~VlEQ%Cmtm@`U#EBuHk@tOZb?C&k-Cg;fn}sv0i-X
z)>f|b&{*(72CrN)X&CIYg5TI0<JmzbX`pJ;Mhdl|B$s>g=xrg@Zg~pBFMY_fwgp$)
zD`R&)<nJN&u8ggwm>0jet+i|0?v#YSNbZLxxP8bQe3{CseaQ2_Y#z4@Nx(NdVR2<j
zTS3ws>xv}Kpk@LdiJ3@AmNeuCkhF3Se&frQEWR7Bw>_LWcjH~Rw`JNizI1yGd#@}1
zZhNpxNgwjXK6;Oh*~+(FIs2+TtJRfv{3_V_b~+tM#Mu!$_>=qp>d8`i^AEnN&!$i3
zhra5|TBmcr9l<WcGlYs*sbXq6@3EsjJJ^M<+!0)Dc^6V)pBKpAyXMIzb>TO61h7wf
zbElo&F7Nafa&!O&NiXZdo9%30;|ls6yxd&YQyhimvv+s~6id=Lkg(8OhKxR=DVOO`
z8ohwhcFp8RcLuRTIsEp{Hf&}uI!Vn2_Trt3Co-)kKU&;@t>{AMaC!JHM>3)LuH$S|
zXU=vnXQdtas@<V%X-9r+cLdAs$e-@^W4~o_&yrkrbrgTMq$4Zrz%P|Vux=fA^*!D!
zdL(bKCyfnF=acvJWY!`4)Sk{YTBiz|pCGSTjPhAOdM@7M6yPkWM~RB{Da>w2(*)BY
zgXt%jU1JJPDg-f)5&X>V5Oyz}@8283j-_+!Um<KwI<K*BN%h_BMU^maM3Jgp!xSI-
z3E45ts}GOb?^A6wP`Ea~1^0gL>8ELFNXP8F@g1aLjzel?H2#Y@Xoa)Fy`Fo8Y5mET
z!mrcCuOY{a`9X{WM#;)PaU@7uA8=3HAIdJj%h&7=VLRXD$M$Ddt2<Pm^3%}5XZ3jF
z0}Z@B5kq*46NbH#Qd!~lfTZ=SuJ8#5;&66{e{rA*>o=ZXKakEEr10p{MNCWMM@tQ^
zos(rnui`+CN$^|1{SM|ck9K_N!9v%zZ6){wCusn>nR$ald9M4>x~OeTkkp0q`IbYU
zxK^`K_uC2HizYtg@FdsSNs_mjq;@m$+lPCyQK`J`*WWXT0ldzUey-)MCC@4*BunP<
zq9a$>(^fqDXaqafiZ4AnlVuFxwaex??@u7syh$*I8~NvD`CiGQ>BhA2c-<D`LDJr@
zqVSf-+On5LeAY2{cC(19$I{sGR{X{>BWsh)M;|x1ZovG6GLk9h##0LUk>jJh(h9Ni
zG2`$_+(G?<N44k|z-d|6&{;Mu<Q-4+V9ss%+7r|0_oKewgs|alc#C5}eB?JFUbknz
zA-JUGYr!98^UuEtXM1P!i{I>FWwBiSb`(1i%k94VjJ=HGTfeJd2b=MgC%d}Rfo-xV
z5T`Ye$JR5s_2e$LE{5+uHQcKudP)NCVP*la`V35K=zxRP?E=p^T$lGe?cy-374rUl
z3?F^Ei|bl+oy6Zu^5;(H-=6Ny_O;*vXId~NnrEJA&0L!CRcD&{>_RPwyP#iPij!jZ
zW{!KHZ-8B#eOqznMC%mI@1F^0@5XTd?;}F)U|x^2r~0D0vOr%<t(;p0o~M_;M=>ZJ
zpUU&U4`&yr@=v}maE)sst@r~|0a)!cl}G;&$u2bELx1S!wH(tnGO>#UM@^~B(zdhw
z-6J0S(GRs^@`#v7`J8%|&bQ$JT+vopRi-$jQQ-xl)9apg8c5oEf5GP9D%#UXo_#i^
zYCU+hq9GrDCeR7*)3q4*5gh}f_L!n<Y{DO%ZNb8$dDOW<tVL7){<&cRgCay9;t4_c
z;VRC@AenWPnrOm<2XOE6;Vi2Q?|8m5tJR!;c;1`!?80}SFRxvaU+Iynry(Y0oA2cF
zT|YKtALR2JKelB3@_D@r^V#XV?O$AYTVXvKa;J;^UH@z#U9s_w@Y9jp?NctERhT}E
zclr4T&x`gVr-@aN({JQ>x*n4TZSfyG{+Gc8{U!W011#5&&fP)MYX2dcRBH*ZBiOd2
zi6;23I|BBX@H+&5E&Gpd1YeM_BH>{Kg948@w<CDBgs<DlEqnvvNRRL?gfEx)C`Fj=
zVa59?TjJwD(xyrHEa-6VF9h2r@#P3>{Ul7I9pDN`lnj*__a@~D5*{kxf|zd!$7F^Q
z4<y`I;_apQW`eg!*p6W9ZDLJu1RdH3QR47FNjrd~U6pXTPQYylwyoA4gQOh<ylBW(
ztF`5ItM$iUt=#KM980;%yItwP*Ia2@qt7Tz%goUiXdSTjHotadAggklx4qg+`GGIL
z+LR5b;HRzzuzn-?gRAXX_mRBiHE+)yC|lUFmx>rmLb9a<VJ-6(AAhZd`!;MLU??65
zGcoRnpG$wylb2qLVZ{ykU)S0*-$0&tJwV?Otsd>Sltwx2WFQ}RJ*nE~^=NQ%$Zt#2
z2E8L%q>W>P);Ey<dOez@)Z=x34bWeI4K30h)#ItZHuwEGKqR~bU5!ZC5;KR~A{xTg
zu6)(6LF`r%zf$4Lzq(nsincY3zx>scYd1q!P8fI5db1<`e1sOlR{Hbz@OTu$cWc4y
zWC*{i`7!4Ju9UZ_R_-U#_$Y*@mHP*j%GeYfYp+c4C4w}?xR0?KlNn0%o7PA)jxDN>
zcXd8&e0}bGD~UC(Pf0o%eQk54HGI70%QAiWnOpVP?jTCK*5V+_e;;v15c(Hs*L;N$
z`+S5E6N7{i@5@*xFx!lnir2}nj9Ai17_mA*7%?Q6j0i{x#xX)i%%H>`iddb^zD;ip
zOh2TW9;ceDG=nN|0#}l`eI(Y9spj^vw1z}95sOGXlCg@!!vkBA0Q~`OKs3~pvK5a;
zrj)O+>^xR^P!em<o}~s;58FY>LEg4pqwZtck+QXtZw>gcR+W4OL0ViT;}OaDzZAZQ
zdh<Z<D&L|0FMUDUNU#|%<+~2mHx{fD9rmOC>MEKSK4bY#mDCBh3ZGTUukoNj?_!||
zF6hT5{8;!*0qqUaq_3kM!{PI^7#L|znJ167E|N!Em&v28EAVi`+hlUB+~2~dDE>!w
zgS0d+QLgr|lHN`f{BH*aN=~ZrFyS;>W7yxK%;h982pbki=W3-}Ps6Qfh&K0QprBKy
zT4T&A%(erlIF)Oh45GAtmax7crAV0nzs<Nqmj3VjoCI916CM;FuF#1syAoQVW|oh~
zp(L?6fDfrqe9)^n6-j1!*B3Qy3{l@_mL~(H-=*k(`;_m<apytTJ>SZxD>@6kF`Lmm
zoo2Zkv>9Gh!9(7qP9W=^0ly<f`uNe-BPfNh;uEz?R}e6XAG^`&!l5ymV3MhfD~;*~
zB;zM6w>;(eww?scf)5`ua7(j{S)}*lQN^AO(@b}9<VzbZ%6(B1esX;qURaijz@ON1
zA;NQW$|p%U6HHp)BCX$m*_KM%RD5=VXl-Rm#!)b_#6#HUEc$-)zC@7llXx<oeusDC
zG8r$<B2&s!n^QLymtwT)-z|U~SdvVCrCHVu6k?l6dQqx51z!h94hls8o8dhjsRH;D
z#Y5dzL#bO8-=5IinsLj`P`AP(9;wz-`AZElW$o54Sh-cd=~+7sJ=}kuh9JNBep_4A
zRwKF}c)k>M@NYO-cDJY7VU^-1PcL6=MyHqgwwpel?O>OD87DVy(eWhppl#N4?t2~V
zmKj^MK6t(S3`em)L#GOd2~*_)#@&M!Fb+cn@HGLR4#8*$w0MG>V^iXu<2M6I`p#dc
zgxyTbx~KgK|BBy1UZxL9ME^|Xnxs!IqqWSdEd-QlmxmFovybSH*SXnxrlq1kp5exo
zKkHTd35uwD3FW1lZ>=vyEW;Rz+`!~T8qRhoSTpDU>F;zC({TFeiqRtE57goZ{!C_1
z!%<#-Jm^sfYf_7+JqmGf5`0y8_~RCQ;a+?8XKR#05WoD$pUtef_;Cp9Rg;H4PG)Q3
z;JoB&CtQWE3q3@SzgEWHMwLPO7vOp8ec^dI?0l4j9^cP_e(s@disJSDYQu)trB>mb
ziWXC@%BG~_iML~!U0pu)b}mbF;eXtYV0stscPE1Nug%l%G-i!!^I3Q5v5_wPlRG_F
zw4VQcC!%f@J!P<}-gpnq7*%o?mLwSJZa3zw?>AsBu40Tk<Hs$33}WxPV38Wk-S4`y
z>v6o%-ImPV1?$yd{_b4|yGe1VV&m@xifXu5kA-m<ueck)#?|39?nT?RKstQoX<zol
zhY!8il>J(Re|XQpsx{;{?q#snZX&r_HAHe}z4`q6O;~9yzW;s*TULwzet$@f>rTRD
zAHr8uLGC{Y3fL-1BZwqx>>sy;-(;`3t%azx<B%h5PXm7VK{qz6rcl|sCU5=Fi@$v%
zh<$<YH{CF>A=UVa8^JYxsUcJ?q8|yb?aN=>h;jVek*ZmKoY?pXb>+Q&k7cVI`J&$g
z>Uc@+4JfdAnn)O)dnXoo@a8YuIkH8e)U2u9RqKT_8s!sUiD+uSV$F*w)e0$3P3`5)
zO8J}3#fHHB`lvvC`Mhg^EWm;P@>@rCb|NNS9=y$sT71c0>zL*D?eR~FQQ-JG0au;`
za?fWw9Z=ixN@WQD@mVCx&*IgdN49L6MT>z~-?O=<)f-$%5I^a@uO(#?;nh#Sr(PGP
zXrE2zdCx<o$`7;n$Il}hZ2Y(Au73XzeRNHV22AHKp8H8ruPh$;BC<i)zeQvJDf+7{
zIc@E<*P<T|<{v|J<Dh>TysPg&Qng;Sr3%p(K6PdOUS;Q$4Xv2Uo4yRMGNhWqv+(SJ
zC&x1x&%-Z6oSr$-B-r_^qq6<s%OvKh6Fqdy1$3MxQ!t_dvj<5Vcv$VMD9t^$06@9T
zeFOgrVNHKnU9BiHJUt|S51mw{ybs}%52?+VGBWOc0FWR32L1uU+MfrBo)9j@I}tov
zv`l9rY3B~AKQU!Y!G0-z^b+t~i618M&Qg4}gx3>1LBb~pj*#$H(5ccAY|GpZgf$ny
zG=nUh;o^|z2Q#)vJp+hwjMUSQ^st+yYFQN}+Vh%Za3u!4bkk*G_@GpEw^PzH?n-?9
zMd0leO4a!`;Sr@Gn~Nkok6<h6E?^76E)pIu;SmI5bwuzqg6|(t_t`04o|_~dO?Z(M
z-$?l01L^}irBUw_KVjy94F&s^po+kX%E0o<z_QA~5?dgFDDciM2v=?bF9u0VJV12&
zHb1NR_DXh#bVRX*@P4U&XQ|jp3zKpIBzIj}+nD4w?kBkfCkZoxf0b|$!SnYQ2US(v
z6n1u>+QLCO$6oAJT^*J7jlbFpxqt1BA3HB>TZ2bs$$f{g7P`0i9Y-aNv5b=9vrbAj
zE9iJuaQ<)xoHpMWK+^ga3u`ukj!b?<@IL9f%?NAp65c1_B?Q}Q$RUD#B>Y&y6A2zC
zi~SkFFL&YtJ$|#GPu=CLER1uPMjSZ}zOJ(V2sNF+2bY`#9Y%aguq~Az5Y`&+RA<#t
z`g`vGLEw!EcYGt6ojcSgHI&YtLnVIn6mUi2oXqIFLmjABx_i1xybs~nr$buKH9*p?
zeO3IOUYVfy{k9#%GOQ|5l$U1qGW}$*q{r{aK#N~fC9Hp}4scaI_Ix0%bovfjI>}V-
zl9h|UEcULc3|82e+tgXLl==lmq=W2ae*?yAl95RGES~%XUF9o|mEQ`!1mg3NzF!5B
zb_9IzN;}Y@#+P85S2`lBeJbGs30qG9w)wt@;JM0HwZ5D3nBCn{?B}ioDg~af7>Z6D
z181uAe%WzwcKbr4^GurYIl&zytb>HsRKnH43h4y|+tP6*X*UTk0Uhudf^AkVM_7Bb
zSt#H6jZPe%>rD7c>5N@u=K0O)h1#&qU8>(v2HfU^+N3^VvpT+x(ts`5tgfu1#Iuf@
z)k}4h`n4KEZ>nXwkDIyYS^PTvnC7!tb@x#G*^isl<{nCzXS6hE(@`kI?l+8cP9lS%
zH>p!SlvC`|=W55gN`1Efb9F_e5}|%vR~a3X32x-##n-Q`=ns-+{0y^IeEcKsn}W86
zEOa4uiK&+4qd_>`ap;bUy<e53ey0B7sqA5+Z>!6_6eGK{K@IR$R>bv2j-ay3A*jT=
zBeKJeRQ|Z0!U_HojwD#Df-TNIAZfeStB<{vOP&v53dCC;1a7Od_dwDPf2vmaD1OXy
zy;|K@X~(|*RPEubbY^otRX_1n`q!!VDdc2TE=$B<hM3v;j#gaPPl;AyZ;C!B<^Ud*
zrF9!&t^Fs&NAHv!4c6lZ6MjB_TyMNiwE+_p(<iFYU+G&XnYjL~TYpmx4^rx=H3Bdk
z_C|JKbs4&nlHIbjZz2a;mye4F1SmTc_GIn)+JTBvr^ed<qUxt#N!7Z7<)Vj;X;A_#
z^vff-uK6BlIkcL>3DYF(MR1~o$5AFemhg1YVZ-y?fNd3aHb`2LgcG0%@Gk`0DqJg4
zo-N_d`*q?#@P5J%$}Dsz?d>EUfiT2Z6MR_0;|Z=W;bjt@MesujuO!$}!c!zXh~P&O
zreQ%VUxhEp$<ILQbj7EGmD;ReDfRpKstLN<k_?$m4wCl83Zf_U-X&lMf^B269Z1?j
z3A>0MIz~eeTUpZXAZg<yyivl(3ARlvh@^D|EZ^;`*`dl#rJ8!pU#V5a=j>&*NtiM(
z<8SHQZaW|sDUIp^9oog^!l+9UZc1>Jgy$iz+8znN4?42sMzF1DK0sJov0Sa$Kv`C2
zDzW{ef~A>bQhrenHc*Det$-p3Q(s-;hl-6_@d24U`U46l?4v&15_5!LR6m0EBdm4$
zKpoUj$?>$8;t7Pel;Vs`JF={}yrB}q;&zI`DCQ4zuO%%cLsL>PajDQh_bZ|Q6v4Iz
zSp<^Sd#T#Hu`-4ASgL;CSV>?9m#8>7P}}9k61=HU?sUq!gM9_<?h>_mgc4hG5U9y<
z+Kdf!Om$jaZQT-ec7zh>vH<j?qse}5;_SxTOVqC-l&-Ar64fD6>0jg7`(n|YYAL9z
zZGT_(UrXPo{_C0N64;1*uc3T(m1ciLX1`dhZi`advbVYVI7(?BH&*if{U!J!q<;nx
zU+={td+8FsL~yi(GYO7etWIpA#IiMu)vZmG262m}8#0N{BKhW#8|Ww>N@0S8TM-P!
zR0_gNAHJv7YN`xk*S}IHHbuA9>~j@IW!l!bi4HcdtwEd;iCL=Zqm^lF>Q;3@v=YZY
z*shjED>s8KLm6^t+5(+@WDdzp?e}-#OVd3ZYZ>^y`hAQt$?X|f^hHBmumRTA-&hKy
z+ScOCW=e0xEf&L-zUWzv*HFqA>apfZyn_QF#?RHnSS3(x9IL#=?rv6F#wrV0n=jOF
zV=?yFeNpTbr!-aA%S~$Q7Rqw=)~4c1EtG`{TfRXZ9j};~^9J>4ywZ;?+*sT@L20SP
z{VjU=n04rlOERP%?t-MTcZ8cRN%$Rtr%3oT!M_^SZ(1qc+3pRhe{03S7Hm*QwpM)D
zm<_6_wGtjQbOUUi`?M;)Y8^|T)agZWV>#kUvt~HtgOa>Kz1UjGWvADxIOKSeX&)E+
zCMk6kmh@?H^ES$E#p@mP;`l6qoqp~Wq+DKx58hyJ9->V?R^Lii#<4RW70*akvJ{_h
z*Ft+CrY^dq`6)`Or4!TdKVA5DWALVZq`pW|HnZF{>ZW!|J+@)3db*u*nsr;Ne$-wW
z&+e~L-3`jTxVxg?i&>6tr6gOHo%b4K^si~c52qzOjbM2U#`y(E+J$NAd4sa~EfcYs
zrzL8$rWL=Ns<dI%Qda_=gzp&f#JhpT&pRqx6lVTV-P}pJU1P#T;@&rpR{Fyx7O(HD
z)Ku7eAE<k}C>J6>c%M>?`2>&3cJe90nvz%9<5m7lmktiC&QlMkqYm!6t-efGa^Gr%
zH!k8cH7Tcg{01*|X;-D5clBjL<qj1phssi{3X=A7E+)QbvXy{pi|}J~Bzk*+`m!su
zZCjwmb;EPk0yU4GDGSss^vqeJ-omq5Q}hDmdQ3a%{l2f-p}W$I4L7TEx+^VeWPC-N
zRhh@IS8d<pD;4Maeb|)oYI%3%66-v!_-GIG)@*4`@yuRID~0tMqwepmykNaYtNSwW
z%owHa?Sp5Zk?Nke@qBwkaY<jLmg01M0qrwB)$R^cf9$6iYOA*R%3*Y1Y{pjl`cL?9
zH6~NZVPl6Cugg?I6;{`*p6U;~FV9z<2H^SWd^Kf&(#$PqzD_5$-b+x_P<vl9W~&Pa
zD2v#`A!@)t<>P9dhoCZHOR`X$U{G%j#0+ZWJhgC;5?3c;9^7dvlL|063I$17>JNjI
z#>_QKtuk2QEMu;^Y_JmN<}<f4sY=d>!D_`wC9v2rOUYE&=7H+4A<9zbK2Ws|QT}F6
z3e{)XFm+#{+H9yYi}mYIhIy-JhbnpOM5fwdnDQ|T&Q$LXQ?{{=v(=A=!y=d2|HYzu
z{nQ7;l?ZmfuNpW47RAm|ca2cuYQHG>w?+ECwv!ra&`4!6%P3G+jU?0mgE8#wVwm1u
zVOKNM=+VjtEG0udHCidOEA1^c_!fA4K#LLkfYY)bwoEylH&{yoj86BgXiPD`;8Ef)
z>)|zoH9HCKknnzj>r40s!8dvd>7^20O>m}!j}m;8;Mre?qI2n+q&^&@OjfdrN9QOH
zs<5NoiU;N@4XUu^U5XdvD?=65q_g_xM07j*I~5O~q|8xRi!}B2WTgqKnWp+rQQX;&
z9o6Pjlq}Y5p}Jy<lE@4l)yq?qxomw0b=Xwpki)Z7>deQf_a`eJs$m+sl0OZq=X6x=
z2!pz4hEiYkoq@h-X?u#yWzOPRUrn5;{ONZO6=$eHpM$oM;aq_T-mcl66j!?!C|%e{
zQ}HJS$~;U#+p3LcEAO#RbJc^hl>pDd?}%OCp2rHW>UU$#g4KMU502x0KUaM|Tj|ff
zd`Im!M+snE=BfpAFe<b%sxE~}IICk+TNf%Z{#ubpedZYhW^(ke^tnMfY5YFFKg<dL
zzDRw)P-)3t6sczll_)1CBc<jNJh(`$UZgax|2?D;ce@Xp-NS9F&fC-Lm4i?0U`iy0
z&@o1JP?6HsX+xo4cHdB_eo>@+9I;2l`?y`qZ)-4TE;3m9D$wO@C&(Em@P_M}e(pzT
zi$winjylVzG-4a(s9zYB8SL5|HT)ecgmiP%UhgQw*n!#Vfp?UrY;=NJGFSPA&5c**
z&ckn{Q{s!S%~PH+78zH3*{s+ptWB)?+X9rWXKb;DMLDl9-)6=4-i2y*uc_+$o`RE0
zP1SbqDJ|H7rs|yclq2j&6E$@)d>7rM_~K&d^tgyANX2hBL|CE6seJ=}k7%-csC^w#
z++m4w!;YQlqDC!Oyx8Ym)XvM5o~(D5;&sb$4uB0Fqi*_8DPlj5R-3F)BH3r7)gddC
zrYwK7`oRix6DgzB<15g-57$>au7m+|>#K8DD$%TKeRbbT@cY$Q@2*s$*zFLt-YU>1
zj#4vLVfhp?O5Lyu^OGtg)wfnFW7zv6i>IzuwlMarUU9>Zlyyqouh4VBp$Btk7VgVK
z>FDxY;Z^(WA!_-@idTUFFvZtop$lJxTJTrOUc432<^Mv|1~%b|wW%cH5vy=3oUs=(
zl7rO{-cJ=aMDT<j9IEeaKc6@{*%BhK8VGq+hw4KQR#c}uF=d1H(~LFx;*>QeweS<g
zmwl6^e*B4YwvIcDfURe8n?5k;8yz&3QmUnc)pyrnsBV;{ez{KR#<mVttA46%3A!>!
zW=uc#w7m#9p94id_Yh(gHOcz#2B|-Nic)p<Rh9K{>KPw3VLhDpp-=II^~xHBJ@r!E
zH=>P|dZ|M<D#`2}FLl#K%spegitpp8unTpIn|-eIP}m%g;su+O-xX!K8owU1?jg0+
z&%S`l(Aw(nU!YMvbywZDD03J-aQ49#s%vxIidSz{4l=gMRUNz?MijXg&)=>bR@i{<
zYL^`-%6{F|IXje0Hl~MqZ3il0>z=B9r_#6D_3qTYxnJs0JYlEul@j+$6vbnH$D<@1
z1%!5W3t??cbqXi!mv9-utt9-A;Lg?6fx8s{0*{(tGuykP{n{o1Mr@ZqH0}En2WIkX
zpeiRFKug1SsH$M(GB-^##hk$ex#D+xWQ4j1`BQ01r6d4sVwBSoC~f+Rp8GoR!n&it
z@%F%3(CJSrkkutkaIV)TQT-M2oRH{Osvf>onT8kG#nE?}#zg?aGHp3R9n9X(X0;5@
zkD*zPNT%=!o8MN+cZ?sdFY1bl9Uq?Wfwc*PHOHYz`x#Qk(gJ-^3_z^Me2^J@KM*!Q
zTp(=T2rl`mh5q)2gf2+vjLc4=pw}qBjj>w(_6cTV%K9Q)ZyZfp@yc=zcnq*5X?}8$
zl5ZEEn^zZ>1YoZxh)gM{Lbh}hw&Yiz<vbS&IF_G*$EBJOo0|B4smc1Mnqx3XtNuz$
z612FKn_p?6FZPl#kDdN$%%Hr2e^~P#sW}QJyb^*j&&)cVe|gF)HOp;k=*`rddFu90
zV=_p~tXEogKntU@N46~WuxS}dS_<B9O-^25JUka8arzbv98{Z>MGIwmqbHzQ&e>3C
zSB^E2uCqDlS<3uILDE;$J*DdRPY+TIh1T%AxWppsWVbYPaI-l`+MK*M{-EYqcvY!z
z+fQ4fS}M9IV*y^VE;)h^+aJN0)cv3OHsjSJdF?P5-^}iWya2M(1IAPqV~a>ATu2H_
z^+qe?W;vJ6$6r*baPEXtea7=R>DJjC{Vdg5mfTXbEd2udg>WZh!Q=c~RK9hysfN`+
z!<g3iA1#UA&&jGc82aFkLf~jgCj^}YmXiP~k*y&ee+BF&;B`aVDuMD{u*Ga21Z^Aa
z^3n@7RLM(2Qx1j!@@qRkU<kttXrwU=60#NFG>NpY%Cx%(I<;a4@XC2@0t_f03)OTs
zD-l1QGMMallN238q;sxj`!5kilHqs_n}`o!A%R^<)&k7_jOmEl4u2R4!iV$>c$D{n
z+y*5Nx!e~jCCcb!nPufXycMK|zHEZ+Zw=5_e?dzFBOc{5?8x$!>4L3a5I#J(Qo!bY
z2I9h}hH$*V8y~9MSMUVgoYu7)CA!k_4Su5INQ3T8ek~410^qE_G1HaKx&e>KGX(Jt
zBFX<##is_?_XK?@zQ$(1yFh5dX?x>o;e)dMIv3QW-!M6)PeeH!6?A->G<?!LRN}`+
zn7(K%D(`CntpO5_Iu19#Yl2p=DEguYC=L1?P$%SY9A&Cf|55Gccoe^dh$ai1T0s7v
zEb?uPgb8NLECI!eaFGbdBV67P%AqZT%zUkFIkZ8+aH7)T4TJ@UdC5RQsyxC0I%%vd
zWGYSiAf`zFje|ZJNKY&7LuOD=SV;N@B7#FO(!k*Ykp_+yVPT*dov`&7KB_lsuRS@_
zDc|vEkqD99<0!?~cK?baMbJCzZUHIAA0a?Qu$Y%j7Is#i{ThXAmq$T0N=rYJ9<dsI
zkr7{#e5I~T+X#y35I!rZfB&F<CpMa|yaJDE%iyDO9O9%eR3I5yDP@w0e^C0U?IM4b
zX+A-6<=>+SAKMpU60hW)pt6jQETu)OSAX(OsK~c;qcKuQ+q@Gi5b2$G5hm}vkuH@H
zH3pe%0kZ#p7LwpWi?KtCF}jG<%CzqN$PkLXDkcvB*$nX)h%_Wfgvk(e5A@-!cQDly
zHo4)6KlC6?lxA5B>iiNVCeAKFd@<U19R2JY_ES;4w*O7j_RWJD&8M}xYmX9AaHO*o
z-;7`N{r?cxj^HDpQOA=^-=d^{qO~JR+5x3c9auGVY^X%@kPXdeE<Q+XzY4PjG_(yU
zB`Bv{A{$#}Hbk-5;j6ZHRlhw-bip4j$&$PVuNY<F%hIDp@H!J3hALeJ6_Hf=|KQZx
zQoa(d6{5db@g6!{v;B>!WR1>%Rdjwsd^2G7*EG9JdE;*ef$88IOtvqx{it0;^_0JK
zlK09Vs}|lKh%{y*4cZ>^x%>M|YdO8Dem&cP#_>X<2Osa}V^^vLCh%*Id>ryR;!ruh
zO*!7rGe~QKBVMUl=fzMVPHX(6^@Ns+k@%=1a=gJYuQ4%>(t5O@T|0Yy5u`CntptdV
zR_>yYR-)WHZNRHBoW9JX?z?)B>EOX~yTWTq;eEw2g>CTHCqLD;FR1)@m>vn>+zkEl
z-1i~52d{xlDH@*8(rGK#{~lPaEKb&uHgr;|;2wr#aPPhj?!vDJ(zn?TTZ28Zk!cO~
z7I$B9_ZRni;vOXKA>tk??hVAfk+?S&_egPXBJR=R-b~zM#l3~N$4|jj*c#kQL=wfl
zjkqU^dpmJAh<gWdPZRgf;+`(<-Ne0zxc3tG4BUsKLg~u!lT+PrHww`^yWxQpsz)K3
zIF!@A|L|lCMY{4D6nvXPIN_}uK7m4i<2D>~E?xOO3Sm=ISN=PNHd5$k3hks2by>rY
zQ0N$iexMNT9SpxtA?)+%hCiUtXB46-Sos<XQIh3LX(=!qKU33{WA3UOjvuV+%Be97
z$FEp*<&!ByCoIZyC`6T~d<cbxP>AduK7m5%6e^@pI|?nPP&|cbx1gLdJA5mJLMc>A
zAzuoe5;XG9@XHi*qR<@*A%OitAJ<9f^1EAu6+9O$J)kUcs2875Pgk#%y7+)H+&;d(
zu6`>OU)JwYwR>Lfh@4?+hf*cGcx$OLM)4nzJwAWXXx)I(*%RPS@yH&p8!#+4dr)3>
zZuWT9=a7=4E<B_RLT{rhzI#Y1W9o?`*eHGeHTH+zI*J|nChGj7%1+D*=wET`GUc4J
znsN>s`@_yDjay}n9W!oFZnpo}+#%Vy{$q#w2T$;yl$(c#uKuX(DHH1ZkIfl9#eYKn
zxN&21^CtL@9Xv8SE3c7%&RF76pPo~ERFCsYZZI*+G%C%b*y!w>VR^%Kc~iz^>jn)O
zqSiVGdj_3T+|(uKkjszGD;wUbE5&+F7&I)q1*PA2?6|xUV{;~Cs@<<E4FdCqXZyp<
zF@ti3_>Ufu16w8R4+41`|I``R6%YGR;!xLISKRA`31C8Ywm(Ua9PdA5Y*zl5?3}zo
zq}hK^p1*qGy5irLgnLfNrc}ejhi8u-=Rb68uD=LO8j&}=GTrbu(`{r+6pa5@0=@;h
z38V9K$LVqhO$r~IpEoW)PbWN{l~)-ZG$Cumh{_1DjmROcocz(FZ9%d|7d)Ybf6tsz
zIb$c~*zymXr6B}`hrbr^&l;3N#WOhDKfho?_7H!Olko6Y%2C)55QaJFQ2NM!c5d$2
zTyj3CJfyo|-D!2gbEnlsXVTTwb<(xgc_U_KJFSOw&4B!FZLS>B-2>l4YaeB&^)5oU
zbvLX}tV?xIt<`l^!2SO<_Z{$2Rq5Mj?o2`w2&q8mL+@cEAqhndMX5??QY`6#KuCrZ
zn&=EgVOdKMmxHLwV2vm`h%{>iccoZH&|U1KtBBYJT@_K`d){;21Cz+Q``_>P|9;<{
z-@WHP&-<SD)O+q}GqYFh^+5GM`H<<(ViX?a>tS|`@=OMH!mR#`#{CZQ{n>kMJ8(Bz
zY!k0rKU+5YaqIkN8`!PZ>tN{aTl^WpHRO35Jaog^9P#|f)(b;_yX68NEWSS5S6n0p
z<9;Yk`lPAo(%lY0ABuc8YZTHw7<yZ+Qk4Tc&%OX#_|MCBm&J(QV!Ut&r<fqnofgre
zjc6;ziuT}oL6!i1BJN!{<3xASL-Z9i*ODswh>kdW;p3F6KCyN3q>F*b+f0!qmWvf)
zCA?fLqLA}8m>Ul7BblEFrYA6cY&e}bBb32j2tG!%hT&f7j1y~V+VpH|6{x<WYj4HU
z9bQ}N9*hT|CqQomOmR#V{ef;onb?#H1#*+P8TS;(dG2;4C63IUJ!?Y*&YmT0jkSb0
zedsXGBI|V+Bq7d2u_7`O0iX9Cu738cmbAiund)d5qvUoLT|`&WO=U7+W7yaw-^A;q
zvE4{{;4@n%2bq@6&uuMJjj2eKtMQbo?&2`gO2A{0B$7o7(GvT4*iQ@NhxBz0ojsc>
zFFkJSa^7$gR+2A&7EZ?*zdF1=^5ijF+w;Eur{dDj!hJUgvy;v~lco-+Do)W!gk_(K
zT9{fpmF(ZD*)N>1-$`$nQ40TGg?&EVzZY||aG{uc8YU3`B7*ogNFW}?-xeWhnd3q}
z&Ylgod;UHw<8&s@<VuLgJnV=?E+>d;)S9ulrXULK#0WgpmEtngrAtM&xI`=zi%_4&
z;R%XU4Z%<}0bRssak;os)S#W2AaDH~Q|s4>T#+a8MS&<3MWR@gz#x5c#9T2%%tPbj
z6cwU_aHI8JBmM|9U(7<sse>p-^RyTdu;I^vmxvqC&e+wnwjAvZJ=}xD9V*HZf`X<4
z<5L_R)m2|!$~k+UqK-uq@zU8SG(Bz61_-fAtQMt8lLEO#U>a8i(&`+yR^3s+`nW>Q
zIALq6{AhES$b`8$Fh`+>bNldKBD4Akmk8A;Sz_PWeTd$9<64tg)4F0M`h<;^92=S@
z1N00wJgCL)sao<r=UT;Z4HsS@14NoQ-*|`H7^74#XhVh1mVRr51jAT*eOR=HGj~Cg
zEF<T)7Q>@O8VLWtH8P6)^YP!>C<{;je`{ociUhr){^yDDWQAqxf0ml1|3S9?UPP9u
zV7O>J|Dwu}&Tap7(U9-k>4M|;a}{~^?<>i_GgABC+XyfJ|NDqgdVlXhBzeQccufC8
zi}bZCoQ6*`Wg;~m=0m+A(lQ6#??boo{PW)(3~8C;{C&7qT1uD~qpDo#J!^ByoUd&W
zZF^dl)w@skuFh_Kd*GIjUL87j>LQ1IZEI)mXQk3jdwc(mF8SiuHjljc8(W87?b^eV
zBLgc7h+ZGu+pUfcr?Ng!pof(v(4oY?Fx%EnY%w!}T2UO)X!|;4U4&l;7(y^zw25uj
zG%l${tJclicZg4jY1=L_xn&9(!TxwP(Q#>ZZ!}Vuh{36yfubngbo3fIq6wPJE~1D0
z?i*XLNW0x`v)N_)kge;wk0aZ9E*dZ(EiL_D9|JQoGBY!?vIY$r-1r!RV<;UvcU~!e
zjN19?zFm81{viA~d$uY531YBlt~zI4QH3`>z5C7K5srxHnASae_wCnzKwA31jKRGf
z=^2?0Te`!Rnr?IS9ynyEh-?xUpOBc8+@fWxl#b3$ox61H*1bnsdQ{(j>AiZ}nzm`%
zzE7XjRHv(#Exnh^dBL>wBy)Yz9qH+|A%h0@=`(1EBQ>={pJvIiS?xOZ>eaDVditP2
zgVNKRH|>y~CFh^ACCSTA+HRBCKiVA8HpG_BNcsLrTbGNQ<M!X3anQj60J<0g-3fti
zhBjf7!@jj$KZ8cuWU&oSnysL-EzWj0skRWN35||?PuR)#o#0Xi8h<ngMD?EDmEC3j
zx3*T%J#b4iBfWMF`_6XOCUZ{On#t_%ZEZZAVWuNKDez96<>YgpR(#h10iXXQBTDTM
z&GzsUCt}gLrj$2D+7gj~B&BJwz5|uE14_FclG0iwrxns4g||Q1i@^zDTl7yN(UE8?
z+G51k-Zoh-LuPxXh$&+7zx_-V;h)LkDtso3Y5&4sxURk@9~8=T_Hj<5FAPr;GuZr0
zK~oWpqXSAGa@$GlC%-1mijv-wwiG-~!$81E_z~46aMI?Wt;I<8|KOAteQ)cvE)<#U
z>4EMI_5S*z*}928^U=4Yrmq)T)jV-6qA5^zWAP-7M!)1T^fc+X2`$NR<zoo0!!Xn}
z{xNq9`EaxqBb4SaNQk=$9p3S<LkRm^@j=ZZBdW~-H5d)gP3Wr5Md!5!z2PNdskl)t
zJY~DuV?!;VXS*5d1@+(K)xeAT;WXlHrN+Fif!aW;4YWGplY$|5Z=ik%wI5<L31=IG
z+8<~l<~0VPvpoiB>W6ssLR^Q7Z1j5vV+@{wS6eq!^Dc;>6SZ-?2NlMArlQJCMbWm!
z*%IfpbD!xb>KXXV#OG>!TA&IyF4zAKw{7T+@~^qd2Mk5!ywm8>Ql(E)4WAiT5z`rG
z2PA{8U2!HMS;?wbOFdi49{Tj-j|&M;MNwv=;3<=OsdEsrq`%T5ZZggh$j}ksMkC|;
z<9@st<3X*MfPqSXP{UO@k4Nr~#k9`lDEUi}uR~GHSt#J)s9WYU5XC<b!=C{-`>J73
zHp+lLSKu=dpGo)-?t_4TFEhtB%%J}qQC89sdO^FGCw2W|t8>`we|p<$=Ru1)9RfQ2
zv+!QE>HA?X<A!;9@|qz}>r@*nBD1k?ArG8CQdl{d779cOM^3a5^__(yuZytNcLA3n
zEPs};#}5)V|6pMS1`Av55Mj?5Dy+~@++PaaY!Tsc4TII;A|hv`u)HJDZM#g^^DYy%
z5FRoAXknoO+p@<B%Qa5e0^@|;Js$j(!seYIB5HGlEoY*zhb9W)ouXr>BRfgp2ej3Z
z6E7U`39w18juyh^Y9So{mS{~dVyjOV9xIeCB7BH#PNs0UvJm?$;qVO-R{db%2<aG$
zyi0`5oh=;Mh-ltOc&5l*E+VqWA;J@dl|4y_>>3zf3gb5lD|Dl<)uIm=TrMI)E5NUY
z{C3#D_|vyuM7SjqxItL)oAJV~y${6w5Y!2~`w?LaJ|gV?E%5LtJU@zY<W><8{{&*Y
z4FNwXMBa8}>r+VmQ$hrG3!8I~u)Chd{XqnDNJRJ#346{f!t%X>9C-}|{||)mi4e74
zK=(@_oYA(3`e>UKA7it-do;B<LRb<C^|e{9el}YUenHQlW3#d++K{a_D`&Dz1h2K(
zWYDsDqSR%K-Ac7`gdA+QGNMx)ScAkdQciSOJ*3ZWMOm&$xdl4WzDO-AkssNu{?W&q
zXy}zMI;=jC*PwV@QF5%q%82P1qecB&%8k8Y-PK7x4L*89C(Tcj%c5c38DTkN>X@6C
zAjd{P*Ow-jL_l|Ry4GDT-*8%8n+YtQF%u=RnNu;Vndu@gA_g%y&*V2^V&vKmT4y%<
zijgleGn$!bd6Jo)%*4u09pTGDhmn~mIgy#;X*z~6a#@VkCAJJo`_EC^SgDQ~d=H12
z)#n)H?H72P%~Y%$MrlQjAAOFQ&rHvA%w}ey&M_*7;OqDR6C;&FVD>X}wY;bcEIWia
z#mo*lu_=me3MenKJQ`VU5*?$n91@f07`e@^y&va5cTf@biR~I8gqw5bN!h8F)g^KY
zC^1kji9umH2g)tvW)GC_#8CCh&=Gt|2i_HZd4Gl++Z3X#OfA|g^Ltx;sh1zfluwgn
zc9xd>S$lF&1C=FvH-l(Diz4M4DOLyhVN)wMvKn&VAi0s`rv_=Sb@Gj#)~M*|gEj0b
z6EMV(zW$ce${sA|#6op9%R0;XNhr;gNQ9x*$Zc(rRnLNoA0lI#L;LtpZRsI7KNdCF
z-Q03UkG@!Qm&%X&SUsYrGmODbdB7}&6XmjAczW^};z2_(#NsIyi<r7qe$*bpbwza!
zTr4-nA^+kpkq61myF{LjqjX=QgSuBo_DiT{U8<>}GNC#7MzzWwCO5`I`{*z&iqN_A
zLRYJK1jPQ~GA04ytPxs_?>%+Xb-j+6mD*N1Dw4QdZXxAGqqOn_Y6SX3J^)cI_IW3g
zXp9!AwxdsEGU`w5IJt&I`=@A8N9}7RME<GrG(^^-tK^boYe3{b!HH>dP7+m{X>wx{
zWUFV8&VblEQKfQbY7;J<VXuH1&D0KRfpnFbNyaj)=~t7X-mzt<MvJc29{0$E?i6EC
zB3HI)0kxw=a!m__os25uEv5Smt7o~~+rqjsdiDbCZLJ*E4c?}}S74zW+Y-@(yQC#j
zHF~jDd61rt9?|<5zO5TXDnIuU*`^hxe~H!%%4Nwgb|;Chmup&4kuH@_lgjiPw8|7+
zq<v99tC?z|bFBze-i>l*3bcEAwDxlSOuPw^*CP*-XunsB4#^i=p=!EXqY2MjE(f=U
zZ1hSkTdxCo45hc5sfXps9>_#6uAAjMP>xx>Mk}9)kO%u&y(6fp$d;W_ET=4OW5rp{
zwQ@-t>q;xMO&)9m;~Tb{IH||w7UWoHyBypWnYw$2Y|{<}`3t!EU0ThFui2vJrz0=w
z_GoG$y>(irP-DL$;x@<aRPWHs!on<+LeI!89q}3pJfoH4s737&?LP-~a|+E`rkc@X
z-X)f@(#_O*^(e<uRvu+)j2vdSTFW^OD>3#S@S*3m{aCrICGsz?z2%6d{N4Y8=7-9)
zEucTMt(6!_O?6<OTtjIaiTk>PT4%XRTjWwoz^iggThy_qa6kK1d74ze#C_fyT6Ld%
zu`@NK$lOy*Ez*&^hVuKc*3wkuouF19mhZHOkymgZU~!Lg4O+^2yA>V9G+sJriL4EW
z<(dwtYH*)s_XN9bkfT=JVL6su$d@R5MCG)#`iOjoa(u%P9f{8BMHl%CvUtN0IoJs=
zyN}2@<Q_jFH<CO0O?go9Z_3jOza@Kj0zdsNITLR5?6<V3P3mn-we9Fz@@djI{+2wU
zH2)^sbOzr2H#xR5YE|%W+Q;|$salFu@Bh1e8lo8YQI40cppjofHv4_qy9>NWeIRFc
zf%ohWv`&F~ImNC-v*BebS3d+#f$}r8O4^dBH3k*+q4xL~mk*i^FH_C+lU3UlPuBFH
z+}IW2xUiRojxE$=_E_HyqPkCHOgBo&CvtE%O39~MB}+%82#rpNsUjVfJ3+ay^N5Zr
z`C?N%k6;!ZlQG@lzxH!2`AS7Ha%dD<z!P!_iSkZp(G}YC0}y$cnxUyTLHU{Dggel~
z4>Gk-c4~o!X(*_kC*_hJu<89y+k8s3K208jDC+w&@{1nUz-Z?WTJ||Tuzi}e!$Qi@
zQ)lGWJt1?Q*0Nkxi<{g6+4R$A<e{F{753G*Y1_-{XFr9TadeaN^BH-4FL?9)tiAn7
zwP;P~g&6e<f`cr^c}B}-Cs7}<x9V%IPLMNuBbuQEm0kGC9a6xL@hhmIyHhmZ`+Q&1
z+K?jK^g(k}pCTubyLzBp(+4fsQFKrGprlR>lreqb_RN&{UwPy>{mvJT4^+D(-=QXg
zB9?`HZgfngtiii{sD{t!cA9#^$1j#``cdpI(W3rZL=iiFsayk*l`~B4CHMGM@-!w!
zty5RY-l_1CgI%F?;2U<-L3<BPPu&c;F%|Em-HWy8CjDHe;O)|%p3fzk#++&gdfb=D
zCHPy#81MC(UKyi$*3n0A(%4VkfFA2Ui)<&|zt|k@Ye!pZq_u%vAG>wrVh(DkXTMD;
z#IT#pZU=UIvO9p?q3mAHZVtOM*)3wXoZUt2E@$@^cGt7(@$t<TcAsMRd3N`+dzjt#
z*geK>h~3ldIu7UrHD@=4-OlXxWj8~+m?>alD!W&+Tf*)lc5h_&W_JI`ZY{fiV)t%#
zee6EW?&Iw4VD}m2V%+&66Mtp*5W4|(-(vS2c0XkIQ+7|V`whEi*ll)D=R{|AGuR!$
z?kI8*z8J^E1a>F0JB{6|+0A9Qklk7A&SkfP-70n$vU@$d9(Gr-y9#b8o*MB-CT?d}
zvg>2_5q7t-`xLv+vilcyUt{+OyGPmmkX+REF4nq$9Ghl!u<i=TIpp3OkZZ`jFCe#&
z`%pk0B=@m^JVEaEfQ(6pyC)!fllubvllv0<lY0RE$$bs};YPd_ppb?|B*|bpUK1a}
z42h4y%s{wb!3??ogc-P=2z*C|G63Uvfwn-MgcEVn(Xx@8`Wz&u8Fe~(usoanlZ;N9
z9;d^_a=JG%a$67~uw<Xk3SPWk!;h8>hKI>1g67aG==ko6kyFn*>`3AJYu}K)GmtOk
zq_=irQfzuqr#OdP5Z!!;7)8m+uJ5dls*~NEGr%ajw$aW}x-E-aJF%6=_k~tlfM%Dx
zn;Z*%qxq$c`1+4D|4^`@zV}1T`y270A2h$4d0Nk)!~2usJz^dQU<BEpX%BlFdGH<6
z{7sD_RLlG=jd(BfuQZB~oB4H0zwmsD^H^|qV?*!jfR8qc5dGX4<=BUfcqewq690+e
zx4+TE(`0?N<%k@WckM`TYZ;quwd*=;lKCWL=jM(qF3GPctDaO-UOc{{Fu$x=Oswo#
zD=*5nlI7@ZYw)#|d8C$`UsY9HS)E&1T`p=x<!r?jEGe$6Am~<5ZTus+NWppeRdXw0
zmKd*1QB`j2O06!*Eu1}<*wr@qMz+<;Q>&#5s>&P6HxOS~R*X%hm6hbdM?~?W(rN;A
z1WJl4N(lHhpsj}lcPlunxVnl^y+WnfK&oQ9UqKxdi9G>L)KnJ|JgN}3#TF3?GE&Jn
zuE4^|(rN`m1QCexc8Wl0Rep8#V)Ey;0O#eGl~pL|Y6Xku70z>$wAMg3ls%$y1LJuW
z3zTIa;qx)9QxNf+ov)JTCp^CjyJ*SSZbFE!39FuPRdpqYwVz>8jS4!z5V=8~k6H<y
z?A!$<=K@0ovT{XiRdqhB-)9reb4AtS#o}Sx9Pyg1!d+NVRGeE>Tvb?ET2L&`L>7sa
zO{zqFlLGN^lUc>(x#FIv((<b6+^XX0T$n)ah&|D6ac{GE`K9IJ>lRl|A67X_{If-I
z`GV5QigK~0Wr;`JgBjv^vr)3eg*Da1xwDb?#g*dEHe^A?tn&PM$di^xO>Tu-9BN6e
zm|b|g;Hqof3%0W2MdBr!+I}hy*z5vR;&u@jNNR(TocX!pZQBCzRji2AI)Ai~BA-Ru
zXHhFW;-Af`QOSz1AyyoSEiFg=dMmcPcu}?ZC>F+M+j7fF3o7#~7mK?sy9kz|^GhKf
zMn1i3A%(eOy`9o4ZgrGY78hf9>=w62R2GZ3B6OjAg|Srq99yn<HbOW`%4(`+=N8nI
zlpu|@_M&1>SuqmL#2+H6#HPqXwJY0j-$pt_pcapI6U3=9U%YHD6R+9}E6Qr-m5Xoe
z$k*@f*byv#wpUZ6S2>D`3u<PG0}h7>u7x)Tb~>Z#e{RPPYO&0*Aiqq!<)DiBBQ!#5
zu^8qMK5SA)DC!zi*O0n;*TF!f4tEy}iRT;?)IJX5bw`<a*TGS_74fWvKCG#$UtR0f
zHK49RT!oz?a8gC!SBjbkaa#wkA*JHQ{0q#et5041xC*Pn&DnvfjUDS^XT<qzWa=&o
z|4*ch3R+!Ru~@twp-S_+2qbMi33PdU7NM*6DR}U2Q0cGVKw?xu%HU;@ViiOIaIm;h
z<;>kGUH8z{yNPtM6}oVCZgqtzrKcmYSvptLlSdyZ6o}U&5e@9a7hhuSMi+Q6a&dKW
zl{iLG#nXinx?hDKc!)slBPx_FbPYU8Mru&)g=~^vosUG$73=Y&6rq(tYdo)@Y_WK{
zNrk((Qtd<+wNdnNiuF;5;bY`?@w|eHGCYL^WyQIwV!qd;I=^tPcpX#C{;klkBQAv%
z9z4-Xye0~jVs5VZB&w#gtQwDTZb4~zk@zeYv4lEG=yAGwx5F!`>R^vXl~>@w{2;1A
zybxVbfi3#pm_l(&OjS)m@gleQHYQ($nidt8prnh?I!g-tDP;{;5ji_wzI?eA=h+;s
z;_z^EzS~`lP`5_UsX%qx9<AbVDuy3caV7?_*+KsOJLy`#OWp5Q*FBVMWZ1#zO7X{L
zB7$3>uc8aZ3o%vV&6on6!Zl47<X7g3KvQ9r(bpfuX-~Ac8I}Y1Z55>R8D*`WtW}76
zVkin!j4Pp!s684}R)%jbh?|<BkSp`c3ulWxG2%;j_wH3*&;W|pVo=w_wx%f5mxwH#
z=f=zRSd1zZaS(jqFDk6R($(w1%OB2Rx(2^c_g}-Cy{5dNq6T3;*i^fZQdX9WUGVP>
zky`ypy4HS6SO1ST8{Pzk;w6avKM@tg6}5=1e8N^vK<@il$!WsKs;cso&MFsYn<AvO
zR6xIyEVR<X)w`Ci!HsmSe*mqom5(xhvKhU~b9D>+Zmh89y74@U1I^Hmi5FT{l`bh3
ze`$$C?jRp{;&Us-`^|F2Y2;Z&MYZ_4S+Tn;zpz+55Q~6zTUePBzCF;jSBcwV-NGMR
ziD$S1jp)8ue%8dFWApKP+yW2Y=P5S6m+4yj3Wb0g_*^W-;B|<7uPSkXuAw7J=_p<O
zZ__n+Qt|i!Ie6ZQ9y!|aQ=V8<n_bDGxoXdkHLtF$!RxJgiC7s|UL)>`E2yX_6I<i-
zcUHvSxWWp&y0^sh^Zi<Uer09;VzD7%E~-kddS!i{puchReL`tD(qCF6)+O>QDyayM
zwb-02EK(PznpYNkN(#%Xg+CrSwv0C82XUq5s;XG5i=&syHwlRCaw1W!9*&z=fLgmf
z4n+bEsZ>}03WqHhVIk`ONT6gLiW9FVib(WVP{rf;8#F&B6cy7eM;u7RTT9%PG_SaF
zmZw;3N}{**gGuCZMZDM_uUqO3@%TQDcs5?W5ckHTCKrhZ;t|A7M7H*33f-r!L3OQP
zO-$eqDpqUg>c53zoh$wxFZLygCOUq1B+Sl7X)R0SNO@Kz>IXkpyp>p3QI5t%e4a?v
zs7QR1STe6#>`Fp1+0^C)u_{U6Rk=Tb{ol&o#m|Y9ibs>!#<nD3FDpeodp`m6_le5j
zGMMt;s^WPYU2AW5sQPyY0pEHh@TvRzl=yzSdLPiqxF=DpgHfs{^QvZv=Ms?+b+<2(
zz8#}(Z$$t>=p)7t(zSl8x_^=^&;#<1L{uE{9JFe8k|eOxqtte(>u$Q%zCc&+i*yaB
zt8cGj_R%${uK~Iby+v35+e-SLVm?y$pVBpmtFWW7doL+hXXl@i#ofu&DL_Bx*Cgt=
zAW9ywB3YI2ACgr&d^=W%g2$AZ<LVlst52c>BkDJ(>qB%6JrrT1&L%aF+u$eg5vFGy
zMb#Dg;yq<a-QL*(D%BN5;-MBb)g@WE;;|M~BR)+Qx8VjwRqer>7mr~wmGnk%Dt4<|
zsJQrAAe@gWw7{=)^*s`aYfxQ7kJG&un<Io>#sB3N3yLdCOBRb)(Z^IT#3S$?43S#s
zB-AW?_f371?Bf>rpKMtBjzpe-a=br~Mxi*<Vu4tR=BsvXG=v+})u*m?>gvZ8jZWoU
z^;X{AvJ#zCb-Rb!Jf#v+*VT8Bfm(IF6IVXGU9z3tsDQ&~^V+>OzoR}f)o07|ca<++
zVQo#RclaFMh<F@6TOhL5s*kE|UK`=F$>mpCYp2vAdtj!>*n&$t^1^X<;1c}3O#R4}
zYIhadc#(=rJ+@`gJw~5`mcR@ylcf`^tOS<Qmn=ydOps4bu==N9vVlC^ZD_`i%Ad#+
zW(r7ph^4L+IXuVeZ|J`>9Y~RP%(GGxbFgWU)IVlEr;Xg3W2LqUF#omDXZ$_(KuokU
zCeg-1@)wT_#m!*4?TRy-Co~9OiAy-9lxL@F|E+OP{<G8N-m4K!rn@j5OqYizTHQSZ
zfxF|u2_4e24I>%5c#J-oaUJ6V!l?P#-)Q|gjOiVXTT#V0_=CnvjXqwqB>w~ByfX@4
zEzlQM2E|#eaF<bFOkGe4@Il6PjO!UwAC2Te#^}+A?pV9a8zv7=LIPg`4zDo*;0x85
z?14JpVo~K(zA<hEyb=*N2fV9taPd42VJe4kOy%GnrR+5o1KFT^6n=q^D#mCX(0Jx^
zM$5g#2bs@fJ_vpa3XW;|p;L-iXtW$Y1?tW*+RQTMonthg!~7k_{200XDwtt<6VrKP
z<lZoPE7R^V(xO0F`&p*FFh1=(eTeB=*bbxLW!eYZVf1mP{jfd#ypbQ6t_MBiJROOC
z3Z*lEAj9aEOb1~*EP~yb4#CJ&7#XWGh4u=N5iwQ{52Hsg9Y0ns52GhB?HnujhSAqD
z?HViZC_8VPejuN0*TP6KXzbOZkm%Pyh|U?Oi`g|^^LHC7<E2Fz&h#TpXOEY|!{{Bx
z%6PeaI!ZbI3T@>e^YK?`KEV9j%m=QJ)=cbc_fNH=VoosWyi${)t3dwDr29%)P=R<%
z(1!6|P|@~Ikb7YuAqUMUC8r<rIdU0FAu%3X;fTJB>G+AH-amoq=}ZR|ohn^35#k&s
z{gdQ<mC&86O)NH+C(FtOR{waWsl!A0=atJ~II$L69Voy}OxI4)Pl<D?=AUBTIaThx
z29G(q45}T=!*|Qc-y4h<F%A+&GvO6_YW6dO9U6bjI2(IX$p2}^B2r^J{F48A#?2Ue
zn<#lxk<3IeO0_$K+W{BBkU6>mU#Q&)aDoaTr}PJ=%EQ-M-P_RLQmS@rgpR;!#@@@d
z{Re=<?LPs0A^X^9s}e-3$z)$#B`dE(&GIvUhI#*0aydO%OedgwK<dG(DBt@hOw(4J
zOuMJa0l8LcYwrxryO=k4h+Ld&O&B~Aba*6-fGLtMHhNvVW@<B=*^FzZwDJ&1H}g+0
z?*>niWO@(N-kEYZo|dE_^M{xRmizu-rN(2UI3@ib#=Javoz*|7p6PFx29{MG1bdBE
z|JA5pBjk4Q3Cu@hIh^vwe~qr#*J|}POy^un9fQ=w5c8?bhrkzrcjamQEaqK#>d{NY
zcN0}CM=>w*<#Kw)3N$^9>G%TG1SAERFJ>NC9=QpzEY$k61C3(oE|kj)5v(ZD{EfzZ
ziQG#(ZO^65S;M@4mb8jUzf|*^jDD#c4nD~_NAr&|4=j(|jBv{|{|xi)GP#%R1Zy<^
z67#_tnMlp)LQNkr<`>H0#T4u!&3|P0MY_eSXZ}a#>ldlUEirzv)^Ccf1(e+Q#nLK4
zZ2Z@2K81O|9ER39(Z5vFeGI)+Rr`3Rhcg|N%b+bo#c0PSGUvNN?xi=<joLyn)7T7!
zruQ7Z&=|f^E}w<;xR-1770kPr%e};VS8KkOdGBgz%|^WQ@YPQ$jt$J`N!x71JNphz
zZ)Q6C4!L|b+C4uo_1^+-=yvY~#>W}I##ms&h0MOsIEV3<jNOcXW_*-!OtiM|Jfi)#
zX6(|~BYHC7W`#_~b&M}(?0r)kn96uR<08h>|EA?tjB6P$XMB_~jYm|6RpE=V%aVz@
zziR_e7zM`9Gj<)-@>dxzI%<<gCRyDEzXu|`kvax^p++jOQ5QiM>?NU^7T73<&!G~&
zNAs!7yYJCGF(306Gw-`cJ#eja{;c)KFmG_KjGk*{CW=j3d^3y1ChAc1Phk2^rh}Vw
z!|c=Ak2CG|aW8YT=AScxY}QY&`##MdGWz!kx#EwgclT@lZ_NAdS50c7ctG>VnHLY}
zM(IIK|H^dygZk->e@OGuP5EhjNWZpy%(r0P_mCbXIqS5(lX+*IJWQjf&?B1f&wS_+
znOF`!{xQwd?=z~W{V`d9zC{YtqnY+Io+$4sN0#P2u6-?Fao*$dW3m={QuE79C{N1H
z72t!rHGd29!QGVTR8MG+=I=84jOoGZinCoOTyPMkF@eGNL7(dEZmxpc7{|Y@t7JW6
zALG{<hZujLu}3)Z!%<}XD^{pw{0rlhceT7}GaX<K<2H;pFz&@Tz&ML>%6r=XD8`Ez
zU!|}I4;vH3tPuac_E60@oAC<9d5rI1e3bEKqmSSJp#=FEyBWU#>;!L)1B5YzJ$D>w
zr0_u_{F%XWbFS56@JYb%XZ&a23q9lU@9NUaiskzCuDowP)s*)%KZ^O#d%9kG-`D&E
z=DqLB&Xv$Ni}f=M{~^8m`zL&))eD)f|43EqNx^?;zJhs!DQl==c`coA!c?)sF%34&
z%K8%apLa};?v81*tC)5l)7>Yg*D~!rrbl;7-@|n6F+I9t`T?eW$K<4PypcZBwzo2k
zT?O(xkJT@+_JkJfFlJ83y_EDXH2tD6^M(Alik>yz262G-;5YI<;?1^(!_0?%P~Dg$
z-qs*KU>;bmqwdFPZT|%G&eO7UHSDNe8OXMi%;%g@y)Buy5U=)AM)|CooJllWI_T?@
z)V%mKpX5X(rM!<~9vDCDZ}m&^u^_>CfS|C(>NcYd2zunbLG7~_VN^Qb<+?kc!ML9B
zSi*>n;H@K58Jn#nMZivog{sek<^hJ+=StuU)#m`m?+M7&J4>Eih_VPW{VdZ#Ie!s~
zG~T8o`xmC;ZF2Z+;F*4%>1=#&XFH7{m_N$A8@xTw>W80dx1wS{V%ASuvSxzSCn>-l
zzGM-w+`bUm7>_Xl<?pX70G2DJqT|kdQk;&yQ=VLmj(Z-{?U)9ZBc{MkEerav09e{*
zQjC_Mw6mEF+U0$#kt~M}^eU#a9VpbvR=<P*3(8m!kn@)yRCk2d_c9GE_o1tq7^(R`
zG4G1h*^uOB!Gp$w5%^iKlLf%?erh(FXiI-(KBoy=s%637SpY0YQ2ld7X&;}m09d6V
zsh$OASO6?X(2PQ~_K=L-KvW@|(cp_<DLY0B+Oq&yu0U=iI-6=is`1fO4p@qDKn`Xo
zsm!vN2bTMg*GbL<Ef{M&Bp`@<Y8hBClLfVyc3p~cNYwgeOp8Pn)qY8NEVzLMz&ddu
z7OZ6fu&lZcLHm-lsRvmAELTvR{K;Cdg9X4cEf;aBZ>a?bSWw?mR^Euzxm#=gUFLyx
z-41$Cla3iPt>w4SPK<A>wSQthzO5X73sS~(9Oj!Tvvb<2oJci%C+6$HugFIm)=rxl
zz<hQ)`7Mn{YddN_oB7&~a)1|+^g1;^k$GTM-ID?=$Y%kt7C1X;A9Gm%Ox2=al9vTu
zV~PcdK^EM?f?y|ExeQ_F_0*Q=FH|XQz;Z<)ax~Oi3m#)ZsJHx<Jox)+{u$<hr5!ad
zktXb^A{}6XNR^e#k?N33^Y0i#F8L(*B<}#tf6hFxN<(6h1!q|h93Tg*z!)h8Q?=9<
zZ}>=iY|VH-<DQJ2A8R@K;JWQ*e7W(@cq-!%<08i5AKHHv<DMFO#BwIwtgx1G9b+Hk
z<BXqRobrh__&j4T<5!J;#_ur>G5&&a)TiVh-L}(AxD<h(t-!WS%8_iwDU7Ex?!kC9
z;|#|2j4xvxVmyVh>zIykA>&%Y2wzk(QO63)81H6W%UFD-4Qyf@&-ii1qZvQPcsk=(
z7|&+>E@8}U<;37;52$i|!h{<H;jbCj#;EDEAwL3#zfi5@3%^kF(sTqbg}f_O`!rNO
zOrs>EYkmUrB3(X7uT-WBn9fPZQ$o*MJQiLk9`q}rWCvIl(kp=ZO6L9GS6~_?AxrBo
zGxoD&;wn50zHypg%RI20jIm9^c+F$&UD?Mx^BvGn%$}_IZHAvL53jPik9!7~YD7I}
z;6cXO$F=_3jPWaPD&EH#ixV3EXyjk;s5-Jm!wgLTrXI@PMpJ)oj?k5mQ%1Na%K<l_
zi^B9YrUR4Z$Ey+lfLn)GY<Rcq{0FOh+Ztes|0!%Kp?qD*c>0$*K10@l2ruA!fiD=J
z`P#rckgNF2$4duukqOM7WWIjBYWkC$Ra*ZC=7HsiIrL_!)`By}L$zGK1}X3@)V#f=
z4#2lizeB`g%||mY7VCDieu?Jem<QIKCb3itQjCYCDEcylaD(PMGw-^AV-&bi3wpC4
zfSIdXC`NZ`KAm~ro$_0Bvl5ve&UElj-NGlirPj}30kHfI{lSC{nxDnI*dVQ2t?q-X
zfYsc4Q~m7Sz}Uxl1>?MCT7HX>H`C81_JTDiy8D4IRCM@*4OR9*$knsC+w>P$@C^$>
z5a|BG9_@p^wNE~LdyrM=NG1kYkivq%9=ZHBt9$QW!0J`<rS_Ob80}1uqdwl?SQT~8
zb->}Zt{C`2Q5Vl>d-p+35iz(9cqO1YNYoW)E#_V5AWQ?oa7+Wj+P^4!&BSwT5QN-U
zXm#`a6-0M*3RA}D%nmSiGJcbBPsS8N5ncFrAM)nFLA+#%{>orfbHcwecJXp~G+fdT
zXzUTmOqd07Cu3eP6`2NKsSQqK?4P7@9%JuhjjIgi$^V;-{wyuu$XL%?<7Kpk33r)R
z*v{C@!yRB8+@$6IF#0}?zcu=sHKt7oltMGLMnBF=*i4-{8OPI{8NCeqGGV5rG8voc
zsNn|lq{CRoX0l<5!5``fT*tWnBaP=UHnRvdjA@p@LlIlfgxRTo3uCjRUotj3|2HxA
z@l-$^WAjY{ztQKR|FcG)$NVob##o<z7!}_}Wx@>d-)3wE_n$I0JN>_8YzFh+8TnbA
z;-49t@w>f^E&?Y)qwtzB_EGwYXu*UTk#=Wn29QG-2l2)t{fUgtcxw)0GtBZbHlwJu
zjLm>#Gh@FeSsUD82p(tbXN(Sl3h*_?rk`-s=yU(zGsXdaPkzt1o?la^8JpLW)mG<-
z$Gn!BFkxOtv5d`YD2cIo{j@W3e(Q8+jJJ!5a4KVNc|;~*$N7yVmuu`1W@pJ%RxmqD
ziWr*}+$zRq1$Q}Pv(mAav03TxF*Yk5PcSws9nUL_=g%y4yvhn@spCDyW~t)~#=O)a
zPBS(u9ntM{3e8GK3S+a<(SxyB>Bu0A?Qg;?bzH^@W~pNeW3$vz$T-AHAC-*FO2;xI
z=ar6H#%85s6JxA&s3LkC*h6Jv=AoZs1v3x*3S%=5{VroO4}F5MnTGy}v6+UBYOiy|
zOhdO~Y^I^Rx5x8O5is-616je$Lyt5Dc$#@KV>1t3z}QSf&u46=p}maFH1zF^%{26%
z=@(2X0%jh1tMS0|&d)M7^U#MFn`yjv7@MKw=Zwuz@)Tn;lx%`uQ={;_JXCCn-<#4o
zz(hC3W-OV`*o-AdFy^tOn8er&CG#1Zp`@F!8A_V)%uv#E8!MQx<h{ngC%Te6#@LJ{
zpJA-Wl0qD0Y=)9=Gd4rX<BZKv@<+xzl=O(mjyea-Sh59UGnVYi*o-C97^|@)n&RP%
z%}{b8V>6V@V{C?!6^!*z(j&x;Oqj9ct&GiB@*c)!Ecqy7Gc<adu^Ad2U~Gm)M;V);
z(Pu_ZLlX~D@B<TOtP<hWIfAi@dQOuWZ(!VoFglrL&s`tJX3t$ZW3%V(Vx#}7wl|hB
z?YUF$|0ztEJ$EyW!ddMhkFnWvSIXGzxvOSu_S`LHY&O@dFqk*j+{PH2YxMhnJribk
z%_hcXcTJr!pm)~@KjUDO?zHY^Ov8J6J-^7<jP4IHu4Va~jJ-`g+QSD-m?6j~jLi__
zD<kKA{f~@IKfh@wT_izl7o-TZCyb?Yk*#r8!kF&Q8>VqTgFU>RXE+mHp8vm&u~{FO
z%h;?BcnF8B53FHq)(7q)9M-MBpRwuIKg`%;`t^PgahPs5-@D(<*nI!Kp0WD=Jrec`
z<76HeyajBxVZIZG4d>@1$Bo%k^CM%kjl|wr$vwjC2T9a~a9ynpbYN^Y@njhJHCjHL
zv00*<X!Nhr@;t&wke`1zU=GX8mZTbm>G@+1t60H3O&gGG!2I%nk8ywvZebi^yo3Fl
z9UIRx#xJ$09689?>;rm}uzLO$YK4zk!E6!v#$evT^Alr{ul1w5=qxsSK~fl--BaBe
zn_W{b#%AlxNMH|@k=YwFjTOwMm~zHu56())W{=HUg9~(oHZe9^ksfCpT&m^IF?Qu?
z{7M(R|0x1F*J>ij3VEDm-!k^ypyiQWb&AbqndXemUZysT{ai=-Fg9B+GL8H(Z7;hk
z%AX=&R`SQNg4s1anQ<^(dnjgX_9Ij>Hro?dF?NmB`u8w4n|%F@&Hl-K9wvelwTHKi
z2OiBHH#kSj@w<~M!r9|BZpPTj0k$%DjF$IgT+cX*vDsbh8O?;*Cp?w0n>`dU4vp3Z
zYZ&7<DOIgr$vDXR>lo)T-pts`*w2{vS9`?MOyrEy247)pwz|G+<ecIV<64eDlkQw6
zCTRa18Ji8a{TQ2_qC*(#Ewd>9@rK|SUc<PSaT#MD<Hd}fJRz}$aXd%pF2*6&uVd_I
zypyq7l%e*go(Z$8^9EzH5c07x&{w~XLq^WaUbY@wC)#Ow9AmFj<Bp8YGGl+nZX3V<
zvzT!5=ysS<;KAfr#%8j0rqOSz11Mq~4}*A^M7fdk;^IQ%A5xO9WQ=uM{r+Fagjsdk
zWE41s+ZmgMzLyzexk?#)kFi-7J;4|&(@OpwV?X0FjB}cx{iPVi_0(BtmigK+Hp_v1
z8JoqdA&gy-+W$DlW~n%ru~{RoW^5L)*D%iZIJ5yD6J{0lNycVbZ69N^{C3zF;39g@
z;PKktmyFGNz%Pu=dPTEdI>8>1r9HG`Lhyt`f5v7JZ7^fAw3)-$tiF{n#+s(e(M62S
zs@*EaW;Ix9>=9-a_z_mX;-@n3G-Ees@gc@RNU6x)WNc=!KQQ_{8~we(JOk3Kw@xvp
zt(E^a3gh`R)7?E;L2S?p>5R?X?`4cJDXa`!%h*gamodg{vXbAx*v#FoU~G1H-$|I>
z|7IiMCL+*diQ+C*9piY$PqG2C9qk3iW;5ME#%5F8-x!-sb)OpfL%O9r39R1#W{V;I
zwn)8PeD`aGggzRZ9gR-LX0Lb}WAkmQp^VLUnno}--&q>Zm==|(2q*Q?^M7=&juI#U
zoWs?P@C}Xd&5iIKjqv71czYxK*FGr!@BrUvr0{Mde5?`vu@ScQZD_AaBOKcZw~%`t
zvf>ijHKM!XpV6(3p7ciakVbe|BRr-Np3n$SYlL$f;aLr_M^rQ<#G*#n+X(-m5w2~7
z?`niMH^PrJz$lw-4G1iQG{Uz;2yrXU+i>2Fvli!Coa=GoE1Lpe*c5l++=%mTocG|o
z7w4aGZo=uqxf$nuIPb?v-=cUB=R-Ij_TW;7lm1?I3(iMzK8ABE&c|`mS1kUB^A4Qr
zaNddYPdNQJab*ABM(*O@jU58{-N?z<Ix9tH)LEC|YtR|hW#w{N9e!SRTb*^Ov^`>t
zmDfCC4eof6z;E1?)RY(I=BB2l4{(LS^Z{9E@{5<PYh~gV>+;B=64&B!SIO(PSk7Iy
zZ?PV*5(Z?2X%EauA1Fs|wU$I)F?&$Wf-&-?t=7uOw1TlknG@udk6Xp^rN^zYQFC*u
zE6T4-t&j%~T5Wc@p0MneCnL-Z;xI4_rn?4(2a=YRo*pJm%gAcrHzPBxfplPI1K7xK
z8Y_Er;<E;YCq8XZTDa%*i_!;#*-FQMZ-l|L%*;Uz;GhQa$a007O3O@dsO(H@Xv@_g
zO_>Am+p<qumqt#XHEl-KG`apsYm)rwN$Xqr%XVv=r-7+~nGL*VWi&9H(J+CTu7;7!
zYM`9uY6u&}*(mo=d6$0CMGZ<RGb216>8^_g$a}Y0ZTk<(2v<vYHB?J$P?+hif%5Bp
zRy+Ge1JmSHJFNMUBPU-mZ{Rrj>JI$=X^Wj!vPb>jW-k5OPi~3%!%X^X&ysV0@_CLn
zB)R;5pe4EL?>6~6+{TO>KT<<V^GeJ04XSI6`pp55)fN1OZ`|h>$xC)x8TPEqOu2BU
zHMD6inV?_lnX^E4+G1r!j!LgAnN+pw+nv^$h^T4PX3ScYhI;>az-lLb&stwZj+}DY
zqUy`!+UKmBBZp5dsG2qY;r7p4wy4oF%IC}|glgPjtFs*Sg0*49gvkZ2d81P+1b$fw
zzYWsArmC`kX?bB;O;K_GLi%IS)Y*c5GpLaM<MjNG2jvzN3dBhL5vY8&&g!%)rQVup
z`~N2Q`tCaZqSe~wIT!P=rpWbgTBfk)ZD7W4TB0y%8tPdC_?rgC6E6PWXkq?M1LL8_
z_kXj6`8N%Wr$NJ)anb+lHYG#nPo`;9{@2@-M6@Xl$~-f3*Mz67Beq>NFI%T<O~W6X
xxd*I{k^0Hrwd#Q7jZXN@FULv85vyyI`Pnzw^@#OTg!+*(+4fEAVh8mF{twMGY32X`

delta 55354
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

diff --git a/docs/site.yml b/docs/site.yml
index b34a9faa..92a690d1 100644
--- a/docs/site.yml
+++ b/docs/site.yml
@@ -1,14 +1,14 @@
 # The key value pairs found below are available within the templates.
 
 
-jq_version: 1.0
+jq_version: 1.1
 # Next line is needed for publishing to github pages
-# root: '/jq'
-root: ''
+root: '/jq'
+# root: ''
 footer: |
   
   This website is made with [Bonsai](http://www.tinytree.info) and
-  [Twitter Boostrap](http://twitter.github.com/bootstrap/), themed
+  [Twitter Bootstrap](http://twitter.github.com/bootstrap/), themed
   with [Bootswatch](http://bootswatch.com).
 
   jq is licensed under the MIT license (code) and the

From 976e4ff7114bd0f876a95edcf88d933c804be746 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 21 Oct 2012 22:16:23 +0100
Subject: [PATCH 117/284] Fix a mistake in the docs. Fixes #10

---
 docs/content/3.manual/manual.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 50c63eca..d3d4c423 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -166,7 +166,7 @@ sections:
             input: '{"foo": 42, "bar": "something else", "baz": true}'
             output: ['42', '"something else"']
 
-          - program: "[.user, .projects[]]"
+          - program: ".user, .projects[]"
             input: '{"user":"stedolan", "projects": ["jq", "wikiflow"]}'
             output: ['"stedolan"', '"jq"', '"wikiflow"']            
             

From c53e001973b5d6d749cae20f739eaa3b674a1d92 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 21 Oct 2012 23:26:31 +0100
Subject: [PATCH 118/284] Version number tracking.

---
 Makefile                         | 10 ++++++++--
 VERSION                          |  1 +
 docs/content/3.manual/manual.yml |  2 +-
 main.c                           |  6 +++++-
 4 files changed, 15 insertions(+), 4 deletions(-)
 create mode 100644 VERSION

diff --git a/Makefile b/Makefile
index ac55fd4a..a9a53e02 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,7 @@
 CC=gcc -Wextra -Wall -Wno-missing-field-initializers -Wno-unused-parameter -std=gnu99 -ggdb -Wno-unused-function
 prefix=/usr/local
 
-.PHONY: all clean releasedep tarball
+.PHONY: all clean releasedep tarball install uninstall test releasetag
 all: jq
 
 clean:
@@ -22,6 +22,10 @@ jv_utf8_tables.gen.h: gen_utf8_tables.py
 	python $^ > $@
 jv_unicode.c: jv_utf8_tables.gen.h
 
+version.gen.h: VERSION
+	sed 's/.*/#define JQ_VERSION "&"/' $^ > $@
+main.c: version.gen.h
+
 JQ_SRC=parser.gen.c lexer.gen.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c
 
 
@@ -31,13 +35,15 @@ jq_test: $(JQ_SRC) jq_test.c
 jq: $(JQ_SRC) main.c
 	$(CC) -O -DJQ_DEBUG=0 -o $@ $^
 
-
 test: jq_test
 	valgrind --error-exitcode=1 -q --leak-check=full ./jq_test >/dev/null
 
 
 releasedep: lexer.gen.c parser.gen.c jv_utf8_tables.gen.h
 
+releasetag:
+	git tag -s "jq-$$(cat VERSION)" -m "jq release $$(cat VERSION)"
+
 docs/content/2.download/source/jq.tgz: jq
 	mkdir -p `dirname $@`
 	tar -czvf $@ `git ls-files; ls *.gen.*`
diff --git a/VERSION b/VERSION
new file mode 100644
index 00000000..9459d4ba
--- /dev/null
+++ b/VERSION
@@ -0,0 +1 @@
+1.1
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index d3d4c423..4ec88c28 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -555,7 +555,7 @@ sections:
           results as `a`, if `a` produces results other than `false`
           and `null`. Otherwise, `a // b` produces the same results as `b`.
 
-          This is useful for providing defaults: `.foo or 1` will
+          This is useful for providing defaults: `.foo // 1` will
           evaluate to `1` if there's no `.foo` element in the
           input. It's similar to how `or` is sometimes used in Python
           (jq's `or` operator is reserved for strictly Boolean
diff --git a/main.c b/main.c
index 48934cc4..30876a37 100644
--- a/main.c
+++ b/main.c
@@ -8,11 +8,12 @@
 #include "locfile.h"
 #include "parser.h"
 #include "execute.h"
+#include "version.gen.h"
 
 static const char* progname;
 
 static void usage() {
-  fprintf(stderr, "\njq - commandline JSON processor\n");
+  fprintf(stderr, "\njq - commandline JSON processor [version %s]\n", JQ_VERSION);
   fprintf(stderr, "Usage: %s [options] <jq filter>\n\n", progname);
   fprintf(stderr, "For a description of the command line options and\n");
   fprintf(stderr, "how to write jq filters (and why you might want to)\n");
@@ -92,6 +93,9 @@ int main(int argc, char* argv[]) {
       options |= PROVIDE_NULL;
     } else if (isoption(argv[i], 'h', "help")) {
       usage();
+    } else if (isoption(argv[i], 'V', "version")) {
+      fprintf(stderr, "jq version %s\n", JQ_VERSION);
+      return 0;
     } else {
       fprintf(stderr, "%s: Unknown option %s\n", progname, argv[i]);
       die();

From ce3328f11e927dd6172f9d5c9d4b3691c3d56238 Mon Sep 17 00:00:00 2001
From: Charles Merriam <charles.merriam@gmail.com>
Date: Mon, 22 Oct 2012 02:43:53 -0700
Subject: [PATCH 119/284] Update docs/content/1.tutorial/default.yml

---
 docs/content/1.tutorial/default.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/content/1.tutorial/default.yml b/docs/content/1.tutorial/default.yml
index 57902d9b..dbae38e9 100644
--- a/docs/content/1.tutorial/default.yml
+++ b/docs/content/1.tutorial/default.yml
@@ -2,7 +2,7 @@ headline: Tutorial
 body:
   - text: |
 
-      Twitter have a JSON API, so let's play with that. This URL gets
+      Twitter has a JSON API, so let's play with that. This URL gets
       us the last 5 tweets about JSON:
       
   - command: "curl 'http://search.twitter.com/search.json?q=json&rpp=5&include_entities=true'"

From 2620e21dcc03efc14f9f570195ee6d1d55cb90a6 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 22 Oct 2012 18:47:52 +0100
Subject: [PATCH 120/284] Make the gen_utf8_tables script Python3 compatible
 (#20)

---
 gen_utf8_tables.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/gen_utf8_tables.py b/gen_utf8_tables.py
index 2179222d..98df9144 100644
--- a/gen_utf8_tables.py
+++ b/gen_utf8_tables.py
@@ -5,12 +5,12 @@ mask = lambda n: (1 << n) - 1
 
 def print_table(type, name, t):
     assert len(t) == 256
-    print "static const",type, name+"[]", "="
+    print("static const %s %s[] =" % (type, name))
     first = True
     for i in range(0,len(t),16):
-        print (" {" if i == 0 else "  ") +\
-            ", ".join("0x%02x"%n for n in t[i:i+16]) + \
-            ("," if i + 16 < 256 else "};")
+        print ((" {" if i == 0 else "  ") +
+               ", ".join("0x%02x"%n for n in t[i:i+16]) + 
+               ("," if i + 16 < 256 else "};"))
 
 
 def utf8info(c):
@@ -24,7 +24,7 @@ def utf8info(c):
         
 table = lambda i: [utf8info(c)[i] for c in range(256)]
 
-print "#define UTF8_CONTINUATION_BYTE ((unsigned char)255)"
+print("#define UTF8_CONTINUATION_BYTE ((unsigned char)255)")
 
 print_table("unsigned char", "utf8_coding_length", table(0))
 print_table("unsigned char", "utf8_coding_bits", table(1))

From f2601ab4f07e8237ab56b00fdf0def899def46c2 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 22 Oct 2012 18:55:56 +0100
Subject: [PATCH 121/284] Fix logic for "slurp" option. Fixes #18

---
 main.c | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/main.c b/main.c
index 30876a37..47cec818 100644
--- a/main.c
+++ b/main.c
@@ -120,8 +120,13 @@ int main(int argc, char* argv[]) {
     process(jv_null());
   } else {
     jv slurped;
-    if (options & SLURP) slurped = jv_invalid();
-    int first = 1;
+    if (options & SLURP) {
+      if (options & RAW_INPUT) {
+        slurped = jv_string("");
+      } else {
+        slurped = jv_array();
+      }
+    }
     struct jv_parser parser;
     jv_parser_init(&parser);
     while (!feof(stdin)) {
@@ -131,8 +136,7 @@ int main(int argc, char* argv[]) {
         int len = strlen(buf);
         if (len > 0) {
           if (options & SLURP) {
-            if (first) slurped = jv_string(buf);
-            else slurped = jv_string_concat(slurped, jv_string(buf));
+            slurped = jv_string_concat(slurped, jv_string(buf));
           } else {
             if (buf[len-1] == '\n') buf[len-1] = 0;
             process(jv_string(buf));
@@ -143,7 +147,6 @@ int main(int argc, char* argv[]) {
         jv value;
         while (jv_is_valid((value = jv_parser_next(&parser)))) {
           if (options & SLURP) {
-            if (first) slurped = jv_array();
             slurped = jv_array_append(slurped, value);
           } else {
             process(value);
@@ -158,15 +161,10 @@ int main(int argc, char* argv[]) {
           jv_free(value);
         }
       }
-      first = 0;
     }
     jv_parser_free(&parser);
     if (options & SLURP) {
-      if (jv_is_valid(slurped)) {
-        process(slurped);
-      } else {
-        jv_free(slurped);
-      }
+      process(slurped);
     }
   }
 

From 48fb7c61b319ed451280c9c307009dd7195092d8 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 22 Oct 2012 19:16:27 +0100
Subject: [PATCH 122/284] Support a -f option to load from a file, and #
 comments

This means '#!/usr/local/bin/jq -f' is now a sensible way
to start a file.

Closes #13
---
 lexer.l |  2 ++
 main.c  | 46 +++++++++++++++++++++++++++++++++++++++++++---
 2 files changed, 45 insertions(+), 3 deletions(-)

diff --git a/lexer.l b/lexer.l
index 1921f380..cac08ec7 100644
--- a/lexer.l
+++ b/lexer.l
@@ -31,6 +31,8 @@
 
 %%
 
+"#"[^\r\n]* { /* comments */ }
+
 "==" { return EQ; }
 "as" { return AS; }
 "def" { return DEF; }
diff --git a/main.c b/main.c
index 47cec818..74ca0e6e 100644
--- a/main.c
+++ b/main.c
@@ -1,4 +1,5 @@
 #include <stdio.h>
+#include <errno.h>
 #include <string.h>
 #include <ctype.h>
 #include "compile.h"
@@ -49,6 +50,8 @@ enum {
   RAW_OUTPUT = 8,
   COMPACT_OUTPUT = 16,
   ASCII_OUTPUT = 32,
+
+  FROM_FILE = 64,
 };
 static int options = 0;
 static struct bytecode* bc;
@@ -71,6 +74,29 @@ static void process(jv value) {
   jq_teardown();
 }
 
+static jv slurp_file(const char* filename) {
+  FILE* file = fopen(filename, "r");
+  if (!file) {
+    return jv_invalid_with_msg(jv_string_fmt("Could not open %s: %s",
+                                             filename,
+                                             strerror(errno)));
+  }
+  jv data = jv_string("");
+  while (!feof(file) && !ferror(file)) {
+    char buf[4096];
+    size_t n = fread(buf, 1, sizeof(buf), file);
+    data = jv_string_concat(data, jv_string_sized(buf, (int)n));
+  }
+  int badread = ferror(file);
+  fclose(file);
+  if (badread) {
+    jv_free(data);
+    return jv_invalid_with_msg(jv_string_fmt("Error reading from %s",
+                                             filename));
+  }
+  return data;
+}
+
 int main(int argc, char* argv[]) {
   if (argc) progname = argv[0];
 
@@ -91,6 +117,8 @@ int main(int argc, char* argv[]) {
       options |= RAW_INPUT;
     } else if (isoption(argv[i], 'n', "null-input")) {
       options |= PROVIDE_NULL;
+    } else if (isoption(argv[i], 'f', "from-file")) {
+      options |= FROM_FILE;
     } else if (isoption(argv[i], 'h', "help")) {
       usage();
     } else if (isoption(argv[i], 'V', "version")) {
@@ -104,11 +132,23 @@ int main(int argc, char* argv[]) {
   if (!program) usage();
 
   if ((options & PROVIDE_NULL) && (options & (RAW_INPUT | SLURP))) {
-    fprintf(stderr, "%s: --null-input cannot be used with --raw-input or --slurp\n", program);
+    fprintf(stderr, "%s: --null-input cannot be used with --raw-input or --slurp\n", progname);
     die();
   }
-
-  bc = jq_compile(program);
+  
+  if (options & FROM_FILE) {
+    jv data = slurp_file(program);
+    if (!jv_is_valid(data)) {
+      data = jv_invalid_get_msg(data);
+      fprintf(stderr, "%s: %s\n", progname, jv_string_value(data));
+      jv_free(data);
+      return 1;
+    }
+    bc = jq_compile(jv_string_value(data));
+    jv_free(data);
+  } else {
+    bc = jq_compile(program);
+  }
   if (!bc) return 1;
 
 #if JQ_DEBUG

From a737a67eda15ef6b0f7d818967b94a778ad9e179 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 22 Oct 2012 19:18:35 +0100
Subject: [PATCH 123/284] updated autogenerated files

---
 lexer.gen.c | 321 +++++++++++++++++++++++++++-------------------------
 lexer.gen.h |   2 +-
 2 files changed, 165 insertions(+), 158 deletions(-)

diff --git a/lexer.gen.c b/lexer.gen.c
index a2f55400..2fb747e6 100644
--- a/lexer.gen.c
+++ b/lexer.gen.c
@@ -358,8 +358,8 @@ static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
 	*yy_cp = '\0'; \
 	yyg->yy_c_buf_p = yy_cp;
 
-#define YY_NUM_RULES 33
-#define YY_END_OF_BUFFER 34
+#define YY_NUM_RULES 34
+#define YY_END_OF_BUFFER 35
 /* This struct is not used in this scanner,
    but its presence is necessary. */
 struct yy_trans_info
@@ -367,35 +367,35 @@ struct yy_trans_info
 	flex_int32_t yy_verify;
 	flex_int32_t yy_nxt;
 	};
-static yyconst flex_int16_t yy_accept[84] =
+static yyconst flex_int16_t yy_accept[86] =
     {   0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,   34,   32,   31,   31,   24,   20,   21,   22,
-       20,   20,   20,   20,   20,   23,   20,   20,   20,   30,
-       30,   30,   30,   30,   30,   30,   20,   28,   28,   26,
-       29,   31,   15,   13,   23,   14,    0,   11,   16,   18,
-        1,   19,   30,   30,    2,   30,   30,   30,    4,    9,
-       30,   12,   28,   27,   25,   27,    0,   23,   17,    8,
-        3,   30,   30,   10,   30,    0,   27,    7,    6,    5,
-       27,   27,    0
+        0,    0,   35,   33,   32,   32,   25,    1,   21,   22,
+       23,   21,   21,   21,   21,   21,   24,   21,   21,   21,
+       31,   31,   31,   31,   31,   31,   31,   21,   29,   29,
+       27,   30,   32,    1,   16,   14,   24,   15,    0,   12,
+       17,   19,    2,   20,   31,   31,    3,   31,   31,   31,
+        5,   10,   31,   13,   29,   28,   26,   28,    0,   24,
+       18,    9,    4,   31,   31,   11,   31,    0,   28,    8,
+        7,    6,   28,   28,    0
     } ;
 
 static yyconst flex_int32_t yy_ec[256] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
+        1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    2,    1,    4,    1,    5,    1,    1,    1,    6,
-        7,    8,    9,   10,   11,   12,   13,   14,   14,   14,
-       14,   14,   14,   14,   14,   14,   14,   15,   16,   17,
-       18,   19,    1,    1,   20,   20,   20,   20,   21,   20,
-       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
-       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
-       22,   23,   24,    1,   25,    1,   26,   20,   20,   27,
+        1,    2,    1,    5,    6,    7,    1,    1,    1,    8,
+        9,   10,   11,   12,   13,   14,   15,   16,   16,   16,
+       16,   16,   16,   16,   16,   16,   16,   17,   18,   19,
+       20,   21,    1,    1,   22,   22,   22,   22,   23,   22,
+       22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
+       22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
+       24,   25,   26,    1,   27,    1,   28,   22,   22,   29,
 
-       28,   29,   20,   30,   31,   20,   20,   32,   20,   33,
-       34,   20,   20,   35,   36,   37,   38,   20,   20,   20,
-       20,   20,   39,   40,   41,    1,    1,    1,    1,    1,
+       30,   31,   22,   32,   33,   22,   22,   34,   22,   35,
+       36,   22,   22,   37,   38,   39,   40,   22,   22,   22,
+       22,   22,   41,   42,   43,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -412,89 +412,91 @@ static yyconst flex_int32_t yy_ec[256] =
         1,    1,    1,    1,    1
     } ;
 
-static yyconst flex_int32_t yy_meta[42] =
+static yyconst flex_int32_t yy_meta[44] =
     {   0,
-        1,    1,    1,    2,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    3,    1,    1,    1,    1,    1,    3,
-        3,    1,    4,    1,    5,    3,    3,    3,    3,    3,
-        3,    3,    3,    3,    3,    3,    3,    3,    1,    1,
-        1
+        1,    1,    2,    2,    3,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    4,    1,    1,    1,    1,
+        1,    4,    4,    1,    5,    1,    6,    4,    4,    4,
+        4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
+        1,    1,    1
     } ;
 
-static yyconst flex_int16_t yy_base[92] =
+static yyconst flex_int16_t yy_base[95] =
     {   0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-       39,   41,  132,  133,   44,   46,  133,  133,  133,  133,
-      113,   98,   38,   39,   41,   49,   96,   93,   85,    0,
-       22,   74,   33,   72,   65,   69,   80,    0,    0,  133,
-       51,   66,  133,  133,   59,  133,   65,   79,  133,  133,
-      133,  133,    0,   69,    0,   66,   47,   67,    0,    0,
-       65,  133,    0,   69,  133,   68,   76,   74,  133,    0,
-        0,   57,   57,    0,   51,   66,   59,    0,    0,    0,
-       58,   52,  133,  104,  107,  112,  117,  120,  122,  124,
-      126
+       41,   42,  142,  143,   46,   48,  143,    0,  143,  143,
+      143,  121,  120,   38,   39,   41,   49,  119,  118,  117,
+        0,   22,  106,   36,  104,   97,  101,  112,    0,    0,
+      143,   51,   71,    0,  143,  143,   62,  143,   64,   96,
+      143,  143,  143,  143,    0,   85,    0,   79,   48,   75,
+        0,    0,   65,  143,    0,   69,  143,   68,   74,   73,
+      143,    0,    0,   57,   57,    0,   49,   56,   58,    0,
+        0,    0,   57,   43,  143,   96,  102,  105,  111,  117,
+      120,  122,  124,  126
 
     } ;
 
-static yyconst flex_int16_t yy_def[92] =
+static yyconst flex_int16_t yy_def[95] =
     {   0,
-       83,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-       84,   84,   83,   83,   83,   83,   83,   83,   83,   83,
-       83,   83,   83,   83,   83,   83,   83,   83,   83,   85,
-       85,   85,   85,   85,   85,   85,   83,   86,   86,   83,
-       87,   83,   83,   83,   83,   83,   83,   83,   83,   83,
-       83,   83,   85,   85,   85,   85,   85,   85,   85,   85,
-       85,   83,   86,   83,   83,   88,   83,   83,   83,   85,
-       85,   85,   85,   85,   85,   87,   89,   85,   85,   85,
-       90,   91,    0,   83,   83,   83,   83,   83,   83,   83,
-       83
+       85,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+       86,   86,   85,   85,   85,   85,   85,   87,   85,   85,
+       85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
+       88,   88,   88,   88,   88,   88,   88,   85,   89,   89,
+       85,   90,   85,   87,   85,   85,   85,   85,   85,   85,
+       85,   85,   85,   85,   88,   88,   88,   88,   88,   88,
+       88,   88,   88,   85,   89,   85,   85,   91,   85,   85,
+       85,   88,   88,   88,   88,   88,   88,   90,   92,   88,
+       88,   88,   93,   94,    0,   85,   85,   85,   85,   85,
+       85,   85,   85,   85
 
     } ;
 
-static yyconst flex_int16_t yy_nxt[175] =
+static yyconst flex_int16_t yy_nxt[187] =
     {   0,
-       14,   15,   16,   17,   18,   19,   20,   21,   22,   18,
-       23,   24,   25,   26,   18,   18,   27,   28,   29,   30,
-       30,   19,   14,   20,   30,   31,   32,   33,   30,   30,
-       34,   30,   30,   35,   30,   30,   36,   30,   19,   37,
-       20,   39,   40,   39,   40,   42,   42,   42,   42,   45,
-       45,   45,   45,   48,   54,   46,   65,   55,   49,   47,
-       45,   41,   45,   41,   57,   58,   47,   42,   42,   47,
-       45,   83,   45,   67,   76,   67,   47,   72,   68,   47,
-       76,   76,   73,   80,   79,   78,   47,   68,   66,   68,
-       76,   76,   75,   74,   71,   70,   69,   62,   61,   60,
+       14,   15,   16,   14,   17,   18,   19,   20,   21,   22,
+       23,   19,   24,   25,   26,   27,   19,   19,   28,   29,
+       30,   31,   31,   20,   14,   21,   31,   32,   33,   34,
+       31,   31,   35,   31,   31,   36,   31,   31,   37,   31,
+       20,   38,   21,   40,   40,   41,   41,   43,   43,   43,
+       43,   47,   47,   47,   47,   50,   56,   48,   67,   57,
+       51,   49,   47,   85,   47,   42,   42,   78,   49,   59,
+       60,   49,   43,   43,   69,   47,   69,   47,   49,   70,
+       74,   78,   78,   82,   49,   75,   81,   80,   70,   70,
+       68,   49,   78,   78,   77,   68,   39,   39,   39,   39,
 
-       59,   56,   52,   66,   38,   38,   38,   38,   38,   53,
-       51,   53,   63,   50,   63,   44,   63,   64,   64,   64,
-       64,   64,   77,   77,   81,   81,   82,   82,   64,   64,
-       43,   83,   13,   83,   83,   83,   83,   83,   83,   83,
-       83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
-       83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
-       83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
-       83,   83,   83,   83
+       39,   39,   44,   76,   44,   44,   44,   44,   55,   73,
+       55,   65,   65,   72,   65,   71,   65,   66,   66,   66,
+       66,   66,   66,   79,   79,   83,   83,   84,   84,   66,
+       66,   64,   63,   62,   61,   58,   54,   53,   52,   46,
+       45,   85,   13,   85,   85,   85,   85,   85,   85,   85,
+       85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
+       85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
+       85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
+       85,   85,   85,   85,   85,   85
     } ;
 
-static yyconst flex_int16_t yy_chk[175] =
+static yyconst flex_int16_t yy_chk[187] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,   11,   11,   12,   12,   15,   15,   16,   16,   23,
-       24,   23,   24,   25,   31,   23,   41,   31,   25,   24,
-       26,   11,   26,   12,   33,   33,   24,   42,   42,   26,
-       45,   76,   45,   47,   82,   47,   26,   57,   47,   45,
-       81,   77,   57,   75,   73,   72,   45,   68,   41,   67,
-       66,   64,   61,   58,   56,   54,   48,   37,   36,   35,
+        1,    1,    1,   11,   12,   11,   12,   15,   15,   16,
+       16,   24,   25,   24,   25,   26,   32,   24,   42,   32,
+       26,   25,   27,   78,   27,   11,   12,   84,   25,   34,
+       34,   27,   43,   43,   49,   47,   49,   47,   27,   49,
+       59,   83,   79,   77,   47,   59,   75,   74,   70,   69,
+       42,   47,   68,   66,   63,   78,   86,   86,   86,   86,
 
-       34,   32,   29,   76,   84,   84,   84,   84,   84,   85,
-       28,   85,   86,   27,   86,   22,   86,   87,   87,   87,
-       87,   87,   88,   88,   89,   89,   90,   90,   91,   91,
-       21,   13,   83,   83,   83,   83,   83,   83,   83,   83,
-       83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
-       83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
-       83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
-       83,   83,   83,   83
+       86,   86,   87,   60,   87,   87,   87,   87,   88,   58,
+       88,   89,   89,   56,   89,   50,   89,   90,   90,   90,
+       90,   90,   90,   91,   91,   92,   92,   93,   93,   94,
+       94,   38,   37,   36,   35,   33,   30,   29,   28,   23,
+       22,   13,   85,   85,   85,   85,   85,   85,   85,   85,
+       85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
+       85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
+       85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
+       85,   85,   85,   85,   85,   85
     } ;
 
 /* The intent behind this definition is that it'll catch
@@ -525,7 +527,7 @@ static yyconst flex_int16_t yy_chk[175] =
   static int enter(int opening, int state, yyscan_t yyscanner);
   static int try_exit(int closing, int state, yyscan_t yyscanner);
 #define YY_NO_INPUT 1
-#line 529 "lexer.gen.c"
+#line 531 "lexer.gen.c"
 
 #define INITIAL 0
 #define IN_PAREN 1
@@ -781,7 +783,7 @@ YY_DECL
 #line 32 "lexer.l"
 
 
-#line 785 "lexer.gen.c"
+#line 787 "lexer.gen.c"
 
     yylval = yylval_param;
 
@@ -838,13 +840,13 @@ yy_match:
 			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 				{
 				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 84 )
+				if ( yy_current_state >= 86 )
 					yy_c = yy_meta[(unsigned int) yy_c];
 				}
 			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 			++yy_cp;
 			}
-		while ( yy_base[yy_current_state] != 133 );
+		while ( yy_base[yy_current_state] != 143 );
 
 yy_find_action:
 		yy_act = yy_accept[yy_current_state];
@@ -871,152 +873,157 @@ do_action:	/* This label is used only to access EOF actions. */
 case 1:
 YY_RULE_SETUP
 #line 34 "lexer.l"
-{ return EQ; }
+{ /* comments */ }
 	YY_BREAK
 case 2:
 YY_RULE_SETUP
-#line 35 "lexer.l"
-{ return AS; }
+#line 36 "lexer.l"
+{ return EQ; }
 	YY_BREAK
 case 3:
 YY_RULE_SETUP
-#line 36 "lexer.l"
-{ return DEF; }
+#line 37 "lexer.l"
+{ return AS; }
 	YY_BREAK
 case 4:
 YY_RULE_SETUP
-#line 37 "lexer.l"
-{ return IF; }
+#line 38 "lexer.l"
+{ return DEF; }
 	YY_BREAK
 case 5:
 YY_RULE_SETUP
-#line 38 "lexer.l"
-{ return THEN; }
+#line 39 "lexer.l"
+{ return IF; }
 	YY_BREAK
 case 6:
 YY_RULE_SETUP
-#line 39 "lexer.l"
-{ return ELSE; }
+#line 40 "lexer.l"
+{ return THEN; }
 	YY_BREAK
 case 7:
 YY_RULE_SETUP
-#line 40 "lexer.l"
-{ return ELSE_IF; }
+#line 41 "lexer.l"
+{ return ELSE; }
 	YY_BREAK
 case 8:
 YY_RULE_SETUP
-#line 41 "lexer.l"
-{ return AND; }
+#line 42 "lexer.l"
+{ return ELSE_IF; }
 	YY_BREAK
 case 9:
 YY_RULE_SETUP
-#line 42 "lexer.l"
-{ return OR; }
+#line 43 "lexer.l"
+{ return AND; }
 	YY_BREAK
 case 10:
 YY_RULE_SETUP
-#line 43 "lexer.l"
-{ return END; }
+#line 44 "lexer.l"
+{ return OR; }
 	YY_BREAK
 case 11:
 YY_RULE_SETUP
-#line 44 "lexer.l"
-{ return DEFINEDOR; }
+#line 45 "lexer.l"
+{ return END; }
 	YY_BREAK
 case 12:
 YY_RULE_SETUP
-#line 45 "lexer.l"
-{ return SETPIPE; }
+#line 46 "lexer.l"
+{ return DEFINEDOR; }
 	YY_BREAK
 case 13:
 YY_RULE_SETUP
-#line 46 "lexer.l"
-{ return SETPLUS; }
+#line 47 "lexer.l"
+{ return SETPIPE; }
 	YY_BREAK
 case 14:
 YY_RULE_SETUP
-#line 47 "lexer.l"
-{ return SETMINUS; }
+#line 48 "lexer.l"
+{ return SETPLUS; }
 	YY_BREAK
 case 15:
 YY_RULE_SETUP
-#line 48 "lexer.l"
-{ return SETMULT; }
+#line 49 "lexer.l"
+{ return SETMINUS; }
 	YY_BREAK
 case 16:
 YY_RULE_SETUP
-#line 49 "lexer.l"
-{ return SETDIV; }
+#line 50 "lexer.l"
+{ return SETMULT; }
 	YY_BREAK
 case 17:
 YY_RULE_SETUP
-#line 50 "lexer.l"
-{ return SETDEFINEDOR; }
+#line 51 "lexer.l"
+{ return SETDIV; }
 	YY_BREAK
 case 18:
 YY_RULE_SETUP
-#line 51 "lexer.l"
-{ return LESSEQ; }
+#line 52 "lexer.l"
+{ return SETDEFINEDOR; }
 	YY_BREAK
 case 19:
 YY_RULE_SETUP
-#line 52 "lexer.l"
-{ return GREATEREQ; }
+#line 53 "lexer.l"
+{ return LESSEQ; }
 	YY_BREAK
 case 20:
 YY_RULE_SETUP
-#line 53 "lexer.l"
-{ return yytext[0];}
+#line 54 "lexer.l"
+{ return GREATEREQ; }
 	YY_BREAK
 case 21:
 YY_RULE_SETUP
 #line 55 "lexer.l"
+{ return yytext[0];}
+	YY_BREAK
+case 22:
+YY_RULE_SETUP
+#line 57 "lexer.l"
 {
   return enter(yytext[0], YY_START, yyscanner);
 }
 	YY_BREAK
-case 22:
+case 23:
 YY_RULE_SETUP
-#line 59 "lexer.l"
+#line 61 "lexer.l"
 {
   return try_exit(yytext[0], YY_START, yyscanner);
 }
 	YY_BREAK
-case 23:
+case 24:
 YY_RULE_SETUP
-#line 64 "lexer.l"
+#line 66 "lexer.l"
 { 
    yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; 
 }
 	YY_BREAK
-case 24:
+case 25:
 YY_RULE_SETUP
-#line 68 "lexer.l"
+#line 70 "lexer.l"
 {
   yy_push_state(IN_QQSTRING, yyscanner);
   return QQSTRING_START;
 }
 	YY_BREAK
 
-case 25:
+case 26:
 YY_RULE_SETUP
-#line 74 "lexer.l"
+#line 76 "lexer.l"
 {
     return enter(QQSTRING_INTERP_START, YY_START, yyscanner);
   }
 	YY_BREAK
-case 26:
+case 27:
 YY_RULE_SETUP
-#line 77 "lexer.l"
+#line 79 "lexer.l"
 {
     yy_pop_state(yyscanner);
     return QQSTRING_END;
   }
 	YY_BREAK
-case 27:
-/* rule 27 can match eol */
+case 28:
+/* rule 28 can match eol */
 YY_RULE_SETUP
-#line 81 "lexer.l"
+#line 83 "lexer.l"
 {
     /* pass escapes to the json parser */
     jv escapes = jv_string_fmt("\"%.*s\"", yyleng, yytext);
@@ -1025,45 +1032,45 @@ YY_RULE_SETUP
     return QQSTRING_TEXT;
   }
 	YY_BREAK
-case 28:
-/* rule 28 can match eol */
+case 29:
+/* rule 29 can match eol */
 YY_RULE_SETUP
-#line 88 "lexer.l"
+#line 90 "lexer.l"
 {
     yylval->literal = jv_string_sized(yytext, yyleng);
     return QQSTRING_TEXT;
   }
 	YY_BREAK
-case 29:
+case 30:
 YY_RULE_SETUP
-#line 92 "lexer.l"
+#line 94 "lexer.l"
 {
     return INVALID_CHARACTER;
   }
 	YY_BREAK
 
-case 30:
-YY_RULE_SETUP
-#line 98 "lexer.l"
-{ yylval->literal = jv_string(yytext); return IDENT;}
-	YY_BREAK
 case 31:
-/* rule 31 can match eol */
 YY_RULE_SETUP
 #line 100 "lexer.l"
-{}
+{ yylval->literal = jv_string(yytext); return IDENT;}
 	YY_BREAK
 case 32:
+/* rule 32 can match eol */
 YY_RULE_SETUP
 #line 102 "lexer.l"
-{ return INVALID_CHARACTER; }
+{}
 	YY_BREAK
 case 33:
 YY_RULE_SETUP
 #line 104 "lexer.l"
+{ return INVALID_CHARACTER; }
+	YY_BREAK
+case 34:
+YY_RULE_SETUP
+#line 106 "lexer.l"
 YY_FATAL_ERROR( "flex scanner jammed" );
 	YY_BREAK
-#line 1067 "lexer.gen.c"
+#line 1074 "lexer.gen.c"
 case YY_STATE_EOF(INITIAL):
 case YY_STATE_EOF(IN_PAREN):
 case YY_STATE_EOF(IN_BRACKET):
@@ -1362,7 +1369,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 			{
 			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 84 )
+			if ( yy_current_state >= 86 )
 				yy_c = yy_meta[(unsigned int) yy_c];
 			}
 		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
@@ -1391,11 +1398,11 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 		{
 		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 84 )
+		if ( yy_current_state >= 86 )
 			yy_c = yy_meta[(unsigned int) yy_c];
 		}
 	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-	yy_is_jam = (yy_current_state == 83);
+	yy_is_jam = (yy_current_state == 85);
 
 	return yy_is_jam ? 0 : yy_current_state;
 }
@@ -2249,7 +2256,7 @@ void jq_yyfree (void * ptr , yyscan_t yyscanner)
 
 #define YYTABLES_NAME "yytables"
 
-#line 104 "lexer.l"
+#line 106 "lexer.l"
 
 
 /* perhaps these should be calls... */
diff --git a/lexer.gen.h b/lexer.gen.h
index 5804e150..bbc095b8 100644
--- a/lexer.gen.h
+++ b/lexer.gen.h
@@ -354,7 +354,7 @@ extern int jq_yylex \
 #undef YY_DECL
 #endif
 
-#line 104 "lexer.l"
+#line 106 "lexer.l"
 
 
 #line 361 "lexer.gen.h"

From c0f1c7dc1a216f7c43b75c39cc5d6f28664d6691 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 22 Oct 2012 19:23:57 +0100
Subject: [PATCH 124/284] Delete a badly-thought-out bit of a Makefile.

---
 Makefile | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/Makefile b/Makefile
index a9a53e02..9c5e1635 100644
--- a/Makefile
+++ b/Makefile
@@ -4,11 +4,6 @@ prefix=/usr/local
 .PHONY: all clean releasedep tarball install uninstall test releasetag
 all: jq
 
-clean:
-	make -Bnd | grep 'Must remake target' | \
-	sed 's/.*`\(.*\)'\''.*/\1/' | grep -v '^all$$' | \
-	xargs rm
-
 
 lexer.gen.c: lexer.l
 	flex -o lexer.gen.c --header-file=lexer.gen.h lexer.l

From 794d29a4309c421f8d6169328d082c8950e5b9b6 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 22 Oct 2012 22:56:56 +0100
Subject: [PATCH 125/284] Docs fixes.

 - Mention homebrew on download page (#25)
 - Document 'keys' and string interpolation
---
 docs/content/2.download/default.yml |  1 +
 docs/content/3.manual/manual.yml    | 36 ++++++++++++++++++-----------
 2 files changed, 23 insertions(+), 14 deletions(-)

diff --git a/docs/content/2.download/default.yml b/docs/content/2.download/default.yml
index 54f4d78b..d1deb300 100644
--- a/docs/content/2.download/default.yml
+++ b/docs/content/2.download/default.yml
@@ -9,6 +9,7 @@ body:
     
        * [Download binary for 64-bit Linux](linux_x86_64/jq)
        * [Download binary for OS X](osx_64/jq)
+         (or use [homebrew](http://mxcl.github.com/homebrew/): `brew install jq`) 
        * [Download source](source/jq.tgz)
 
       The binaries should just run, but you may need to make them
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 4ec88c28..9039caf5 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -373,6 +373,23 @@ sections:
             input: '[[1,2], "string", {"a":2}, null]'
             output: [2, 6, 1, 0]
 
+      - title: `keys`
+        body: |
+          
+          The builtin function `keys`, when given an object, returns
+          its keys in an array.
+
+          The keys are sorted "alphabetically", by unicode codepoint
+          order. This is not an order that makes particular sense in
+          any particular language, but you can count on it being the
+          same for any two objects with the same set of keys,
+          regardless of locale settings.
+
+        examples:
+          - program: 'keys'
+            input: '{"abc": 1, "abcd": 2, "Foo": 3}'
+            output: ['["Foo", "abc", "abcd"]']
+
       - title: `map(x)`
         body: |
 
@@ -434,24 +451,15 @@ sections:
             input: '[1, "1", [1]]'
             output: ['"1"', '"1"', '"[1]"']
 
-      - title: "String interpolation - `@(text)`"
+      - title: "String interpolation - `\(foo)`"
         body: |
 
-          jq supports an alternative syntax for strings. Instead of
-          "foo", you can write `@(foo)`. When using this syntax,
-          `%(expression)` may be used to insert the value of
-          `expression` into the string (converted with `tostring`).
-
-          String interpolation does not occur for normal double-quoted
-          strings (like `"foo"`) in order to be fully compatible with
-          JSON.
-
-          All of the usual JSON escapes (`\n`, `\r` and the like) work
-          inside `@()`-quoted strings, as well as `\%` and `\)` if
-          those characters are needed literally.
+          Inside a string, you can put an expression inside parens
+          after a backslash. Whatever the expression returns will be
+          interpolated into the string.
 
         examples:
-          - program: '@(The input was %(.), which is one less than %(.+1))'
+          - program: '"The input was \(.), which is one less than \(.+1)"'
             input: '42'
             output: ['"The input was 42, which is one less than 43"']
           

From 93f80b27260743dc0ea092dfdbaf81666b853508 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 22 Oct 2012 23:14:34 +0100
Subject: [PATCH 126/284] I should probably document select and empty :) (#29,
 #5)

---
 docs/content/3.manual/manual.yml | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 9039caf5..5981ce42 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -390,6 +390,36 @@ sections:
             input: '{"abc": 1, "abcd": 2, "Foo": 3}'
             output: ['["Foo", "abc", "abcd"]']
 
+      - title: `select`
+        body: |
+          
+          The function `select(foo)` produces its input unchanged if
+          `foo` returns true for that input, and produces no output
+          otherwise.
+
+          It's useful for filtering lists: `[1,2,3] | select(. >= 2)`
+          will give you `[3]`.
+
+        examples:
+          - program: 'select(. >= 2)'
+            input: '[1,5,3,0,7]'
+            output: ['[5,3,7]']
+
+      - title: `empty`
+        body: |
+          
+          `empty` returns no results. None at all. Not even `null`.
+
+          It's useful on occasion. You'll know if you need it :)
+
+        examples:
+          - program: '1, empty, 2'
+            input: 'null'
+            output: [1,2]
+          - program: '[1,2,empty,3]'
+            input: 'null'
+            output: ['[1,2,3]']
+
       - title: `map(x)`
         body: |
 

From 2a610da2d14583a08f016d0f985db65203d1f76f Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 22 Oct 2012 23:31:07 +0100
Subject: [PATCH 127/284] Allow the 'keys' function to take arrays.

---
 builtin.c                        | 6 ++++++
 docs/content/3.manual/manual.yml | 6 ++++++
 2 files changed, 12 insertions(+)

diff --git a/builtin.c b/builtin.c
index c3d6af19..f184ff7f 100644
--- a/builtin.c
+++ b/builtin.c
@@ -228,6 +228,12 @@ static void f_keys(jv input[], jv output[]) {
     }
     free(keys);
     jv_free(input[0]);
+  } else if (jv_get_kind(input[0]) == JV_KIND_ARRAY) {
+    int n = jv_array_length(input[0]);
+    output[0] = jv_array();
+    for (int i=0; i<n; i++){
+      output[0] = jv_array_set(output[0], i, jv_number(i));
+    }
   } else {
     output[0] = jv_invalid_with_msg(jv_string_fmt("'keys' only supports object, not %s",
                                                   jv_kind_name(jv_get_kind(input[0]))));
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 5981ce42..6c107700 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -385,10 +385,16 @@ sections:
           same for any two objects with the same set of keys,
           regardless of locale settings.
 
+          When `keys` is given an array, it returns the valid indices
+          for that array: the integers from 0 to length-1.
+
         examples:
           - program: 'keys'
             input: '{"abc": 1, "abcd": 2, "Foo": 3}'
             output: ['["Foo", "abc", "abcd"]']
+          - program: 'keys'
+            input: '[42,3,35]'
+            output: ['[0,1,2]']
 
       - title: `select`
         body: |

From 56aa4cf1dfcd7f563e40b1ffbb09f2c75d91bb41 Mon Sep 17 00:00:00 2001
From: Alex Chamberlain <alex@alexchamberlain.co.uk>
Date: Tue, 23 Oct 2012 14:46:44 +0100
Subject: [PATCH 128/284] Add docs for installing on Arch Linux.

---
 docs/content/2.download/default.yml | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/docs/content/2.download/default.yml b/docs/content/2.download/default.yml
index d1deb300..7834ce72 100644
--- a/docs/content/2.download/default.yml
+++ b/docs/content/2.download/default.yml
@@ -20,6 +20,18 @@ body:
       jq is licensed under the MIT license. For all of the gory
       details, read the file `COPYING` in the source distribution.
 
+      Arch Linux
+      ----------
+
+      A PKGBUILD for jq-1.1 is in the
+      [AUR](https://aur.archlinux.org/packages.php?ID=63849), as well as a
+      PKGBUILD for the HEAD of master
+      ([jq-git](https://aur.archlinux.org/packages.php?ID=63850)).
+
+      You can install jq using [Yaourt](https://wiki.archlinux.org/index.php/Yaourt)
+      or manually by following instructions on
+      [Arch Linux's Wiki](https://wiki.archlinux.org/index.php/Arch_User_Repository).
+
       Hacking on jq
       =============
 
@@ -55,4 +67,4 @@ body:
 
       jq's documentation is compiled into static HTML using
       [Bonsai](http://www.tinytree.info). To view the documentation
-      locally, run `rake serve` from the docs/ subdirectory.
\ No newline at end of file
+      locally, run `rake serve` from the docs/ subdirectory.

From b193bca563f377f97b9a6efcf5b054bd70fb1f46 Mon Sep 17 00:00:00 2001
From: Damian Gryski <damian@gryski.com>
Date: Tue, 23 Oct 2012 17:00:42 +0200
Subject: [PATCH 129/284] yyscan_t isn't exposed by some versions of flex.

---
 parser.y | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/parser.y b/parser.y
index 0effe07c..38e72ee3 100644
--- a/parser.y
+++ b/parser.y
@@ -2,6 +2,9 @@
 #include <stdio.h>
 #include <string.h>
 #include "compile.h"
+
+typedef void* yyscan_t;
+
 %}
 %code requires {
 #include "locfile.h"

From 553de39b2a9c45110ed25a714fb249bd6037f874 Mon Sep 17 00:00:00 2001
From: Damian Gryski <damian@gryski.com>
Date: Tue, 23 Oct 2012 17:01:39 +0200
Subject: [PATCH 130/284] Implement 'not equal' (!=) as a binop

---
 builtin.c | 6 ++++++
 lexer.l   | 1 +
 parser.y  | 8 +++++++-
 3 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/builtin.c b/builtin.c
index f184ff7f..3d726854 100644
--- a/builtin.c
+++ b/builtin.c
@@ -120,6 +120,11 @@ static void f_equal(jv input[], jv output[]) {
   output[0] = jv_bool(jv_equal(input[2], input[1]));
 }
 
+static void f_notequal(jv input[], jv output[]) {
+  jv_free(input[0]);
+  output[0] = jv_bool(jv_equal(input[2], input[1]) == 0);
+}
+
 static void order_cmp(jv input[], jv output[], int op) {
   jv_free(input[0]);
   jv a = input[2];
@@ -284,6 +289,7 @@ static struct cfunction function_list[] = {
   {f_tostring, "tostring", CALL_BUILTIN_1_1},
   {f_keys, "keys", CALL_BUILTIN_1_1},
   {f_equal, "_equal", CALL_BUILTIN_3_1},
+  {f_notequal, "_notequal", CALL_BUILTIN_3_1},
   {f_less, "_less", CALL_BUILTIN_3_1},
   {f_greater, "_greater", CALL_BUILTIN_3_1},
   {f_lesseq, "_lesseq", CALL_BUILTIN_3_1},
diff --git a/lexer.l b/lexer.l
index cac08ec7..5c6b62f4 100644
--- a/lexer.l
+++ b/lexer.l
@@ -33,6 +33,7 @@
 
 "#"[^\r\n]* { /* comments */ }
 
+"!=" { return NEQ; }
 "==" { return EQ; }
 "as" { return AS; }
 "def" { return DEF; }
diff --git a/parser.y b/parser.y
index 38e72ee3..b0e4e521 100644
--- a/parser.y
+++ b/parser.y
@@ -46,6 +46,7 @@ typedef void* yyscan_t;
 %token <literal> IDENT
 %token <literal> LITERAL
 %token EQ "=="
+%token NEQ "!="
 %token DEFINEDOR "//"
 %token AS "as"
 %token DEF "def"
@@ -79,7 +80,7 @@ typedef void* yyscan_t;
 %nonassoc '=' SETPIPE SETPLUS SETMINUS SETMULT SETDIV SETDEFINEDOR
 %left OR
 %left AND
-%nonassoc EQ '<' '>' LESSEQ GREATEREQ
+%nonassoc NEQ EQ '<' '>' LESSEQ GREATEREQ
 %left '+' '-'
 %left '*' '/'
 
@@ -142,6 +143,7 @@ static block gen_binop(block a, block b, int op) {
   case '*': funcname = "_multiply"; break;
   case '/': funcname = "_divide"; break;
   case EQ: funcname = "_equal"; break;
+  case NEQ: funcname = "_notequal"; break;
   case '<': funcname = "_less"; break;
   case '>': funcname = "_greater"; break;
   case LESSEQ: funcname = "_lesseq"; break;
@@ -282,6 +284,10 @@ Exp "==" Exp {
   $$ = gen_binop($1, $3, EQ);
 } |
 
+Exp "!=" Exp {
+  $$ = gen_binop($1, $3, NEQ);
+} |
+
 Exp '<' Exp {
   $$ = gen_binop($1, $3, '<');
 } |

From 409456f581f192253b4f07effdd6acb304b790fd Mon Sep 17 00:00:00 2001
From: Damian Gryski <damian@gryski.com>
Date: Tue, 23 Oct 2012 17:02:19 +0200
Subject: [PATCH 131/284] Regenerate lex/yacc files

---
 lexer.gen.c     |  353 +++--
 lexer.gen.h     |   31 +-
 parser.gen.c    | 1430 +++++++++---------
 parser.gen.h    |   97 +-
 parser.gen.info | 3844 ++++++++++++++++++++++++-----------------------
 5 files changed, 2909 insertions(+), 2846 deletions(-)

diff --git a/lexer.gen.c b/lexer.gen.c
index 2fb747e6..7d8b953c 100644
--- a/lexer.gen.c
+++ b/lexer.gen.c
@@ -9,7 +9,7 @@
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 5
-#define YY_FLEX_SUBMINOR_VERSION 35
+#define YY_FLEX_SUBMINOR_VERSION 37
 #if YY_FLEX_SUBMINOR_VERSION > 0
 #define FLEX_BETA
 #endif
@@ -159,15 +159,7 @@ typedef void* yyscan_t;
 
 /* Size of default input buffer. */
 #ifndef YY_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k.
- * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
- * Ditto for the __ia64__ case accordingly.
- */
-#define YY_BUF_SIZE 32768
-#else
 #define YY_BUF_SIZE 16384
-#endif /* __ia64__ */
 #endif
 
 /* The state buf must be large enough to hold one state per character in the main buffer.
@@ -179,6 +171,11 @@ typedef void* yyscan_t;
 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 #endif
 
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
 #define EOB_ACT_CONTINUE_SCAN 0
 #define EOB_ACT_END_OF_FILE 1
 #define EOB_ACT_LAST_MATCH 2
@@ -201,11 +198,6 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE;
 
 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
 
-#ifndef YY_TYPEDEF_YY_SIZE_T
-#define YY_TYPEDEF_YY_SIZE_T
-typedef size_t yy_size_t;
-#endif
-
 #ifndef YY_STRUCT_YY_BUFFER_STATE
 #define YY_STRUCT_YY_BUFFER_STATE
 struct yy_buffer_state
@@ -223,7 +215,7 @@ struct yy_buffer_state
 	/* Number of characters read into yy_ch_buf, not including EOB
 	 * characters.
 	 */
-	int yy_n_chars;
+	yy_size_t yy_n_chars;
 
 	/* Whether we "own" the buffer - i.e., we know we created it,
 	 * and can realloc() it to grow it, and should free() it to
@@ -302,7 +294,7 @@ static void jq_yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner
 
 YY_BUFFER_STATE jq_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
 YY_BUFFER_STATE jq_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
-YY_BUFFER_STATE jq_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
+YY_BUFFER_STATE jq_yy_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner );
 
 void *jq_yyalloc (yy_size_t ,yyscan_t yyscanner );
 void *jq_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
@@ -334,7 +326,7 @@ void jq_yyfree (void * ,yyscan_t yyscanner );
 
 /* Begin user sect3 */
 
-#define jq_yywrap(n) 1
+#define jq_yywrap(yyscanner) 1
 #define YY_SKIP_YYWRAP
 
 typedef unsigned char YY_CHAR;
@@ -358,8 +350,8 @@ static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
 	*yy_cp = '\0'; \
 	yyg->yy_c_buf_p = yy_cp;
 
-#define YY_NUM_RULES 34
-#define YY_END_OF_BUFFER 35
+#define YY_NUM_RULES 35
+#define YY_END_OF_BUFFER 36
 /* This struct is not used in this scanner,
    but its presence is necessary. */
 struct yy_trans_info
@@ -367,17 +359,17 @@ struct yy_trans_info
 	flex_int32_t yy_verify;
 	flex_int32_t yy_nxt;
 	};
-static yyconst flex_int16_t yy_accept[86] =
+static yyconst flex_int16_t yy_accept[88] =
     {   0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,   35,   33,   32,   32,   25,    1,   21,   22,
-       23,   21,   21,   21,   21,   21,   24,   21,   21,   21,
-       31,   31,   31,   31,   31,   31,   31,   21,   29,   29,
-       27,   30,   32,    1,   16,   14,   24,   15,    0,   12,
-       17,   19,    2,   20,   31,   31,    3,   31,   31,   31,
-        5,   10,   31,   13,   29,   28,   26,   28,    0,   24,
-       18,    9,    4,   31,   31,   11,   31,    0,   28,    8,
-        7,    6,   28,   28,    0
+        0,    0,   36,   34,   33,   33,   34,   26,    1,   22,
+       23,   24,   22,   22,   22,   22,   22,   25,   22,   22,
+       22,   32,   32,   32,   32,   32,   32,   32,   22,   30,
+       30,   28,   31,   33,    2,    1,   17,   15,   25,   16,
+        0,   13,   18,   20,    3,   21,   32,   32,    4,   32,
+       32,   32,    6,   11,   32,   14,   30,   29,   27,   29,
+        0,   25,   19,   10,    5,   32,   32,   12,   32,    0,
+       29,    9,    8,    7,   29,   29,    0
     } ;
 
 static yyconst flex_int32_t yy_ec[256] =
@@ -385,17 +377,17 @@ static yyconst flex_int32_t yy_ec[256] =
         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
         1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    2,    1,    5,    6,    7,    1,    1,    1,    8,
-        9,   10,   11,   12,   13,   14,   15,   16,   16,   16,
-       16,   16,   16,   16,   16,   16,   16,   17,   18,   19,
-       20,   21,    1,    1,   22,   22,   22,   22,   23,   22,
-       22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
-       22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
-       24,   25,   26,    1,   27,    1,   28,   22,   22,   29,
+        1,    2,    5,    6,    7,    8,    1,    1,    1,    9,
+       10,   11,   12,   13,   14,   15,   16,   17,   17,   17,
+       17,   17,   17,   17,   17,   17,   17,   18,   19,   20,
+       21,   22,    1,    1,   23,   23,   23,   23,   24,   23,
+       23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
+       23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
+       25,   26,   27,    1,   28,    1,   29,   23,   23,   30,
 
-       30,   31,   22,   32,   33,   22,   22,   34,   22,   35,
-       36,   22,   22,   37,   38,   39,   40,   22,   22,   22,
-       22,   22,   41,   42,   43,    1,    1,    1,    1,    1,
+       31,   32,   23,   33,   34,   23,   23,   35,   23,   36,
+       37,   23,   23,   38,   39,   40,   41,   23,   23,   23,
+       23,   23,   42,   43,   44,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -412,91 +404,91 @@ static yyconst flex_int32_t yy_ec[256] =
         1,    1,    1,    1,    1
     } ;
 
-static yyconst flex_int32_t yy_meta[44] =
+static yyconst flex_int32_t yy_meta[45] =
     {   0,
-        1,    1,    2,    2,    3,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    4,    1,    1,    1,    1,
-        1,    4,    4,    1,    5,    1,    6,    4,    4,    4,
+        1,    1,    2,    2,    1,    3,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    4,    1,    1,    1,
+        1,    1,    4,    4,    1,    5,    1,    6,    4,    4,
         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
-        1,    1,    1
+        4,    1,    1,    1
     } ;
 
-static yyconst flex_int16_t yy_base[95] =
+static yyconst flex_int16_t yy_base[97] =
     {   0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-       41,   42,  142,  143,   46,   48,  143,    0,  143,  143,
-      143,  121,  120,   38,   39,   41,   49,  119,  118,  117,
-        0,   22,  106,   36,  104,   97,  101,  112,    0,    0,
-      143,   51,   71,    0,  143,  143,   62,  143,   64,   96,
-      143,  143,  143,  143,    0,   85,    0,   79,   48,   75,
-        0,    0,   65,  143,    0,   69,  143,   68,   74,   73,
-      143,    0,    0,   57,   57,    0,   49,   56,   58,    0,
-        0,    0,   57,   43,  143,   96,  102,  105,  111,  117,
-      120,  122,  124,  126
+       42,   43,  144,  145,   48,   50,  122,  145,    0,  145,
+      145,  145,  121,  120,   39,   40,   42,   50,  119,  118,
+      117,    0,   23,   91,   37,   88,   78,   77,   80,    0,
+        0,  145,   38,   73,  145,    0,  145,  145,   63,  145,
+       71,   79,  145,  145,  145,  145,    0,   69,    0,   66,
+       27,   67,    0,    0,   65,  145,    0,   69,  145,   67,
+       75,   74,  145,    0,    0,   58,   58,    0,   50,   61,
+       58,    0,    0,    0,   56,   51,  145,  102,  108,  111,
+      117,  123,  126,  128,  130,  132
 
     } ;
 
-static yyconst flex_int16_t yy_def[95] =
+static yyconst flex_int16_t yy_def[97] =
     {   0,
-       85,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-       86,   86,   85,   85,   85,   85,   85,   87,   85,   85,
-       85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
-       88,   88,   88,   88,   88,   88,   88,   85,   89,   89,
-       85,   90,   85,   87,   85,   85,   85,   85,   85,   85,
-       85,   85,   85,   85,   88,   88,   88,   88,   88,   88,
-       88,   88,   88,   85,   89,   85,   85,   91,   85,   85,
-       85,   88,   88,   88,   88,   88,   88,   90,   92,   88,
-       88,   88,   93,   94,    0,   85,   85,   85,   85,   85,
-       85,   85,   85,   85
+       87,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+       88,   88,   87,   87,   87,   87,   87,   87,   89,   87,
+       87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
+       87,   90,   90,   90,   90,   90,   90,   90,   87,   91,
+       91,   87,   92,   87,   87,   89,   87,   87,   87,   87,
+       87,   87,   87,   87,   87,   87,   90,   90,   90,   90,
+       90,   90,   90,   90,   90,   87,   91,   87,   87,   93,
+       87,   87,   87,   90,   90,   90,   90,   90,   90,   92,
+       94,   90,   90,   90,   95,   96,    0,   87,   87,   87,
+       87,   87,   87,   87,   87,   87
 
     } ;
 
-static yyconst flex_int16_t yy_nxt[187] =
+static yyconst flex_int16_t yy_nxt[190] =
     {   0,
        14,   15,   16,   14,   17,   18,   19,   20,   21,   22,
-       23,   19,   24,   25,   26,   27,   19,   19,   28,   29,
-       30,   31,   31,   20,   14,   21,   31,   32,   33,   34,
-       31,   31,   35,   31,   31,   36,   31,   31,   37,   31,
-       20,   38,   21,   40,   40,   41,   41,   43,   43,   43,
-       43,   47,   47,   47,   47,   50,   56,   48,   67,   57,
-       51,   49,   47,   85,   47,   42,   42,   78,   49,   59,
-       60,   49,   43,   43,   69,   47,   69,   47,   49,   70,
-       74,   78,   78,   82,   49,   75,   81,   80,   70,   70,
-       68,   49,   78,   78,   77,   68,   39,   39,   39,   39,
+       23,   24,   20,   25,   26,   27,   28,   20,   20,   29,
+       30,   31,   32,   32,   21,   14,   22,   32,   33,   34,
+       35,   32,   32,   36,   32,   32,   37,   32,   32,   38,
+       32,   21,   39,   22,   41,   41,   69,   42,   42,   44,
+       44,   44,   44,   49,   49,   49,   49,   52,   58,   50,
+       76,   59,   53,   51,   49,   77,   49,   43,   43,   87,
+       51,   61,   62,   51,   44,   44,   80,   49,   70,   49,
+       51,   80,   71,   80,   71,   84,   51,   72,   83,   82,
+       72,   72,   80,   51,   80,   79,   78,   75,   74,   73,
 
-       39,   39,   44,   76,   44,   44,   44,   44,   55,   73,
-       55,   65,   65,   72,   65,   71,   65,   66,   66,   66,
-       66,   66,   66,   79,   79,   83,   83,   84,   84,   66,
-       66,   64,   63,   62,   61,   58,   54,   53,   52,   46,
-       45,   85,   13,   85,   85,   85,   85,   85,   85,   85,
-       85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
-       85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
-       85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
-       85,   85,   85,   85,   85,   85
+       66,   70,   40,   40,   40,   40,   40,   40,   46,   65,
+       46,   46,   46,   46,   57,   64,   57,   67,   67,   63,
+       67,   60,   67,   68,   68,   68,   68,   68,   68,   81,
+       81,   85,   85,   86,   86,   68,   68,   56,   55,   54,
+       48,   47,   45,   87,   13,   87,   87,   87,   87,   87,
+       87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
+       87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
+       87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
+       87,   87,   87,   87,   87,   87,   87,   87,   87
     } ;
 
-static yyconst flex_int16_t yy_chk[187] =
+static yyconst flex_int16_t yy_chk[190] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,   11,   12,   11,   12,   15,   15,   16,
-       16,   24,   25,   24,   25,   26,   32,   24,   42,   32,
-       26,   25,   27,   78,   27,   11,   12,   84,   25,   34,
-       34,   27,   43,   43,   49,   47,   49,   47,   27,   49,
-       59,   83,   79,   77,   47,   59,   75,   74,   70,   69,
-       42,   47,   68,   66,   63,   78,   86,   86,   86,   86,
+        1,    1,    1,    1,   11,   12,   43,   11,   12,   15,
+       15,   16,   16,   25,   26,   25,   26,   27,   33,   25,
+       61,   33,   27,   26,   28,   61,   28,   11,   12,   80,
+       26,   35,   35,   28,   44,   44,   86,   49,   43,   49,
+       28,   85,   51,   81,   51,   79,   49,   51,   77,   76,
+       72,   71,   70,   49,   68,   65,   62,   60,   58,   52,
 
-       86,   86,   87,   60,   87,   87,   87,   87,   88,   58,
-       88,   89,   89,   56,   89,   50,   89,   90,   90,   90,
-       90,   90,   90,   91,   91,   92,   92,   93,   93,   94,
-       94,   38,   37,   36,   35,   33,   30,   29,   28,   23,
-       22,   13,   85,   85,   85,   85,   85,   85,   85,   85,
-       85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
-       85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
-       85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
-       85,   85,   85,   85,   85,   85
+       39,   80,   88,   88,   88,   88,   88,   88,   89,   38,
+       89,   89,   89,   89,   90,   37,   90,   91,   91,   36,
+       91,   34,   91,   92,   92,   92,   92,   92,   92,   93,
+       93,   94,   94,   95,   95,   96,   96,   31,   30,   29,
+       24,   23,   17,   13,   87,   87,   87,   87,   87,   87,
+       87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
+       87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
+       87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
+       87,   87,   87,   87,   87,   87,   87,   87,   87
     } ;
 
 /* The intent behind this definition is that it'll catch
@@ -527,7 +519,7 @@ static yyconst flex_int16_t yy_chk[187] =
   static int enter(int opening, int state, yyscan_t yyscanner);
   static int try_exit(int closing, int state, yyscan_t yyscanner);
 #define YY_NO_INPUT 1
-#line 531 "lexer.gen.c"
+#line 523 "lexer.gen.c"
 
 #define INITIAL 0
 #define IN_PAREN 1
@@ -559,8 +551,8 @@ struct yyguts_t
     size_t yy_buffer_stack_max; /**< capacity of stack. */
     YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
     char yy_hold_char;
-    int yy_n_chars;
-    int yyleng_r;
+    yy_size_t yy_n_chars;
+    yy_size_t yyleng_r;
     char *yy_c_buf_p;
     int yy_init;
     int yy_start;
@@ -617,7 +609,7 @@ FILE *jq_yyget_out (yyscan_t yyscanner );
 
 void jq_yyset_out  (FILE * out_str ,yyscan_t yyscanner );
 
-int jq_yyget_leng (yyscan_t yyscanner );
+yy_size_t jq_yyget_leng (yyscan_t yyscanner );
 
 char *jq_yyget_text (yyscan_t yyscanner );
 
@@ -625,6 +617,10 @@ int jq_yyget_lineno (yyscan_t yyscanner );
 
 void jq_yyset_lineno (int line_number ,yyscan_t yyscanner );
 
+int jq_yyget_column  (yyscan_t yyscanner );
+
+void jq_yyset_column (int column_no ,yyscan_t yyscanner );
+
 YYSTYPE * jq_yyget_lval (yyscan_t yyscanner );
 
 void jq_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
@@ -671,12 +667,7 @@ static int input (yyscan_t yyscanner );
     
 /* Amount of stuff to slurp up with each read. */
 #ifndef YY_READ_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k */
-#define YY_READ_BUF_SIZE 16384
-#else
 #define YY_READ_BUF_SIZE 8192
-#endif /* __ia64__ */
 #endif
 
 /* Copy whatever the last rule matched to the standard output. */
@@ -783,7 +774,7 @@ YY_DECL
 #line 32 "lexer.l"
 
 
-#line 787 "lexer.gen.c"
+#line 778 "lexer.gen.c"
 
     yylval = yylval_param;
 
@@ -840,13 +831,13 @@ yy_match:
 			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 				{
 				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 86 )
+				if ( yy_current_state >= 88 )
 					yy_c = yy_meta[(unsigned int) yy_c];
 				}
 			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 			++yy_cp;
 			}
-		while ( yy_base[yy_current_state] != 143 );
+		while ( yy_base[yy_current_state] != 145 );
 
 yy_find_action:
 		yy_act = yy_accept[yy_current_state];
@@ -878,152 +869,157 @@ YY_RULE_SETUP
 case 2:
 YY_RULE_SETUP
 #line 36 "lexer.l"
-{ return EQ; }
+{ return NEQ; }
 	YY_BREAK
 case 3:
 YY_RULE_SETUP
 #line 37 "lexer.l"
-{ return AS; }
+{ return EQ; }
 	YY_BREAK
 case 4:
 YY_RULE_SETUP
 #line 38 "lexer.l"
-{ return DEF; }
+{ return AS; }
 	YY_BREAK
 case 5:
 YY_RULE_SETUP
 #line 39 "lexer.l"
-{ return IF; }
+{ return DEF; }
 	YY_BREAK
 case 6:
 YY_RULE_SETUP
 #line 40 "lexer.l"
-{ return THEN; }
+{ return IF; }
 	YY_BREAK
 case 7:
 YY_RULE_SETUP
 #line 41 "lexer.l"
-{ return ELSE; }
+{ return THEN; }
 	YY_BREAK
 case 8:
 YY_RULE_SETUP
 #line 42 "lexer.l"
-{ return ELSE_IF; }
+{ return ELSE; }
 	YY_BREAK
 case 9:
 YY_RULE_SETUP
 #line 43 "lexer.l"
-{ return AND; }
+{ return ELSE_IF; }
 	YY_BREAK
 case 10:
 YY_RULE_SETUP
 #line 44 "lexer.l"
-{ return OR; }
+{ return AND; }
 	YY_BREAK
 case 11:
 YY_RULE_SETUP
 #line 45 "lexer.l"
-{ return END; }
+{ return OR; }
 	YY_BREAK
 case 12:
 YY_RULE_SETUP
 #line 46 "lexer.l"
-{ return DEFINEDOR; }
+{ return END; }
 	YY_BREAK
 case 13:
 YY_RULE_SETUP
 #line 47 "lexer.l"
-{ return SETPIPE; }
+{ return DEFINEDOR; }
 	YY_BREAK
 case 14:
 YY_RULE_SETUP
 #line 48 "lexer.l"
-{ return SETPLUS; }
+{ return SETPIPE; }
 	YY_BREAK
 case 15:
 YY_RULE_SETUP
 #line 49 "lexer.l"
-{ return SETMINUS; }
+{ return SETPLUS; }
 	YY_BREAK
 case 16:
 YY_RULE_SETUP
 #line 50 "lexer.l"
-{ return SETMULT; }
+{ return SETMINUS; }
 	YY_BREAK
 case 17:
 YY_RULE_SETUP
 #line 51 "lexer.l"
-{ return SETDIV; }
+{ return SETMULT; }
 	YY_BREAK
 case 18:
 YY_RULE_SETUP
 #line 52 "lexer.l"
-{ return SETDEFINEDOR; }
+{ return SETDIV; }
 	YY_BREAK
 case 19:
 YY_RULE_SETUP
 #line 53 "lexer.l"
-{ return LESSEQ; }
+{ return SETDEFINEDOR; }
 	YY_BREAK
 case 20:
 YY_RULE_SETUP
 #line 54 "lexer.l"
-{ return GREATEREQ; }
+{ return LESSEQ; }
 	YY_BREAK
 case 21:
 YY_RULE_SETUP
 #line 55 "lexer.l"
-{ return yytext[0];}
+{ return GREATEREQ; }
 	YY_BREAK
 case 22:
 YY_RULE_SETUP
-#line 57 "lexer.l"
+#line 56 "lexer.l"
+{ return yytext[0];}
+	YY_BREAK
+case 23:
+YY_RULE_SETUP
+#line 58 "lexer.l"
 {
   return enter(yytext[0], YY_START, yyscanner);
 }
 	YY_BREAK
-case 23:
+case 24:
 YY_RULE_SETUP
-#line 61 "lexer.l"
+#line 62 "lexer.l"
 {
   return try_exit(yytext[0], YY_START, yyscanner);
 }
 	YY_BREAK
-case 24:
+case 25:
 YY_RULE_SETUP
-#line 66 "lexer.l"
+#line 67 "lexer.l"
 { 
    yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; 
 }
 	YY_BREAK
-case 25:
+case 26:
 YY_RULE_SETUP
-#line 70 "lexer.l"
+#line 71 "lexer.l"
 {
   yy_push_state(IN_QQSTRING, yyscanner);
   return QQSTRING_START;
 }
 	YY_BREAK
 
-case 26:
+case 27:
 YY_RULE_SETUP
-#line 76 "lexer.l"
+#line 77 "lexer.l"
 {
     return enter(QQSTRING_INTERP_START, YY_START, yyscanner);
   }
 	YY_BREAK
-case 27:
+case 28:
 YY_RULE_SETUP
-#line 79 "lexer.l"
+#line 80 "lexer.l"
 {
     yy_pop_state(yyscanner);
     return QQSTRING_END;
   }
 	YY_BREAK
-case 28:
-/* rule 28 can match eol */
+case 29:
+/* rule 29 can match eol */
 YY_RULE_SETUP
-#line 83 "lexer.l"
+#line 84 "lexer.l"
 {
     /* pass escapes to the json parser */
     jv escapes = jv_string_fmt("\"%.*s\"", yyleng, yytext);
@@ -1032,45 +1028,45 @@ YY_RULE_SETUP
     return QQSTRING_TEXT;
   }
 	YY_BREAK
-case 29:
-/* rule 29 can match eol */
+case 30:
+/* rule 30 can match eol */
 YY_RULE_SETUP
-#line 90 "lexer.l"
+#line 91 "lexer.l"
 {
     yylval->literal = jv_string_sized(yytext, yyleng);
     return QQSTRING_TEXT;
   }
 	YY_BREAK
-case 30:
+case 31:
 YY_RULE_SETUP
-#line 94 "lexer.l"
+#line 95 "lexer.l"
 {
     return INVALID_CHARACTER;
   }
 	YY_BREAK
 
-case 31:
+case 32:
 YY_RULE_SETUP
-#line 100 "lexer.l"
+#line 101 "lexer.l"
 { yylval->literal = jv_string(yytext); return IDENT;}
 	YY_BREAK
-case 32:
-/* rule 32 can match eol */
-YY_RULE_SETUP
-#line 102 "lexer.l"
-{}
-	YY_BREAK
 case 33:
+/* rule 33 can match eol */
 YY_RULE_SETUP
-#line 104 "lexer.l"
-{ return INVALID_CHARACTER; }
+#line 103 "lexer.l"
+{}
 	YY_BREAK
 case 34:
 YY_RULE_SETUP
-#line 106 "lexer.l"
+#line 105 "lexer.l"
+{ return INVALID_CHARACTER; }
+	YY_BREAK
+case 35:
+YY_RULE_SETUP
+#line 107 "lexer.l"
 YY_FATAL_ERROR( "flex scanner jammed" );
 	YY_BREAK
-#line 1074 "lexer.gen.c"
+#line 1070 "lexer.gen.c"
 case YY_STATE_EOF(INITIAL):
 case YY_STATE_EOF(IN_PAREN):
 case YY_STATE_EOF(IN_BRACKET):
@@ -1262,21 +1258,21 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 
 	else
 		{
-			int num_to_read =
+			yy_size_t num_to_read =
 			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
 
 		while ( num_to_read <= 0 )
 			{ /* Not enough room in the buffer - grow it. */
 
 			/* just a shorter name for the current buffer */
-			YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
+			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
 
 			int yy_c_buf_p_offset =
 				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);
 
 			if ( b->yy_is_our_buffer )
 				{
-				int new_size = b->yy_buf_size * 2;
+				yy_size_t new_size = b->yy_buf_size * 2;
 
 				if ( new_size <= 0 )
 					b->yy_buf_size += b->yy_buf_size / 8;
@@ -1307,7 +1303,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 
 		/* Read in more data. */
 		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
-			yyg->yy_n_chars, (size_t) num_to_read );
+			yyg->yy_n_chars, num_to_read );
 
 		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
 		}
@@ -1369,7 +1365,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 			{
 			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 86 )
+			if ( yy_current_state >= 88 )
 				yy_c = yy_meta[(unsigned int) yy_c];
 			}
 		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
@@ -1398,12 +1394,13 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 		{
 		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 86 )
+		if ( yy_current_state >= 88 )
 			yy_c = yy_meta[(unsigned int) yy_c];
 		}
 	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-	yy_is_jam = (yy_current_state == 85);
+	yy_is_jam = (yy_current_state == 87);
 
+	(void)yyg;
 	return yy_is_jam ? 0 : yy_current_state;
 }
 
@@ -1432,7 +1429,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 
 		else
 			{ /* need more input */
-			int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
+			yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
 			++yyg->yy_c_buf_p;
 
 			switch ( yy_get_next_buffer( yyscanner ) )
@@ -1596,10 +1593,6 @@ static void jq_yy_load_buffer_state  (yyscan_t yyscanner)
 	jq_yyfree((void *) b ,yyscanner );
 }
 
-#ifndef __cplusplus
-extern int isatty (int );
-#endif /* __cplusplus */
-    
 /* Initializes or reinitializes a buffer.
  * This function is sometimes called more than once on the same buffer,
  * such as during a jq_yyrestart() or at EOF.
@@ -1716,7 +1709,7 @@ void jq_yypop_buffer_state (yyscan_t yyscanner)
  */
 static void jq_yyensure_buffer_stack (yyscan_t yyscanner)
 {
-	int num_to_alloc;
+	yy_size_t num_to_alloc;
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
 	if (!yyg->yy_buffer_stack) {
@@ -1814,7 +1807,7 @@ YY_BUFFER_STATE jq_yy_scan_string (yyconst char * yystr , yyscan_t yyscanner)
  * @param yyscanner The scanner object.
  * @return the newly allocated buffer state object.
  */
-YY_BUFFER_STATE jq_yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
+YY_BUFFER_STATE jq_yy_scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len , yyscan_t yyscanner)
 {
 	YY_BUFFER_STATE b;
 	char *buf;
@@ -1969,7 +1962,7 @@ FILE *jq_yyget_out  (yyscan_t yyscanner)
 /** Get the length of the current token.
  * @param yyscanner The scanner object.
  */
-int jq_yyget_leng  (yyscan_t yyscanner)
+yy_size_t jq_yyget_leng  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     return yyleng;
@@ -2005,7 +1998,7 @@ void jq_yyset_lineno (int  line_number , yyscan_t yyscanner)
 
         /* lineno is only valid if an input buffer exists. */
         if (! YY_CURRENT_BUFFER )
-           yy_fatal_error( "jq_yyset_lineno called with no buffer" , yyscanner); 
+           YY_FATAL_ERROR( "jq_yyset_lineno called with no buffer" );
     
     yylineno = line_number;
 }
@@ -2020,7 +2013,7 @@ void jq_yyset_column (int  column_no , yyscan_t yyscanner)
 
         /* column is only valid if an input buffer exists. */
         if (! YY_CURRENT_BUFFER )
-           yy_fatal_error( "jq_yyset_column called with no buffer" , yyscanner); 
+           YY_FATAL_ERROR( "jq_yyset_column called with no buffer" );
     
     yycolumn = column_no;
 }
@@ -2256,7 +2249,7 @@ void jq_yyfree (void * ptr , yyscan_t yyscanner)
 
 #define YYTABLES_NAME "yytables"
 
-#line 106 "lexer.l"
+#line 107 "lexer.l"
 
 
 /* perhaps these should be calls... */
diff --git a/lexer.gen.h b/lexer.gen.h
index bbc095b8..ee486e8a 100644
--- a/lexer.gen.h
+++ b/lexer.gen.h
@@ -13,7 +13,7 @@
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 5
-#define YY_FLEX_SUBMINOR_VERSION 35
+#define YY_FLEX_SUBMINOR_VERSION 37
 #if YY_FLEX_SUBMINOR_VERSION > 0
 #define FLEX_BETA
 #endif
@@ -132,15 +132,7 @@ typedef void* yyscan_t;
 
 /* Size of default input buffer. */
 #ifndef YY_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k.
- * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
- * Ditto for the __ia64__ case accordingly.
- */
-#define YY_BUF_SIZE 32768
-#else
 #define YY_BUF_SIZE 16384
-#endif /* __ia64__ */
 #endif
 
 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
@@ -170,7 +162,7 @@ struct yy_buffer_state
 	/* Number of characters read into yy_ch_buf, not including EOB
 	 * characters.
 	 */
-	int yy_n_chars;
+	yy_size_t yy_n_chars;
 
 	/* Whether we "own" the buffer - i.e., we know we created it,
 	 * and can realloc() it to grow it, and should free() it to
@@ -214,7 +206,7 @@ void jq_yypop_buffer_state (yyscan_t yyscanner );
 
 YY_BUFFER_STATE jq_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
 YY_BUFFER_STATE jq_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
-YY_BUFFER_STATE jq_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
+YY_BUFFER_STATE jq_yy_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner );
 
 void *jq_yyalloc (yy_size_t ,yyscan_t yyscanner );
 void *jq_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
@@ -222,7 +214,7 @@ void jq_yyfree (void * ,yyscan_t yyscanner );
 
 /* Begin user sect3 */
 
-#define jq_yywrap(n) 1
+#define jq_yywrap(yyscanner) 1
 #define YY_SKIP_YYWRAP
 
 #define yytext_ptr yytext_r
@@ -272,7 +264,7 @@ FILE *jq_yyget_out (yyscan_t yyscanner );
 
 void jq_yyset_out  (FILE * out_str ,yyscan_t yyscanner );
 
-int jq_yyget_leng (yyscan_t yyscanner );
+yy_size_t jq_yyget_leng (yyscan_t yyscanner );
 
 char *jq_yyget_text (yyscan_t yyscanner );
 
@@ -280,6 +272,10 @@ int jq_yyget_lineno (yyscan_t yyscanner );
 
 void jq_yyset_lineno (int line_number ,yyscan_t yyscanner );
 
+int jq_yyget_column  (yyscan_t yyscanner );
+
+void jq_yyset_column (int column_no ,yyscan_t yyscanner );
+
 YYSTYPE * jq_yyget_lval (yyscan_t yyscanner );
 
 void jq_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
@@ -314,12 +310,7 @@ static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
 
 /* Amount of stuff to slurp up with each read. */
 #ifndef YY_READ_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k */
-#define YY_READ_BUF_SIZE 16384
-#else
 #define YY_READ_BUF_SIZE 8192
-#endif /* __ia64__ */
 #endif
 
 /* Number of entries by which start-condition stack grows. */
@@ -354,9 +345,9 @@ extern int jq_yylex \
 #undef YY_DECL
 #endif
 
-#line 106 "lexer.l"
+#line 107 "lexer.l"
 
 
-#line 361 "lexer.gen.h"
+#line 352 "lexer.gen.h"
 #undef jq_yyIN_HEADER
 #endif /* jq_yyHEADER_H */
diff --git a/parser.gen.c b/parser.gen.c
index 346a94b9..79213801 100644
--- a/parser.gen.c
+++ b/parser.gen.c
@@ -1,8 +1,8 @@
-/* A Bison parser, made by GNU Bison 2.5.  */
+/* A Bison parser, made by GNU Bison 2.6.2.  */
 
 /* Bison implementation for Yacc-like parsers in C
    
-      Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
+      Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc.
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -44,7 +44,7 @@
 #define YYBISON 1
 
 /* Bison version.  */
-#define YYBISON_VERSION "2.5"
+#define YYBISON_VERSION "2.6.2"
 
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"
@@ -58,28 +58,30 @@
 /* Pull parsers.  */
 #define YYPULL 1
 
-/* Using locations.  */
-#define YYLSP_NEEDED 1
 
 
 
 /* Copy the first part of user declarations.  */
-
-/* Line 268 of yacc.c  */
+/* Line 336 of yacc.c  */
 #line 1 "parser.y"
 
 #include <stdio.h>
 #include <string.h>
 #include "compile.h"
 
+typedef void* yyscan_t;
 
-/* Line 268 of yacc.c  */
-#line 78 "parser.gen.c"
 
-/* Enabling traces.  */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
+/* Line 336 of yacc.c  */
+#line 77 "parser.gen.c"
+
+# ifndef YY_NULL
+#  if defined __cplusplus && 201103L <= __cplusplus
+#   define YY_NULL nullptr
+#  else
+#   define YY_NULL 0
+#  endif
+# endif
 
 /* Enabling verbose error messages.  */
 #ifdef YYERROR_VERBOSE
@@ -89,15 +91,20 @@
 # define YYERROR_VERBOSE 1
 #endif
 
-/* Enabling the token table.  */
-#ifndef YYTOKEN_TABLE
-# define YYTOKEN_TABLE 0
+/* In a future release of Bison, this section will be replaced
+   by #include "parser.gen.h".  */
+#ifndef YY_PARSER_GEN_H
+# define YY_PARSER_GEN_H
+/* Enabling traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int yydebug;
 #endif
-
 /* "%code requires" blocks.  */
-
-/* Line 288 of yacc.c  */
-#line 6 "parser.y"
+/* Line 350 of yacc.c  */
+#line 9 "parser.y"
 
 #include "locfile.h"
 #define YYLTYPE location
@@ -113,9 +120,8 @@
   } while (0)
  
 
-
-/* Line 288 of yacc.c  */
-#line 119 "parser.gen.c"
+/* Line 350 of yacc.c  */
+#line 125 "parser.gen.c"
 
 /* Tokens.  */
 #ifndef YYTOKENTYPE
@@ -127,48 +133,46 @@
      IDENT = 259,
      LITERAL = 260,
      EQ = 261,
-     DEFINEDOR = 262,
-     AS = 263,
-     DEF = 264,
-     IF = 265,
-     THEN = 266,
-     ELSE = 267,
-     ELSE_IF = 268,
-     END = 269,
-     AND = 270,
-     OR = 271,
-     SETPIPE = 272,
-     SETPLUS = 273,
-     SETMINUS = 274,
-     SETMULT = 275,
-     SETDIV = 276,
-     SETDEFINEDOR = 277,
-     LESSEQ = 278,
-     GREATEREQ = 279,
-     QQSTRING_START = 280,
-     QQSTRING_TEXT = 281,
-     QQSTRING_INTERP_START = 282,
-     QQSTRING_INTERP_END = 283,
-     QQSTRING_END = 284
+     NEQ = 262,
+     DEFINEDOR = 263,
+     AS = 264,
+     DEF = 265,
+     IF = 266,
+     THEN = 267,
+     ELSE = 268,
+     ELSE_IF = 269,
+     END = 270,
+     AND = 271,
+     OR = 272,
+     SETPIPE = 273,
+     SETPLUS = 274,
+     SETMINUS = 275,
+     SETMULT = 276,
+     SETDIV = 277,
+     SETDEFINEDOR = 278,
+     LESSEQ = 279,
+     GREATEREQ = 280,
+     QQSTRING_START = 281,
+     QQSTRING_TEXT = 282,
+     QQSTRING_INTERP_START = 283,
+     QQSTRING_INTERP_END = 284,
+     QQSTRING_END = 285
    };
 #endif
 
 
-
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 typedef union YYSTYPE
 {
-
-/* Line 293 of yacc.c  */
-#line 24 "parser.y"
+/* Line 350 of yacc.c  */
+#line 27 "parser.y"
 
   jv literal;
   block blk;
 
 
-
-/* Line 293 of yacc.c  */
-#line 172 "parser.gen.c"
+/* Line 350 of yacc.c  */
+#line 176 "parser.gen.c"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
@@ -189,10 +193,25 @@ typedef struct YYLTYPE
 #endif
 
 
-/* Copy the second part of user declarations.  */
+#ifdef YYPARSE_PARAM
+#if defined __STDC__ || defined __cplusplus
+int yyparse (void *YYPARSE_PARAM);
+#else
+int yyparse ();
+#endif
+#else /* ! YYPARSE_PARAM */
+#if defined __STDC__ || defined __cplusplus
+int yyparse (block* answer, int* errors, struct locfile* locations, yyscan_t lexer);
+#else
+int yyparse ();
+#endif
+#endif /* ! YYPARSE_PARAM */
 
-/* Line 343 of yacc.c  */
-#line 85 "parser.y"
+#endif /* !YY_PARSER_GEN_H  */
+
+/* Copy the second part of user declarations.  */
+/* Line 353 of yacc.c  */
+#line 89 "parser.y"
 
 #include "lexer.gen.h"
 #define FAIL(loc, msg)                                   \
@@ -250,6 +269,7 @@ static block gen_binop(block a, block b, int op) {
   case '*': funcname = "_multiply"; break;
   case '/': funcname = "_divide"; break;
   case EQ: funcname = "_equal"; break;
+  case NEQ: funcname = "_notequal"; break;
   case '<': funcname = "_less"; break;
   case '>': funcname = "_greater"; break;
   case LESSEQ: funcname = "_lesseq"; break;
@@ -279,9 +299,8 @@ static block gen_update(block a, block op, int optype) {
 }
 
 
-
-/* Line 343 of yacc.c  */
-#line 285 "parser.gen.c"
+/* Line 353 of yacc.c  */
+#line 304 "parser.gen.c"
 
 #ifdef short
 # undef short
@@ -387,6 +406,7 @@ YYID (yyi)
 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
 #     ifndef EXIT_SUCCESS
 #      define EXIT_SUCCESS 0
 #     endif
@@ -480,20 +500,20 @@ union yyalloc
 #endif
 
 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
-/* Copy COUNT objects from FROM to TO.  The source and destination do
+/* Copy COUNT objects from SRC to DST.  The source and destination do
    not overlap.  */
 # ifndef YYCOPY
 #  if defined __GNUC__ && 1 < __GNUC__
-#   define YYCOPY(To, From, Count) \
-      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
+#   define YYCOPY(Dst, Src, Count) \
+      __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
 #  else
-#   define YYCOPY(To, From, Count)		\
-      do					\
-	{					\
-	  YYSIZE_T yyi;				\
-	  for (yyi = 0; yyi < (Count); yyi++)	\
-	    (To)[yyi] = (From)[yyi];		\
-	}					\
+#   define YYCOPY(Dst, Src, Count)              \
+      do                                        \
+        {                                       \
+          YYSIZE_T yyi;                         \
+          for (yyi = 0; yyi < (Count); yyi++)   \
+            (Dst)[yyi] = (Src)[yyi];            \
+        }                                       \
       while (YYID (0))
 #  endif
 # endif
@@ -502,20 +522,20 @@ union yyalloc
 /* YYFINAL -- State number of the termination state.  */
 #define YYFINAL  35
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   808
+#define YYLAST   831
 
 /* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  49
+#define YYNTOKENS  50
 /* YYNNTS -- Number of nonterminals.  */
 #define YYNNTS  12
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  68
+#define YYNRULES  69
 /* YYNRULES -- Number of states.  */
-#define YYNSTATES  147
+#define YYNSTATES  149
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 #define YYUNDEFTOK  2
-#define YYMAXUTOK   284
+#define YYMAXUTOK   285
 
 #define YYTRANSLATE(YYX)						\
   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
@@ -526,16 +546,16 @@ static const yytype_uint8 yytranslate[] =
        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,    40,     2,     2,     2,
-      42,    43,    38,    36,    32,    37,    44,    39,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,    41,    30,
-      34,    33,    35,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,    41,     2,     2,     2,
+      43,    44,    39,    37,    33,    38,    45,    40,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,    42,    31,
+      35,    34,    36,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,    45,     2,    46,     2,     2,     2,     2,     2,     2,
+       2,    46,     2,    47,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,    47,    31,    48,     2,     2,     2,     2,
+       2,     2,     2,    48,    32,    49,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
@@ -551,74 +571,75 @@ static const yytype_uint8 yytranslate[] =
        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29
+      25,    26,    27,    28,    29,    30
 };
 
 #if YYDEBUG
 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
    YYRHS.  */
-static const yytype_uint8 yyprhs[] =
+static const yytype_uint16 yyprhs[] =
 {
        0,     0,     3,     5,     7,     8,    11,    14,    21,    27,
       31,    35,    39,    43,    47,    51,    55,    59,    63,    67,
       71,    75,    79,    83,    87,    91,    95,    99,   103,   107,
-     111,   115,   117,   119,   123,   129,   138,   139,   142,   147,
-     153,   157,   161,   163,   165,   169,   172,   177,   181,   183,
-     187,   191,   194,   198,   201,   203,   208,   212,   216,   221,
-     225,   226,   228,   232,   236,   240,   244,   246,   252
+     111,   115,   119,   121,   123,   127,   133,   142,   143,   146,
+     151,   157,   161,   165,   167,   169,   173,   176,   181,   185,
+     187,   191,   195,   198,   202,   205,   207,   212,   216,   220,
+     225,   229,   230,   232,   236,   240,   244,   248,   250,   256
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 static const yytype_int8 yyrhs[] =
 {
-      50,     0,    -1,    52,    -1,    51,    -1,    -1,    54,    51,
-      -1,    54,    52,    -1,    58,     8,    40,     4,    31,    52,
-      -1,    10,    52,    11,    52,    56,    -1,    10,    52,     1,
-      -1,    52,    33,    52,    -1,    52,    16,    52,    -1,    52,
-      15,    52,    -1,    52,     7,    52,    -1,    52,    22,    52,
-      -1,    52,    17,    52,    -1,    52,    31,    52,    -1,    52,
-      32,    52,    -1,    52,    36,    52,    -1,    52,    18,    52,
-      -1,    52,    37,    52,    -1,    52,    19,    52,    -1,    52,
-      38,    52,    -1,    52,    20,    52,    -1,    52,    39,    52,
-      -1,    52,    21,    52,    -1,    52,     6,    52,    -1,    52,
-      34,    52,    -1,    52,    35,    52,    -1,    52,    23,    52,
-      -1,    52,    24,    52,    -1,    53,    -1,    58,    -1,    25,
-      55,    29,    -1,     9,     4,    41,    52,    30,    -1,     9,
-       4,    42,     4,    43,    41,    52,    30,    -1,    -1,    55,
-      26,    -1,    55,    27,    52,    28,    -1,    13,    52,    11,
-      52,    56,    -1,    12,    52,    14,    -1,    57,    31,    57,
-      -1,    58,    -1,    44,    -1,    58,    44,     4,    -1,    44,
-       4,    -1,    58,    45,    52,    46,    -1,    58,    45,    46,
-      -1,     5,    -1,    42,    52,    43,    -1,    45,    52,    46,
-      -1,    45,    46,    -1,    47,    59,    48,    -1,    40,     4,
-      -1,     4,    -1,     4,    42,    52,    43,    -1,    42,     1,
-      43,    -1,    45,     1,    46,    -1,    58,    45,     1,    46,
-      -1,    47,     1,    48,    -1,    -1,    60,    -1,    60,    32,
-      59,    -1,     1,    32,    59,    -1,     4,    41,    57,    -1,
-      53,    41,    57,    -1,     4,    -1,    42,    52,    43,    41,
-      57,    -1,    42,     1,    43,    41,    57,    -1
+      51,     0,    -1,    53,    -1,    52,    -1,    -1,    55,    52,
+      -1,    55,    53,    -1,    59,     9,    41,     4,    32,    53,
+      -1,    11,    53,    12,    53,    57,    -1,    11,    53,     1,
+      -1,    53,    34,    53,    -1,    53,    17,    53,    -1,    53,
+      16,    53,    -1,    53,     8,    53,    -1,    53,    23,    53,
+      -1,    53,    18,    53,    -1,    53,    32,    53,    -1,    53,
+      33,    53,    -1,    53,    37,    53,    -1,    53,    19,    53,
+      -1,    53,    38,    53,    -1,    53,    20,    53,    -1,    53,
+      39,    53,    -1,    53,    21,    53,    -1,    53,    40,    53,
+      -1,    53,    22,    53,    -1,    53,     6,    53,    -1,    53,
+       7,    53,    -1,    53,    35,    53,    -1,    53,    36,    53,
+      -1,    53,    24,    53,    -1,    53,    25,    53,    -1,    54,
+      -1,    59,    -1,    26,    56,    30,    -1,    10,     4,    42,
+      53,    31,    -1,    10,     4,    43,     4,    44,    42,    53,
+      31,    -1,    -1,    56,    27,    -1,    56,    28,    53,    29,
+      -1,    14,    53,    12,    53,    57,    -1,    13,    53,    15,
+      -1,    58,    32,    58,    -1,    59,    -1,    45,    -1,    59,
+      45,     4,    -1,    45,     4,    -1,    59,    46,    53,    47,
+      -1,    59,    46,    47,    -1,     5,    -1,    43,    53,    44,
+      -1,    46,    53,    47,    -1,    46,    47,    -1,    48,    60,
+      49,    -1,    41,     4,    -1,     4,    -1,     4,    43,    53,
+      44,    -1,    43,     1,    44,    -1,    46,     1,    47,    -1,
+      59,    46,     1,    47,    -1,    48,     1,    49,    -1,    -1,
+      61,    -1,    61,    33,    60,    -1,     1,    33,    60,    -1,
+       4,    42,    58,    -1,    54,    42,    58,    -1,     4,    -1,
+      43,    53,    44,    42,    58,    -1,    43,     1,    44,    42,
+      58,    -1
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 static const yytype_uint16 yyrline[] =
 {
-       0,   174,   174,   177,   182,   185,   190,   194,   201,   204,
-     209,   218,   222,   226,   230,   234,   238,   242,   246,   250,
-     254,   258,   262,   266,   270,   274,   278,   282,   286,   290,
-     294,   298,   302,   307,   312,   318,   326,   329,   332,   338,
-     341,   346,   350,   356,   359,   362,   366,   369,   372,   375,
-     378,   381,   384,   389,   393,   397,   407,   408,   409,   410,
-     413,   416,   417,   418,   421,   424,   427,   431,   434
+       0,   179,   179,   182,   187,   190,   195,   199,   206,   209,
+     214,   223,   227,   231,   235,   239,   243,   247,   251,   255,
+     259,   263,   267,   271,   275,   279,   283,   287,   291,   295,
+     299,   303,   307,   311,   316,   321,   327,   335,   338,   341,
+     347,   350,   355,   359,   365,   368,   371,   375,   378,   381,
+     384,   387,   390,   393,   398,   402,   406,   416,   417,   418,
+     419,   422,   425,   426,   427,   430,   433,   436,   440,   443
 };
 #endif
 
-#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
+#if YYDEBUG || YYERROR_VERBOSE || 1
 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 static const char *const yytname[] =
 {
   "$end", "error", "$undefined", "INVALID_CHARACTER", "IDENT", "LITERAL",
-  "\"==\"", "\"//\"", "\"as\"", "\"def\"", "\"if\"", "\"then\"",
+  "\"==\"", "\"!=\"", "\"//\"", "\"as\"", "\"def\"", "\"if\"", "\"then\"",
   "\"else\"", "\"elif\"", "\"end\"", "\"and\"", "\"or\"", "\"|=\"",
   "\"+=\"", "\"-=\"", "\"*=\"", "\"/=\"", "\"//=\"", "\"<=\"", "\">=\"",
   "QQSTRING_START", "QQSTRING_TEXT", "QQSTRING_INTERP_START",
@@ -626,7 +647,7 @@ static const char *const yytname[] =
   "'>'", "'+'", "'-'", "'*'", "'/'", "'$'", "':'", "'('", "')'", "'.'",
   "'['", "']'", "'{'", "'}'", "$accept", "TopLevel", "FuncDefs", "Exp",
   "String", "FuncDef", "QQString", "ElseBody", "ExpD", "Term", "MkDict",
-  "MkDictPair", 0
+  "MkDictPair", YY_NULL
 };
 #endif
 
@@ -638,21 +659,21 @@ static const yytype_uint16 yytoknum[] =
        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-      59,   124,    44,    61,    60,    62,    43,    45,    42,    47,
-      36,    58,    40,    41,    46,    91,    93,   123,   125
+     285,    59,   124,    44,    61,    60,    62,    43,    45,    42,
+      47,    36,    58,    40,    41,    46,    91,    93,   123,   125
 };
 # endif
 
 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 static const yytype_uint8 yyr1[] =
 {
-       0,    49,    50,    50,    51,    51,    52,    52,    52,    52,
-      52,    52,    52,    52,    52,    52,    52,    52,    52,    52,
-      52,    52,    52,    52,    52,    52,    52,    52,    52,    52,
-      52,    52,    52,    53,    54,    54,    55,    55,    55,    56,
-      56,    57,    57,    58,    58,    58,    58,    58,    58,    58,
-      58,    58,    58,    58,    58,    58,    58,    58,    58,    58,
-      59,    59,    59,    59,    60,    60,    60,    60,    60
+       0,    50,    51,    51,    52,    52,    53,    53,    53,    53,
+      53,    53,    53,    53,    53,    53,    53,    53,    53,    53,
+      53,    53,    53,    53,    53,    53,    53,    53,    53,    53,
+      53,    53,    53,    53,    54,    55,    55,    56,    56,    56,
+      57,    57,    58,    58,    59,    59,    59,    59,    59,    59,
+      59,    59,    59,    59,    59,    59,    59,    59,    59,    59,
+      59,    60,    60,    60,    60,    61,    61,    61,    61,    61
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
@@ -661,10 +682,10 @@ static const yytype_uint8 yyr2[] =
        0,     2,     1,     1,     0,     2,     2,     6,     5,     3,
        3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
        3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-       3,     1,     1,     3,     5,     8,     0,     2,     4,     5,
-       3,     3,     1,     1,     3,     2,     4,     3,     1,     3,
-       3,     2,     3,     2,     1,     4,     3,     3,     4,     3,
-       0,     1,     3,     3,     3,     3,     1,     5,     5
+       3,     3,     1,     1,     3,     5,     8,     0,     2,     4,
+       5,     3,     3,     1,     1,     3,     2,     4,     3,     1,
+       3,     3,     2,     3,     2,     1,     4,     3,     3,     4,
+       3,     0,     1,     3,     3,     3,     3,     1,     5,     5
 };
 
 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
@@ -672,258 +693,264 @@ static const yytype_uint8 yyr2[] =
    means the default is an error.  */
 static const yytype_uint8 yydefact[] =
 {
-       4,    54,    48,     0,     0,    36,     0,     0,    43,     0,
-       0,     0,     3,     2,    31,     4,    32,     0,     0,     0,
-       0,     0,    53,     0,     0,    45,     0,    51,     0,     0,
-      66,     0,     0,     0,    61,     1,     0,     0,     0,     0,
+       4,    55,    49,     0,     0,    37,     0,     0,    44,     0,
+       0,     0,     3,     2,    32,     4,    33,     0,     0,     0,
+       0,     0,    54,     0,     0,    46,     0,    52,     0,     0,
+      67,     0,     0,     0,    62,     1,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     5,     6,     0,
-       0,     0,     0,     0,     0,     9,     0,    37,     0,    33,
-      56,    49,    57,    50,     0,    59,     0,     0,     0,     0,
-      52,     0,    26,    13,    12,    11,    15,    19,    21,    23,
-      25,    14,    29,    30,    16,    17,    10,    27,    28,    18,
-      20,    22,    24,     0,    44,     0,    47,     0,    55,     0,
-       0,     0,     0,     0,    63,    64,    42,     0,     0,    65,
-      62,     0,    58,    46,    34,     0,     0,     0,     8,    38,
-       0,     0,     0,     0,     0,     0,     0,    41,    68,    67,
-       7,     0,    40,     0,    35,     0,    39
+       0,     0,     0,     0,     0,     0,     0,     0,     5,     6,
+       0,     0,     0,     0,     0,     0,     9,     0,    38,     0,
+      34,    57,    50,    58,    51,     0,    60,     0,     0,     0,
+       0,    53,     0,    26,    27,    13,    12,    11,    15,    19,
+      21,    23,    25,    14,    30,    31,    16,    17,    10,    28,
+      29,    18,    20,    22,    24,     0,    45,     0,    48,     0,
+      56,     0,     0,     0,     0,     0,    64,    65,    43,     0,
+       0,    66,    63,     0,    59,    47,    35,     0,     0,     0,
+       8,    39,     0,     0,     0,     0,     0,     0,     0,    42,
+      69,    68,     7,     0,    41,     0,    36,     0,    40
 };
 
 /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int16 yydefgoto[] =
 {
-      -1,    11,    12,    58,    14,    20,    21,   128,   115,    16,
+      -1,    11,    12,    59,    14,    20,    21,   130,   117,    16,
       33,    34
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
-#define YYPACT_NINF -74
+#define YYPACT_NINF -75
 static const yytype_int16 yypact[] =
 {
-     194,   -40,   -74,    10,   194,   -74,    16,   137,    18,    77,
-      63,    28,   -74,   651,   -74,   194,    54,   194,   -26,   311,
-     194,   -16,   -74,   -13,   345,   -74,   -17,   -74,   236,   -27,
-      -8,   150,    -7,    12,     3,   -74,   194,   194,   194,   194,
-     194,   194,   194,   194,   194,   194,   194,   194,   194,   194,
-     194,   194,   194,   194,   194,   194,   194,   -74,   651,    34,
-      71,   127,   379,   194,    73,   -74,   194,   -74,   194,   -74,
-     -74,   -74,   -74,   -74,    72,   -74,   181,   -11,   413,   181,
-     -74,    72,   177,   719,   763,   769,   744,   744,   744,   744,
-     744,   744,   177,   177,   685,   719,   744,   177,   177,   -14,
-     -14,   -74,   -74,    75,   -74,    37,   -74,   270,   -74,   481,
-      41,   447,   515,    48,   -74,    58,   -18,    44,    49,    58,
-     -74,    60,   -74,   -74,   -74,    51,   194,   194,   -74,   -74,
-     181,   181,   181,   194,   194,   549,   583,   -74,    58,    58,
-     685,   617,   -74,   194,   -74,   447,   -74
+     175,   -41,   -75,    10,   175,   -75,    16,   129,    18,    78,
+      64,    28,   -75,   645,   -75,   175,    52,   175,   -27,   295,
+     175,   -17,   -75,   -14,   330,   -75,   -18,   -75,   218,   -28,
+     -10,   152,    -8,   -16,     2,   -75,   175,   175,   175,   175,
+     175,   175,   175,   175,   175,   175,   175,   175,   175,   175,
+     175,   175,   175,   175,   175,   175,   175,   175,   -75,   645,
+      22,    71,   101,   365,   175,    72,   -75,   175,   -75,   175,
+     -75,   -75,   -75,   -75,   -75,    73,   -75,   146,    34,   400,
+     146,   -75,    73,   785,   785,   715,   791,   765,   740,   740,
+     740,   740,   740,   740,   785,   785,   680,   715,   740,   785,
+     785,   -15,   -15,   -75,   -75,    76,   -75,    37,   -75,   253,
+     -75,   470,    41,   435,   505,    48,   -75,    54,   -19,    45,
+      49,    54,   -75,    60,   -75,   -75,   -75,    51,   175,   175,
+     -75,   -75,   146,   146,   146,   175,   175,   540,   575,   -75,
+      54,    54,   680,   610,   -75,   175,   -75,   435,   -75
 };
 
 /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int8 yypgoto[] =
 {
-     -74,   -74,    78,     0,    -9,     8,   -74,   -51,   -61,   -73,
-     -62,   -74
+     -75,   -75,    79,     0,    -9,     8,   -75,   -52,   -62,   -74,
+     -63,   -75
 };
 
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If YYTABLE_NINF, syntax error.  */
-#define YYTABLE_NINF -61
+#define YYTABLE_NINF -62
 static const yytype_int16 yytable[] =
 {
-      13,    32,    17,   116,    19,    74,   116,    24,    15,    28,
-      67,    68,   114,    69,    18,    63,    64,    62,   119,   120,
-      22,    75,    25,    15,    55,    56,    60,    61,    35,    72,
-      70,    78,   117,    76,    79,    81,    82,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
-      96,    97,    98,    99,   100,   101,   102,   116,   116,   116,
-      80,   107,    59,   109,    29,    32,   111,    30,   112,   137,
-     138,   139,    32,   113,   103,   104,    30,   110,    26,   121,
-      74,     1,     2,   122,   125,   131,     3,     4,     5,   130,
-     132,   133,   134,    57,   146,     0,     0,     5,    60,    61,
-       0,     0,     5,     0,     0,    31,     0,     0,     0,     0,
-       0,   -60,     0,     0,    31,     0,     0,     6,     0,     7,
-     -60,     8,     9,    27,    10,     0,   135,   136,   105,     0,
-       0,     1,     2,   140,   141,     0,     3,     4,    23,     0,
-       0,     1,     2,   145,     0,     0,     3,     4,     0,     0,
-       0,    77,     5,     0,     1,     2,     0,     0,     0,     3,
-       4,     0,     5,     0,     0,     0,     0,     6,     0,     7,
-       0,     8,     9,   106,    10,     5,     0,     6,     0,     7,
-       0,     8,     9,   -61,    10,     1,     2,     0,     0,     0,
-       6,     0,     7,     0,     8,     9,     0,    10,     1,     2,
-     -61,   -61,     0,     3,     4,     0,     0,     0,     0,     0,
-       0,   -61,   -61,    53,    54,    55,    56,     0,     0,     5,
-       0,     6,     0,     7,     0,     8,     9,     0,    10,     0,
-       0,     0,     0,     0,     6,     0,     7,     0,     8,     9,
-       0,    10,    36,    37,     0,     0,     0,     0,     0,     0,
-       0,    38,    39,    40,    41,    42,    43,    44,    45,    46,
-      47,     0,     0,     0,     0,     0,     0,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    36,    37,     0,     0,
-       0,     0,    73,     0,     0,    38,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,     0,     0,     0,     0,     0,
-       0,    48,    49,    50,    51,    52,    53,    54,    55,    56,
-       0,     0,    65,     0,     0,     0,   123,    36,    37,     0,
-       0,     0,    66,     0,     0,     0,    38,    39,    40,    41,
-      42,    43,    44,    45,    46,    47,     0,     0,     0,     0,
-       0,     0,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    36,    37,     0,     0,     0,     0,     0,     0,     0,
-      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
-       0,     0,     0,     0,     0,     0,    48,    49,    50,    51,
-      52,    53,    54,    55,    56,    36,    37,     0,    71,     0,
-       0,     0,     0,     0,    38,    39,    40,    41,    42,    43,
-      44,    45,    46,    47,     0,     0,     0,     0,     0,     0,
-      48,    49,    50,    51,    52,    53,    54,    55,    56,    36,
-      37,     0,   108,     0,     0,     0,     0,     0,    38,    39,
-      40,    41,    42,    43,    44,    45,    46,    47,     0,     0,
-       0,     0,     0,     0,    48,    49,    50,    51,    52,    53,
-      54,    55,    56,    36,    37,     0,   118,     0,     0,   126,
-     127,     0,    38,    39,    40,    41,    42,    43,    44,    45,
-      46,    47,     0,     0,     0,     0,     0,     0,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    36,    37,     0,
-       0,     0,     0,     0,     0,     0,    38,    39,    40,    41,
-      42,    43,    44,    45,    46,    47,     0,     0,     0,     0,
-       0,   124,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    36,    37,     0,     0,     0,     0,     0,     0,     0,
-      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
-       0,     0,     0,   129,     0,     0,    48,    49,    50,    51,
-      52,    53,    54,    55,    56,    36,    37,     0,     0,     0,
-       0,     0,     0,   142,    38,    39,    40,    41,    42,    43,
-      44,    45,    46,    47,     0,     0,     0,     0,     0,     0,
-      48,    49,    50,    51,    52,    53,    54,    55,    56,    36,
-      37,     0,     0,     0,   143,     0,     0,     0,    38,    39,
-      40,    41,    42,    43,    44,    45,    46,    47,     0,     0,
-       0,     0,     0,     0,    48,    49,    50,    51,    52,    53,
-      54,    55,    56,    36,    37,     0,     0,     0,     0,     0,
-       0,     0,    38,    39,    40,    41,    42,    43,    44,    45,
-      46,    47,     0,     0,     0,     0,     0,   144,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    36,    37,     0,
-       0,     0,     0,     0,     0,     0,    38,    39,    40,    41,
-      42,    43,    44,    45,    46,    47,     0,     0,     0,     0,
-       0,     0,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    36,    37,     0,     0,     0,     0,     0,     0,     0,
-      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
-       0,     0,     0,     0,     0,     0,     0,    49,    50,    51,
-      52,    53,    54,    55,    56,    36,    37,     0,     0,     0,
-       0,     0,     0,     0,    38,    39,    40,    41,    42,    43,
-      44,    45,    46,    47,     0,     0,     0,     0,     0,     0,
-      36,     0,    50,    51,    52,    53,    54,    55,    56,    38,
-      39,   -61,   -61,   -61,   -61,   -61,   -61,    46,    47,    36,
-       0,     0,     0,     0,     0,    36,     0,   -61,    51,    52,
-      53,    54,    55,    56,    38,     0,    46,    47,     0,     0,
-       0,     0,    46,    47,     0,     0,     0,    51,    52,    53,
-      54,    55,    56,    51,    52,    53,    54,    55,    56
+      13,    32,    17,   118,    19,    75,   118,    24,    15,    28,
+      68,    69,   116,    70,    18,    64,    65,    63,   121,   122,
+      22,    76,    25,    15,    56,    57,    61,    62,    35,    73,
+      71,    79,    77,    81,    80,    82,    83,    84,    85,    86,
+      87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
+      97,    98,    99,   100,   101,   102,   103,   104,   118,   118,
+     118,    60,   109,   105,   111,    29,    32,   113,    30,   114,
+     139,   140,   141,    32,   115,   106,   112,    30,   119,    26,
+     123,    75,     1,     2,   124,   127,   132,   133,     3,     4,
+       5,   134,   135,   136,    58,   148,     0,    61,    62,     5,
+       0,     0,   107,     0,     5,     1,     2,    31,     0,     0,
+       0,     3,     4,   -61,     0,     0,    31,     0,     0,     6,
+       0,     7,   -61,     8,     9,    27,    10,     5,   137,   138,
+      23,     0,     0,     1,     2,   142,   143,     0,     0,     3,
+       4,     0,     6,     0,     7,   147,     8,     9,   108,    10,
+       1,     2,     0,    78,     0,     5,     1,     2,     0,     0,
+       0,     0,     3,     4,     0,     0,     0,     0,     0,     0,
+       6,     0,     7,     0,     8,     9,     0,    10,     5,     1,
+       2,     0,     0,     0,     0,     3,     4,     6,     0,     7,
+       0,     8,     9,     6,    10,     7,     0,     8,     9,     0,
+      10,     5,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     6,     0,     7,     0,
+       8,     9,     0,    10,    36,    37,    38,     0,     0,     0,
+       0,     0,     0,     0,    39,    40,    41,    42,    43,    44,
+      45,    46,    47,    48,     0,     0,     0,     0,     0,     0,
+      49,    50,    51,    52,    53,    54,    55,    56,    57,    36,
+      37,    38,     0,     0,     0,    74,     0,     0,     0,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,    48,     0,
+       0,     0,     0,     0,     0,    49,    50,    51,    52,    53,
+      54,    55,    56,    57,     0,     0,    66,     0,     0,     0,
+     125,    36,    37,    38,     0,     0,     0,    67,     0,     0,
+       0,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,     0,     0,     0,     0,     0,     0,    49,    50,    51,
+      52,    53,    54,    55,    56,    57,    36,    37,    38,     0,
+       0,     0,     0,     0,     0,     0,    39,    40,    41,    42,
+      43,    44,    45,    46,    47,    48,     0,     0,     0,     0,
+       0,     0,    49,    50,    51,    52,    53,    54,    55,    56,
+      57,    36,    37,    38,    72,     0,     0,     0,     0,     0,
+       0,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,     0,     0,     0,     0,     0,     0,    49,    50,    51,
+      52,    53,    54,    55,    56,    57,    36,    37,    38,   110,
+       0,     0,     0,     0,     0,     0,    39,    40,    41,    42,
+      43,    44,    45,    46,    47,    48,     0,     0,     0,     0,
+       0,     0,    49,    50,    51,    52,    53,    54,    55,    56,
+      57,    36,    37,    38,   120,     0,     0,     0,   128,   129,
+       0,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,     0,     0,     0,     0,     0,     0,    49,    50,    51,
+      52,    53,    54,    55,    56,    57,    36,    37,    38,     0,
+       0,     0,     0,     0,     0,     0,    39,    40,    41,    42,
+      43,    44,    45,    46,    47,    48,     0,     0,     0,     0,
+       0,   126,    49,    50,    51,    52,    53,    54,    55,    56,
+      57,    36,    37,    38,     0,     0,     0,     0,     0,     0,
+       0,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,     0,     0,     0,   131,     0,     0,    49,    50,    51,
+      52,    53,    54,    55,    56,    57,    36,    37,    38,     0,
+       0,     0,     0,     0,     0,   144,    39,    40,    41,    42,
+      43,    44,    45,    46,    47,    48,     0,     0,     0,     0,
+       0,     0,    49,    50,    51,    52,    53,    54,    55,    56,
+      57,    36,    37,    38,     0,     0,     0,   145,     0,     0,
+       0,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,     0,     0,     0,     0,     0,     0,    49,    50,    51,
+      52,    53,    54,    55,    56,    57,    36,    37,    38,     0,
+       0,     0,     0,     0,     0,     0,    39,    40,    41,    42,
+      43,    44,    45,    46,    47,    48,     0,     0,     0,     0,
+       0,   146,    49,    50,    51,    52,    53,    54,    55,    56,
+      57,    36,    37,    38,     0,     0,     0,     0,     0,     0,
+       0,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,     0,     0,     0,     0,     0,     0,    49,    50,    51,
+      52,    53,    54,    55,    56,    57,    36,    37,    38,     0,
+       0,     0,     0,     0,     0,     0,    39,    40,    41,    42,
+      43,    44,    45,    46,    47,    48,     0,     0,     0,     0,
+       0,     0,     0,    50,    51,    52,    53,    54,    55,    56,
+      57,    36,    37,    38,     0,     0,     0,     0,     0,     0,
+       0,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,     0,     0,     0,     0,     0,    36,    37,     0,    51,
+      52,    53,    54,    55,    56,    57,    39,    40,   -62,   -62,
+     -62,   -62,   -62,   -62,    47,    48,     0,     0,     0,     0,
+       0,    36,    37,     0,   -62,    52,    53,    54,    55,    56,
+      57,    39,     0,     0,     0,     0,     0,     0,     0,    47,
+      48,   -62,   -62,     0,     0,     0,     0,    36,    37,     0,
+      52,    53,    54,    55,    56,    57,     0,     0,     0,   -62,
+     -62,     0,     0,     0,     0,    47,    48,     0,     0,     0,
+     -62,   -62,    54,    55,    56,    57,    52,    53,    54,    55,
+      56,    57
 };
 
 #define yypact_value_is_default(yystate) \
-  ((yystate) == (-74))
+  ((yystate) == (-75))
 
 #define yytable_value_is_error(yytable_value) \
-  ((yytable_value) == (-61))
+  ((yytable_value) == (-62))
 
 static const yytype_int16 yycheck[] =
 {
-       0,    10,    42,    76,     4,    32,    79,     7,     0,     9,
-      26,    27,    74,    29,     4,    41,    42,    17,    79,    81,
-       4,    48,     4,    15,    38,    39,    44,    45,     0,    46,
-      43,    31,    43,    41,    41,    32,    36,    37,    38,    39,
+       0,    10,    43,    77,     4,    33,    80,     7,     0,     9,
+      27,    28,    75,    30,     4,    42,    43,    17,    80,    82,
+       4,    49,     4,    15,    39,    40,    45,    46,     0,    47,
+      44,    31,    42,    49,    42,    33,    36,    37,    38,    39,
       40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,   130,   131,   132,
-      48,    61,     8,    63,     1,    74,    66,     4,    68,   130,
-     131,   132,    81,     1,    40,     4,     4,     4,     1,     4,
-      32,     4,     5,    46,    43,    41,     9,    10,    25,    31,
-      41,    31,    41,    15,   145,    -1,    -1,    25,    44,    45,
-      -1,    -1,    25,    -1,    -1,    42,    -1,    -1,    -1,    -1,
-      -1,    48,    -1,    -1,    42,    -1,    -1,    40,    -1,    42,
-      48,    44,    45,    46,    47,    -1,   126,   127,     1,    -1,
-      -1,     4,     5,   133,   134,    -1,     9,    10,     1,    -1,
-      -1,     4,     5,   143,    -1,    -1,     9,    10,    -1,    -1,
-      -1,     1,    25,    -1,     4,     5,    -1,    -1,    -1,     9,
-      10,    -1,    25,    -1,    -1,    -1,    -1,    40,    -1,    42,
-      -1,    44,    45,    46,    47,    25,    -1,    40,    -1,    42,
-      -1,    44,    45,     6,    47,     4,     5,    -1,    -1,    -1,
-      40,    -1,    42,    -1,    44,    45,    -1,    47,     4,     5,
-      23,    24,    -1,     9,    10,    -1,    -1,    -1,    -1,    -1,
-      -1,    34,    35,    36,    37,    38,    39,    -1,    -1,    25,
-      -1,    40,    -1,    42,    -1,    44,    45,    -1,    47,    -1,
-      -1,    -1,    -1,    -1,    40,    -1,    42,    -1,    44,    45,
-      -1,    47,     6,     7,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    -1,    -1,    -1,    -1,    -1,    -1,    31,    32,    33,
-      34,    35,    36,    37,    38,    39,     6,     7,    -1,    -1,
-      -1,    -1,    46,    -1,    -1,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
+      50,    51,    52,    53,    54,    55,    56,    57,   132,   133,
+     134,     9,    62,    41,    64,     1,    75,    67,     4,    69,
+     132,   133,   134,    82,     1,     4,     4,     4,    44,     1,
+       4,    33,     4,     5,    47,    44,    32,    42,    10,    11,
+      26,    42,    32,    42,    15,   147,    -1,    45,    46,    26,
+      -1,    -1,     1,    -1,    26,     4,     5,    43,    -1,    -1,
+      -1,    10,    11,    49,    -1,    -1,    43,    -1,    -1,    41,
+      -1,    43,    49,    45,    46,    47,    48,    26,   128,   129,
+       1,    -1,    -1,     4,     5,   135,   136,    -1,    -1,    10,
+      11,    -1,    41,    -1,    43,   145,    45,    46,    47,    48,
+       4,     5,    -1,     1,    -1,    26,     4,     5,    -1,    -1,
+      -1,    -1,    10,    11,    -1,    -1,    -1,    -1,    -1,    -1,
+      41,    -1,    43,    -1,    45,    46,    -1,    48,    26,     4,
+       5,    -1,    -1,    -1,    -1,    10,    11,    41,    -1,    43,
+      -1,    45,    46,    41,    48,    43,    -1,    45,    46,    -1,
+      48,    26,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    41,    -1,    43,    -1,
+      45,    46,    -1,    48,     6,     7,     8,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    -1,    -1,    -1,    -1,    -1,    -1,
+      32,    33,    34,    35,    36,    37,    38,    39,    40,     6,
+       7,     8,    -1,    -1,    -1,    47,    -1,    -1,    -1,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    25,    -1,
+      -1,    -1,    -1,    -1,    -1,    32,    33,    34,    35,    36,
+      37,    38,    39,    40,    -1,    -1,     1,    -1,    -1,    -1,
+      47,     6,     7,     8,    -1,    -1,    -1,    12,    -1,    -1,
+      -1,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    -1,    -1,    -1,    -1,    -1,    -1,    32,    33,    34,
+      35,    36,    37,    38,    39,    40,     6,     7,     8,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    -1,    -1,    -1,    -1,
+      -1,    -1,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,     6,     7,     8,    44,    -1,    -1,    -1,    -1,    -1,
+      -1,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    -1,    -1,    -1,    -1,    -1,    -1,    32,    33,    34,
+      35,    36,    37,    38,    39,    40,     6,     7,     8,    44,
+      -1,    -1,    -1,    -1,    -1,    -1,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    -1,    -1,    -1,    -1,
+      -1,    -1,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,     6,     7,     8,    44,    -1,    -1,    -1,    13,    14,
+      -1,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    -1,    -1,    -1,    -1,    -1,    -1,    32,    33,    34,
+      35,    36,    37,    38,    39,    40,     6,     7,     8,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    -1,    -1,    -1,    -1,
       -1,    31,    32,    33,    34,    35,    36,    37,    38,    39,
-      -1,    -1,     1,    -1,    -1,    -1,    46,     6,     7,    -1,
-      -1,    -1,    11,    -1,    -1,    -1,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
-      -1,    -1,    31,    32,    33,    34,    35,    36,    37,    38,
-      39,     6,     7,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      -1,    -1,    -1,    -1,    -1,    -1,    31,    32,    33,    34,
-      35,    36,    37,    38,    39,     6,     7,    -1,    43,    -1,
-      -1,    -1,    -1,    -1,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    -1,
-      31,    32,    33,    34,    35,    36,    37,    38,    39,     6,
-       7,    -1,    43,    -1,    -1,    -1,    -1,    -1,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
-      -1,    -1,    -1,    -1,    31,    32,    33,    34,    35,    36,
-      37,    38,    39,     6,     7,    -1,    43,    -1,    -1,    12,
-      13,    -1,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    -1,    -1,    -1,    -1,    -1,    -1,    31,    32,
-      33,    34,    35,    36,    37,    38,    39,     6,     7,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
-      -1,    30,    31,    32,    33,    34,    35,    36,    37,    38,
-      39,     6,     7,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      -1,    -1,    -1,    28,    -1,    -1,    31,    32,    33,    34,
-      35,    36,    37,    38,    39,     6,     7,    -1,    -1,    -1,
-      -1,    -1,    -1,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    -1,
-      31,    32,    33,    34,    35,    36,    37,    38,    39,     6,
-       7,    -1,    -1,    -1,    11,    -1,    -1,    -1,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
-      -1,    -1,    -1,    -1,    31,    32,    33,    34,    35,    36,
-      37,    38,    39,     6,     7,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
-      33,    34,    35,    36,    37,    38,    39,     6,     7,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
-      -1,    -1,    31,    32,    33,    34,    35,    36,    37,    38,
-      39,     6,     7,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    32,    33,    34,
-      35,    36,    37,    38,    39,     6,     7,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    -1,
-       6,    -1,    33,    34,    35,    36,    37,    38,    39,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,     6,
-      -1,    -1,    -1,    -1,    -1,     6,    -1,    33,    34,    35,
-      36,    37,    38,    39,    15,    -1,    23,    24,    -1,    -1,
-      -1,    -1,    23,    24,    -1,    -1,    -1,    34,    35,    36,
-      37,    38,    39,    34,    35,    36,    37,    38,    39
+      40,     6,     7,     8,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    -1,    -1,    -1,    29,    -1,    -1,    32,    33,    34,
+      35,    36,    37,    38,    39,    40,     6,     7,     8,    -1,
+      -1,    -1,    -1,    -1,    -1,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    -1,    -1,    -1,    -1,
+      -1,    -1,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,     6,     7,     8,    -1,    -1,    -1,    12,    -1,    -1,
+      -1,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    -1,    -1,    -1,    -1,    -1,    -1,    32,    33,    34,
+      35,    36,    37,    38,    39,    40,     6,     7,     8,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    -1,    -1,    -1,    -1,
+      -1,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,     6,     7,     8,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    -1,    -1,    -1,    -1,    -1,    -1,    32,    33,    34,
+      35,    36,    37,    38,    39,    40,     6,     7,     8,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    33,    34,    35,    36,    37,    38,    39,
+      40,     6,     7,     8,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    -1,    -1,    -1,    -1,    -1,     6,     7,    -1,    34,
+      35,    36,    37,    38,    39,    40,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    -1,    -1,    -1,    -1,
+      -1,     6,     7,    -1,    34,    35,    36,    37,    38,    39,
+      40,    16,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    24,
+      25,     6,     7,    -1,    -1,    -1,    -1,     6,     7,    -1,
+      35,    36,    37,    38,    39,    40,    -1,    -1,    -1,    24,
+      25,    -1,    -1,    -1,    -1,    24,    25,    -1,    -1,    -1,
+      35,    36,    37,    38,    39,    40,    35,    36,    37,    38,
+      39,    40
 };
 
 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
    symbol of state STATE-NUM.  */
 static const yytype_uint8 yystos[] =
 {
-       0,     4,     5,     9,    10,    25,    40,    42,    44,    45,
-      47,    50,    51,    52,    53,    54,    58,    42,     4,    52,
-      54,    55,     4,     1,    52,     4,     1,    46,    52,     1,
-       4,    42,    53,    59,    60,     0,     6,     7,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    31,    32,
-      33,    34,    35,    36,    37,    38,    39,    51,    52,     8,
-      44,    45,    52,    41,    42,     1,    11,    26,    27,    29,
-      43,    43,    46,    46,    32,    48,    41,     1,    52,    41,
-      48,    32,    52,    52,    52,    52,    52,    52,    52,    52,
-      52,    52,    52,    52,    52,    52,    52,    52,    52,    52,
-      52,    52,    52,    40,     4,     1,    46,    52,    43,    52,
-       4,    52,    52,     1,    59,    57,    58,    43,    43,    57,
-      59,     4,    46,    46,    30,    43,    12,    13,    56,    28,
-      31,    41,    41,    31,    41,    52,    52,    57,    57,    57,
-      52,    52,    14,    11,    30,    52,    56
+       0,     4,     5,    10,    11,    26,    41,    43,    45,    46,
+      48,    51,    52,    53,    54,    55,    59,    43,     4,    53,
+      55,    56,     4,     1,    53,     4,     1,    47,    53,     1,
+       4,    43,    54,    60,    61,     0,     6,     7,     8,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    25,    32,
+      33,    34,    35,    36,    37,    38,    39,    40,    52,    53,
+       9,    45,    46,    53,    42,    43,     1,    12,    27,    28,
+      30,    44,    44,    47,    47,    33,    49,    42,     1,    53,
+      42,    49,    33,    53,    53,    53,    53,    53,    53,    53,
+      53,    53,    53,    53,    53,    53,    53,    53,    53,    53,
+      53,    53,    53,    53,    53,    41,     4,     1,    47,    53,
+      44,    53,     4,    53,    53,     1,    60,    58,    59,    44,
+      44,    58,    60,     4,    47,    47,    31,    44,    13,    14,
+      57,    29,    32,    42,    42,    32,    42,    53,    53,    58,
+      58,    58,    53,    53,    15,    12,    31,    53,    57
 };
 
 #define yyerrok		(yyerrstatus = 0)
@@ -953,17 +980,18 @@ static const yytype_uint8 yystos[] =
 
 #define YYRECOVERING()  (!!yyerrstatus)
 
-#define YYBACKUP(Token, Value)					\
-do								\
-  if (yychar == YYEMPTY && yylen == 1)				\
-    {								\
-      yychar = (Token);						\
-      yylval = (Value);						\
-      YYPOPSTACK (1);						\
-      goto yybackup;						\
-    }								\
-  else								\
-    {								\
+#define YYBACKUP(Token, Value)                                  \
+do                                                              \
+  if (yychar == YYEMPTY)                                        \
+    {                                                           \
+      yychar = (Token);                                         \
+      yylval = (Value);                                         \
+      YYPOPSTACK (yylen);                                       \
+      yystate = *yyssp;                                         \
+      goto yybackup;                                            \
+    }                                                           \
+  else                                                          \
+    {                                                           \
       yyerror (&yylloc, answer, errors, locations, lexer, YY_("syntax error: cannot back up")); \
       YYERROR;							\
     }								\
@@ -973,32 +1001,33 @@ while (YYID (0))
 #define YYTERROR	1
 #define YYERRCODE	256
 
-
 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
    If N is 0, then set CURRENT to the empty location which ends
    the previous symbol: RHS[0] (always defined).  */
 
-#define YYRHSLOC(Rhs, K) ((Rhs)[K])
 #ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N)				\
-    do									\
-      if (YYID (N))                                                    \
-	{								\
-	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
-	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
-	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
-	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
-	}								\
-      else								\
-	{								\
-	  (Current).first_line   = (Current).last_line   =		\
-	    YYRHSLOC (Rhs, 0).last_line;				\
-	  (Current).first_column = (Current).last_column =		\
-	    YYRHSLOC (Rhs, 0).last_column;				\
-	}								\
+# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
+    do                                                                  \
+      if (YYID (N))                                                     \
+        {                                                               \
+          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
+          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
+          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
+          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
+        }                                                               \
+      else                                                              \
+        {                                                               \
+          (Current).first_line   = (Current).last_line   =              \
+            YYRHSLOC (Rhs, 0).last_line;                                \
+          (Current).first_column = (Current).last_column =              \
+            YYRHSLOC (Rhs, 0).last_column;                              \
+        }                                                               \
     while (YYID (0))
 #endif
 
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])
+
+
 
 /* YY_LOCATION_PRINT -- Print the location on the stream.
    This macro was not mandated originally: define only if we know
@@ -1072,6 +1101,8 @@ yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors,
     yyscan_t lexer;
 #endif
 {
+  FILE *yyo = yyoutput;
+  YYUSE (yyo);
   if (!yyvaluep)
     return;
   YYUSE (yylocationp);
@@ -1340,12 +1371,12 @@ static int
 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
                 yytype_int16 *yyssp, int yytoken)
 {
-  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
+  YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
   YYSIZE_T yysize = yysize0;
   YYSIZE_T yysize1;
   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
   /* Internationalized format string. */
-  const char *yyformat = 0;
+  const char *yyformat = YY_NULL;
   /* Arguments of yyformat. */
   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
   /* Number of reported tokens (one for the "unexpected", one per
@@ -1405,7 +1436,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
                     break;
                   }
                 yyarg[yycount++] = yytname[yyx];
-                yysize1 = yysize + yytnamerr (0, yytname[yyx]);
+                yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
                 if (! (yysize <= yysize1
                        && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
                   return 2;
@@ -1500,122 +1531,96 @@ yydestruct (yymsg, yytype, yyvaluep, yylocationp, answer, errors, locations, lex
 
   switch (yytype)
     {
-      case 4: /* "IDENT" */
-
-/* Line 1391 of yacc.c  */
-#line 29 "parser.y"
-	{ jv_free((yyvaluep->literal)); };
-
-/* Line 1391 of yacc.c  */
-#line 1511 "parser.gen.c"
+      case 4: /* IDENT */
+/* Line 1381 of yacc.c  */
+#line 32 "parser.y"
+	{ jv_free(((*yyvaluep).literal)); };
+/* Line 1381 of yacc.c  */
+#line 1540 "parser.gen.c"
 	break;
-      case 5: /* "LITERAL" */
-
-/* Line 1391 of yacc.c  */
-#line 29 "parser.y"
-	{ jv_free((yyvaluep->literal)); };
-
-/* Line 1391 of yacc.c  */
-#line 1520 "parser.gen.c"
-	break;
-      case 26: /* "QQSTRING_TEXT" */
-
-/* Line 1391 of yacc.c  */
-#line 29 "parser.y"
-	{ jv_free((yyvaluep->literal)); };
-
-/* Line 1391 of yacc.c  */
-#line 1529 "parser.gen.c"
-	break;
-      case 51: /* "FuncDefs" */
-
-/* Line 1391 of yacc.c  */
-#line 30 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1538 "parser.gen.c"
-	break;
-      case 52: /* "Exp" */
-
-/* Line 1391 of yacc.c  */
-#line 30 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
+      case 5: /* LITERAL */
+/* Line 1381 of yacc.c  */
+#line 32 "parser.y"
+	{ jv_free(((*yyvaluep).literal)); };
+/* Line 1381 of yacc.c  */
 #line 1547 "parser.gen.c"
 	break;
-      case 53: /* "String" */
-
-/* Line 1391 of yacc.c  */
-#line 30 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1556 "parser.gen.c"
+      case 27: /* QQSTRING_TEXT */
+/* Line 1381 of yacc.c  */
+#line 32 "parser.y"
+	{ jv_free(((*yyvaluep).literal)); };
+/* Line 1381 of yacc.c  */
+#line 1554 "parser.gen.c"
 	break;
-      case 54: /* "FuncDef" */
-
-/* Line 1391 of yacc.c  */
-#line 30 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1565 "parser.gen.c"
+      case 52: /* FuncDefs */
+/* Line 1381 of yacc.c  */
+#line 33 "parser.y"
+	{ block_free(((*yyvaluep).blk)); };
+/* Line 1381 of yacc.c  */
+#line 1561 "parser.gen.c"
 	break;
-      case 55: /* "QQString" */
-
-/* Line 1391 of yacc.c  */
-#line 30 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1574 "parser.gen.c"
+      case 53: /* Exp */
+/* Line 1381 of yacc.c  */
+#line 33 "parser.y"
+	{ block_free(((*yyvaluep).blk)); };
+/* Line 1381 of yacc.c  */
+#line 1568 "parser.gen.c"
 	break;
-      case 56: /* "ElseBody" */
-
-/* Line 1391 of yacc.c  */
-#line 30 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1583 "parser.gen.c"
+      case 54: /* String */
+/* Line 1381 of yacc.c  */
+#line 33 "parser.y"
+	{ block_free(((*yyvaluep).blk)); };
+/* Line 1381 of yacc.c  */
+#line 1575 "parser.gen.c"
 	break;
-      case 57: /* "ExpD" */
-
-/* Line 1391 of yacc.c  */
-#line 30 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1592 "parser.gen.c"
+      case 55: /* FuncDef */
+/* Line 1381 of yacc.c  */
+#line 33 "parser.y"
+	{ block_free(((*yyvaluep).blk)); };
+/* Line 1381 of yacc.c  */
+#line 1582 "parser.gen.c"
 	break;
-      case 58: /* "Term" */
-
-/* Line 1391 of yacc.c  */
-#line 30 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1601 "parser.gen.c"
+      case 56: /* QQString */
+/* Line 1381 of yacc.c  */
+#line 33 "parser.y"
+	{ block_free(((*yyvaluep).blk)); };
+/* Line 1381 of yacc.c  */
+#line 1589 "parser.gen.c"
 	break;
-      case 59: /* "MkDict" */
-
-/* Line 1391 of yacc.c  */
-#line 30 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
+      case 57: /* ElseBody */
+/* Line 1381 of yacc.c  */
+#line 33 "parser.y"
+	{ block_free(((*yyvaluep).blk)); };
+/* Line 1381 of yacc.c  */
+#line 1596 "parser.gen.c"
+	break;
+      case 58: /* ExpD */
+/* Line 1381 of yacc.c  */
+#line 33 "parser.y"
+	{ block_free(((*yyvaluep).blk)); };
+/* Line 1381 of yacc.c  */
+#line 1603 "parser.gen.c"
+	break;
+      case 59: /* Term */
+/* Line 1381 of yacc.c  */
+#line 33 "parser.y"
+	{ block_free(((*yyvaluep).blk)); };
+/* Line 1381 of yacc.c  */
 #line 1610 "parser.gen.c"
 	break;
-      case 60: /* "MkDictPair" */
-
-/* Line 1391 of yacc.c  */
-#line 30 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1619 "parser.gen.c"
+      case 60: /* MkDict */
+/* Line 1381 of yacc.c  */
+#line 33 "parser.y"
+	{ block_free(((*yyvaluep).blk)); };
+/* Line 1381 of yacc.c  */
+#line 1617 "parser.gen.c"
+	break;
+      case 61: /* MkDictPair */
+/* Line 1381 of yacc.c  */
+#line 33 "parser.y"
+	{ block_free(((*yyvaluep).blk)); };
+/* Line 1381 of yacc.c  */
+#line 1624 "parser.gen.c"
 	break;
 
       default:
@@ -1624,20 +1629,6 @@ yydestruct (yymsg, yytype, yyvaluep, yylocationp, answer, errors, locations, lex
 }
 
 
-/* Prevent warnings from -Wmissing-prototypes.  */
-#ifdef YYPARSE_PARAM
-#if defined __STDC__ || defined __cplusplus
-int yyparse (void *YYPARSE_PARAM);
-#else
-int yyparse ();
-#endif
-#else /* ! YYPARSE_PARAM */
-#if defined __STDC__ || defined __cplusplus
-int yyparse (block* answer, int* errors, struct locfile* locations, yyscan_t lexer);
-#else
-int yyparse ();
-#endif
-#endif /* ! YYPARSE_PARAM */
 
 
 /*----------.
@@ -1690,7 +1681,7 @@ YYLTYPE yylloc;
        `yyvs': related to semantic values.
        `yyls': related to locations.
 
-       Refer to the stacks thru separate pointers, to allow yyoverflow
+       Refer to the stacks through separate pointers, to allow yyoverflow
        to reallocate them elsewhere.  */
 
     /* The state stack.  */
@@ -1761,7 +1752,6 @@ YYLTYPE yylloc;
   yylloc.first_line   = yylloc.last_line   = 1;
   yylloc.first_column = yylloc.last_column = 1;
 #endif
-
   goto yysetstate;
 
 /*------------------------------------------------------------.
@@ -1945,54 +1935,48 @@ yyreduce:
   switch (yyn)
     {
         case 2:
-
-/* Line 1806 of yacc.c  */
-#line 174 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 179 "parser.y"
     {
   *answer = (yyvsp[(1) - (1)].blk);
 }
     break;
 
   case 3:
-
-/* Line 1806 of yacc.c  */
-#line 177 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 182 "parser.y"
     {
   *answer = (yyvsp[(1) - (1)].blk);
 }
     break;
 
   case 4:
-
-/* Line 1806 of yacc.c  */
-#line 182 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 187 "parser.y"
     {
   (yyval.blk) = gen_noop();
 }
     break;
 
   case 5:
-
-/* Line 1806 of yacc.c  */
-#line 185 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 190 "parser.y"
     {
   (yyval.blk) = block_join((yyvsp[(1) - (2)].blk), (yyvsp[(2) - (2)].blk));
 }
     break;
 
   case 6:
-
-/* Line 1806 of yacc.c  */
-#line 190 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 195 "parser.y"
     {
   (yyval.blk) = block_bind((yyvsp[(1) - (2)].blk), (yyvsp[(2) - (2)].blk), OP_IS_CALL_PSEUDO);
 }
     break;
 
   case 7:
-
-/* Line 1806 of yacc.c  */
-#line 194 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 199 "parser.y"
     {
   (yyval.blk) = gen_op_simple(DUP);
   block_append(&(yyval.blk), (yyvsp[(1) - (6)].blk));
@@ -2002,18 +1986,16 @@ yyreduce:
     break;
 
   case 8:
-
-/* Line 1806 of yacc.c  */
-#line 201 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 206 "parser.y"
     {
   (yyval.blk) = gen_cond((yyvsp[(2) - (5)].blk), (yyvsp[(4) - (5)].blk), (yyvsp[(5) - (5)].blk));
 }
     break;
 
   case 9:
-
-/* Line 1806 of yacc.c  */
-#line 204 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 209 "parser.y"
     {
   FAIL((yyloc), "Possibly unterminated 'if' statment");
   (yyval.blk) = (yyvsp[(2) - (3)].blk);
@@ -2021,9 +2003,8 @@ yyreduce:
     break;
 
   case 10:
-
-/* Line 1806 of yacc.c  */
-#line 209 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 214 "parser.y"
     {
   block assign = gen_op_simple(DUP);
   block_append(&assign, (yyvsp[(3) - (3)].blk));
@@ -2035,216 +2016,200 @@ yyreduce:
     break;
 
   case 11:
-
-/* Line 1806 of yacc.c  */
-#line 218 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 223 "parser.y"
     {
   (yyval.blk) = gen_or((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
 }
     break;
 
   case 12:
-
-/* Line 1806 of yacc.c  */
-#line 222 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 227 "parser.y"
     {
   (yyval.blk) = gen_and((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
 }
     break;
 
   case 13:
-
-/* Line 1806 of yacc.c  */
-#line 226 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 231 "parser.y"
     {
   (yyval.blk) = gen_definedor((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
 }
     break;
 
   case 14:
-
-/* Line 1806 of yacc.c  */
-#line 230 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 235 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), gen_definedor(gen_noop(), (yyvsp[(3) - (3)].blk)), 0);
 }
     break;
 
   case 15:
-
-/* Line 1806 of yacc.c  */
-#line 234 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 239 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), 0);
 }
     break;
 
   case 16:
-
-/* Line 1806 of yacc.c  */
-#line 238 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 243 "parser.y"
     { 
   (yyval.blk) = block_join((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk)); 
 }
     break;
 
   case 17:
-
-/* Line 1806 of yacc.c  */
-#line 242 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 247 "parser.y"
     { 
   (yyval.blk) = gen_both((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk)); 
 }
     break;
 
   case 18:
-
-/* Line 1806 of yacc.c  */
-#line 246 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 251 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '+');
 }
     break;
 
   case 19:
-
-/* Line 1806 of yacc.c  */
-#line 250 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 255 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '+');
 }
     break;
 
   case 20:
-
-/* Line 1806 of yacc.c  */
-#line 254 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 259 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '-');
 }
     break;
 
   case 21:
-
-/* Line 1806 of yacc.c  */
-#line 258 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 263 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '-');
 }
     break;
 
   case 22:
-
-/* Line 1806 of yacc.c  */
-#line 262 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 267 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '*');
 }
     break;
 
   case 23:
-
-/* Line 1806 of yacc.c  */
-#line 266 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 271 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '*');
 }
     break;
 
   case 24:
-
-/* Line 1806 of yacc.c  */
-#line 270 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 275 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '/');
 }
     break;
 
   case 25:
-
-/* Line 1806 of yacc.c  */
-#line 274 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 279 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '/');
 }
     break;
 
   case 26:
-
-/* Line 1806 of yacc.c  */
-#line 278 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 283 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), EQ);
 }
     break;
 
   case 27:
+/* Line 1787 of yacc.c  */
+#line 287 "parser.y"
+    {
+  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), NEQ);
+}
+    break;
 
-/* Line 1806 of yacc.c  */
-#line 282 "parser.y"
+  case 28:
+/* Line 1787 of yacc.c  */
+#line 291 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '<');
 }
     break;
 
-  case 28:
-
-/* Line 1806 of yacc.c  */
-#line 286 "parser.y"
+  case 29:
+/* Line 1787 of yacc.c  */
+#line 295 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '>');
 }
     break;
 
-  case 29:
-
-/* Line 1806 of yacc.c  */
-#line 290 "parser.y"
+  case 30:
+/* Line 1787 of yacc.c  */
+#line 299 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), LESSEQ);
 }
     break;
 
-  case 30:
-
-/* Line 1806 of yacc.c  */
-#line 294 "parser.y"
+  case 31:
+/* Line 1787 of yacc.c  */
+#line 303 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), GREATEREQ);
 }
     break;
 
-  case 31:
-
-/* Line 1806 of yacc.c  */
-#line 298 "parser.y"
+  case 32:
+/* Line 1787 of yacc.c  */
+#line 307 "parser.y"
     {
   (yyval.blk) = (yyvsp[(1) - (1)].blk);
 }
     break;
 
-  case 32:
-
-/* Line 1806 of yacc.c  */
-#line 302 "parser.y"
+  case 33:
+/* Line 1787 of yacc.c  */
+#line 311 "parser.y"
     { 
   (yyval.blk) = (yyvsp[(1) - (1)].blk); 
 }
     break;
 
-  case 33:
-
-/* Line 1806 of yacc.c  */
-#line 307 "parser.y"
+  case 34:
+/* Line 1787 of yacc.c  */
+#line 316 "parser.y"
     {
   (yyval.blk) = (yyvsp[(2) - (3)].blk);
 }
     break;
 
-  case 34:
-
-/* Line 1806 of yacc.c  */
-#line 312 "parser.y"
+  case 35:
+/* Line 1787 of yacc.c  */
+#line 321 "parser.y"
     {
   block body = block_join((yyvsp[(4) - (5)].blk), gen_op_simple(RET));
   (yyval.blk) = gen_op_block_defn_rec(CLOSURE_CREATE, jv_string_value((yyvsp[(2) - (5)].literal)), body);
@@ -2252,10 +2217,9 @@ yyreduce:
 }
     break;
 
-  case 35:
-
-/* Line 1806 of yacc.c  */
-#line 318 "parser.y"
+  case 36:
+/* Line 1787 of yacc.c  */
+#line 327 "parser.y"
     {
   block body = block_bind(gen_op_block_unbound(CLOSURE_PARAM, jv_string_value((yyvsp[(4) - (8)].literal))), block_join((yyvsp[(7) - (8)].blk), gen_op_simple(RET)), OP_IS_CALL_PSEUDO);
   (yyval.blk) = gen_op_block_defn_rec(CLOSURE_CREATE, jv_string_value((yyvsp[(2) - (8)].literal)), body);
@@ -2264,154 +2228,137 @@ yyreduce:
 }
     break;
 
-  case 36:
-
-/* Line 1806 of yacc.c  */
-#line 326 "parser.y"
+  case 37:
+/* Line 1787 of yacc.c  */
+#line 335 "parser.y"
     {
   (yyval.blk) = gen_op_const(LOADK, jv_string(""));
 }
     break;
 
-  case 37:
-
-/* Line 1806 of yacc.c  */
-#line 329 "parser.y"
+  case 38:
+/* Line 1787 of yacc.c  */
+#line 338 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (2)].blk), gen_op_const(LOADK, (yyvsp[(2) - (2)].literal)), '+');
 }
     break;
 
-  case 38:
-
-/* Line 1806 of yacc.c  */
-#line 332 "parser.y"
+  case 39:
+/* Line 1787 of yacc.c  */
+#line 341 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (4)].blk), gen_format((yyvsp[(3) - (4)].blk)), '+');
 }
     break;
 
-  case 39:
-
-/* Line 1806 of yacc.c  */
-#line 338 "parser.y"
+  case 40:
+/* Line 1787 of yacc.c  */
+#line 347 "parser.y"
     {
   (yyval.blk) = gen_cond((yyvsp[(2) - (5)].blk), (yyvsp[(4) - (5)].blk), (yyvsp[(5) - (5)].blk));
 }
     break;
 
-  case 40:
-
-/* Line 1806 of yacc.c  */
-#line 341 "parser.y"
+  case 41:
+/* Line 1787 of yacc.c  */
+#line 350 "parser.y"
     {
   (yyval.blk) = (yyvsp[(2) - (3)].blk);
 }
     break;
 
-  case 41:
-
-/* Line 1806 of yacc.c  */
-#line 346 "parser.y"
+  case 42:
+/* Line 1787 of yacc.c  */
+#line 355 "parser.y"
     { 
   (yyval.blk) = block_join((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
 }
     break;
 
-  case 42:
-
-/* Line 1806 of yacc.c  */
-#line 350 "parser.y"
+  case 43:
+/* Line 1787 of yacc.c  */
+#line 359 "parser.y"
     {
   (yyval.blk) = (yyvsp[(1) - (1)].blk);
 }
     break;
 
-  case 43:
-
-/* Line 1806 of yacc.c  */
-#line 356 "parser.y"
+  case 44:
+/* Line 1787 of yacc.c  */
+#line 365 "parser.y"
     {
   (yyval.blk) = gen_noop(); 
 }
     break;
 
-  case 44:
-
-/* Line 1806 of yacc.c  */
-#line 359 "parser.y"
+  case 45:
+/* Line 1787 of yacc.c  */
+#line 368 "parser.y"
     {
   (yyval.blk) = gen_index((yyvsp[(1) - (3)].blk), gen_op_const(LOADK, (yyvsp[(3) - (3)].literal))); 
 }
     break;
 
-  case 45:
-
-/* Line 1806 of yacc.c  */
-#line 362 "parser.y"
+  case 46:
+/* Line 1787 of yacc.c  */
+#line 371 "parser.y"
     { 
   (yyval.blk) = gen_index(gen_noop(), gen_op_const(LOADK, (yyvsp[(2) - (2)].literal))); 
 }
     break;
 
-  case 46:
-
-/* Line 1806 of yacc.c  */
-#line 366 "parser.y"
+  case 47:
+/* Line 1787 of yacc.c  */
+#line 375 "parser.y"
     {
   (yyval.blk) = gen_index((yyvsp[(1) - (4)].blk), (yyvsp[(3) - (4)].blk)); 
 }
     break;
 
-  case 47:
-
-/* Line 1806 of yacc.c  */
-#line 369 "parser.y"
+  case 48:
+/* Line 1787 of yacc.c  */
+#line 378 "parser.y"
     {
   (yyval.blk) = block_join((yyvsp[(1) - (3)].blk), gen_op_simple(EACH)); 
 }
     break;
 
-  case 48:
-
-/* Line 1806 of yacc.c  */
-#line 372 "parser.y"
+  case 49:
+/* Line 1787 of yacc.c  */
+#line 381 "parser.y"
     {
   (yyval.blk) = gen_op_const(LOADK, (yyvsp[(1) - (1)].literal)); 
 }
     break;
 
-  case 49:
-
-/* Line 1806 of yacc.c  */
-#line 375 "parser.y"
+  case 50:
+/* Line 1787 of yacc.c  */
+#line 384 "parser.y"
     { 
   (yyval.blk) = (yyvsp[(2) - (3)].blk); 
 }
     break;
 
-  case 50:
-
-/* Line 1806 of yacc.c  */
-#line 378 "parser.y"
+  case 51:
+/* Line 1787 of yacc.c  */
+#line 387 "parser.y"
     { 
   (yyval.blk) = gen_collect((yyvsp[(2) - (3)].blk)); 
 }
     break;
 
-  case 51:
-
-/* Line 1806 of yacc.c  */
-#line 381 "parser.y"
+  case 52:
+/* Line 1787 of yacc.c  */
+#line 390 "parser.y"
     { 
   (yyval.blk) = gen_op_const(LOADK, jv_array()); 
 }
     break;
 
-  case 52:
-
-/* Line 1806 of yacc.c  */
-#line 384 "parser.y"
+  case 53:
+/* Line 1787 of yacc.c  */
+#line 393 "parser.y"
     { 
   (yyval.blk) = gen_subexp(gen_op_const(LOADK, jv_object()));
   block_append(&(yyval.blk), (yyvsp[(2) - (3)].blk));
@@ -2419,30 +2366,27 @@ yyreduce:
 }
     break;
 
-  case 53:
-
-/* Line 1806 of yacc.c  */
-#line 389 "parser.y"
+  case 54:
+/* Line 1787 of yacc.c  */
+#line 398 "parser.y"
     {
   (yyval.blk) = gen_location((yyloc), gen_op_var_unbound(LOADV, jv_string_value((yyvsp[(2) - (2)].literal))));
   jv_free((yyvsp[(2) - (2)].literal));
 }
     break;
 
-  case 54:
-
-/* Line 1806 of yacc.c  */
-#line 393 "parser.y"
+  case 55:
+/* Line 1787 of yacc.c  */
+#line 402 "parser.y"
     {
   (yyval.blk) = gen_location((yyloc), gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, jv_string_value((yyvsp[(1) - (1)].literal)))));
   jv_free((yyvsp[(1) - (1)].literal));
 }
     break;
 
-  case 55:
-
-/* Line 1806 of yacc.c  */
-#line 397 "parser.y"
+  case 56:
+/* Line 1787 of yacc.c  */
+#line 406 "parser.y"
     {
   (yyval.blk) = gen_op_call(CALL_1_1, 
                    block_join(gen_op_block_unbound(CLOSURE_REF, jv_string_value((yyvsp[(1) - (4)].literal))),
@@ -2455,112 +2399,98 @@ yyreduce:
 }
     break;
 
-  case 56:
-
-/* Line 1806 of yacc.c  */
-#line 407 "parser.y"
-    { (yyval.blk) = gen_noop(); }
-    break;
-
   case 57:
-
-/* Line 1806 of yacc.c  */
-#line 408 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 416 "parser.y"
     { (yyval.blk) = gen_noop(); }
     break;
 
   case 58:
-
-/* Line 1806 of yacc.c  */
-#line 409 "parser.y"
-    { (yyval.blk) = (yyvsp[(1) - (4)].blk); }
-    break;
-
-  case 59:
-
-/* Line 1806 of yacc.c  */
-#line 410 "parser.y"
+/* Line 1787 of yacc.c  */
+#line 417 "parser.y"
     { (yyval.blk) = gen_noop(); }
     break;
 
-  case 60:
+  case 59:
+/* Line 1787 of yacc.c  */
+#line 418 "parser.y"
+    { (yyval.blk) = (yyvsp[(1) - (4)].blk); }
+    break;
 
-/* Line 1806 of yacc.c  */
-#line 413 "parser.y"
+  case 60:
+/* Line 1787 of yacc.c  */
+#line 419 "parser.y"
+    { (yyval.blk) = gen_noop(); }
+    break;
+
+  case 61:
+/* Line 1787 of yacc.c  */
+#line 422 "parser.y"
     { 
   (yyval.blk)=gen_noop(); 
 }
     break;
 
-  case 61:
-
-/* Line 1806 of yacc.c  */
-#line 416 "parser.y"
+  case 62:
+/* Line 1787 of yacc.c  */
+#line 425 "parser.y"
     { (yyval.blk) = (yyvsp[(1) - (1)].blk); }
     break;
 
-  case 62:
-
-/* Line 1806 of yacc.c  */
-#line 417 "parser.y"
+  case 63:
+/* Line 1787 of yacc.c  */
+#line 426 "parser.y"
     { (yyval.blk)=block_join((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk)); }
     break;
 
-  case 63:
-
-/* Line 1806 of yacc.c  */
-#line 418 "parser.y"
+  case 64:
+/* Line 1787 of yacc.c  */
+#line 427 "parser.y"
     { (yyval.blk) = (yyvsp[(3) - (3)].blk); }
     break;
 
-  case 64:
-
-/* Line 1806 of yacc.c  */
-#line 421 "parser.y"
+  case 65:
+/* Line 1787 of yacc.c  */
+#line 430 "parser.y"
     { 
   (yyval.blk) = gen_dictpair(gen_op_const(LOADK, (yyvsp[(1) - (3)].literal)), (yyvsp[(3) - (3)].blk));
  }
     break;
 
-  case 65:
-
-/* Line 1806 of yacc.c  */
-#line 424 "parser.y"
+  case 66:
+/* Line 1787 of yacc.c  */
+#line 433 "parser.y"
     {
   (yyval.blk) = gen_dictpair((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
   }
     break;
 
-  case 66:
-
-/* Line 1806 of yacc.c  */
-#line 427 "parser.y"
+  case 67:
+/* Line 1787 of yacc.c  */
+#line 436 "parser.y"
     {
   (yyval.blk) = gen_dictpair(gen_op_const(LOADK, jv_copy((yyvsp[(1) - (1)].literal))),
                     gen_index(gen_noop(), gen_op_const(LOADK, (yyvsp[(1) - (1)].literal))));
   }
     break;
 
-  case 67:
-
-/* Line 1806 of yacc.c  */
-#line 431 "parser.y"
+  case 68:
+/* Line 1787 of yacc.c  */
+#line 440 "parser.y"
     {
   (yyval.blk) = gen_dictpair((yyvsp[(2) - (5)].blk), (yyvsp[(5) - (5)].blk));
   }
     break;
 
-  case 68:
-
-/* Line 1806 of yacc.c  */
-#line 434 "parser.y"
+  case 69:
+/* Line 1787 of yacc.c  */
+#line 443 "parser.y"
     { (yyval.blk) = (yyvsp[(5) - (5)].blk); }
     break;
 
 
-
-/* Line 1806 of yacc.c  */
-#line 2564 "parser.gen.c"
+/* Line 1787 of yacc.c  */
+#line 2494 "parser.gen.c"
       default: break;
     }
   /* User semantic actions sometimes alter yychar, and that requires
@@ -2754,7 +2684,7 @@ yyabortlab:
   yyresult = 1;
   goto yyreturn;
 
-#if !defined(yyoverflow) || YYERROR_VERBOSE
+#if !defined yyoverflow || YYERROR_VERBOSE
 /*-------------------------------------------------.
 | yyexhaustedlab -- memory exhaustion comes here.  |
 `-------------------------------------------------*/
@@ -2796,9 +2726,8 @@ yyreturn:
 }
 
 
-
-/* Line 2067 of yacc.c  */
-#line 435 "parser.y"
+/* Line 2048 of yacc.c  */
+#line 444 "parser.y"
 
 
 int jq_parse(struct locfile* locations, block* answer) {
@@ -2827,4 +2756,3 @@ int jq_parse_library(struct locfile* locations, block* answer) {
   }
   return 0;
 }
-
diff --git a/parser.gen.h b/parser.gen.h
index 49bf4cc7..d29c12a0 100644
--- a/parser.gen.h
+++ b/parser.gen.h
@@ -1,8 +1,8 @@
-/* A Bison parser, made by GNU Bison 2.5.  */
+/* A Bison parser, made by GNU Bison 2.6.2.  */
 
 /* Bison interface for Yacc-like parsers in C
    
-      Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
+      Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc.
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -30,10 +30,18 @@
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 
+#ifndef YY_PARSER_GEN_H
+# define YY_PARSER_GEN_H
+/* Enabling traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int yydebug;
+#endif
 /* "%code requires" blocks.  */
-
-/* Line 2068 of yacc.c  */
-#line 6 "parser.y"
+/* Line 2049 of yacc.c  */
+#line 9 "parser.y"
 
 #include "locfile.h"
 #define YYLTYPE location
@@ -49,9 +57,8 @@
   } while (0)
  
 
-
-/* Line 2068 of yacc.c  */
-#line 55 "parser.gen.h"
+/* Line 2049 of yacc.c  */
+#line 62 "parser.gen.h"
 
 /* Tokens.  */
 #ifndef YYTOKENTYPE
@@ -63,56 +70,52 @@
      IDENT = 259,
      LITERAL = 260,
      EQ = 261,
-     DEFINEDOR = 262,
-     AS = 263,
-     DEF = 264,
-     IF = 265,
-     THEN = 266,
-     ELSE = 267,
-     ELSE_IF = 268,
-     END = 269,
-     AND = 270,
-     OR = 271,
-     SETPIPE = 272,
-     SETPLUS = 273,
-     SETMINUS = 274,
-     SETMULT = 275,
-     SETDIV = 276,
-     SETDEFINEDOR = 277,
-     LESSEQ = 278,
-     GREATEREQ = 279,
-     QQSTRING_START = 280,
-     QQSTRING_TEXT = 281,
-     QQSTRING_INTERP_START = 282,
-     QQSTRING_INTERP_END = 283,
-     QQSTRING_END = 284
+     NEQ = 262,
+     DEFINEDOR = 263,
+     AS = 264,
+     DEF = 265,
+     IF = 266,
+     THEN = 267,
+     ELSE = 268,
+     ELSE_IF = 269,
+     END = 270,
+     AND = 271,
+     OR = 272,
+     SETPIPE = 273,
+     SETPLUS = 274,
+     SETMINUS = 275,
+     SETMULT = 276,
+     SETDIV = 277,
+     SETDEFINEDOR = 278,
+     LESSEQ = 279,
+     GREATEREQ = 280,
+     QQSTRING_START = 281,
+     QQSTRING_TEXT = 282,
+     QQSTRING_INTERP_START = 283,
+     QQSTRING_INTERP_END = 284,
+     QQSTRING_END = 285
    };
 #endif
 
 
-
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 typedef union YYSTYPE
 {
-
-/* Line 2068 of yacc.c  */
-#line 24 "parser.y"
+/* Line 2049 of yacc.c  */
+#line 27 "parser.y"
 
   jv literal;
   block blk;
 
 
-
-/* Line 2068 of yacc.c  */
-#line 108 "parser.gen.h"
+/* Line 2049 of yacc.c  */
+#line 113 "parser.gen.h"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 # define YYSTYPE_IS_DECLARED 1
 #endif
 
-
-
 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
 typedef struct YYLTYPE
 {
@@ -127,4 +130,18 @@ typedef struct YYLTYPE
 #endif
 
 
+#ifdef YYPARSE_PARAM
+#if defined __STDC__ || defined __cplusplus
+int yyparse (void *YYPARSE_PARAM);
+#else
+int yyparse ();
+#endif
+#else /* ! YYPARSE_PARAM */
+#if defined __STDC__ || defined __cplusplus
+int yyparse (block* answer, int* errors, struct locfile* locations, yyscan_t lexer);
+#else
+int yyparse ();
+#endif
+#endif /* ! YYPARSE_PARAM */
 
+#endif /* !YY_PARSER_GEN_H  */
diff --git a/parser.gen.info b/parser.gen.info
index 6c84d979..d2fb1fdf 100644
--- a/parser.gen.info
+++ b/parser.gen.info
@@ -1,16 +1,16 @@
-Terminals unused in grammar
+Terminaux inutilisés dans la grammaire
 
    INVALID_CHARACTER
 
 
-Grammar
+Grammaire
 
     0 $accept: TopLevel $end
 
     1 TopLevel: Exp
     2         | FuncDefs
 
-    3 FuncDefs: /* empty */
+    3 FuncDefs: /* vide */
     4         | FuncDef FuncDefs
 
     5 Exp: FuncDef Exp
@@ -34,320 +34,322 @@ Grammar
    23    | Exp '/' Exp
    24    | Exp "/=" Exp
    25    | Exp "==" Exp
-   26    | Exp '<' Exp
-   27    | Exp '>' Exp
-   28    | Exp "<=" Exp
-   29    | Exp ">=" Exp
-   30    | String
-   31    | Term
+   26    | Exp "!=" Exp
+   27    | Exp '<' Exp
+   28    | Exp '>' Exp
+   29    | Exp "<=" Exp
+   30    | Exp ">=" Exp
+   31    | String
+   32    | Term
 
-   32 String: QQSTRING_START QQString QQSTRING_END
+   33 String: QQSTRING_START QQString QQSTRING_END
 
-   33 FuncDef: "def" IDENT ':' Exp ';'
-   34        | "def" IDENT '(' IDENT ')' ':' Exp ';'
+   34 FuncDef: "def" IDENT ':' Exp ';'
+   35        | "def" IDENT '(' IDENT ')' ':' Exp ';'
 
-   35 QQString: /* empty */
-   36         | QQString QQSTRING_TEXT
-   37         | QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END
+   36 QQString: /* vide */
+   37         | QQString QQSTRING_TEXT
+   38         | QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END
 
-   38 ElseBody: "elif" Exp "then" Exp ElseBody
-   39         | "else" Exp "end"
+   39 ElseBody: "elif" Exp "then" Exp ElseBody
+   40         | "else" Exp "end"
 
-   40 ExpD: ExpD '|' ExpD
-   41     | Term
+   41 ExpD: ExpD '|' ExpD
+   42     | Term
 
-   42 Term: '.'
-   43     | Term '.' IDENT
-   44     | '.' IDENT
-   45     | Term '[' Exp ']'
-   46     | Term '[' ']'
-   47     | LITERAL
-   48     | '(' Exp ')'
-   49     | '[' Exp ']'
-   50     | '[' ']'
-   51     | '{' MkDict '}'
-   52     | '$' IDENT
-   53     | IDENT
-   54     | IDENT '(' Exp ')'
-   55     | '(' error ')'
-   56     | '[' error ']'
-   57     | Term '[' error ']'
-   58     | '{' error '}'
+   43 Term: '.'
+   44     | Term '.' IDENT
+   45     | '.' IDENT
+   46     | Term '[' Exp ']'
+   47     | Term '[' ']'
+   48     | LITERAL
+   49     | '(' Exp ')'
+   50     | '[' Exp ']'
+   51     | '[' ']'
+   52     | '{' MkDict '}'
+   53     | '$' IDENT
+   54     | IDENT
+   55     | IDENT '(' Exp ')'
+   56     | '(' error ')'
+   57     | '[' error ']'
+   58     | Term '[' error ']'
+   59     | '{' error '}'
 
-   59 MkDict: /* empty */
-   60       | MkDictPair
-   61       | MkDictPair ',' MkDict
-   62       | error ',' MkDict
+   60 MkDict: /* vide */
+   61       | MkDictPair
+   62       | MkDictPair ',' MkDict
+   63       | error ',' MkDict
 
-   63 MkDictPair: IDENT ':' ExpD
-   64           | String ':' ExpD
-   65           | IDENT
-   66           | '(' Exp ')' ':' ExpD
-   67           | '(' error ')' ':' ExpD
+   64 MkDictPair: IDENT ':' ExpD
+   65           | String ':' ExpD
+   66           | IDENT
+   67           | '(' Exp ')' ':' ExpD
+   68           | '(' error ')' ':' ExpD
 
 
-Terminals, with rules where they appear
+Terminaux, suivis des règles où ils apparaissent
 
 $end (0) 0
-'$' (36) 6 52
-'(' (40) 34 48 54 55 66 67
-')' (41) 34 48 54 55 66 67
+'$' (36) 6 53
+'(' (40) 35 49 55 56 67 68
+')' (41) 35 49 55 56 67 68
 '*' (42) 21
 '+' (43) 17
-',' (44) 16 61 62
+',' (44) 16 62 63
 '-' (45) 19
-'.' (46) 42 43 44
+'.' (46) 43 44 45
 '/' (47) 23
-':' (58) 33 34 63 64 66 67
-';' (59) 33 34
-'<' (60) 26
+':' (58) 34 35 64 65 67 68
+';' (59) 34 35
+'<' (60) 27
 '=' (61) 9
-'>' (62) 27
-'[' (91) 45 46 49 50 56 57
-']' (93) 45 46 49 50 56 57
-'{' (123) 51 58
-'|' (124) 6 15 40
-'}' (125) 51 58
-error (256) 8 55 56 57 58 62 67
+'>' (62) 28
+'[' (91) 46 47 50 51 57 58
+']' (93) 46 47 50 51 57 58
+'{' (123) 52 59
+'|' (124) 6 15 41
+'}' (125) 52 59
+error (256) 8 56 57 58 59 63 68
 INVALID_CHARACTER (258)
-IDENT (259) 6 33 34 43 44 52 53 54 63 65
-LITERAL (260) 47
+IDENT (259) 6 34 35 44 45 53 54 55 64 66
+LITERAL (260) 48
 "==" (261) 25
-"//" (262) 12
-"as" (263) 6
-"def" (264) 33 34
-"if" (265) 7 8
-"then" (266) 7 38
-"else" (267) 39
-"elif" (268) 38
-"end" (269) 39
-"and" (270) 11
-"or" (271) 10
-"|=" (272) 14
-"+=" (273) 18
-"-=" (274) 20
-"*=" (275) 22
-"/=" (276) 24
-"//=" (277) 13
-"<=" (278) 28
-">=" (279) 29
-QQSTRING_START (280) 32
-QQSTRING_TEXT (281) 36
-QQSTRING_INTERP_START (282) 37
-QQSTRING_INTERP_END (283) 37
-QQSTRING_END (284) 32
+"!=" (262) 26
+"//" (263) 12
+"as" (264) 6
+"def" (265) 34 35
+"if" (266) 7 8
+"then" (267) 7 39
+"else" (268) 40
+"elif" (269) 39
+"end" (270) 40
+"and" (271) 11
+"or" (272) 10
+"|=" (273) 14
+"+=" (274) 18
+"-=" (275) 20
+"*=" (276) 22
+"/=" (277) 24
+"//=" (278) 13
+"<=" (279) 29
+">=" (280) 30
+QQSTRING_START (281) 33
+QQSTRING_TEXT (282) 37
+QQSTRING_INTERP_START (283) 38
+QQSTRING_INTERP_END (284) 38
+QQSTRING_END (285) 33
 
 
-Nonterminals, with rules where they appear
+Non-terminaux, suivis des règles où ils apparaissent
 
-$accept (49)
-    on left: 0
-TopLevel (50)
-    on left: 1 2, on right: 0
-FuncDefs (51)
-    on left: 3 4, on right: 2 4
-Exp (52)
-    on left: 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
-    25 26 27 28 29 30 31, on right: 1 5 6 7 8 9 10 11 12 13 14 15 16
-    17 18 19 20 21 22 23 24 25 26 27 28 29 33 34 37 38 39 45 48 49
-    54 66
-String (53)
-    on left: 32, on right: 30 64
-FuncDef (54)
-    on left: 33 34, on right: 4 5
-QQString (55)
-    on left: 35 36 37, on right: 32 36 37
-ElseBody (56)
-    on left: 38 39, on right: 7 38
-ExpD (57)
-    on left: 40 41, on right: 40 63 64 66 67
-Term (58)
-    on left: 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58, on right:
-    6 31 41 43 45 46 57
-MkDict (59)
-    on left: 59 60 61 62, on right: 51 61 62
-MkDictPair (60)
-    on left: 63 64 65 66 67, on right: 60 61
+$accept (50)
+    à gauche: 0
+TopLevel (51)
+    à gauche: 1 2, à droite: 0
+FuncDefs (52)
+    à gauche: 3 4, à droite: 2 4
+Exp (53)
+    à gauche: 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
+    24 25 26 27 28 29 30 31 32, à droite: 1 5 6 7 8 9 10 11 12 13
+    14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 34 35 38 39
+    40 46 49 50 55 67
+String (54)
+    à gauche: 33, à droite: 31 65
+FuncDef (55)
+    à gauche: 34 35, à droite: 4 5
+QQString (56)
+    à gauche: 36 37 38, à droite: 33 37 38
+ElseBody (57)
+    à gauche: 39 40, à droite: 7 39
+ExpD (58)
+    à gauche: 41 42, à droite: 41 64 65 67 68
+Term (59)
+    à gauche: 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59,
+    à droite: 6 32 42 44 46 47 58
+MkDict (60)
+    à gauche: 60 61 62 63, à droite: 52 62 63
+MkDictPair (61)
+    à gauche: 64 65 66 67 68, à droite: 61 62
 
 
-state 0
+état 0
 
     0 $accept: . TopLevel $end
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    $default  reduce using rule 3 (FuncDefs)
+    $défaut  réduction par utilisation de la règle 3 (FuncDefs)
 
-    TopLevel  go to state 11
-    FuncDefs  go to state 12
-    Exp       go to state 13
-    String    go to state 14
-    FuncDef   go to state 15
-    Term      go to state 16
+    TopLevel  aller à l'état 11
+    FuncDefs  aller à l'état 12
+    Exp       aller à l'état 13
+    String    aller à l'état 14
+    FuncDef   aller à l'état 15
+    Term      aller à l'état 16
 
 
-state 1
+état 1
 
-   53 Term: IDENT .
-   54     | IDENT . '(' Exp ')'
+   54 Term: IDENT .
+   55     | IDENT . '(' Exp ')'
 
-    '('  shift, and go to state 17
+    '('  décalage et aller à l'état 17
 
-    $default  reduce using rule 53 (Term)
+    $défaut  réduction par utilisation de la règle 54 (Term)
 
 
-state 2
+état 2
 
-   47 Term: LITERAL .
+   48 Term: LITERAL .
 
-    $default  reduce using rule 47 (Term)
+    $défaut  réduction par utilisation de la règle 48 (Term)
 
 
-state 3
+état 3
 
-   33 FuncDef: "def" . IDENT ':' Exp ';'
-   34        | "def" . IDENT '(' IDENT ')' ':' Exp ';'
+   34 FuncDef: "def" . IDENT ':' Exp ';'
+   35        | "def" . IDENT '(' IDENT ')' ':' Exp ';'
 
-    IDENT  shift, and go to state 18
+    IDENT  décalage et aller à l'état 18
 
 
-state 4
+état 4
 
     7 Exp: "if" . Exp "then" Exp ElseBody
     8    | "if" . Exp error
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 19
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 19
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 5
+état 5
 
-   32 String: QQSTRING_START . QQString QQSTRING_END
+   33 String: QQSTRING_START . QQString QQSTRING_END
 
-    $default  reduce using rule 35 (QQString)
+    $défaut  réduction par utilisation de la règle 36 (QQString)
 
-    QQString  go to state 21
+    QQString  aller à l'état 21
 
 
-state 6
+état 6
 
-   52 Term: '$' . IDENT
+   53 Term: '$' . IDENT
 
-    IDENT  shift, and go to state 22
+    IDENT  décalage et aller à l'état 22
 
 
-state 7
+état 7
 
-   48 Term: '(' . Exp ')'
-   55     | '(' . error ')'
+   49 Term: '(' . Exp ')'
+   56     | '(' . error ')'
 
-    error           shift, and go to state 23
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    error           décalage et aller à l'état 23
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 24
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 24
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 8
+état 8
 
-   42 Term: '.' .
-   44     | '.' . IDENT
+   43 Term: '.' .
+   45     | '.' . IDENT
 
-    IDENT  shift, and go to state 25
+    IDENT  décalage et aller à l'état 25
 
-    $default  reduce using rule 42 (Term)
+    $défaut  réduction par utilisation de la règle 43 (Term)
 
 
-state 9
+état 9
 
-   49 Term: '[' . Exp ']'
-   50     | '[' . ']'
-   56     | '[' . error ']'
+   50 Term: '[' . Exp ']'
+   51     | '[' . ']'
+   57     | '[' . error ']'
 
-    error           shift, and go to state 26
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    ']'             shift, and go to state 27
-    '{'             shift, and go to state 10
+    error           décalage et aller à l'état 26
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    ']'             décalage et aller à l'état 27
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 28
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 28
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 10
+état 10
 
-   51 Term: '{' . MkDict '}'
-   58     | '{' . error '}'
+   52 Term: '{' . MkDict '}'
+   59     | '{' . error '}'
 
-    error           shift, and go to state 29
-    IDENT           shift, and go to state 30
-    QQSTRING_START  shift, and go to state 5
-    '('             shift, and go to state 31
+    error           décalage et aller à l'état 29
+    IDENT           décalage et aller à l'état 30
+    QQSTRING_START  décalage et aller à l'état 5
+    '('             décalage et aller à l'état 31
 
-    '}'  reduce using rule 59 (MkDict)
+    '}'  réduction par utilisation de la règle 60 (MkDict)
 
-    String      go to state 32
-    MkDict      go to state 33
-    MkDictPair  go to state 34
+    String      aller à l'état 32
+    MkDict      aller à l'état 33
+    MkDictPair  aller à l'état 34
 
 
-state 11
+état 11
 
     0 $accept: TopLevel . $end
 
-    $end  shift, and go to state 35
+    $end  décalage et aller à l'état 35
 
 
-state 12
+état 12
 
     2 TopLevel: FuncDefs .
 
-    $default  reduce using rule 2 (TopLevel)
+    $défaut  réduction par utilisation de la règle 2 (TopLevel)
 
 
-state 13
+état 13
 
     1 TopLevel: Exp .
     9 Exp: Exp . '=' Exp
@@ -367,115 +369,117 @@ state 13
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    "=="   shift, and go to state 36
-    "//"   shift, and go to state 37
-    "and"  shift, and go to state 38
-    "or"   shift, and go to state 39
-    "|="   shift, and go to state 40
-    "+="   shift, and go to state 41
-    "-="   shift, and go to state 42
-    "*="   shift, and go to state 43
-    "/="   shift, and go to state 44
-    "//="  shift, and go to state 45
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    '|'    shift, and go to state 48
-    ','    shift, and go to state 49
-    '='    shift, and go to state 50
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "//"   décalage et aller à l'état 38
+    "and"  décalage et aller à l'état 39
+    "or"   décalage et aller à l'état 40
+    "|="   décalage et aller à l'état 41
+    "+="   décalage et aller à l'état 42
+    "-="   décalage et aller à l'état 43
+    "*="   décalage et aller à l'état 44
+    "/="   décalage et aller à l'état 45
+    "//="  décalage et aller à l'état 46
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    '|'    décalage et aller à l'état 49
+    ','    décalage et aller à l'état 50
+    '='    décalage et aller à l'état 51
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
 
-    $default  reduce using rule 1 (TopLevel)
+    $défaut  réduction par utilisation de la règle 1 (TopLevel)
 
 
-state 14
+état 14
 
-   30 Exp: String .
+   31 Exp: String .
 
-    $default  reduce using rule 30 (Exp)
+    $défaut  réduction par utilisation de la règle 31 (Exp)
 
 
-state 15
+état 15
 
     4 FuncDefs: FuncDef . FuncDefs
     5 Exp: FuncDef . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    $default  reduce using rule 3 (FuncDefs)
+    $défaut  réduction par utilisation de la règle 3 (FuncDefs)
 
-    FuncDefs  go to state 57
-    Exp       go to state 58
-    String    go to state 14
-    FuncDef   go to state 15
-    Term      go to state 16
+    FuncDefs  aller à l'état 58
+    Exp       aller à l'état 59
+    String    aller à l'état 14
+    FuncDef   aller à l'état 15
+    Term      aller à l'état 16
 
 
-state 16
+état 16
 
     6 Exp: Term . "as" '$' IDENT '|' Exp
-   31    | Term .
-   43 Term: Term . '.' IDENT
-   45     | Term . '[' Exp ']'
-   46     | Term . '[' ']'
-   57     | Term . '[' error ']'
+   32    | Term .
+   44 Term: Term . '.' IDENT
+   46     | Term . '[' Exp ']'
+   47     | Term . '[' ']'
+   58     | Term . '[' error ']'
 
-    "as"  shift, and go to state 59
-    '.'   shift, and go to state 60
-    '['   shift, and go to state 61
+    "as"  décalage et aller à l'état 60
+    '.'   décalage et aller à l'état 61
+    '['   décalage et aller à l'état 62
 
-    $default  reduce using rule 31 (Exp)
+    $défaut  réduction par utilisation de la règle 32 (Exp)
 
 
-state 17
+état 17
 
-   54 Term: IDENT '(' . Exp ')'
+   55 Term: IDENT '(' . Exp ')'
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 62
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 63
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 18
+état 18
 
-   33 FuncDef: "def" IDENT . ':' Exp ';'
-   34        | "def" IDENT . '(' IDENT ')' ':' Exp ';'
+   34 FuncDef: "def" IDENT . ':' Exp ';'
+   35        | "def" IDENT . '(' IDENT ')' ':' Exp ';'
 
-    ':'  shift, and go to state 63
-    '('  shift, and go to state 64
+    ':'  décalage et aller à l'état 64
+    '('  décalage et aller à l'état 65
 
 
-state 19
+état 19
 
     7 Exp: "if" Exp . "then" Exp ElseBody
     8    | "if" Exp . error
@@ -496,83 +500,85 @@ state 19
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    error   shift, and go to state 65
-    "=="    shift, and go to state 36
-    "//"    shift, and go to state 37
-    "then"  shift, and go to state 66
-    "and"   shift, and go to state 38
-    "or"    shift, and go to state 39
-    "|="    shift, and go to state 40
-    "+="    shift, and go to state 41
-    "-="    shift, and go to state 42
-    "*="    shift, and go to state 43
-    "/="    shift, and go to state 44
-    "//="   shift, and go to state 45
-    "<="    shift, and go to state 46
-    ">="    shift, and go to state 47
-    '|'     shift, and go to state 48
-    ','     shift, and go to state 49
-    '='     shift, and go to state 50
-    '<'     shift, and go to state 51
-    '>'     shift, and go to state 52
-    '+'     shift, and go to state 53
-    '-'     shift, and go to state 54
-    '*'     shift, and go to state 55
-    '/'     shift, and go to state 56
+    error   décalage et aller à l'état 66
+    "=="    décalage et aller à l'état 36
+    "!="    décalage et aller à l'état 37
+    "//"    décalage et aller à l'état 38
+    "then"  décalage et aller à l'état 67
+    "and"   décalage et aller à l'état 39
+    "or"    décalage et aller à l'état 40
+    "|="    décalage et aller à l'état 41
+    "+="    décalage et aller à l'état 42
+    "-="    décalage et aller à l'état 43
+    "*="    décalage et aller à l'état 44
+    "/="    décalage et aller à l'état 45
+    "//="   décalage et aller à l'état 46
+    "<="    décalage et aller à l'état 47
+    ">="    décalage et aller à l'état 48
+    '|'     décalage et aller à l'état 49
+    ','     décalage et aller à l'état 50
+    '='     décalage et aller à l'état 51
+    '<'     décalage et aller à l'état 52
+    '>'     décalage et aller à l'état 53
+    '+'     décalage et aller à l'état 54
+    '-'     décalage et aller à l'état 55
+    '*'     décalage et aller à l'état 56
+    '/'     décalage et aller à l'état 57
 
 
-state 20
+état 20
 
     5 Exp: FuncDef . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 58
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 59
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 21
+état 21
 
-   32 String: QQSTRING_START QQString . QQSTRING_END
-   36 QQString: QQString . QQSTRING_TEXT
-   37         | QQString . QQSTRING_INTERP_START Exp QQSTRING_INTERP_END
+   33 String: QQSTRING_START QQString . QQSTRING_END
+   37 QQString: QQString . QQSTRING_TEXT
+   38         | QQString . QQSTRING_INTERP_START Exp QQSTRING_INTERP_END
 
-    QQSTRING_TEXT          shift, and go to state 67
-    QQSTRING_INTERP_START  shift, and go to state 68
-    QQSTRING_END           shift, and go to state 69
+    QQSTRING_TEXT          décalage et aller à l'état 68
+    QQSTRING_INTERP_START  décalage et aller à l'état 69
+    QQSTRING_END           décalage et aller à l'état 70
 
 
-state 22
+état 22
 
-   52 Term: '$' IDENT .
+   53 Term: '$' IDENT .
 
-    $default  reduce using rule 52 (Term)
+    $défaut  réduction par utilisation de la règle 53 (Term)
 
 
-state 23
+état 23
 
-   55 Term: '(' error . ')'
+   56 Term: '(' error . ')'
 
-    ')'  shift, and go to state 70
+    ')'  décalage et aller à l'état 71
 
 
-state 24
+état 24
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -591,58 +597,60 @@ state 24
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
-   48 Term: '(' Exp . ')'
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
+   49 Term: '(' Exp . ')'
 
-    "=="   shift, and go to state 36
-    "//"   shift, and go to state 37
-    "and"  shift, and go to state 38
-    "or"   shift, and go to state 39
-    "|="   shift, and go to state 40
-    "+="   shift, and go to state 41
-    "-="   shift, and go to state 42
-    "*="   shift, and go to state 43
-    "/="   shift, and go to state 44
-    "//="  shift, and go to state 45
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    '|'    shift, and go to state 48
-    ','    shift, and go to state 49
-    '='    shift, and go to state 50
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
-    ')'    shift, and go to state 71
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "//"   décalage et aller à l'état 38
+    "and"  décalage et aller à l'état 39
+    "or"   décalage et aller à l'état 40
+    "|="   décalage et aller à l'état 41
+    "+="   décalage et aller à l'état 42
+    "-="   décalage et aller à l'état 43
+    "*="   décalage et aller à l'état 44
+    "/="   décalage et aller à l'état 45
+    "//="  décalage et aller à l'état 46
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    '|'    décalage et aller à l'état 49
+    ','    décalage et aller à l'état 50
+    '='    décalage et aller à l'état 51
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
+    ')'    décalage et aller à l'état 72
 
 
-state 25
+état 25
 
-   44 Term: '.' IDENT .
+   45 Term: '.' IDENT .
 
-    $default  reduce using rule 44 (Term)
+    $défaut  réduction par utilisation de la règle 45 (Term)
 
 
-state 26
+état 26
 
-   56 Term: '[' error . ']'
+   57 Term: '[' error . ']'
 
-    ']'  shift, and go to state 72
+    ']'  décalage et aller à l'état 73
 
 
-state 27
+état 27
 
-   50 Term: '[' ']' .
+   51 Term: '[' ']' .
 
-    $default  reduce using rule 50 (Term)
+    $défaut  réduction par utilisation de la règle 51 (Term)
 
 
-state 28
+état 28
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -661,558 +669,581 @@ state 28
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
-   49 Term: '[' Exp . ']'
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
+   50 Term: '[' Exp . ']'
 
-    "=="   shift, and go to state 36
-    "//"   shift, and go to state 37
-    "and"  shift, and go to state 38
-    "or"   shift, and go to state 39
-    "|="   shift, and go to state 40
-    "+="   shift, and go to state 41
-    "-="   shift, and go to state 42
-    "*="   shift, and go to state 43
-    "/="   shift, and go to state 44
-    "//="  shift, and go to state 45
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    '|'    shift, and go to state 48
-    ','    shift, and go to state 49
-    '='    shift, and go to state 50
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
-    ']'    shift, and go to state 73
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "//"   décalage et aller à l'état 38
+    "and"  décalage et aller à l'état 39
+    "or"   décalage et aller à l'état 40
+    "|="   décalage et aller à l'état 41
+    "+="   décalage et aller à l'état 42
+    "-="   décalage et aller à l'état 43
+    "*="   décalage et aller à l'état 44
+    "/="   décalage et aller à l'état 45
+    "//="  décalage et aller à l'état 46
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    '|'    décalage et aller à l'état 49
+    ','    décalage et aller à l'état 50
+    '='    décalage et aller à l'état 51
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
+    ']'    décalage et aller à l'état 74
 
 
-state 29
+état 29
 
-   58 Term: '{' error . '}'
-   62 MkDict: error . ',' MkDict
+   59 Term: '{' error . '}'
+   63 MkDict: error . ',' MkDict
 
-    ','  shift, and go to state 74
-    '}'  shift, and go to state 75
+    ','  décalage et aller à l'état 75
+    '}'  décalage et aller à l'état 76
 
 
-state 30
+état 30
 
-   63 MkDictPair: IDENT . ':' ExpD
-   65           | IDENT .
+   64 MkDictPair: IDENT . ':' ExpD
+   66           | IDENT .
 
-    ':'  shift, and go to state 76
+    ':'  décalage et aller à l'état 77
 
-    $default  reduce using rule 65 (MkDictPair)
+    $défaut  réduction par utilisation de la règle 66 (MkDictPair)
 
 
-state 31
+état 31
 
-   66 MkDictPair: '(' . Exp ')' ':' ExpD
-   67           | '(' . error ')' ':' ExpD
+   67 MkDictPair: '(' . Exp ')' ':' ExpD
+   68           | '(' . error ')' ':' ExpD
 
-    error           shift, and go to state 77
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    error           décalage et aller à l'état 78
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 78
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 79
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 32
+état 32
 
-   64 MkDictPair: String . ':' ExpD
+   65 MkDictPair: String . ':' ExpD
 
-    ':'  shift, and go to state 79
+    ':'  décalage et aller à l'état 80
 
 
-state 33
+état 33
 
-   51 Term: '{' MkDict . '}'
+   52 Term: '{' MkDict . '}'
 
-    '}'  shift, and go to state 80
+    '}'  décalage et aller à l'état 81
 
 
-state 34
+état 34
 
-   60 MkDict: MkDictPair .
-   61       | MkDictPair . ',' MkDict
+   61 MkDict: MkDictPair .
+   62       | MkDictPair . ',' MkDict
 
-    ','  shift, and go to state 81
+    ','  décalage et aller à l'état 82
 
-    $default  reduce using rule 60 (MkDict)
+    $défaut  réduction par utilisation de la règle 61 (MkDict)
 
 
-state 35
+état 35
 
     0 $accept: TopLevel $end .
 
-    $default  accept
+    $défaut  accepter
 
 
-state 36
+état 36
 
    25 Exp: Exp "==" . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 82
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 83
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 37
+état 37
+
+   26 Exp: Exp "!=" . Exp
+
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
+
+    Exp      aller à l'état 84
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
+
+
+état 38
 
    12 Exp: Exp "//" . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 83
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 85
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 38
+état 39
 
    11 Exp: Exp "and" . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 84
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 86
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 39
+état 40
 
    10 Exp: Exp "or" . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 85
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 87
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 40
+état 41
 
    14 Exp: Exp "|=" . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 86
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 88
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 41
+état 42
 
    18 Exp: Exp "+=" . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 87
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 89
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 42
+état 43
 
    20 Exp: Exp "-=" . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 88
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 90
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 43
+état 44
 
    22 Exp: Exp "*=" . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 89
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 91
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 44
+état 45
 
    24 Exp: Exp "/=" . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 90
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 92
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 45
+état 46
 
    13 Exp: Exp "//=" . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 91
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 93
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 46
+état 47
 
-   28 Exp: Exp "<=" . Exp
+   29 Exp: Exp "<=" . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 92
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 94
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 47
+état 48
 
-   29 Exp: Exp ">=" . Exp
+   30 Exp: Exp ">=" . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 93
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 95
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 48
+état 49
 
    15 Exp: Exp '|' . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 94
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 96
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 49
+état 50
 
    16 Exp: Exp ',' . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 95
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 97
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 50
+état 51
 
     9 Exp: Exp '=' . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 96
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 98
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 51
+état 52
 
-   26 Exp: Exp '<' . Exp
+   27 Exp: Exp '<' . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 97
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 99
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 52
+état 53
 
-   27 Exp: Exp '>' . Exp
+   28 Exp: Exp '>' . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 98
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 100
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 53
+état 54
 
    17 Exp: Exp '+' . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 99
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 101
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 54
+état 55
 
    19 Exp: Exp '-' . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 100
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 102
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 55
+état 56
 
    21 Exp: Exp '*' . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 101
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 103
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 56
+état 57
 
    23 Exp: Exp '/' . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 102
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 104
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 57
+état 58
 
     4 FuncDefs: FuncDef FuncDefs .
 
-    $default  reduce using rule 4 (FuncDefs)
+    $défaut  réduction par utilisation de la règle 4 (FuncDefs)
 
 
-state 58
+état 59
 
     5 Exp: FuncDef Exp .
     9    | Exp . '=' Exp
@@ -1232,76 +1263,78 @@ state 58
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    "=="   shift, and go to state 36
-    "//"   shift, and go to state 37
-    "and"  shift, and go to state 38
-    "or"   shift, and go to state 39
-    "|="   shift, and go to state 40
-    "+="   shift, and go to state 41
-    "-="   shift, and go to state 42
-    "*="   shift, and go to state 43
-    "/="   shift, and go to state 44
-    "//="  shift, and go to state 45
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    '|'    shift, and go to state 48
-    ','    shift, and go to state 49
-    '='    shift, and go to state 50
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "//"   décalage et aller à l'état 38
+    "and"  décalage et aller à l'état 39
+    "or"   décalage et aller à l'état 40
+    "|="   décalage et aller à l'état 41
+    "+="   décalage et aller à l'état 42
+    "-="   décalage et aller à l'état 43
+    "*="   décalage et aller à l'état 44
+    "/="   décalage et aller à l'état 45
+    "//="  décalage et aller à l'état 46
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    '|'    décalage et aller à l'état 49
+    ','    décalage et aller à l'état 50
+    '='    décalage et aller à l'état 51
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
 
-    $default  reduce using rule 5 (Exp)
+    $défaut  réduction par utilisation de la règle 5 (Exp)
 
 
-state 59
+état 60
 
     6 Exp: Term "as" . '$' IDENT '|' Exp
 
-    '$'  shift, and go to state 103
+    '$'  décalage et aller à l'état 105
 
 
-state 60
+état 61
 
-   43 Term: Term '.' . IDENT
+   44 Term: Term '.' . IDENT
 
-    IDENT  shift, and go to state 104
+    IDENT  décalage et aller à l'état 106
 
 
-state 61
+état 62
 
-   45 Term: Term '[' . Exp ']'
-   46     | Term '[' . ']'
-   57     | Term '[' . error ']'
+   46 Term: Term '[' . Exp ']'
+   47     | Term '[' . ']'
+   58     | Term '[' . error ']'
 
-    error           shift, and go to state 105
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    ']'             shift, and go to state 106
-    '{'             shift, and go to state 10
+    error           décalage et aller à l'état 107
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    ']'             décalage et aller à l'état 108
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 107
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 109
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 62
+état 63
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1320,202 +1353,204 @@ state 62
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
-   54 Term: IDENT '(' Exp . ')'
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
+   55 Term: IDENT '(' Exp . ')'
 
-    "=="   shift, and go to state 36
-    "//"   shift, and go to state 37
-    "and"  shift, and go to state 38
-    "or"   shift, and go to state 39
-    "|="   shift, and go to state 40
-    "+="   shift, and go to state 41
-    "-="   shift, and go to state 42
-    "*="   shift, and go to state 43
-    "/="   shift, and go to state 44
-    "//="  shift, and go to state 45
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    '|'    shift, and go to state 48
-    ','    shift, and go to state 49
-    '='    shift, and go to state 50
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
-    ')'    shift, and go to state 108
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "//"   décalage et aller à l'état 38
+    "and"  décalage et aller à l'état 39
+    "or"   décalage et aller à l'état 40
+    "|="   décalage et aller à l'état 41
+    "+="   décalage et aller à l'état 42
+    "-="   décalage et aller à l'état 43
+    "*="   décalage et aller à l'état 44
+    "/="   décalage et aller à l'état 45
+    "//="  décalage et aller à l'état 46
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    '|'    décalage et aller à l'état 49
+    ','    décalage et aller à l'état 50
+    '='    décalage et aller à l'état 51
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
+    ')'    décalage et aller à l'état 110
 
 
-state 63
+état 64
 
-   33 FuncDef: "def" IDENT ':' . Exp ';'
+   34 FuncDef: "def" IDENT ':' . Exp ';'
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 109
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 111
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 64
+état 65
 
-   34 FuncDef: "def" IDENT '(' . IDENT ')' ':' Exp ';'
+   35 FuncDef: "def" IDENT '(' . IDENT ')' ':' Exp ';'
 
-    IDENT  shift, and go to state 110
+    IDENT  décalage et aller à l'état 112
 
 
-state 65
+état 66
 
     8 Exp: "if" Exp error .
 
-    $default  reduce using rule 8 (Exp)
+    $défaut  réduction par utilisation de la règle 8 (Exp)
 
 
-state 66
+état 67
 
     7 Exp: "if" Exp "then" . Exp ElseBody
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 111
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 113
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 67
+état 68
 
-   36 QQString: QQString QQSTRING_TEXT .
+   37 QQString: QQString QQSTRING_TEXT .
 
-    $default  reduce using rule 36 (QQString)
+    $défaut  réduction par utilisation de la règle 37 (QQString)
 
 
-state 68
+état 69
 
-   37 QQString: QQString QQSTRING_INTERP_START . Exp QQSTRING_INTERP_END
+   38 QQString: QQString QQSTRING_INTERP_START . Exp QQSTRING_INTERP_END
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 112
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 114
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 69
+état 70
 
-   32 String: QQSTRING_START QQString QQSTRING_END .
+   33 String: QQSTRING_START QQString QQSTRING_END .
 
-    $default  reduce using rule 32 (String)
+    $défaut  réduction par utilisation de la règle 33 (String)
 
 
-state 70
+état 71
 
-   55 Term: '(' error ')' .
+   56 Term: '(' error ')' .
 
-    $default  reduce using rule 55 (Term)
+    $défaut  réduction par utilisation de la règle 56 (Term)
 
 
-state 71
+état 72
 
-   48 Term: '(' Exp ')' .
+   49 Term: '(' Exp ')' .
 
-    $default  reduce using rule 48 (Term)
+    $défaut  réduction par utilisation de la règle 49 (Term)
 
 
-state 72
+état 73
 
-   56 Term: '[' error ']' .
+   57 Term: '[' error ']' .
 
-    $default  reduce using rule 56 (Term)
+    $défaut  réduction par utilisation de la règle 57 (Term)
 
 
-state 73
+état 74
 
-   49 Term: '[' Exp ']' .
+   50 Term: '[' Exp ']' .
 
-    $default  reduce using rule 49 (Term)
+    $défaut  réduction par utilisation de la règle 50 (Term)
 
 
-state 74
+état 75
 
-   62 MkDict: error ',' . MkDict
+   63 MkDict: error ',' . MkDict
 
-    error           shift, and go to state 113
-    IDENT           shift, and go to state 30
-    QQSTRING_START  shift, and go to state 5
-    '('             shift, and go to state 31
+    error           décalage et aller à l'état 115
+    IDENT           décalage et aller à l'état 30
+    QQSTRING_START  décalage et aller à l'état 5
+    '('             décalage et aller à l'état 31
 
-    '}'  reduce using rule 59 (MkDict)
+    '}'  réduction par utilisation de la règle 60 (MkDict)
 
-    String      go to state 32
-    MkDict      go to state 114
-    MkDictPair  go to state 34
+    String      aller à l'état 32
+    MkDict      aller à l'état 116
+    MkDictPair  aller à l'état 34
 
 
-state 75
+état 76
 
-   58 Term: '{' error '}' .
+   59 Term: '{' error '}' .
 
-    $default  reduce using rule 58 (Term)
+    $défaut  réduction par utilisation de la règle 59 (Term)
 
 
-state 76
+état 77
 
-   63 MkDictPair: IDENT ':' . ExpD
+   64 MkDictPair: IDENT ':' . ExpD
 
-    IDENT    shift, and go to state 1
-    LITERAL  shift, and go to state 2
-    '$'      shift, and go to state 6
-    '('      shift, and go to state 7
-    '.'      shift, and go to state 8
-    '['      shift, and go to state 9
-    '{'      shift, and go to state 10
+    IDENT    décalage et aller à l'état 1
+    LITERAL  décalage et aller à l'état 2
+    '$'      décalage et aller à l'état 6
+    '('      décalage et aller à l'état 7
+    '.'      décalage et aller à l'état 8
+    '['      décalage et aller à l'état 9
+    '{'      décalage et aller à l'état 10
 
-    ExpD  go to state 115
-    Term  go to state 116
+    ExpD  aller à l'état 117
+    Term  aller à l'état 118
 
 
-state 77
+état 78
 
-   67 MkDictPair: '(' error . ')' ':' ExpD
+   68 MkDictPair: '(' error . ')' ':' ExpD
 
-    ')'  shift, and go to state 117
+    ')'  décalage et aller à l'état 119
 
 
-state 78
+état 79
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1534,76 +1569,78 @@ state 78
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
-   66 MkDictPair: '(' Exp . ')' ':' ExpD
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
+   67 MkDictPair: '(' Exp . ')' ':' ExpD
 
-    "=="   shift, and go to state 36
-    "//"   shift, and go to state 37
-    "and"  shift, and go to state 38
-    "or"   shift, and go to state 39
-    "|="   shift, and go to state 40
-    "+="   shift, and go to state 41
-    "-="   shift, and go to state 42
-    "*="   shift, and go to state 43
-    "/="   shift, and go to state 44
-    "//="  shift, and go to state 45
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    '|'    shift, and go to state 48
-    ','    shift, and go to state 49
-    '='    shift, and go to state 50
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
-    ')'    shift, and go to state 118
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "//"   décalage et aller à l'état 38
+    "and"  décalage et aller à l'état 39
+    "or"   décalage et aller à l'état 40
+    "|="   décalage et aller à l'état 41
+    "+="   décalage et aller à l'état 42
+    "-="   décalage et aller à l'état 43
+    "*="   décalage et aller à l'état 44
+    "/="   décalage et aller à l'état 45
+    "//="  décalage et aller à l'état 46
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    '|'    décalage et aller à l'état 49
+    ','    décalage et aller à l'état 50
+    '='    décalage et aller à l'état 51
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
+    ')'    décalage et aller à l'état 120
 
 
-state 79
+état 80
 
-   64 MkDictPair: String ':' . ExpD
+   65 MkDictPair: String ':' . ExpD
 
-    IDENT    shift, and go to state 1
-    LITERAL  shift, and go to state 2
-    '$'      shift, and go to state 6
-    '('      shift, and go to state 7
-    '.'      shift, and go to state 8
-    '['      shift, and go to state 9
-    '{'      shift, and go to state 10
+    IDENT    décalage et aller à l'état 1
+    LITERAL  décalage et aller à l'état 2
+    '$'      décalage et aller à l'état 6
+    '('      décalage et aller à l'état 7
+    '.'      décalage et aller à l'état 8
+    '['      décalage et aller à l'état 9
+    '{'      décalage et aller à l'état 10
 
-    ExpD  go to state 119
-    Term  go to state 116
+    ExpD  aller à l'état 121
+    Term  aller à l'état 118
 
 
-state 80
+état 81
 
-   51 Term: '{' MkDict '}' .
+   52 Term: '{' MkDict '}' .
 
-    $default  reduce using rule 51 (Term)
+    $défaut  réduction par utilisation de la règle 52 (Term)
 
 
-state 81
+état 82
 
-   61 MkDict: MkDictPair ',' . MkDict
+   62 MkDict: MkDictPair ',' . MkDict
 
-    error           shift, and go to state 113
-    IDENT           shift, and go to state 30
-    QQSTRING_START  shift, and go to state 5
-    '('             shift, and go to state 31
+    error           décalage et aller à l'état 115
+    IDENT           décalage et aller à l'état 30
+    QQSTRING_START  décalage et aller à l'état 5
+    '('             décalage et aller à l'état 31
 
-    '}'  reduce using rule 59 (MkDict)
+    '}'  réduction par utilisation de la règle 60 (MkDict)
 
-    String      go to state 32
-    MkDict      go to state 120
-    MkDictPair  go to state 34
+    String      aller à l'état 32
+    MkDict      aller à l'état 122
+    MkDictPair  aller à l'état 34
 
 
-state 82
+état 83
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1623,26 +1660,69 @@ state 82
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
    25    | Exp "==" Exp .
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    '+'  shift, and go to state 53
-    '-'  shift, and go to state 54
-    '*'  shift, and go to state 55
-    '/'  shift, and go to state 56
+    '+'  décalage et aller à l'état 54
+    '-'  décalage et aller à l'état 55
+    '*'  décalage et aller à l'état 56
+    '/'  décalage et aller à l'état 57
 
-    "=="  error (nonassociative)
-    "<="  error (nonassociative)
-    ">="  error (nonassociative)
-    '<'   error (nonassociative)
-    '>'   error (nonassociative)
+    "=="  erreur (non-associative)
+    "!="  erreur (non-associative)
+    "<="  erreur (non-associative)
+    ">="  erreur (non-associative)
+    '<'   erreur (non-associative)
+    '>'   erreur (non-associative)
 
-    $default  reduce using rule 25 (Exp)
+    $défaut  réduction par utilisation de la règle 25 (Exp)
 
 
-state 83
+état 84
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . "!=" Exp
+   26    | Exp "!=" Exp .
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
+
+    '+'  décalage et aller à l'état 54
+    '-'  décalage et aller à l'état 55
+    '*'  décalage et aller à l'état 56
+    '/'  décalage et aller à l'état 57
+
+    "=="  erreur (non-associative)
+    "!="  erreur (non-associative)
+    "<="  erreur (non-associative)
+    ">="  erreur (non-associative)
+    '<'   erreur (non-associative)
+    '>'   erreur (non-associative)
+
+    $défaut  réduction par utilisation de la règle 26 (Exp)
+
+
+état 85
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1662,35 +1742,37 @@ state 83
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    "=="   shift, and go to state 36
-    "//"   shift, and go to state 37
-    "and"  shift, and go to state 38
-    "or"   shift, and go to state 39
-    "|="   shift, and go to state 40
-    "+="   shift, and go to state 41
-    "-="   shift, and go to state 42
-    "*="   shift, and go to state 43
-    "/="   shift, and go to state 44
-    "//="  shift, and go to state 45
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    '='    shift, and go to state 50
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "//"   décalage et aller à l'état 38
+    "and"  décalage et aller à l'état 39
+    "or"   décalage et aller à l'état 40
+    "|="   décalage et aller à l'état 41
+    "+="   décalage et aller à l'état 42
+    "-="   décalage et aller à l'état 43
+    "*="   décalage et aller à l'état 44
+    "/="   décalage et aller à l'état 45
+    "//="  décalage et aller à l'état 46
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    '='    décalage et aller à l'état 51
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
 
-    $default  reduce using rule 12 (Exp)
+    $défaut  réduction par utilisation de la règle 12 (Exp)
 
 
-state 84
+état 86
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1710,25 +1792,27 @@ state 84
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    "=="  shift, and go to state 36
-    "<="  shift, and go to state 46
-    ">="  shift, and go to state 47
-    '<'   shift, and go to state 51
-    '>'   shift, and go to state 52
-    '+'   shift, and go to state 53
-    '-'   shift, and go to state 54
-    '*'   shift, and go to state 55
-    '/'   shift, and go to state 56
+    "=="  décalage et aller à l'état 36
+    "!="  décalage et aller à l'état 37
+    "<="  décalage et aller à l'état 47
+    ">="  décalage et aller à l'état 48
+    '<'   décalage et aller à l'état 52
+    '>'   décalage et aller à l'état 53
+    '+'   décalage et aller à l'état 54
+    '-'   décalage et aller à l'état 55
+    '*'   décalage et aller à l'état 56
+    '/'   décalage et aller à l'état 57
 
-    $default  reduce using rule 11 (Exp)
+    $défaut  réduction par utilisation de la règle 11 (Exp)
 
 
-state 85
+état 87
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1748,26 +1832,28 @@ state 85
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    "=="   shift, and go to state 36
-    "and"  shift, and go to state 38
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "and"  décalage et aller à l'état 39
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
 
-    $default  reduce using rule 10 (Exp)
+    $défaut  réduction par utilisation de la règle 10 (Exp)
 
 
-state 86
+état 88
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1787,35 +1873,37 @@ state 86
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    "=="   shift, and go to state 36
-    "and"  shift, and go to state 38
-    "or"   shift, and go to state 39
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "and"  décalage et aller à l'état 39
+    "or"   décalage et aller à l'état 40
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
 
-    "|="   error (nonassociative)
-    "+="   error (nonassociative)
-    "-="   error (nonassociative)
-    "*="   error (nonassociative)
-    "/="   error (nonassociative)
-    "//="  error (nonassociative)
-    '='    error (nonassociative)
+    "|="   erreur (non-associative)
+    "+="   erreur (non-associative)
+    "-="   erreur (non-associative)
+    "*="   erreur (non-associative)
+    "/="   erreur (non-associative)
+    "//="  erreur (non-associative)
+    '='    erreur (non-associative)
 
-    $default  reduce using rule 14 (Exp)
+    $défaut  réduction par utilisation de la règle 14 (Exp)
 
 
-state 87
+état 89
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1835,35 +1923,37 @@ state 87
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    "=="   shift, and go to state 36
-    "and"  shift, and go to state 38
-    "or"   shift, and go to state 39
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "and"  décalage et aller à l'état 39
+    "or"   décalage et aller à l'état 40
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
 
-    "|="   error (nonassociative)
-    "+="   error (nonassociative)
-    "-="   error (nonassociative)
-    "*="   error (nonassociative)
-    "/="   error (nonassociative)
-    "//="  error (nonassociative)
-    '='    error (nonassociative)
+    "|="   erreur (non-associative)
+    "+="   erreur (non-associative)
+    "-="   erreur (non-associative)
+    "*="   erreur (non-associative)
+    "/="   erreur (non-associative)
+    "//="  erreur (non-associative)
+    '='    erreur (non-associative)
 
-    $default  reduce using rule 18 (Exp)
+    $défaut  réduction par utilisation de la règle 18 (Exp)
 
 
-state 88
+état 90
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1883,35 +1973,37 @@ state 88
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    "=="   shift, and go to state 36
-    "and"  shift, and go to state 38
-    "or"   shift, and go to state 39
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "and"  décalage et aller à l'état 39
+    "or"   décalage et aller à l'état 40
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
 
-    "|="   error (nonassociative)
-    "+="   error (nonassociative)
-    "-="   error (nonassociative)
-    "*="   error (nonassociative)
-    "/="   error (nonassociative)
-    "//="  error (nonassociative)
-    '='    error (nonassociative)
+    "|="   erreur (non-associative)
+    "+="   erreur (non-associative)
+    "-="   erreur (non-associative)
+    "*="   erreur (non-associative)
+    "/="   erreur (non-associative)
+    "//="  erreur (non-associative)
+    '='    erreur (non-associative)
 
-    $default  reduce using rule 20 (Exp)
+    $défaut  réduction par utilisation de la règle 20 (Exp)
 
 
-state 89
+état 91
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1931,35 +2023,37 @@ state 89
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    "=="   shift, and go to state 36
-    "and"  shift, and go to state 38
-    "or"   shift, and go to state 39
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "and"  décalage et aller à l'état 39
+    "or"   décalage et aller à l'état 40
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
 
-    "|="   error (nonassociative)
-    "+="   error (nonassociative)
-    "-="   error (nonassociative)
-    "*="   error (nonassociative)
-    "/="   error (nonassociative)
-    "//="  error (nonassociative)
-    '='    error (nonassociative)
+    "|="   erreur (non-associative)
+    "+="   erreur (non-associative)
+    "-="   erreur (non-associative)
+    "*="   erreur (non-associative)
+    "/="   erreur (non-associative)
+    "//="  erreur (non-associative)
+    '='    erreur (non-associative)
 
-    $default  reduce using rule 22 (Exp)
+    $défaut  réduction par utilisation de la règle 22 (Exp)
 
 
-state 90
+état 92
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1979,35 +2073,37 @@ state 90
    24    | Exp . "/=" Exp
    24    | Exp "/=" Exp .
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    "=="   shift, and go to state 36
-    "and"  shift, and go to state 38
-    "or"   shift, and go to state 39
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "and"  décalage et aller à l'état 39
+    "or"   décalage et aller à l'état 40
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
 
-    "|="   error (nonassociative)
-    "+="   error (nonassociative)
-    "-="   error (nonassociative)
-    "*="   error (nonassociative)
-    "/="   error (nonassociative)
-    "//="  error (nonassociative)
-    '='    error (nonassociative)
+    "|="   erreur (non-associative)
+    "+="   erreur (non-associative)
+    "-="   erreur (non-associative)
+    "*="   erreur (non-associative)
+    "/="   erreur (non-associative)
+    "//="  erreur (non-associative)
+    '='    erreur (non-associative)
 
-    $default  reduce using rule 24 (Exp)
+    $défaut  réduction par utilisation de la règle 24 (Exp)
 
 
-state 91
+état 93
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2027,35 +2123,37 @@ state 91
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    "=="   shift, and go to state 36
-    "and"  shift, and go to state 38
-    "or"   shift, and go to state 39
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "and"  décalage et aller à l'état 39
+    "or"   décalage et aller à l'état 40
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
 
-    "|="   error (nonassociative)
-    "+="   error (nonassociative)
-    "-="   error (nonassociative)
-    "*="   error (nonassociative)
-    "/="   error (nonassociative)
-    "//="  error (nonassociative)
-    '='    error (nonassociative)
+    "|="   erreur (non-associative)
+    "+="   erreur (non-associative)
+    "-="   erreur (non-associative)
+    "*="   erreur (non-associative)
+    "/="   erreur (non-associative)
+    "//="  erreur (non-associative)
+    '='    erreur (non-associative)
 
-    $default  reduce using rule 13 (Exp)
+    $défaut  réduction par utilisation de la règle 13 (Exp)
 
 
-state 92
+état 94
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2074,27 +2172,29 @@ state 92
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   28    | Exp "<=" Exp .
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   29    | Exp "<=" Exp .
+   30    | Exp . ">=" Exp
 
-    '+'  shift, and go to state 53
-    '-'  shift, and go to state 54
-    '*'  shift, and go to state 55
-    '/'  shift, and go to state 56
+    '+'  décalage et aller à l'état 54
+    '-'  décalage et aller à l'état 55
+    '*'  décalage et aller à l'état 56
+    '/'  décalage et aller à l'état 57
 
-    "=="  error (nonassociative)
-    "<="  error (nonassociative)
-    ">="  error (nonassociative)
-    '<'   error (nonassociative)
-    '>'   error (nonassociative)
+    "=="  erreur (non-associative)
+    "!="  erreur (non-associative)
+    "<="  erreur (non-associative)
+    ">="  erreur (non-associative)
+    '<'   erreur (non-associative)
+    '>'   erreur (non-associative)
 
-    $default  reduce using rule 28 (Exp)
+    $défaut  réduction par utilisation de la règle 29 (Exp)
 
 
-state 93
+état 95
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2113,27 +2213,29 @@ state 93
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
-   29    | Exp ">=" Exp .
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
+   30    | Exp ">=" Exp .
 
-    '+'  shift, and go to state 53
-    '-'  shift, and go to state 54
-    '*'  shift, and go to state 55
-    '/'  shift, and go to state 56
+    '+'  décalage et aller à l'état 54
+    '-'  décalage et aller à l'état 55
+    '*'  décalage et aller à l'état 56
+    '/'  décalage et aller à l'état 57
 
-    "=="  error (nonassociative)
-    "<="  error (nonassociative)
-    ">="  error (nonassociative)
-    '<'   error (nonassociative)
-    '>'   error (nonassociative)
+    "=="  erreur (non-associative)
+    "!="  erreur (non-associative)
+    "<="  erreur (non-associative)
+    ">="  erreur (non-associative)
+    '<'   erreur (non-associative)
+    '>'   erreur (non-associative)
 
-    $default  reduce using rule 29 (Exp)
+    $défaut  réduction par utilisation de la règle 30 (Exp)
 
 
-state 94
+état 96
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2153,36 +2255,38 @@ state 94
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    "=="   shift, and go to state 36
-    "//"   shift, and go to state 37
-    "and"  shift, and go to state 38
-    "or"   shift, and go to state 39
-    "|="   shift, and go to state 40
-    "+="   shift, and go to state 41
-    "-="   shift, and go to state 42
-    "*="   shift, and go to state 43
-    "/="   shift, and go to state 44
-    "//="  shift, and go to state 45
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    ','    shift, and go to state 49
-    '='    shift, and go to state 50
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "//"   décalage et aller à l'état 38
+    "and"  décalage et aller à l'état 39
+    "or"   décalage et aller à l'état 40
+    "|="   décalage et aller à l'état 41
+    "+="   décalage et aller à l'état 42
+    "-="   décalage et aller à l'état 43
+    "*="   décalage et aller à l'état 44
+    "/="   décalage et aller à l'état 45
+    "//="  décalage et aller à l'état 46
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    ','    décalage et aller à l'état 50
+    '='    décalage et aller à l'état 51
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
 
-    $default  reduce using rule 15 (Exp)
+    $défaut  réduction par utilisation de la règle 15 (Exp)
 
 
-state 95
+état 97
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2202,35 +2306,37 @@ state 95
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    "=="   shift, and go to state 36
-    "//"   shift, and go to state 37
-    "and"  shift, and go to state 38
-    "or"   shift, and go to state 39
-    "|="   shift, and go to state 40
-    "+="   shift, and go to state 41
-    "-="   shift, and go to state 42
-    "*="   shift, and go to state 43
-    "/="   shift, and go to state 44
-    "//="  shift, and go to state 45
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    '='    shift, and go to state 50
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "//"   décalage et aller à l'état 38
+    "and"  décalage et aller à l'état 39
+    "or"   décalage et aller à l'état 40
+    "|="   décalage et aller à l'état 41
+    "+="   décalage et aller à l'état 42
+    "-="   décalage et aller à l'état 43
+    "*="   décalage et aller à l'état 44
+    "/="   décalage et aller à l'état 45
+    "//="  décalage et aller à l'état 46
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    '='    décalage et aller à l'état 51
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
 
-    $default  reduce using rule 16 (Exp)
+    $défaut  réduction par utilisation de la règle 16 (Exp)
 
 
-state 96
+état 98
 
     9 Exp: Exp . '=' Exp
     9    | Exp '=' Exp .
@@ -2250,35 +2356,37 @@ state 96
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    "=="   shift, and go to state 36
-    "and"  shift, and go to state 38
-    "or"   shift, and go to state 39
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "and"  décalage et aller à l'état 39
+    "or"   décalage et aller à l'état 40
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
 
-    "|="   error (nonassociative)
-    "+="   error (nonassociative)
-    "-="   error (nonassociative)
-    "*="   error (nonassociative)
-    "/="   error (nonassociative)
-    "//="  error (nonassociative)
-    '='    error (nonassociative)
+    "|="   erreur (non-associative)
+    "+="   erreur (non-associative)
+    "-="   erreur (non-associative)
+    "*="   erreur (non-associative)
+    "/="   erreur (non-associative)
+    "//="  erreur (non-associative)
+    '='    erreur (non-associative)
 
-    $default  reduce using rule 9 (Exp)
+    $défaut  réduction par utilisation de la règle 9 (Exp)
 
 
-state 97
+état 99
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2297,27 +2405,29 @@ state 97
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   26    | Exp '<' Exp .
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   27    | Exp '<' Exp .
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    '+'  shift, and go to state 53
-    '-'  shift, and go to state 54
-    '*'  shift, and go to state 55
-    '/'  shift, and go to state 56
+    '+'  décalage et aller à l'état 54
+    '-'  décalage et aller à l'état 55
+    '*'  décalage et aller à l'état 56
+    '/'  décalage et aller à l'état 57
 
-    "=="  error (nonassociative)
-    "<="  error (nonassociative)
-    ">="  error (nonassociative)
-    '<'   error (nonassociative)
-    '>'   error (nonassociative)
+    "=="  erreur (non-associative)
+    "!="  erreur (non-associative)
+    "<="  erreur (non-associative)
+    ">="  erreur (non-associative)
+    '<'   erreur (non-associative)
+    '>'   erreur (non-associative)
 
-    $default  reduce using rule 26 (Exp)
+    $défaut  réduction par utilisation de la règle 27 (Exp)
 
 
-state 98
+état 100
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2336,27 +2446,29 @@ state 98
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   27    | Exp '>' Exp .
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   28    | Exp '>' Exp .
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    '+'  shift, and go to state 53
-    '-'  shift, and go to state 54
-    '*'  shift, and go to state 55
-    '/'  shift, and go to state 56
+    '+'  décalage et aller à l'état 54
+    '-'  décalage et aller à l'état 55
+    '*'  décalage et aller à l'état 56
+    '/'  décalage et aller à l'état 57
 
-    "=="  error (nonassociative)
-    "<="  error (nonassociative)
-    ">="  error (nonassociative)
-    '<'   error (nonassociative)
-    '>'   error (nonassociative)
+    "=="  erreur (non-associative)
+    "!="  erreur (non-associative)
+    "<="  erreur (non-associative)
+    ">="  erreur (non-associative)
+    '<'   erreur (non-associative)
+    '>'   erreur (non-associative)
 
-    $default  reduce using rule 27 (Exp)
+    $défaut  réduction par utilisation de la règle 28 (Exp)
 
 
-state 99
+état 101
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2376,18 +2488,19 @@ state 99
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    '*'  shift, and go to state 55
-    '/'  shift, and go to state 56
+    '*'  décalage et aller à l'état 56
+    '/'  décalage et aller à l'état 57
 
-    $default  reduce using rule 17 (Exp)
+    $défaut  réduction par utilisation de la règle 17 (Exp)
 
 
-state 100
+état 102
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2407,18 +2520,19 @@ state 100
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    '*'  shift, and go to state 55
-    '/'  shift, and go to state 56
+    '*'  décalage et aller à l'état 56
+    '/'  décalage et aller à l'état 57
 
-    $default  reduce using rule 19 (Exp)
+    $défaut  réduction par utilisation de la règle 19 (Exp)
 
 
-state 101
+état 103
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2438,15 +2552,16 @@ state 101
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    $default  reduce using rule 21 (Exp)
+    $défaut  réduction par utilisation de la règle 21 (Exp)
 
 
-state 102
+état 104
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2466,43 +2581,44 @@ state 102
    23    | Exp '/' Exp .
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    $default  reduce using rule 23 (Exp)
+    $défaut  réduction par utilisation de la règle 23 (Exp)
 
 
-state 103
+état 105
 
     6 Exp: Term "as" '$' . IDENT '|' Exp
 
-    IDENT  shift, and go to state 121
+    IDENT  décalage et aller à l'état 123
 
 
-state 104
+état 106
 
-   43 Term: Term '.' IDENT .
+   44 Term: Term '.' IDENT .
 
-    $default  reduce using rule 43 (Term)
+    $défaut  réduction par utilisation de la règle 44 (Term)
 
 
-state 105
+état 107
 
-   57 Term: Term '[' error . ']'
+   58 Term: Term '[' error . ']'
 
-    ']'  shift, and go to state 122
+    ']'  décalage et aller à l'état 124
 
 
-state 106
+état 108
 
-   46 Term: Term '[' ']' .
+   47 Term: Term '[' ']' .
 
-    $default  reduce using rule 46 (Term)
+    $défaut  réduction par utilisation de la règle 47 (Term)
 
 
-state 107
+état 109
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2521,44 +2637,46 @@ state 107
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
-   45 Term: Term '[' Exp . ']'
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
+   46 Term: Term '[' Exp . ']'
 
-    "=="   shift, and go to state 36
-    "//"   shift, and go to state 37
-    "and"  shift, and go to state 38
-    "or"   shift, and go to state 39
-    "|="   shift, and go to state 40
-    "+="   shift, and go to state 41
-    "-="   shift, and go to state 42
-    "*="   shift, and go to state 43
-    "/="   shift, and go to state 44
-    "//="  shift, and go to state 45
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    '|'    shift, and go to state 48
-    ','    shift, and go to state 49
-    '='    shift, and go to state 50
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
-    ']'    shift, and go to state 123
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "//"   décalage et aller à l'état 38
+    "and"  décalage et aller à l'état 39
+    "or"   décalage et aller à l'état 40
+    "|="   décalage et aller à l'état 41
+    "+="   décalage et aller à l'état 42
+    "-="   décalage et aller à l'état 43
+    "*="   décalage et aller à l'état 44
+    "/="   décalage et aller à l'état 45
+    "//="  décalage et aller à l'état 46
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    '|'    décalage et aller à l'état 49
+    ','    décalage et aller à l'état 50
+    '='    décalage et aller à l'état 51
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
+    ']'    décalage et aller à l'état 125
 
 
-state 108
+état 110
 
-   54 Term: IDENT '(' Exp ')' .
+   55 Term: IDENT '(' Exp ')' .
 
-    $default  reduce using rule 54 (Term)
+    $défaut  réduction par utilisation de la règle 55 (Term)
 
 
-state 109
+état 111
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2577,44 +2695,46 @@ state 109
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
-   33 FuncDef: "def" IDENT ':' Exp . ';'
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
+   34 FuncDef: "def" IDENT ':' Exp . ';'
 
-    "=="   shift, and go to state 36
-    "//"   shift, and go to state 37
-    "and"  shift, and go to state 38
-    "or"   shift, and go to state 39
-    "|="   shift, and go to state 40
-    "+="   shift, and go to state 41
-    "-="   shift, and go to state 42
-    "*="   shift, and go to state 43
-    "/="   shift, and go to state 44
-    "//="  shift, and go to state 45
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    ';'    shift, and go to state 124
-    '|'    shift, and go to state 48
-    ','    shift, and go to state 49
-    '='    shift, and go to state 50
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "//"   décalage et aller à l'état 38
+    "and"  décalage et aller à l'état 39
+    "or"   décalage et aller à l'état 40
+    "|="   décalage et aller à l'état 41
+    "+="   décalage et aller à l'état 42
+    "-="   décalage et aller à l'état 43
+    "*="   décalage et aller à l'état 44
+    "/="   décalage et aller à l'état 45
+    "//="  décalage et aller à l'état 46
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    ';'    décalage et aller à l'état 126
+    '|'    décalage et aller à l'état 49
+    ','    décalage et aller à l'état 50
+    '='    décalage et aller à l'état 51
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
 
 
-state 110
+état 112
 
-   34 FuncDef: "def" IDENT '(' IDENT . ')' ':' Exp ';'
+   35 FuncDef: "def" IDENT '(' IDENT . ')' ':' Exp ';'
 
-    ')'  shift, and go to state 125
+    ')'  décalage et aller à l'état 127
 
 
-state 111
+état 113
 
     7 Exp: "if" Exp "then" Exp . ElseBody
     9    | Exp . '=' Exp
@@ -2634,39 +2754,41 @@ state 111
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    "=="    shift, and go to state 36
-    "//"    shift, and go to state 37
-    "else"  shift, and go to state 126
-    "elif"  shift, and go to state 127
-    "and"   shift, and go to state 38
-    "or"    shift, and go to state 39
-    "|="    shift, and go to state 40
-    "+="    shift, and go to state 41
-    "-="    shift, and go to state 42
-    "*="    shift, and go to state 43
-    "/="    shift, and go to state 44
-    "//="   shift, and go to state 45
-    "<="    shift, and go to state 46
-    ">="    shift, and go to state 47
-    '|'     shift, and go to state 48
-    ','     shift, and go to state 49
-    '='     shift, and go to state 50
-    '<'     shift, and go to state 51
-    '>'     shift, and go to state 52
-    '+'     shift, and go to state 53
-    '-'     shift, and go to state 54
-    '*'     shift, and go to state 55
-    '/'     shift, and go to state 56
+    "=="    décalage et aller à l'état 36
+    "!="    décalage et aller à l'état 37
+    "//"    décalage et aller à l'état 38
+    "else"  décalage et aller à l'état 128
+    "elif"  décalage et aller à l'état 129
+    "and"   décalage et aller à l'état 39
+    "or"    décalage et aller à l'état 40
+    "|="    décalage et aller à l'état 41
+    "+="    décalage et aller à l'état 42
+    "-="    décalage et aller à l'état 43
+    "*="    décalage et aller à l'état 44
+    "/="    décalage et aller à l'état 45
+    "//="   décalage et aller à l'état 46
+    "<="    décalage et aller à l'état 47
+    ">="    décalage et aller à l'état 48
+    '|'     décalage et aller à l'état 49
+    ','     décalage et aller à l'état 50
+    '='     décalage et aller à l'état 51
+    '<'     décalage et aller à l'état 52
+    '>'     décalage et aller à l'état 53
+    '+'     décalage et aller à l'état 54
+    '-'     décalage et aller à l'état 55
+    '*'     décalage et aller à l'état 56
+    '/'     décalage et aller à l'état 57
 
-    ElseBody  go to state 128
+    ElseBody  aller à l'état 130
 
 
-state 112
+état 114
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2685,287 +2807,289 @@ state 112
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
-   37 QQString: QQString QQSTRING_INTERP_START Exp . QQSTRING_INTERP_END
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
+   38 QQString: QQString QQSTRING_INTERP_START Exp . QQSTRING_INTERP_END
 
-    "=="                 shift, and go to state 36
-    "//"                 shift, and go to state 37
-    "and"                shift, and go to state 38
-    "or"                 shift, and go to state 39
-    "|="                 shift, and go to state 40
-    "+="                 shift, and go to state 41
-    "-="                 shift, and go to state 42
-    "*="                 shift, and go to state 43
-    "/="                 shift, and go to state 44
-    "//="                shift, and go to state 45
-    "<="                 shift, and go to state 46
-    ">="                 shift, and go to state 47
-    QQSTRING_INTERP_END  shift, and go to state 129
-    '|'                  shift, and go to state 48
-    ','                  shift, and go to state 49
-    '='                  shift, and go to state 50
-    '<'                  shift, and go to state 51
-    '>'                  shift, and go to state 52
-    '+'                  shift, and go to state 53
-    '-'                  shift, and go to state 54
-    '*'                  shift, and go to state 55
-    '/'                  shift, and go to state 56
+    "=="                 décalage et aller à l'état 36
+    "!="                 décalage et aller à l'état 37
+    "//"                 décalage et aller à l'état 38
+    "and"                décalage et aller à l'état 39
+    "or"                 décalage et aller à l'état 40
+    "|="                 décalage et aller à l'état 41
+    "+="                 décalage et aller à l'état 42
+    "-="                 décalage et aller à l'état 43
+    "*="                 décalage et aller à l'état 44
+    "/="                 décalage et aller à l'état 45
+    "//="                décalage et aller à l'état 46
+    "<="                 décalage et aller à l'état 47
+    ">="                 décalage et aller à l'état 48
+    QQSTRING_INTERP_END  décalage et aller à l'état 131
+    '|'                  décalage et aller à l'état 49
+    ','                  décalage et aller à l'état 50
+    '='                  décalage et aller à l'état 51
+    '<'                  décalage et aller à l'état 52
+    '>'                  décalage et aller à l'état 53
+    '+'                  décalage et aller à l'état 54
+    '-'                  décalage et aller à l'état 55
+    '*'                  décalage et aller à l'état 56
+    '/'                  décalage et aller à l'état 57
 
 
-state 113
+état 115
 
-   62 MkDict: error . ',' MkDict
+   63 MkDict: error . ',' MkDict
 
-    ','  shift, and go to state 74
+    ','  décalage et aller à l'état 75
 
 
-state 114
+état 116
 
-   62 MkDict: error ',' MkDict .
+   63 MkDict: error ',' MkDict .
 
-    $default  reduce using rule 62 (MkDict)
+    $défaut  réduction par utilisation de la règle 63 (MkDict)
 
 
-state 115
+état 117
 
-   40 ExpD: ExpD . '|' ExpD
-   63 MkDictPair: IDENT ':' ExpD .
+   41 ExpD: ExpD . '|' ExpD
+   64 MkDictPair: IDENT ':' ExpD .
 
-    '|'  shift, and go to state 130
+    '|'  décalage et aller à l'état 132
 
-    $default  reduce using rule 63 (MkDictPair)
+    $défaut  réduction par utilisation de la règle 64 (MkDictPair)
 
 
-state 116
+état 118
 
-   41 ExpD: Term .
-   43 Term: Term . '.' IDENT
-   45     | Term . '[' Exp ']'
-   46     | Term . '[' ']'
-   57     | Term . '[' error ']'
+   42 ExpD: Term .
+   44 Term: Term . '.' IDENT
+   46     | Term . '[' Exp ']'
+   47     | Term . '[' ']'
+   58     | Term . '[' error ']'
 
-    '.'  shift, and go to state 60
-    '['  shift, and go to state 61
+    '.'  décalage et aller à l'état 61
+    '['  décalage et aller à l'état 62
 
-    $default  reduce using rule 41 (ExpD)
+    $défaut  réduction par utilisation de la règle 42 (ExpD)
 
 
-state 117
+état 119
 
-   67 MkDictPair: '(' error ')' . ':' ExpD
+   68 MkDictPair: '(' error ')' . ':' ExpD
 
-    ':'  shift, and go to state 131
+    ':'  décalage et aller à l'état 133
 
 
-state 118
+état 120
 
-   66 MkDictPair: '(' Exp ')' . ':' ExpD
+   67 MkDictPair: '(' Exp ')' . ':' ExpD
 
-    ':'  shift, and go to state 132
+    ':'  décalage et aller à l'état 134
 
 
-state 119
+état 121
 
-   40 ExpD: ExpD . '|' ExpD
-   64 MkDictPair: String ':' ExpD .
+   41 ExpD: ExpD . '|' ExpD
+   65 MkDictPair: String ':' ExpD .
 
-    '|'  shift, and go to state 130
+    '|'  décalage et aller à l'état 132
 
-    $default  reduce using rule 64 (MkDictPair)
+    $défaut  réduction par utilisation de la règle 65 (MkDictPair)
 
 
-state 120
+état 122
 
-   61 MkDict: MkDictPair ',' MkDict .
+   62 MkDict: MkDictPair ',' MkDict .
 
-    $default  reduce using rule 61 (MkDict)
+    $défaut  réduction par utilisation de la règle 62 (MkDict)
 
 
-state 121
+état 123
 
     6 Exp: Term "as" '$' IDENT . '|' Exp
 
-    '|'  shift, and go to state 133
+    '|'  décalage et aller à l'état 135
 
 
-state 122
+état 124
 
-   57 Term: Term '[' error ']' .
+   58 Term: Term '[' error ']' .
 
-    $default  reduce using rule 57 (Term)
+    $défaut  réduction par utilisation de la règle 58 (Term)
 
 
-state 123
+état 125
 
-   45 Term: Term '[' Exp ']' .
+   46 Term: Term '[' Exp ']' .
 
-    $default  reduce using rule 45 (Term)
+    $défaut  réduction par utilisation de la règle 46 (Term)
 
 
-state 124
+état 126
 
-   33 FuncDef: "def" IDENT ':' Exp ';' .
+   34 FuncDef: "def" IDENT ':' Exp ';' .
 
-    $default  reduce using rule 33 (FuncDef)
+    $défaut  réduction par utilisation de la règle 34 (FuncDef)
 
 
-state 125
+état 127
 
-   34 FuncDef: "def" IDENT '(' IDENT ')' . ':' Exp ';'
+   35 FuncDef: "def" IDENT '(' IDENT ')' . ':' Exp ';'
 
-    ':'  shift, and go to state 134
+    ':'  décalage et aller à l'état 136
 
 
-state 126
+état 128
 
-   39 ElseBody: "else" . Exp "end"
+   40 ElseBody: "else" . Exp "end"
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 135
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 137
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 127
+état 129
 
-   38 ElseBody: "elif" . Exp "then" Exp ElseBody
+   39 ElseBody: "elif" . Exp "then" Exp ElseBody
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 136
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 138
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 128
+état 130
 
     7 Exp: "if" Exp "then" Exp ElseBody .
 
-    $default  reduce using rule 7 (Exp)
+    $défaut  réduction par utilisation de la règle 7 (Exp)
 
 
-state 129
+état 131
 
-   37 QQString: QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END .
+   38 QQString: QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END .
 
-    $default  reduce using rule 37 (QQString)
+    $défaut  réduction par utilisation de la règle 38 (QQString)
 
 
-state 130
+état 132
 
-   40 ExpD: ExpD '|' . ExpD
+   41 ExpD: ExpD '|' . ExpD
 
-    IDENT    shift, and go to state 1
-    LITERAL  shift, and go to state 2
-    '$'      shift, and go to state 6
-    '('      shift, and go to state 7
-    '.'      shift, and go to state 8
-    '['      shift, and go to state 9
-    '{'      shift, and go to state 10
+    IDENT    décalage et aller à l'état 1
+    LITERAL  décalage et aller à l'état 2
+    '$'      décalage et aller à l'état 6
+    '('      décalage et aller à l'état 7
+    '.'      décalage et aller à l'état 8
+    '['      décalage et aller à l'état 9
+    '{'      décalage et aller à l'état 10
 
-    ExpD  go to state 137
-    Term  go to state 116
+    ExpD  aller à l'état 139
+    Term  aller à l'état 118
 
 
-state 131
+état 133
 
-   67 MkDictPair: '(' error ')' ':' . ExpD
+   68 MkDictPair: '(' error ')' ':' . ExpD
 
-    IDENT    shift, and go to state 1
-    LITERAL  shift, and go to state 2
-    '$'      shift, and go to state 6
-    '('      shift, and go to state 7
-    '.'      shift, and go to state 8
-    '['      shift, and go to state 9
-    '{'      shift, and go to state 10
+    IDENT    décalage et aller à l'état 1
+    LITERAL  décalage et aller à l'état 2
+    '$'      décalage et aller à l'état 6
+    '('      décalage et aller à l'état 7
+    '.'      décalage et aller à l'état 8
+    '['      décalage et aller à l'état 9
+    '{'      décalage et aller à l'état 10
 
-    ExpD  go to state 138
-    Term  go to state 116
+    ExpD  aller à l'état 140
+    Term  aller à l'état 118
 
 
-state 132
+état 134
 
-   66 MkDictPair: '(' Exp ')' ':' . ExpD
+   67 MkDictPair: '(' Exp ')' ':' . ExpD
 
-    IDENT    shift, and go to state 1
-    LITERAL  shift, and go to state 2
-    '$'      shift, and go to state 6
-    '('      shift, and go to state 7
-    '.'      shift, and go to state 8
-    '['      shift, and go to state 9
-    '{'      shift, and go to state 10
+    IDENT    décalage et aller à l'état 1
+    LITERAL  décalage et aller à l'état 2
+    '$'      décalage et aller à l'état 6
+    '('      décalage et aller à l'état 7
+    '.'      décalage et aller à l'état 8
+    '['      décalage et aller à l'état 9
+    '{'      décalage et aller à l'état 10
 
-    ExpD  go to state 139
-    Term  go to state 116
+    ExpD  aller à l'état 141
+    Term  aller à l'état 118
 
 
-state 133
+état 135
 
     6 Exp: Term "as" '$' IDENT '|' . Exp
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 140
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 142
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 134
+état 136
 
-   34 FuncDef: "def" IDENT '(' IDENT ')' ':' . Exp ';'
+   35 FuncDef: "def" IDENT '(' IDENT ')' ':' . Exp ';'
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 141
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 143
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 135
+état 137
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2984,37 +3108,39 @@ state 135
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
-   39 ElseBody: "else" Exp . "end"
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
+   40 ElseBody: "else" Exp . "end"
 
-    "=="   shift, and go to state 36
-    "//"   shift, and go to state 37
-    "end"  shift, and go to state 142
-    "and"  shift, and go to state 38
-    "or"   shift, and go to state 39
-    "|="   shift, and go to state 40
-    "+="   shift, and go to state 41
-    "-="   shift, and go to state 42
-    "*="   shift, and go to state 43
-    "/="   shift, and go to state 44
-    "//="  shift, and go to state 45
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    '|'    shift, and go to state 48
-    ','    shift, and go to state 49
-    '='    shift, and go to state 50
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "//"   décalage et aller à l'état 38
+    "end"  décalage et aller à l'état 144
+    "and"  décalage et aller à l'état 39
+    "or"   décalage et aller à l'état 40
+    "|="   décalage et aller à l'état 41
+    "+="   décalage et aller à l'état 42
+    "-="   décalage et aller à l'état 43
+    "*="   décalage et aller à l'état 44
+    "/="   décalage et aller à l'état 45
+    "//="  décalage et aller à l'état 46
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    '|'    décalage et aller à l'état 49
+    ','    décalage et aller à l'état 50
+    '='    décalage et aller à l'état 51
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
 
 
-state 136
+état 138
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -3033,65 +3159,67 @@ state 136
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
-   38 ElseBody: "elif" Exp . "then" Exp ElseBody
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
+   39 ElseBody: "elif" Exp . "then" Exp ElseBody
 
-    "=="    shift, and go to state 36
-    "//"    shift, and go to state 37
-    "then"  shift, and go to state 143
-    "and"   shift, and go to state 38
-    "or"    shift, and go to state 39
-    "|="    shift, and go to state 40
-    "+="    shift, and go to state 41
-    "-="    shift, and go to state 42
-    "*="    shift, and go to state 43
-    "/="    shift, and go to state 44
-    "//="   shift, and go to state 45
-    "<="    shift, and go to state 46
-    ">="    shift, and go to state 47
-    '|'     shift, and go to state 48
-    ','     shift, and go to state 49
-    '='     shift, and go to state 50
-    '<'     shift, and go to state 51
-    '>'     shift, and go to state 52
-    '+'     shift, and go to state 53
-    '-'     shift, and go to state 54
-    '*'     shift, and go to state 55
-    '/'     shift, and go to state 56
+    "=="    décalage et aller à l'état 36
+    "!="    décalage et aller à l'état 37
+    "//"    décalage et aller à l'état 38
+    "then"  décalage et aller à l'état 145
+    "and"   décalage et aller à l'état 39
+    "or"    décalage et aller à l'état 40
+    "|="    décalage et aller à l'état 41
+    "+="    décalage et aller à l'état 42
+    "-="    décalage et aller à l'état 43
+    "*="    décalage et aller à l'état 44
+    "/="    décalage et aller à l'état 45
+    "//="   décalage et aller à l'état 46
+    "<="    décalage et aller à l'état 47
+    ">="    décalage et aller à l'état 48
+    '|'     décalage et aller à l'état 49
+    ','     décalage et aller à l'état 50
+    '='     décalage et aller à l'état 51
+    '<'     décalage et aller à l'état 52
+    '>'     décalage et aller à l'état 53
+    '+'     décalage et aller à l'état 54
+    '-'     décalage et aller à l'état 55
+    '*'     décalage et aller à l'état 56
+    '/'     décalage et aller à l'état 57
 
 
-state 137
+état 139
 
-   40 ExpD: ExpD . '|' ExpD
-   40     | ExpD '|' ExpD .
+   41 ExpD: ExpD . '|' ExpD
+   41     | ExpD '|' ExpD .
 
-    $default  reduce using rule 40 (ExpD)
+    $défaut  réduction par utilisation de la règle 41 (ExpD)
 
 
-state 138
+état 140
 
-   40 ExpD: ExpD . '|' ExpD
-   67 MkDictPair: '(' error ')' ':' ExpD .
+   41 ExpD: ExpD . '|' ExpD
+   68 MkDictPair: '(' error ')' ':' ExpD .
 
-    '|'  shift, and go to state 130
+    '|'  décalage et aller à l'état 132
 
-    $default  reduce using rule 67 (MkDictPair)
+    $défaut  réduction par utilisation de la règle 68 (MkDictPair)
 
 
-state 139
+état 141
 
-   40 ExpD: ExpD . '|' ExpD
-   66 MkDictPair: '(' Exp ')' ':' ExpD .
+   41 ExpD: ExpD . '|' ExpD
+   67 MkDictPair: '(' Exp ')' ':' ExpD .
 
-    '|'  shift, and go to state 130
+    '|'  décalage et aller à l'état 132
 
-    $default  reduce using rule 66 (MkDictPair)
+    $défaut  réduction par utilisation de la règle 67 (MkDictPair)
 
 
-state 140
+état 142
 
     6 Exp: Term "as" '$' IDENT '|' Exp .
     9    | Exp . '=' Exp
@@ -3111,36 +3239,38 @@ state 140
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
 
-    "=="   shift, and go to state 36
-    "//"   shift, and go to state 37
-    "and"  shift, and go to state 38
-    "or"   shift, and go to state 39
-    "|="   shift, and go to state 40
-    "+="   shift, and go to state 41
-    "-="   shift, and go to state 42
-    "*="   shift, and go to state 43
-    "/="   shift, and go to state 44
-    "//="  shift, and go to state 45
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    ','    shift, and go to state 49
-    '='    shift, and go to state 50
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "//"   décalage et aller à l'état 38
+    "and"  décalage et aller à l'état 39
+    "or"   décalage et aller à l'état 40
+    "|="   décalage et aller à l'état 41
+    "+="   décalage et aller à l'état 42
+    "-="   décalage et aller à l'état 43
+    "*="   décalage et aller à l'état 44
+    "/="   décalage et aller à l'état 45
+    "//="  décalage et aller à l'état 46
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    ','    décalage et aller à l'état 50
+    '='    décalage et aller à l'état 51
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
 
-    $default  reduce using rule 6 (Exp)
+    $défaut  réduction par utilisation de la règle 6 (Exp)
 
 
-state 141
+état 143
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -3159,72 +3289,74 @@ state 141
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
-   34 FuncDef: "def" IDENT '(' IDENT ')' ':' Exp . ';'
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
+   35 FuncDef: "def" IDENT '(' IDENT ')' ':' Exp . ';'
 
-    "=="   shift, and go to state 36
-    "//"   shift, and go to state 37
-    "and"  shift, and go to state 38
-    "or"   shift, and go to state 39
-    "|="   shift, and go to state 40
-    "+="   shift, and go to state 41
-    "-="   shift, and go to state 42
-    "*="   shift, and go to state 43
-    "/="   shift, and go to state 44
-    "//="  shift, and go to state 45
-    "<="   shift, and go to state 46
-    ">="   shift, and go to state 47
-    ';'    shift, and go to state 144
-    '|'    shift, and go to state 48
-    ','    shift, and go to state 49
-    '='    shift, and go to state 50
-    '<'    shift, and go to state 51
-    '>'    shift, and go to state 52
-    '+'    shift, and go to state 53
-    '-'    shift, and go to state 54
-    '*'    shift, and go to state 55
-    '/'    shift, and go to state 56
+    "=="   décalage et aller à l'état 36
+    "!="   décalage et aller à l'état 37
+    "//"   décalage et aller à l'état 38
+    "and"  décalage et aller à l'état 39
+    "or"   décalage et aller à l'état 40
+    "|="   décalage et aller à l'état 41
+    "+="   décalage et aller à l'état 42
+    "-="   décalage et aller à l'état 43
+    "*="   décalage et aller à l'état 44
+    "/="   décalage et aller à l'état 45
+    "//="  décalage et aller à l'état 46
+    "<="   décalage et aller à l'état 47
+    ">="   décalage et aller à l'état 48
+    ';'    décalage et aller à l'état 146
+    '|'    décalage et aller à l'état 49
+    ','    décalage et aller à l'état 50
+    '='    décalage et aller à l'état 51
+    '<'    décalage et aller à l'état 52
+    '>'    décalage et aller à l'état 53
+    '+'    décalage et aller à l'état 54
+    '-'    décalage et aller à l'état 55
+    '*'    décalage et aller à l'état 56
+    '/'    décalage et aller à l'état 57
 
 
-state 142
+état 144
 
-   39 ElseBody: "else" Exp "end" .
+   40 ElseBody: "else" Exp "end" .
 
-    $default  reduce using rule 39 (ElseBody)
+    $défaut  réduction par utilisation de la règle 40 (ElseBody)
 
 
-state 143
+état 145
 
-   38 ElseBody: "elif" Exp "then" . Exp ElseBody
+   39 ElseBody: "elif" Exp "then" . Exp ElseBody
 
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
+    IDENT           décalage et aller à l'état 1
+    LITERAL         décalage et aller à l'état 2
+    "def"           décalage et aller à l'état 3
+    "if"            décalage et aller à l'état 4
+    QQSTRING_START  décalage et aller à l'état 5
+    '$'             décalage et aller à l'état 6
+    '('             décalage et aller à l'état 7
+    '.'             décalage et aller à l'état 8
+    '['             décalage et aller à l'état 9
+    '{'             décalage et aller à l'état 10
 
-    Exp      go to state 145
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
+    Exp      aller à l'état 147
+    String   aller à l'état 14
+    FuncDef  aller à l'état 20
+    Term     aller à l'état 16
 
 
-state 144
+état 146
 
-   34 FuncDef: "def" IDENT '(' IDENT ')' ':' Exp ';' .
+   35 FuncDef: "def" IDENT '(' IDENT ')' ':' Exp ';' .
 
-    $default  reduce using rule 34 (FuncDef)
+    $défaut  réduction par utilisation de la règle 35 (FuncDef)
 
 
-state 145
+état 147
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -3243,41 +3375,43 @@ state 145
    23    | Exp . '/' Exp
    24    | Exp . "/=" Exp
    25    | Exp . "==" Exp
-   26    | Exp . '<' Exp
-   27    | Exp . '>' Exp
-   28    | Exp . "<=" Exp
-   29    | Exp . ">=" Exp
-   38 ElseBody: "elif" Exp "then" Exp . ElseBody
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
+   39 ElseBody: "elif" Exp "then" Exp . ElseBody
 
-    "=="    shift, and go to state 36
-    "//"    shift, and go to state 37
-    "else"  shift, and go to state 126
-    "elif"  shift, and go to state 127
-    "and"   shift, and go to state 38
-    "or"    shift, and go to state 39
-    "|="    shift, and go to state 40
-    "+="    shift, and go to state 41
-    "-="    shift, and go to state 42
-    "*="    shift, and go to state 43
-    "/="    shift, and go to state 44
-    "//="   shift, and go to state 45
-    "<="    shift, and go to state 46
-    ">="    shift, and go to state 47
-    '|'     shift, and go to state 48
-    ','     shift, and go to state 49
-    '='     shift, and go to state 50
-    '<'     shift, and go to state 51
-    '>'     shift, and go to state 52
-    '+'     shift, and go to state 53
-    '-'     shift, and go to state 54
-    '*'     shift, and go to state 55
-    '/'     shift, and go to state 56
+    "=="    décalage et aller à l'état 36
+    "!="    décalage et aller à l'état 37
+    "//"    décalage et aller à l'état 38
+    "else"  décalage et aller à l'état 128
+    "elif"  décalage et aller à l'état 129
+    "and"   décalage et aller à l'état 39
+    "or"    décalage et aller à l'état 40
+    "|="    décalage et aller à l'état 41
+    "+="    décalage et aller à l'état 42
+    "-="    décalage et aller à l'état 43
+    "*="    décalage et aller à l'état 44
+    "/="    décalage et aller à l'état 45
+    "//="   décalage et aller à l'état 46
+    "<="    décalage et aller à l'état 47
+    ">="    décalage et aller à l'état 48
+    '|'     décalage et aller à l'état 49
+    ','     décalage et aller à l'état 50
+    '='     décalage et aller à l'état 51
+    '<'     décalage et aller à l'état 52
+    '>'     décalage et aller à l'état 53
+    '+'     décalage et aller à l'état 54
+    '-'     décalage et aller à l'état 55
+    '*'     décalage et aller à l'état 56
+    '/'     décalage et aller à l'état 57
 
-    ElseBody  go to state 146
+    ElseBody  aller à l'état 148
 
 
-state 146
+état 148
 
-   38 ElseBody: "elif" Exp "then" Exp ElseBody .
+   39 ElseBody: "elif" Exp "then" Exp ElseBody .
 
-    $default  reduce using rule 38 (ElseBody)
+    $défaut  réduction par utilisation de la règle 39 (ElseBody)

From 45b6fc81481677e3b3b716871f4f9fe3d311590e Mon Sep 17 00:00:00 2001
From: Damian Gryski <damian@gryski.com>
Date: Tue, 23 Oct 2012 21:12:47 +0200
Subject: [PATCH 132/284] Add some in/equality test cases

---
 testdata | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/testdata b/testdata
index 6f04a1d5..8cd5e27c 100644
--- a/testdata
+++ b/testdata
@@ -372,4 +372,26 @@ def inc(x): x |= .+1; inc(.[].a)
 
 [10 >= 0, 10 >= 10, 10 >= 20, 10 <= 0, 10 <= 10, 10 <= 20]
 {}
-[true,true,false,false,true,true]
\ No newline at end of file
+[true,true,false,false,true,true]
+
+# And some in/equality tests
+[ 10 == 10, 10 != 10, 10 != 11, 10 == 11]
+{}
+[true,false,true,false]
+
+["hello" == "hello", "hello" != "hello", "hello" == "world", "hello" != "world" ]
+{}
+[true,false,false,true]
+
+[[1,2,3] == [1,2,3], [1,2,3] != [1,2,3], [1,2,3] == [4,5,6], [1,2,3] != [4,5,6]]
+{}
+[true,false,false,true]
+
+[{"foo":42} == {"foo":42},{"foo":42} != {"foo":42}, {"foo":42} != {"bar":42}, {"foo":42} == {"bar":42}]
+{}
+[true,false,true,false]
+
+# ugly complicated thing
+[{"foo":[1,2,{"bar":18},"world"]} == {"foo":[1,2,{"bar":18},"world"]},{"foo":[1,2,{"bar":18},"world"]} == {"foo":[1,2,{"bar":19},"world"]}]
+{}
+[true,false]

From 5a64a297745987030735763254224958bc08159a Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 23 Oct 2012 21:58:50 +0100
Subject: [PATCH 133/284] Remove .gitignore from tarballs.

---
 .gitattributes | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 .gitattributes

diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 00000000..59661532
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,2 @@
+.gitattributes export-ignore
+.gitignore export-ignore

From e40778727b6bb0b9c714d0426abcdcd67896fc52 Mon Sep 17 00:00:00 2001
From: Damian Gryski <damian@gryski.com>
Date: Wed, 24 Oct 2012 09:28:27 +0200
Subject: [PATCH 134/284] Replace yyscan_t with another pointer type that we
 control.

This prevents the circuluar dependency between parser.gen.h and
lexer.gen.h.  Newer versions of bison add a prototype for yyparse() to
parser.gen.h that include the as-yet-undeclared yyscan_t type.
---
 lexer.l  |  3 +++
 parser.y | 36 ++++++++++++++++++++----------------
 2 files changed, 23 insertions(+), 16 deletions(-)

diff --git a/lexer.l b/lexer.l
index 5c6b62f4..e0bb2b7b 100644
--- a/lexer.l
+++ b/lexer.l
@@ -1,5 +1,8 @@
 %{
 #include "compile.h"
+
+struct lexer_param;
+
 #include "parser.gen.h"  /* Generated by bison. */
 
 #define YY_USER_ACTION                           \
diff --git a/parser.y b/parser.y
index b0e4e521..e2e591df 100644
--- a/parser.y
+++ b/parser.y
@@ -3,7 +3,7 @@
 #include <string.h>
 #include "compile.h"
 
-typedef void* yyscan_t;
+struct lexer_param;
 
 %}
 %code requires {
@@ -35,11 +35,11 @@ typedef void* yyscan_t;
 %parse-param {block* answer}
 %parse-param {int* errors}
 %parse-param {struct locfile* locations}
-%parse-param {yyscan_t lexer}
+%parse-param {struct lexer_param* lexer_param_ptr}
 %lex-param {block* answer}
 %lex-param {int* errors}
 %lex-param {struct locfile* locations}
-%lex-param {yyscan_t lexer}
+%lex-param {struct lexer_param* lexer_param_ptr}
 
 
 %token INVALID_CHARACTER
@@ -88,21 +88,25 @@ typedef void* yyscan_t;
 %type <blk> Exp Term MkDict MkDictPair ExpD ElseBody QQString FuncDef FuncDefs String
 %{
 #include "lexer.gen.h"
-#define FAIL(loc, msg)                                   \
-  do {                                                   \
-    location l = loc;                                    \
-    yyerror(&l, answer, errors, locations, lexer, msg);  \
-    /*YYERROR*/;                                         \
+struct lexer_param {
+  yyscan_t lexer;
+};
+#define FAIL(loc, msg)                                             \
+  do {                                                             \
+    location l = loc;                                              \
+    yyerror(&l, answer, errors, locations, lexer_param_ptr, msg);  \
+    /*YYERROR*/;                                                   \
   } while (0)
 
 void yyerror(YYLTYPE* loc, block* answer, int* errors, 
-             struct locfile* locations, yyscan_t lexer, const char *s){
+             struct locfile* locations, struct lexer_param* lexer_param_ptr, const char *s){
   (*errors)++;
   locfile_locate(locations, *loc, "error: %s", s);
 }
 
 int yylex(YYSTYPE* yylval, YYLTYPE* yylloc, block* answer, int* errors, 
-          struct locfile* locations, yyscan_t lexer) {
+          struct locfile* locations, struct lexer_param* lexer_param_ptr) {
+  yyscan_t lexer = lexer_param_ptr->lexer;
   while (1) {
     int tok = jq_yylex(yylval, yylloc, lexer);
     if (tok == INVALID_CHARACTER) {
@@ -444,15 +448,15 @@ MkDictPair
 %%
 
 int jq_parse(struct locfile* locations, block* answer) {
-  yyscan_t scanner;
+  struct lexer_param scanner;
   YY_BUFFER_STATE buf;
-  jq_yylex_init_extra(0, &scanner);
-  buf = jq_yy_scan_bytes(locations->data, locations->length, scanner);
+  jq_yylex_init_extra(0, &scanner.lexer);
+  buf = jq_yy_scan_bytes(locations->data, locations->length, scanner.lexer);
   int errors = 0;
   *answer = gen_noop();
-  yyparse(answer, &errors, locations, scanner);
-  jq_yy_delete_buffer(buf, scanner);
-  jq_yylex_destroy(scanner);
+  yyparse(answer, &errors, locations, &scanner);
+  jq_yy_delete_buffer(buf, scanner.lexer);
+  jq_yylex_destroy(scanner.lexer);
   if (errors > 0) {
     block_free(*answer);
     *answer = gen_noop();

From 0adf4638d1aa53549ef1e91b5a3f75f5e835f15d Mon Sep 17 00:00:00 2001
From: Damian Gryski <damian@gryski.com>
Date: Wed, 24 Oct 2012 09:31:21 +0200
Subject: [PATCH 135/284] Update generated lexer.gen.* and parser.gen.* files

---
 lexer.gen.c  |  85 ++++++++--------
 lexer.gen.h  |   2 +-
 parser.gen.c | 276 ++++++++++++++++++++++++++-------------------------
 parser.gen.h |   2 +-
 4 files changed, 186 insertions(+), 179 deletions(-)

diff --git a/lexer.gen.c b/lexer.gen.c
index 7d8b953c..dbaf0abc 100644
--- a/lexer.gen.c
+++ b/lexer.gen.c
@@ -501,6 +501,9 @@ static yyconst flex_int16_t yy_chk[190] =
 #line 1 "lexer.l"
 #line 2 "lexer.l"
 #include "compile.h"
+
+struct lexer_param;
+
 #include "parser.gen.h"  /* Generated by bison. */
 
 #define YY_USER_ACTION                           \
@@ -515,11 +518,11 @@ static yyconst flex_int16_t yy_chk[190] =
 
 
 
-#line 20 "lexer.l"
+#line 23 "lexer.l"
   static int enter(int opening, int state, yyscan_t yyscanner);
   static int try_exit(int closing, int state, yyscan_t yyscanner);
 #define YY_NO_INPUT 1
-#line 523 "lexer.gen.c"
+#line 526 "lexer.gen.c"
 
 #define INITIAL 0
 #define IN_PAREN 1
@@ -771,10 +774,10 @@ YY_DECL
 	register int yy_act;
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
-#line 32 "lexer.l"
+#line 35 "lexer.l"
 
 
-#line 778 "lexer.gen.c"
+#line 781 "lexer.gen.c"
 
     yylval = yylval_param;
 
@@ -863,138 +866,138 @@ do_action:	/* This label is used only to access EOF actions. */
 
 case 1:
 YY_RULE_SETUP
-#line 34 "lexer.l"
+#line 37 "lexer.l"
 { /* comments */ }
 	YY_BREAK
 case 2:
 YY_RULE_SETUP
-#line 36 "lexer.l"
+#line 39 "lexer.l"
 { return NEQ; }
 	YY_BREAK
 case 3:
 YY_RULE_SETUP
-#line 37 "lexer.l"
+#line 40 "lexer.l"
 { return EQ; }
 	YY_BREAK
 case 4:
 YY_RULE_SETUP
-#line 38 "lexer.l"
+#line 41 "lexer.l"
 { return AS; }
 	YY_BREAK
 case 5:
 YY_RULE_SETUP
-#line 39 "lexer.l"
+#line 42 "lexer.l"
 { return DEF; }
 	YY_BREAK
 case 6:
 YY_RULE_SETUP
-#line 40 "lexer.l"
+#line 43 "lexer.l"
 { return IF; }
 	YY_BREAK
 case 7:
 YY_RULE_SETUP
-#line 41 "lexer.l"
+#line 44 "lexer.l"
 { return THEN; }
 	YY_BREAK
 case 8:
 YY_RULE_SETUP
-#line 42 "lexer.l"
+#line 45 "lexer.l"
 { return ELSE; }
 	YY_BREAK
 case 9:
 YY_RULE_SETUP
-#line 43 "lexer.l"
+#line 46 "lexer.l"
 { return ELSE_IF; }
 	YY_BREAK
 case 10:
 YY_RULE_SETUP
-#line 44 "lexer.l"
+#line 47 "lexer.l"
 { return AND; }
 	YY_BREAK
 case 11:
 YY_RULE_SETUP
-#line 45 "lexer.l"
+#line 48 "lexer.l"
 { return OR; }
 	YY_BREAK
 case 12:
 YY_RULE_SETUP
-#line 46 "lexer.l"
+#line 49 "lexer.l"
 { return END; }
 	YY_BREAK
 case 13:
 YY_RULE_SETUP
-#line 47 "lexer.l"
+#line 50 "lexer.l"
 { return DEFINEDOR; }
 	YY_BREAK
 case 14:
 YY_RULE_SETUP
-#line 48 "lexer.l"
+#line 51 "lexer.l"
 { return SETPIPE; }
 	YY_BREAK
 case 15:
 YY_RULE_SETUP
-#line 49 "lexer.l"
+#line 52 "lexer.l"
 { return SETPLUS; }
 	YY_BREAK
 case 16:
 YY_RULE_SETUP
-#line 50 "lexer.l"
+#line 53 "lexer.l"
 { return SETMINUS; }
 	YY_BREAK
 case 17:
 YY_RULE_SETUP
-#line 51 "lexer.l"
+#line 54 "lexer.l"
 { return SETMULT; }
 	YY_BREAK
 case 18:
 YY_RULE_SETUP
-#line 52 "lexer.l"
+#line 55 "lexer.l"
 { return SETDIV; }
 	YY_BREAK
 case 19:
 YY_RULE_SETUP
-#line 53 "lexer.l"
+#line 56 "lexer.l"
 { return SETDEFINEDOR; }
 	YY_BREAK
 case 20:
 YY_RULE_SETUP
-#line 54 "lexer.l"
+#line 57 "lexer.l"
 { return LESSEQ; }
 	YY_BREAK
 case 21:
 YY_RULE_SETUP
-#line 55 "lexer.l"
+#line 58 "lexer.l"
 { return GREATEREQ; }
 	YY_BREAK
 case 22:
 YY_RULE_SETUP
-#line 56 "lexer.l"
+#line 59 "lexer.l"
 { return yytext[0];}
 	YY_BREAK
 case 23:
 YY_RULE_SETUP
-#line 58 "lexer.l"
+#line 61 "lexer.l"
 {
   return enter(yytext[0], YY_START, yyscanner);
 }
 	YY_BREAK
 case 24:
 YY_RULE_SETUP
-#line 62 "lexer.l"
+#line 65 "lexer.l"
 {
   return try_exit(yytext[0], YY_START, yyscanner);
 }
 	YY_BREAK
 case 25:
 YY_RULE_SETUP
-#line 67 "lexer.l"
+#line 70 "lexer.l"
 { 
    yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; 
 }
 	YY_BREAK
 case 26:
 YY_RULE_SETUP
-#line 71 "lexer.l"
+#line 74 "lexer.l"
 {
   yy_push_state(IN_QQSTRING, yyscanner);
   return QQSTRING_START;
@@ -1003,14 +1006,14 @@ YY_RULE_SETUP
 
 case 27:
 YY_RULE_SETUP
-#line 77 "lexer.l"
+#line 80 "lexer.l"
 {
     return enter(QQSTRING_INTERP_START, YY_START, yyscanner);
   }
 	YY_BREAK
 case 28:
 YY_RULE_SETUP
-#line 80 "lexer.l"
+#line 83 "lexer.l"
 {
     yy_pop_state(yyscanner);
     return QQSTRING_END;
@@ -1019,7 +1022,7 @@ YY_RULE_SETUP
 case 29:
 /* rule 29 can match eol */
 YY_RULE_SETUP
-#line 84 "lexer.l"
+#line 87 "lexer.l"
 {
     /* pass escapes to the json parser */
     jv escapes = jv_string_fmt("\"%.*s\"", yyleng, yytext);
@@ -1031,7 +1034,7 @@ YY_RULE_SETUP
 case 30:
 /* rule 30 can match eol */
 YY_RULE_SETUP
-#line 91 "lexer.l"
+#line 94 "lexer.l"
 {
     yylval->literal = jv_string_sized(yytext, yyleng);
     return QQSTRING_TEXT;
@@ -1039,7 +1042,7 @@ YY_RULE_SETUP
 	YY_BREAK
 case 31:
 YY_RULE_SETUP
-#line 95 "lexer.l"
+#line 98 "lexer.l"
 {
     return INVALID_CHARACTER;
   }
@@ -1047,26 +1050,26 @@ YY_RULE_SETUP
 
 case 32:
 YY_RULE_SETUP
-#line 101 "lexer.l"
+#line 104 "lexer.l"
 { yylval->literal = jv_string(yytext); return IDENT;}
 	YY_BREAK
 case 33:
 /* rule 33 can match eol */
 YY_RULE_SETUP
-#line 103 "lexer.l"
+#line 106 "lexer.l"
 {}
 	YY_BREAK
 case 34:
 YY_RULE_SETUP
-#line 105 "lexer.l"
+#line 108 "lexer.l"
 { return INVALID_CHARACTER; }
 	YY_BREAK
 case 35:
 YY_RULE_SETUP
-#line 107 "lexer.l"
+#line 110 "lexer.l"
 YY_FATAL_ERROR( "flex scanner jammed" );
 	YY_BREAK
-#line 1070 "lexer.gen.c"
+#line 1073 "lexer.gen.c"
 case YY_STATE_EOF(INITIAL):
 case YY_STATE_EOF(IN_PAREN):
 case YY_STATE_EOF(IN_BRACKET):
@@ -2249,7 +2252,7 @@ void jq_yyfree (void * ptr , yyscan_t yyscanner)
 
 #define YYTABLES_NAME "yytables"
 
-#line 107 "lexer.l"
+#line 110 "lexer.l"
 
 
 /* perhaps these should be calls... */
diff --git a/lexer.gen.h b/lexer.gen.h
index ee486e8a..e22ddb29 100644
--- a/lexer.gen.h
+++ b/lexer.gen.h
@@ -345,7 +345,7 @@ extern int jq_yylex \
 #undef YY_DECL
 #endif
 
-#line 107 "lexer.l"
+#line 110 "lexer.l"
 
 
 #line 352 "lexer.gen.h"
diff --git a/parser.gen.c b/parser.gen.c
index 79213801..32a2a205 100644
--- a/parser.gen.c
+++ b/parser.gen.c
@@ -69,7 +69,7 @@
 #include <string.h>
 #include "compile.h"
 
-typedef void* yyscan_t;
+struct lexer_param;
 
 
 /* Line 336 of yacc.c  */
@@ -201,7 +201,7 @@ int yyparse ();
 #endif
 #else /* ! YYPARSE_PARAM */
 #if defined __STDC__ || defined __cplusplus
-int yyparse (block* answer, int* errors, struct locfile* locations, yyscan_t lexer);
+int yyparse (block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr);
 #else
 int yyparse ();
 #endif
@@ -214,21 +214,25 @@ int yyparse ();
 #line 89 "parser.y"
 
 #include "lexer.gen.h"
-#define FAIL(loc, msg)                                   \
-  do {                                                   \
-    location l = loc;                                    \
-    yyerror(&l, answer, errors, locations, lexer, msg);  \
-    /*YYERROR*/;                                         \
+struct lexer_param {
+  yyscan_t lexer;
+};
+#define FAIL(loc, msg)                                             \
+  do {                                                             \
+    location l = loc;                                              \
+    yyerror(&l, answer, errors, locations, lexer_param_ptr, msg);  \
+    /*YYERROR*/;                                                   \
   } while (0)
 
 void yyerror(YYLTYPE* loc, block* answer, int* errors, 
-             struct locfile* locations, yyscan_t lexer, const char *s){
+             struct locfile* locations, struct lexer_param* lexer_param_ptr, const char *s){
   (*errors)++;
   locfile_locate(locations, *loc, "error: %s", s);
 }
 
 int yylex(YYSTYPE* yylval, YYLTYPE* yylloc, block* answer, int* errors, 
-          struct locfile* locations, yyscan_t lexer) {
+          struct locfile* locations, struct lexer_param* lexer_param_ptr) {
+  yyscan_t lexer = lexer_param_ptr->lexer;
   while (1) {
     int tok = jq_yylex(yylval, yylloc, lexer);
     if (tok == INVALID_CHARACTER) {
@@ -300,7 +304,7 @@ static block gen_update(block a, block op, int optype) {
 
 
 /* Line 353 of yacc.c  */
-#line 304 "parser.gen.c"
+#line 308 "parser.gen.c"
 
 #ifdef short
 # undef short
@@ -623,13 +627,13 @@ static const yytype_int8 yyrhs[] =
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 static const yytype_uint16 yyrline[] =
 {
-       0,   179,   179,   182,   187,   190,   195,   199,   206,   209,
-     214,   223,   227,   231,   235,   239,   243,   247,   251,   255,
-     259,   263,   267,   271,   275,   279,   283,   287,   291,   295,
-     299,   303,   307,   311,   316,   321,   327,   335,   338,   341,
-     347,   350,   355,   359,   365,   368,   371,   375,   378,   381,
-     384,   387,   390,   393,   398,   402,   406,   416,   417,   418,
-     419,   422,   425,   426,   427,   430,   433,   436,   440,   443
+       0,   183,   183,   186,   191,   194,   199,   203,   210,   213,
+     218,   227,   231,   235,   239,   243,   247,   251,   255,   259,
+     263,   267,   271,   275,   279,   283,   287,   291,   295,   299,
+     303,   307,   311,   315,   320,   325,   331,   339,   342,   345,
+     351,   354,   359,   363,   369,   372,   375,   379,   382,   385,
+     388,   391,   394,   397,   402,   406,   410,   420,   421,   422,
+     423,   426,   429,   430,   431,   434,   437,   440,   444,   447
 };
 #endif
 
@@ -992,7 +996,7 @@ do                                                              \
     }                                                           \
   else                                                          \
     {                                                           \
-      yyerror (&yylloc, answer, errors, locations, lexer, YY_("syntax error: cannot back up")); \
+      yyerror (&yylloc, answer, errors, locations, lexer_param_ptr, YY_("syntax error: cannot back up")); \
       YYERROR;							\
     }								\
 while (YYID (0))
@@ -1050,7 +1054,7 @@ while (YYID (0))
 #ifdef YYLEX_PARAM
 # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
 #else
-# define YYLEX yylex (&yylval, &yylloc, answer, errors, locations, lexer)
+# define YYLEX yylex (&yylval, &yylloc, answer, errors, locations, lexer_param_ptr)
 #endif
 
 /* Enable debugging if requested.  */
@@ -1073,7 +1077,7 @@ do {									  \
     {									  \
       YYFPRINTF (stderr, "%s ", Title);					  \
       yy_symbol_print (stderr,						  \
-		  Type, Value, Location, answer, errors, locations, lexer); \
+		  Type, Value, Location, answer, errors, locations, lexer_param_ptr); \
       YYFPRINTF (stderr, "\n");						  \
     }									  \
 } while (YYID (0))
@@ -1087,10 +1091,10 @@ do {									  \
 #if (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 static void
-yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, block* answer, int* errors, struct locfile* locations, yyscan_t lexer)
+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr)
 #else
 static void
-yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors, locations, lexer)
+yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors, locations, lexer_param_ptr)
     FILE *yyoutput;
     int yytype;
     YYSTYPE const * const yyvaluep;
@@ -1098,7 +1102,7 @@ yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors,
     block* answer;
     int* errors;
     struct locfile* locations;
-    yyscan_t lexer;
+    struct lexer_param* lexer_param_ptr;
 #endif
 {
   FILE *yyo = yyoutput;
@@ -1109,7 +1113,7 @@ yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors,
   YYUSE (answer);
   YYUSE (errors);
   YYUSE (locations);
-  YYUSE (lexer);
+  YYUSE (lexer_param_ptr);
 # ifdef YYPRINT
   if (yytype < YYNTOKENS)
     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
@@ -1131,10 +1135,10 @@ yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors,
 #if (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 static void
-yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, block* answer, int* errors, struct locfile* locations, yyscan_t lexer)
+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr)
 #else
 static void
-yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors, locations, lexer)
+yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors, locations, lexer_param_ptr)
     FILE *yyoutput;
     int yytype;
     YYSTYPE const * const yyvaluep;
@@ -1142,7 +1146,7 @@ yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors, locati
     block* answer;
     int* errors;
     struct locfile* locations;
-    yyscan_t lexer;
+    struct lexer_param* lexer_param_ptr;
 #endif
 {
   if (yytype < YYNTOKENS)
@@ -1152,7 +1156,7 @@ yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors, locati
 
   YY_LOCATION_PRINT (yyoutput, *yylocationp);
   YYFPRINTF (yyoutput, ": ");
-  yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors, locations, lexer);
+  yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors, locations, lexer_param_ptr);
   YYFPRINTF (yyoutput, ")");
 }
 
@@ -1195,17 +1199,17 @@ do {								\
 #if (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 static void
-yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, block* answer, int* errors, struct locfile* locations, yyscan_t lexer)
+yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr)
 #else
 static void
-yy_reduce_print (yyvsp, yylsp, yyrule, answer, errors, locations, lexer)
+yy_reduce_print (yyvsp, yylsp, yyrule, answer, errors, locations, lexer_param_ptr)
     YYSTYPE *yyvsp;
     YYLTYPE *yylsp;
     int yyrule;
     block* answer;
     int* errors;
     struct locfile* locations;
-    yyscan_t lexer;
+    struct lexer_param* lexer_param_ptr;
 #endif
 {
   int yynrhs = yyr2[yyrule];
@@ -1219,7 +1223,7 @@ yy_reduce_print (yyvsp, yylsp, yyrule, answer, errors, locations, lexer)
       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
 		       &(yyvsp[(yyi + 1) - (yynrhs)])
-		       , &(yylsp[(yyi + 1) - (yynrhs)])		       , answer, errors, locations, lexer);
+		       , &(yylsp[(yyi + 1) - (yynrhs)])		       , answer, errors, locations, lexer_param_ptr);
       YYFPRINTF (stderr, "\n");
     }
 }
@@ -1227,7 +1231,7 @@ yy_reduce_print (yyvsp, yylsp, yyrule, answer, errors, locations, lexer)
 # define YY_REDUCE_PRINT(Rule)		\
 do {					\
   if (yydebug)				\
-    yy_reduce_print (yyvsp, yylsp, Rule, answer, errors, locations, lexer); \
+    yy_reduce_print (yyvsp, yylsp, Rule, answer, errors, locations, lexer_param_ptr); \
 } while (YYID (0))
 
 /* Nonzero means print parse trace.  It is left uninitialized so that
@@ -1504,10 +1508,10 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
 #if (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 static void
-yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, block* answer, int* errors, struct locfile* locations, yyscan_t lexer)
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr)
 #else
 static void
-yydestruct (yymsg, yytype, yyvaluep, yylocationp, answer, errors, locations, lexer)
+yydestruct (yymsg, yytype, yyvaluep, yylocationp, answer, errors, locations, lexer_param_ptr)
     const char *yymsg;
     int yytype;
     YYSTYPE *yyvaluep;
@@ -1515,7 +1519,7 @@ yydestruct (yymsg, yytype, yyvaluep, yylocationp, answer, errors, locations, lex
     block* answer;
     int* errors;
     struct locfile* locations;
-    yyscan_t lexer;
+    struct lexer_param* lexer_param_ptr;
 #endif
 {
   YYUSE (yyvaluep);
@@ -1523,7 +1527,7 @@ yydestruct (yymsg, yytype, yyvaluep, yylocationp, answer, errors, locations, lex
   YYUSE (answer);
   YYUSE (errors);
   YYUSE (locations);
-  YYUSE (lexer);
+  YYUSE (lexer_param_ptr);
 
   if (!yymsg)
     yymsg = "Deleting";
@@ -1536,91 +1540,91 @@ yydestruct (yymsg, yytype, yyvaluep, yylocationp, answer, errors, locations, lex
 #line 32 "parser.y"
 	{ jv_free(((*yyvaluep).literal)); };
 /* Line 1381 of yacc.c  */
-#line 1540 "parser.gen.c"
+#line 1544 "parser.gen.c"
 	break;
       case 5: /* LITERAL */
 /* Line 1381 of yacc.c  */
 #line 32 "parser.y"
 	{ jv_free(((*yyvaluep).literal)); };
 /* Line 1381 of yacc.c  */
-#line 1547 "parser.gen.c"
+#line 1551 "parser.gen.c"
 	break;
       case 27: /* QQSTRING_TEXT */
 /* Line 1381 of yacc.c  */
 #line 32 "parser.y"
 	{ jv_free(((*yyvaluep).literal)); };
 /* Line 1381 of yacc.c  */
-#line 1554 "parser.gen.c"
+#line 1558 "parser.gen.c"
 	break;
       case 52: /* FuncDefs */
 /* Line 1381 of yacc.c  */
 #line 33 "parser.y"
 	{ block_free(((*yyvaluep).blk)); };
 /* Line 1381 of yacc.c  */
-#line 1561 "parser.gen.c"
+#line 1565 "parser.gen.c"
 	break;
       case 53: /* Exp */
 /* Line 1381 of yacc.c  */
 #line 33 "parser.y"
 	{ block_free(((*yyvaluep).blk)); };
 /* Line 1381 of yacc.c  */
-#line 1568 "parser.gen.c"
+#line 1572 "parser.gen.c"
 	break;
       case 54: /* String */
 /* Line 1381 of yacc.c  */
 #line 33 "parser.y"
 	{ block_free(((*yyvaluep).blk)); };
 /* Line 1381 of yacc.c  */
-#line 1575 "parser.gen.c"
+#line 1579 "parser.gen.c"
 	break;
       case 55: /* FuncDef */
 /* Line 1381 of yacc.c  */
 #line 33 "parser.y"
 	{ block_free(((*yyvaluep).blk)); };
 /* Line 1381 of yacc.c  */
-#line 1582 "parser.gen.c"
+#line 1586 "parser.gen.c"
 	break;
       case 56: /* QQString */
 /* Line 1381 of yacc.c  */
 #line 33 "parser.y"
 	{ block_free(((*yyvaluep).blk)); };
 /* Line 1381 of yacc.c  */
-#line 1589 "parser.gen.c"
+#line 1593 "parser.gen.c"
 	break;
       case 57: /* ElseBody */
 /* Line 1381 of yacc.c  */
 #line 33 "parser.y"
 	{ block_free(((*yyvaluep).blk)); };
 /* Line 1381 of yacc.c  */
-#line 1596 "parser.gen.c"
+#line 1600 "parser.gen.c"
 	break;
       case 58: /* ExpD */
 /* Line 1381 of yacc.c  */
 #line 33 "parser.y"
 	{ block_free(((*yyvaluep).blk)); };
 /* Line 1381 of yacc.c  */
-#line 1603 "parser.gen.c"
+#line 1607 "parser.gen.c"
 	break;
       case 59: /* Term */
 /* Line 1381 of yacc.c  */
 #line 33 "parser.y"
 	{ block_free(((*yyvaluep).blk)); };
 /* Line 1381 of yacc.c  */
-#line 1610 "parser.gen.c"
+#line 1614 "parser.gen.c"
 	break;
       case 60: /* MkDict */
 /* Line 1381 of yacc.c  */
 #line 33 "parser.y"
 	{ block_free(((*yyvaluep).blk)); };
 /* Line 1381 of yacc.c  */
-#line 1617 "parser.gen.c"
+#line 1621 "parser.gen.c"
 	break;
       case 61: /* MkDictPair */
 /* Line 1381 of yacc.c  */
 #line 33 "parser.y"
 	{ block_free(((*yyvaluep).blk)); };
 /* Line 1381 of yacc.c  */
-#line 1624 "parser.gen.c"
+#line 1628 "parser.gen.c"
 	break;
 
       default:
@@ -1649,14 +1653,14 @@ yyparse (YYPARSE_PARAM)
 #if (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 int
-yyparse (block* answer, int* errors, struct locfile* locations, yyscan_t lexer)
+yyparse (block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr)
 #else
 int
-yyparse (answer, errors, locations, lexer)
+yyparse (answer, errors, locations, lexer_param_ptr)
     block* answer;
     int* errors;
     struct locfile* locations;
-    yyscan_t lexer;
+    struct lexer_param* lexer_param_ptr;
 #endif
 #endif
 {
@@ -1936,7 +1940,7 @@ yyreduce:
     {
         case 2:
 /* Line 1787 of yacc.c  */
-#line 179 "parser.y"
+#line 183 "parser.y"
     {
   *answer = (yyvsp[(1) - (1)].blk);
 }
@@ -1944,7 +1948,7 @@ yyreduce:
 
   case 3:
 /* Line 1787 of yacc.c  */
-#line 182 "parser.y"
+#line 186 "parser.y"
     {
   *answer = (yyvsp[(1) - (1)].blk);
 }
@@ -1952,7 +1956,7 @@ yyreduce:
 
   case 4:
 /* Line 1787 of yacc.c  */
-#line 187 "parser.y"
+#line 191 "parser.y"
     {
   (yyval.blk) = gen_noop();
 }
@@ -1960,7 +1964,7 @@ yyreduce:
 
   case 5:
 /* Line 1787 of yacc.c  */
-#line 190 "parser.y"
+#line 194 "parser.y"
     {
   (yyval.blk) = block_join((yyvsp[(1) - (2)].blk), (yyvsp[(2) - (2)].blk));
 }
@@ -1968,7 +1972,7 @@ yyreduce:
 
   case 6:
 /* Line 1787 of yacc.c  */
-#line 195 "parser.y"
+#line 199 "parser.y"
     {
   (yyval.blk) = block_bind((yyvsp[(1) - (2)].blk), (yyvsp[(2) - (2)].blk), OP_IS_CALL_PSEUDO);
 }
@@ -1976,7 +1980,7 @@ yyreduce:
 
   case 7:
 /* Line 1787 of yacc.c  */
-#line 199 "parser.y"
+#line 203 "parser.y"
     {
   (yyval.blk) = gen_op_simple(DUP);
   block_append(&(yyval.blk), (yyvsp[(1) - (6)].blk));
@@ -1987,7 +1991,7 @@ yyreduce:
 
   case 8:
 /* Line 1787 of yacc.c  */
-#line 206 "parser.y"
+#line 210 "parser.y"
     {
   (yyval.blk) = gen_cond((yyvsp[(2) - (5)].blk), (yyvsp[(4) - (5)].blk), (yyvsp[(5) - (5)].blk));
 }
@@ -1995,7 +1999,7 @@ yyreduce:
 
   case 9:
 /* Line 1787 of yacc.c  */
-#line 209 "parser.y"
+#line 213 "parser.y"
     {
   FAIL((yyloc), "Possibly unterminated 'if' statment");
   (yyval.blk) = (yyvsp[(2) - (3)].blk);
@@ -2004,7 +2008,7 @@ yyreduce:
 
   case 10:
 /* Line 1787 of yacc.c  */
-#line 214 "parser.y"
+#line 218 "parser.y"
     {
   block assign = gen_op_simple(DUP);
   block_append(&assign, (yyvsp[(3) - (3)].blk));
@@ -2017,7 +2021,7 @@ yyreduce:
 
   case 11:
 /* Line 1787 of yacc.c  */
-#line 223 "parser.y"
+#line 227 "parser.y"
     {
   (yyval.blk) = gen_or((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
 }
@@ -2025,7 +2029,7 @@ yyreduce:
 
   case 12:
 /* Line 1787 of yacc.c  */
-#line 227 "parser.y"
+#line 231 "parser.y"
     {
   (yyval.blk) = gen_and((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
 }
@@ -2033,7 +2037,7 @@ yyreduce:
 
   case 13:
 /* Line 1787 of yacc.c  */
-#line 231 "parser.y"
+#line 235 "parser.y"
     {
   (yyval.blk) = gen_definedor((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
 }
@@ -2041,7 +2045,7 @@ yyreduce:
 
   case 14:
 /* Line 1787 of yacc.c  */
-#line 235 "parser.y"
+#line 239 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), gen_definedor(gen_noop(), (yyvsp[(3) - (3)].blk)), 0);
 }
@@ -2049,7 +2053,7 @@ yyreduce:
 
   case 15:
 /* Line 1787 of yacc.c  */
-#line 239 "parser.y"
+#line 243 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), 0);
 }
@@ -2057,7 +2061,7 @@ yyreduce:
 
   case 16:
 /* Line 1787 of yacc.c  */
-#line 243 "parser.y"
+#line 247 "parser.y"
     { 
   (yyval.blk) = block_join((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk)); 
 }
@@ -2065,7 +2069,7 @@ yyreduce:
 
   case 17:
 /* Line 1787 of yacc.c  */
-#line 247 "parser.y"
+#line 251 "parser.y"
     { 
   (yyval.blk) = gen_both((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk)); 
 }
@@ -2073,7 +2077,7 @@ yyreduce:
 
   case 18:
 /* Line 1787 of yacc.c  */
-#line 251 "parser.y"
+#line 255 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '+');
 }
@@ -2081,7 +2085,7 @@ yyreduce:
 
   case 19:
 /* Line 1787 of yacc.c  */
-#line 255 "parser.y"
+#line 259 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '+');
 }
@@ -2089,7 +2093,7 @@ yyreduce:
 
   case 20:
 /* Line 1787 of yacc.c  */
-#line 259 "parser.y"
+#line 263 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '-');
 }
@@ -2097,7 +2101,7 @@ yyreduce:
 
   case 21:
 /* Line 1787 of yacc.c  */
-#line 263 "parser.y"
+#line 267 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '-');
 }
@@ -2105,7 +2109,7 @@ yyreduce:
 
   case 22:
 /* Line 1787 of yacc.c  */
-#line 267 "parser.y"
+#line 271 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '*');
 }
@@ -2113,7 +2117,7 @@ yyreduce:
 
   case 23:
 /* Line 1787 of yacc.c  */
-#line 271 "parser.y"
+#line 275 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '*');
 }
@@ -2121,7 +2125,7 @@ yyreduce:
 
   case 24:
 /* Line 1787 of yacc.c  */
-#line 275 "parser.y"
+#line 279 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '/');
 }
@@ -2129,7 +2133,7 @@ yyreduce:
 
   case 25:
 /* Line 1787 of yacc.c  */
-#line 279 "parser.y"
+#line 283 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '/');
 }
@@ -2137,7 +2141,7 @@ yyreduce:
 
   case 26:
 /* Line 1787 of yacc.c  */
-#line 283 "parser.y"
+#line 287 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), EQ);
 }
@@ -2145,7 +2149,7 @@ yyreduce:
 
   case 27:
 /* Line 1787 of yacc.c  */
-#line 287 "parser.y"
+#line 291 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), NEQ);
 }
@@ -2153,7 +2157,7 @@ yyreduce:
 
   case 28:
 /* Line 1787 of yacc.c  */
-#line 291 "parser.y"
+#line 295 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '<');
 }
@@ -2161,7 +2165,7 @@ yyreduce:
 
   case 29:
 /* Line 1787 of yacc.c  */
-#line 295 "parser.y"
+#line 299 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '>');
 }
@@ -2169,7 +2173,7 @@ yyreduce:
 
   case 30:
 /* Line 1787 of yacc.c  */
-#line 299 "parser.y"
+#line 303 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), LESSEQ);
 }
@@ -2177,7 +2181,7 @@ yyreduce:
 
   case 31:
 /* Line 1787 of yacc.c  */
-#line 303 "parser.y"
+#line 307 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), GREATEREQ);
 }
@@ -2185,7 +2189,7 @@ yyreduce:
 
   case 32:
 /* Line 1787 of yacc.c  */
-#line 307 "parser.y"
+#line 311 "parser.y"
     {
   (yyval.blk) = (yyvsp[(1) - (1)].blk);
 }
@@ -2193,7 +2197,7 @@ yyreduce:
 
   case 33:
 /* Line 1787 of yacc.c  */
-#line 311 "parser.y"
+#line 315 "parser.y"
     { 
   (yyval.blk) = (yyvsp[(1) - (1)].blk); 
 }
@@ -2201,7 +2205,7 @@ yyreduce:
 
   case 34:
 /* Line 1787 of yacc.c  */
-#line 316 "parser.y"
+#line 320 "parser.y"
     {
   (yyval.blk) = (yyvsp[(2) - (3)].blk);
 }
@@ -2209,7 +2213,7 @@ yyreduce:
 
   case 35:
 /* Line 1787 of yacc.c  */
-#line 321 "parser.y"
+#line 325 "parser.y"
     {
   block body = block_join((yyvsp[(4) - (5)].blk), gen_op_simple(RET));
   (yyval.blk) = gen_op_block_defn_rec(CLOSURE_CREATE, jv_string_value((yyvsp[(2) - (5)].literal)), body);
@@ -2219,7 +2223,7 @@ yyreduce:
 
   case 36:
 /* Line 1787 of yacc.c  */
-#line 327 "parser.y"
+#line 331 "parser.y"
     {
   block body = block_bind(gen_op_block_unbound(CLOSURE_PARAM, jv_string_value((yyvsp[(4) - (8)].literal))), block_join((yyvsp[(7) - (8)].blk), gen_op_simple(RET)), OP_IS_CALL_PSEUDO);
   (yyval.blk) = gen_op_block_defn_rec(CLOSURE_CREATE, jv_string_value((yyvsp[(2) - (8)].literal)), body);
@@ -2230,7 +2234,7 @@ yyreduce:
 
   case 37:
 /* Line 1787 of yacc.c  */
-#line 335 "parser.y"
+#line 339 "parser.y"
     {
   (yyval.blk) = gen_op_const(LOADK, jv_string(""));
 }
@@ -2238,7 +2242,7 @@ yyreduce:
 
   case 38:
 /* Line 1787 of yacc.c  */
-#line 338 "parser.y"
+#line 342 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (2)].blk), gen_op_const(LOADK, (yyvsp[(2) - (2)].literal)), '+');
 }
@@ -2246,7 +2250,7 @@ yyreduce:
 
   case 39:
 /* Line 1787 of yacc.c  */
-#line 341 "parser.y"
+#line 345 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (4)].blk), gen_format((yyvsp[(3) - (4)].blk)), '+');
 }
@@ -2254,7 +2258,7 @@ yyreduce:
 
   case 40:
 /* Line 1787 of yacc.c  */
-#line 347 "parser.y"
+#line 351 "parser.y"
     {
   (yyval.blk) = gen_cond((yyvsp[(2) - (5)].blk), (yyvsp[(4) - (5)].blk), (yyvsp[(5) - (5)].blk));
 }
@@ -2262,7 +2266,7 @@ yyreduce:
 
   case 41:
 /* Line 1787 of yacc.c  */
-#line 350 "parser.y"
+#line 354 "parser.y"
     {
   (yyval.blk) = (yyvsp[(2) - (3)].blk);
 }
@@ -2270,7 +2274,7 @@ yyreduce:
 
   case 42:
 /* Line 1787 of yacc.c  */
-#line 355 "parser.y"
+#line 359 "parser.y"
     { 
   (yyval.blk) = block_join((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
 }
@@ -2278,7 +2282,7 @@ yyreduce:
 
   case 43:
 /* Line 1787 of yacc.c  */
-#line 359 "parser.y"
+#line 363 "parser.y"
     {
   (yyval.blk) = (yyvsp[(1) - (1)].blk);
 }
@@ -2286,7 +2290,7 @@ yyreduce:
 
   case 44:
 /* Line 1787 of yacc.c  */
-#line 365 "parser.y"
+#line 369 "parser.y"
     {
   (yyval.blk) = gen_noop(); 
 }
@@ -2294,7 +2298,7 @@ yyreduce:
 
   case 45:
 /* Line 1787 of yacc.c  */
-#line 368 "parser.y"
+#line 372 "parser.y"
     {
   (yyval.blk) = gen_index((yyvsp[(1) - (3)].blk), gen_op_const(LOADK, (yyvsp[(3) - (3)].literal))); 
 }
@@ -2302,7 +2306,7 @@ yyreduce:
 
   case 46:
 /* Line 1787 of yacc.c  */
-#line 371 "parser.y"
+#line 375 "parser.y"
     { 
   (yyval.blk) = gen_index(gen_noop(), gen_op_const(LOADK, (yyvsp[(2) - (2)].literal))); 
 }
@@ -2310,7 +2314,7 @@ yyreduce:
 
   case 47:
 /* Line 1787 of yacc.c  */
-#line 375 "parser.y"
+#line 379 "parser.y"
     {
   (yyval.blk) = gen_index((yyvsp[(1) - (4)].blk), (yyvsp[(3) - (4)].blk)); 
 }
@@ -2318,7 +2322,7 @@ yyreduce:
 
   case 48:
 /* Line 1787 of yacc.c  */
-#line 378 "parser.y"
+#line 382 "parser.y"
     {
   (yyval.blk) = block_join((yyvsp[(1) - (3)].blk), gen_op_simple(EACH)); 
 }
@@ -2326,7 +2330,7 @@ yyreduce:
 
   case 49:
 /* Line 1787 of yacc.c  */
-#line 381 "parser.y"
+#line 385 "parser.y"
     {
   (yyval.blk) = gen_op_const(LOADK, (yyvsp[(1) - (1)].literal)); 
 }
@@ -2334,7 +2338,7 @@ yyreduce:
 
   case 50:
 /* Line 1787 of yacc.c  */
-#line 384 "parser.y"
+#line 388 "parser.y"
     { 
   (yyval.blk) = (yyvsp[(2) - (3)].blk); 
 }
@@ -2342,7 +2346,7 @@ yyreduce:
 
   case 51:
 /* Line 1787 of yacc.c  */
-#line 387 "parser.y"
+#line 391 "parser.y"
     { 
   (yyval.blk) = gen_collect((yyvsp[(2) - (3)].blk)); 
 }
@@ -2350,7 +2354,7 @@ yyreduce:
 
   case 52:
 /* Line 1787 of yacc.c  */
-#line 390 "parser.y"
+#line 394 "parser.y"
     { 
   (yyval.blk) = gen_op_const(LOADK, jv_array()); 
 }
@@ -2358,7 +2362,7 @@ yyreduce:
 
   case 53:
 /* Line 1787 of yacc.c  */
-#line 393 "parser.y"
+#line 397 "parser.y"
     { 
   (yyval.blk) = gen_subexp(gen_op_const(LOADK, jv_object()));
   block_append(&(yyval.blk), (yyvsp[(2) - (3)].blk));
@@ -2368,7 +2372,7 @@ yyreduce:
 
   case 54:
 /* Line 1787 of yacc.c  */
-#line 398 "parser.y"
+#line 402 "parser.y"
     {
   (yyval.blk) = gen_location((yyloc), gen_op_var_unbound(LOADV, jv_string_value((yyvsp[(2) - (2)].literal))));
   jv_free((yyvsp[(2) - (2)].literal));
@@ -2377,7 +2381,7 @@ yyreduce:
 
   case 55:
 /* Line 1787 of yacc.c  */
-#line 402 "parser.y"
+#line 406 "parser.y"
     {
   (yyval.blk) = gen_location((yyloc), gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, jv_string_value((yyvsp[(1) - (1)].literal)))));
   jv_free((yyvsp[(1) - (1)].literal));
@@ -2386,7 +2390,7 @@ yyreduce:
 
   case 56:
 /* Line 1787 of yacc.c  */
-#line 406 "parser.y"
+#line 410 "parser.y"
     {
   (yyval.blk) = gen_op_call(CALL_1_1, 
                    block_join(gen_op_block_unbound(CLOSURE_REF, jv_string_value((yyvsp[(1) - (4)].literal))),
@@ -2401,31 +2405,31 @@ yyreduce:
 
   case 57:
 /* Line 1787 of yacc.c  */
-#line 416 "parser.y"
+#line 420 "parser.y"
     { (yyval.blk) = gen_noop(); }
     break;
 
   case 58:
 /* Line 1787 of yacc.c  */
-#line 417 "parser.y"
+#line 421 "parser.y"
     { (yyval.blk) = gen_noop(); }
     break;
 
   case 59:
 /* Line 1787 of yacc.c  */
-#line 418 "parser.y"
+#line 422 "parser.y"
     { (yyval.blk) = (yyvsp[(1) - (4)].blk); }
     break;
 
   case 60:
 /* Line 1787 of yacc.c  */
-#line 419 "parser.y"
+#line 423 "parser.y"
     { (yyval.blk) = gen_noop(); }
     break;
 
   case 61:
 /* Line 1787 of yacc.c  */
-#line 422 "parser.y"
+#line 426 "parser.y"
     { 
   (yyval.blk)=gen_noop(); 
 }
@@ -2433,25 +2437,25 @@ yyreduce:
 
   case 62:
 /* Line 1787 of yacc.c  */
-#line 425 "parser.y"
+#line 429 "parser.y"
     { (yyval.blk) = (yyvsp[(1) - (1)].blk); }
     break;
 
   case 63:
 /* Line 1787 of yacc.c  */
-#line 426 "parser.y"
+#line 430 "parser.y"
     { (yyval.blk)=block_join((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk)); }
     break;
 
   case 64:
 /* Line 1787 of yacc.c  */
-#line 427 "parser.y"
+#line 431 "parser.y"
     { (yyval.blk) = (yyvsp[(3) - (3)].blk); }
     break;
 
   case 65:
 /* Line 1787 of yacc.c  */
-#line 430 "parser.y"
+#line 434 "parser.y"
     { 
   (yyval.blk) = gen_dictpair(gen_op_const(LOADK, (yyvsp[(1) - (3)].literal)), (yyvsp[(3) - (3)].blk));
  }
@@ -2459,7 +2463,7 @@ yyreduce:
 
   case 66:
 /* Line 1787 of yacc.c  */
-#line 433 "parser.y"
+#line 437 "parser.y"
     {
   (yyval.blk) = gen_dictpair((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
   }
@@ -2467,7 +2471,7 @@ yyreduce:
 
   case 67:
 /* Line 1787 of yacc.c  */
-#line 436 "parser.y"
+#line 440 "parser.y"
     {
   (yyval.blk) = gen_dictpair(gen_op_const(LOADK, jv_copy((yyvsp[(1) - (1)].literal))),
                     gen_index(gen_noop(), gen_op_const(LOADK, (yyvsp[(1) - (1)].literal))));
@@ -2476,7 +2480,7 @@ yyreduce:
 
   case 68:
 /* Line 1787 of yacc.c  */
-#line 440 "parser.y"
+#line 444 "parser.y"
     {
   (yyval.blk) = gen_dictpair((yyvsp[(2) - (5)].blk), (yyvsp[(5) - (5)].blk));
   }
@@ -2484,13 +2488,13 @@ yyreduce:
 
   case 69:
 /* Line 1787 of yacc.c  */
-#line 443 "parser.y"
+#line 447 "parser.y"
     { (yyval.blk) = (yyvsp[(5) - (5)].blk); }
     break;
 
 
 /* Line 1787 of yacc.c  */
-#line 2494 "parser.gen.c"
+#line 2498 "parser.gen.c"
       default: break;
     }
   /* User semantic actions sometimes alter yychar, and that requires
@@ -2541,7 +2545,7 @@ yyerrlab:
     {
       ++yynerrs;
 #if ! YYERROR_VERBOSE
-      yyerror (&yylloc, answer, errors, locations, lexer, YY_("syntax error"));
+      yyerror (&yylloc, answer, errors, locations, lexer_param_ptr, YY_("syntax error"));
 #else
 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
                                         yyssp, yytoken)
@@ -2568,7 +2572,7 @@ yyerrlab:
                 yymsgp = yymsg;
               }
           }
-        yyerror (&yylloc, answer, errors, locations, lexer, yymsgp);
+        yyerror (&yylloc, answer, errors, locations, lexer_param_ptr, yymsgp);
         if (yysyntax_error_status == 2)
           goto yyexhaustedlab;
       }
@@ -2592,7 +2596,7 @@ yyerrlab:
       else
 	{
 	  yydestruct ("Error: discarding",
-		      yytoken, &yylval, &yylloc, answer, errors, locations, lexer);
+		      yytoken, &yylval, &yylloc, answer, errors, locations, lexer_param_ptr);
 	  yychar = YYEMPTY;
 	}
     }
@@ -2649,7 +2653,7 @@ yyerrlab1:
 
       yyerror_range[1] = *yylsp;
       yydestruct ("Error: popping",
-		  yystos[yystate], yyvsp, yylsp, answer, errors, locations, lexer);
+		  yystos[yystate], yyvsp, yylsp, answer, errors, locations, lexer_param_ptr);
       YYPOPSTACK (1);
       yystate = *yyssp;
       YY_STACK_PRINT (yyss, yyssp);
@@ -2689,7 +2693,7 @@ yyabortlab:
 | yyexhaustedlab -- memory exhaustion comes here.  |
 `-------------------------------------------------*/
 yyexhaustedlab:
-  yyerror (&yylloc, answer, errors, locations, lexer, YY_("memory exhausted"));
+  yyerror (&yylloc, answer, errors, locations, lexer_param_ptr, YY_("memory exhausted"));
   yyresult = 2;
   /* Fall through.  */
 #endif
@@ -2701,7 +2705,7 @@ yyreturn:
          user semantic actions for why this is necessary.  */
       yytoken = YYTRANSLATE (yychar);
       yydestruct ("Cleanup: discarding lookahead",
-                  yytoken, &yylval, &yylloc, answer, errors, locations, lexer);
+                  yytoken, &yylval, &yylloc, answer, errors, locations, lexer_param_ptr);
     }
   /* Do not reclaim the symbols of the rule which action triggered
      this YYABORT or YYACCEPT.  */
@@ -2710,7 +2714,7 @@ yyreturn:
   while (yyssp != yyss)
     {
       yydestruct ("Cleanup: popping",
-		  yystos[*yyssp], yyvsp, yylsp, answer, errors, locations, lexer);
+		  yystos[*yyssp], yyvsp, yylsp, answer, errors, locations, lexer_param_ptr);
       YYPOPSTACK (1);
     }
 #ifndef yyoverflow
@@ -2727,19 +2731,19 @@ yyreturn:
 
 
 /* Line 2048 of yacc.c  */
-#line 444 "parser.y"
+#line 448 "parser.y"
 
 
 int jq_parse(struct locfile* locations, block* answer) {
-  yyscan_t scanner;
+  struct lexer_param scanner;
   YY_BUFFER_STATE buf;
-  jq_yylex_init_extra(0, &scanner);
-  buf = jq_yy_scan_bytes(locations->data, locations->length, scanner);
+  jq_yylex_init_extra(0, &scanner.lexer);
+  buf = jq_yy_scan_bytes(locations->data, locations->length, scanner.lexer);
   int errors = 0;
   *answer = gen_noop();
-  yyparse(answer, &errors, locations, scanner);
-  jq_yy_delete_buffer(buf, scanner);
-  jq_yylex_destroy(scanner);
+  yyparse(answer, &errors, locations, &scanner);
+  jq_yy_delete_buffer(buf, scanner.lexer);
+  jq_yylex_destroy(scanner.lexer);
   if (errors > 0) {
     block_free(*answer);
     *answer = gen_noop();
diff --git a/parser.gen.h b/parser.gen.h
index d29c12a0..0e5c8007 100644
--- a/parser.gen.h
+++ b/parser.gen.h
@@ -138,7 +138,7 @@ int yyparse ();
 #endif
 #else /* ! YYPARSE_PARAM */
 #if defined __STDC__ || defined __cplusplus
-int yyparse (block* answer, int* errors, struct locfile* locations, yyscan_t lexer);
+int yyparse (block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr);
 #else
 int yyparse ();
 #endif

From 5e25c2a259d2337d38b730d5dc22e7db67ea88cb Mon Sep 17 00:00:00 2001
From: Stephen Roantree <stroantree@gmail.com>
Date: Wed, 24 Oct 2012 11:42:25 -0700
Subject: [PATCH 136/284] Implemented contains operator

---
 builtin.c                        |   16 +
 docs/content/3.manual/manual.yml |   28 +-
 jv.c                             |   60 +
 jv.h                             |    1 +
 lexer.gen.c                      |  301 +--
 lexer.gen.h                      |   31 +-
 lexer.l                          |    1 +
 parser.gen.c                     | 1376 ++++++------
 parser.gen.h                     |   57 +-
 parser.gen.info                  | 3618 ++++++++++++++++--------------
 parser.y                         |    8 +-
 testdata                         |   25 +
 12 files changed, 2965 insertions(+), 2557 deletions(-)

diff --git a/builtin.c b/builtin.c
index 3d726854..fb6f072c 100644
--- a/builtin.c
+++ b/builtin.c
@@ -161,6 +161,21 @@ static void f_greatereq(jv input[], jv output[]) {
   order_cmp(input, output, CMP_OP_GREATEREQ);
 }
 
+static void f_contains(jv input[], jv output[]) {
+  jv_free(input[0]);
+  jv a = input[2];
+  jv b = input[1];
+  jv_kind akind = jv_get_kind(a);
+
+  if (akind == jv_get_kind(b)) {
+    output[0] = jv_bool(jv_contains(a, b));
+  } else {  
+    output[0] = jv_invalid_with_msg(jv_string_fmt("Can only check containment of values of the same type."));
+    jv_free(a);
+    jv_free(b);
+  }
+}
+
 static void f_tonumber(jv input[], jv output[]) {
   if (jv_get_kind(input[0]) == JV_KIND_NUMBER) {
     output[0] = input[0];
@@ -294,6 +309,7 @@ static struct cfunction function_list[] = {
   {f_greater, "_greater", CALL_BUILTIN_3_1},
   {f_lesseq, "_lesseq", CALL_BUILTIN_3_1},
   {f_greatereq, "_greatereq", CALL_BUILTIN_3_1},
+  {f_contains, "_contains", CALL_BUILTIN_3_1},
   {f_length, "length", CALL_BUILTIN_1_1},
   {f_type, "type", CALL_BUILTIN_1_1},
   {f_add, "add", CALL_BUILTIN_1_1},
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 6c107700..437afdff 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -522,7 +522,33 @@ sections:
           - program: '.[] == 1'
             input: '[1, 1.0, "1", "banana"]'
             output: ['[true, true, false, false]']
-          
+      - title: `contains`
+        body: |
+
+          The expression 'a contains b' will produce true if b is completely
+          contained within a. A string B is contained in a string A if B is a
+          substring of A. An array B is contained in an array A is all elements
+          in B are contained in any element in A. An object B is contained in
+          object A if all of the values in B are contained in the value in A with
+          the same key. All other types are assumed to be contained in each other
+          if they are equal.
+
+        examples:
+          - program: '. == contains "bar"'
+            input: '"foobar"'
+            output: ['true']
+          - program: '. contains ["baz", "bar"]'
+            input: '["foobar", "foobaz", "blarp"]'
+            output: ['true']
+          - program: '. contains ["bazzzzz", "bar"]'
+            input: '["foobar", "foobaz", "blarp"]'
+            output: ['false']
+          - program: '. contains {foo: 12, bar: [{barp: 12}]}'
+            input: '{foo: 12, bar:[1,2,{barp:12, blip:13}]}'
+            output: ['true']
+          - program: '. contains {foo: 12, bar: [{barp: 15}]}'
+            input: '{foo: 12, bar:[1,2,{barp:12, blip:13}]}'
+            output: ['false']
       - title: if-then-else
         body: |
 
diff --git a/jv.c b/jv.c
index 2d91366b..8515e7f4 100644
--- a/jv.c
+++ b/jv.c
@@ -250,6 +250,27 @@ static int jvp_array_equal(jv_complex* a, jv_complex* b) {
   return 1;
 }
 
+static int jvp_array_contains(jv_complex* a, jv_complex* b) {
+  int r = 1;
+  for (int bi = 0; bi < jvp_array_length(b); bi++) {
+    int ri = 0;
+    jv* bval = jvp_array_read(b, bi);
+    for (int ai = 0; ai < jvp_array_length(a); ai++) {
+      jv aval = jv_copy(*jvp_array_read(a, ai));
+      jv bval_copy = jv_copy(*bval);
+      if (jv_contains(aval, bval_copy)) {
+        ri = 1;
+        break;
+      }
+    }
+    if (!ri) {
+      r = 0;
+      break;
+    }
+  }
+  return r;
+}
+
 static jv_complex jvp_array_slice(jv_complex* a, int start, int end) {
   // FIXME: maybe slice should reallocate if the slice is small enough
   assert(start <= end);
@@ -863,6 +884,27 @@ jv jv_object_merge(jv a, jv b) {
   return a;
 }
 
+int jv_object_contains(jv a, jv b) {
+  assert(jv_get_kind(a) == JV_KIND_OBJECT);
+  assert(jv_get_kind(b) == JV_KIND_OBJECT);
+  int r = 1;
+
+  for (int i=0; i<jvp_object_size(&b.val.complex); i++) {
+    struct object_slot* slotb = jvp_object_get_slot(&b.val.complex, i);
+    if (!slotb->string) continue;
+    jv* slota = jvp_object_read(&a.val.complex, slotb->string);
+    if (!(slota && jv_get_kind(slotb->value) == jv_get_kind(*slota)
+       && jv_contains(jv_copy(*slota), jv_copy(slotb->value)))) {
+      r = 0;
+      break;
+    }
+  }
+
+  jv_free(a);
+  jv_free(b);
+  return r;
+}
+
 /*
  * Object iteration (internal helpers)
  */
@@ -977,3 +1019,21 @@ int jv_equal(jv a, jv b) {
   jv_free(b);
   return r;
 }
+
+int jv_contains(jv a, jv b) {
+  int r = 1;
+  if (jv_get_kind(a) != jv_get_kind(b)) {
+    r = 0;
+  } else if (jv_get_kind(a) == JV_KIND_OBJECT) {
+    r = jv_object_contains(jv_copy(a), jv_copy(b));
+  } else if (jv_get_kind(a) == JV_KIND_ARRAY) {
+    r = jvp_array_contains(&a.val.complex, &b.val.complex);
+  } else if (jv_get_kind(a) == JV_KIND_STRING) {
+    r = strstr(jv_string_value(a), jv_string_value(b)) != 0;
+  } else {
+    r = jv_equal(jv_copy(a), jv_copy(b));
+  }
+  jv_free(a);
+  jv_free(b);
+  return r;
+}
\ No newline at end of file
diff --git a/jv.h b/jv.h
index e67d614a..a77346c3 100644
--- a/jv.h
+++ b/jv.h
@@ -48,6 +48,7 @@ jv jv_copy(jv);
 void jv_free(jv);
 
 int jv_equal(jv, jv);
+int jv_contains(jv, jv);
 
 jv jv_invalid();
 jv jv_invalid_with_msg(jv);
diff --git a/lexer.gen.c b/lexer.gen.c
index dbaf0abc..c1458c69 100644
--- a/lexer.gen.c
+++ b/lexer.gen.c
@@ -9,7 +9,7 @@
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 5
-#define YY_FLEX_SUBMINOR_VERSION 37
+#define YY_FLEX_SUBMINOR_VERSION 35
 #if YY_FLEX_SUBMINOR_VERSION > 0
 #define FLEX_BETA
 #endif
@@ -159,7 +159,15 @@ typedef void* yyscan_t;
 
 /* Size of default input buffer. */
 #ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
 #define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
 #endif
 
 /* The state buf must be large enough to hold one state per character in the main buffer.
@@ -171,11 +179,6 @@ typedef void* yyscan_t;
 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 #endif
 
-#ifndef YY_TYPEDEF_YY_SIZE_T
-#define YY_TYPEDEF_YY_SIZE_T
-typedef size_t yy_size_t;
-#endif
-
 #define EOB_ACT_CONTINUE_SCAN 0
 #define EOB_ACT_END_OF_FILE 1
 #define EOB_ACT_LAST_MATCH 2
@@ -198,6 +201,11 @@ typedef size_t yy_size_t;
 
 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
 
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
 #ifndef YY_STRUCT_YY_BUFFER_STATE
 #define YY_STRUCT_YY_BUFFER_STATE
 struct yy_buffer_state
@@ -215,7 +223,7 @@ struct yy_buffer_state
 	/* Number of characters read into yy_ch_buf, not including EOB
 	 * characters.
 	 */
-	yy_size_t yy_n_chars;
+	int yy_n_chars;
 
 	/* Whether we "own" the buffer - i.e., we know we created it,
 	 * and can realloc() it to grow it, and should free() it to
@@ -294,7 +302,7 @@ static void jq_yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner
 
 YY_BUFFER_STATE jq_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
 YY_BUFFER_STATE jq_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
-YY_BUFFER_STATE jq_yy_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner );
+YY_BUFFER_STATE jq_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
 
 void *jq_yyalloc (yy_size_t ,yyscan_t yyscanner );
 void *jq_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
@@ -326,7 +334,7 @@ void jq_yyfree (void * ,yyscan_t yyscanner );
 
 /* Begin user sect3 */
 
-#define jq_yywrap(yyscanner) 1
+#define jq_yywrap(n) 1
 #define YY_SKIP_YYWRAP
 
 typedef unsigned char YY_CHAR;
@@ -350,8 +358,8 @@ static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
 	*yy_cp = '\0'; \
 	yyg->yy_c_buf_p = yy_cp;
 
-#define YY_NUM_RULES 35
-#define YY_END_OF_BUFFER 36
+#define YY_NUM_RULES 36
+#define YY_END_OF_BUFFER 37
 /* This struct is not used in this scanner,
    but its presence is necessary. */
 struct yy_trans_info
@@ -359,17 +367,19 @@ struct yy_trans_info
 	flex_int32_t yy_verify;
 	flex_int32_t yy_nxt;
 	};
-static yyconst flex_int16_t yy_accept[88] =
+static yyconst flex_int16_t yy_accept[96] =
     {   0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,   36,   34,   33,   33,   34,   26,    1,   22,
-       23,   24,   22,   22,   22,   22,   22,   25,   22,   22,
-       22,   32,   32,   32,   32,   32,   32,   32,   22,   30,
-       30,   28,   31,   33,    2,    1,   17,   15,   25,   16,
-        0,   13,   18,   20,    3,   21,   32,   32,    4,   32,
-       32,   32,    6,   11,   32,   14,   30,   29,   27,   29,
-        0,   25,   19,   10,    5,   32,   32,   12,   32,    0,
-       29,    9,    8,    7,   29,   29,    0
+        0,    0,   37,   35,   34,   34,   35,   27,    1,   23,
+       24,   25,   23,   23,   23,   23,   23,   26,   23,   23,
+       23,   33,   33,   33,   33,   33,   33,   33,   33,   23,
+       31,   31,   29,   32,   34,    2,    1,   17,   15,   26,
+       16,    0,   13,   18,   20,    3,   21,   33,   33,    4,
+       33,   33,   33,   33,    6,   11,   33,   14,   31,   30,
+       28,   30,    0,   26,   19,   10,   33,    5,   33,   33,
+       12,   33,    0,   30,   33,    9,    8,    7,   30,   33,
+       30,   33,   33,   22,    0
+
     } ;
 
 static yyconst flex_int32_t yy_ec[256] =
@@ -383,11 +393,11 @@ static yyconst flex_int32_t yy_ec[256] =
        21,   22,    1,    1,   23,   23,   23,   23,   24,   23,
        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
-       25,   26,   27,    1,   28,    1,   29,   23,   23,   30,
+       25,   26,   27,    1,   28,    1,   29,   23,   30,   31,
 
-       31,   32,   23,   33,   34,   23,   23,   35,   23,   36,
-       37,   23,   23,   38,   39,   40,   41,   23,   23,   23,
-       23,   23,   42,   43,   44,    1,    1,    1,    1,    1,
+       32,   33,   23,   34,   35,   23,   23,   36,   23,   37,
+       38,   23,   23,   39,   40,   41,   42,   23,   23,   23,
+       23,   23,   43,   44,   45,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -404,91 +414,97 @@ static yyconst flex_int32_t yy_ec[256] =
         1,    1,    1,    1,    1
     } ;
 
-static yyconst flex_int32_t yy_meta[45] =
+static yyconst flex_int32_t yy_meta[46] =
     {   0,
         1,    1,    2,    2,    1,    3,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    4,    1,    1,    1,
         1,    1,    4,    4,    1,    5,    1,    6,    4,    4,
         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
-        4,    1,    1,    1
+        4,    4,    1,    1,    1
     } ;
 
-static yyconst flex_int16_t yy_base[97] =
+static yyconst flex_int16_t yy_base[105] =
     {   0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-       42,   43,  144,  145,   48,   50,  122,  145,    0,  145,
-      145,  145,  121,  120,   39,   40,   42,   50,  119,  118,
-      117,    0,   23,   91,   37,   88,   78,   77,   80,    0,
-        0,  145,   38,   73,  145,    0,  145,  145,   63,  145,
-       71,   79,  145,  145,  145,  145,    0,   69,    0,   66,
-       27,   67,    0,    0,   65,  145,    0,   69,  145,   67,
-       75,   74,  145,    0,    0,   58,   58,    0,   50,   61,
-       58,    0,    0,    0,   56,   51,  145,  102,  108,  111,
-      117,  123,  126,  128,  130,  132
+       43,   44,  152,  153,   49,   51,  130,  153,    0,  153,
+      153,  153,  129,  128,   40,   41,   43,   51,  127,  126,
+      125,    0,   23,  107,  112,   35,  110,   88,   91,  100,
+        0,    0,  153,   39,   74,  153,    0,  153,  153,   63,
+      153,   72,   94,  153,  153,  153,  153,    0,   75,    0,
+       68,   71,   27,   72,    0,    0,   70,  153,    0,   75,
+      153,   74,   82,   81,  153,    0,   56,    0,   63,   62,
+        0,   56,   65,   66,   62,    0,    0,    0,   64,   53,
+       59,   45,   39,    0,  153,  107,  113,  116,  122,  128,
 
+      131,  133,  135,  137
     } ;
 
-static yyconst flex_int16_t yy_def[97] =
+static yyconst flex_int16_t yy_def[105] =
     {   0,
-       87,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-       88,   88,   87,   87,   87,   87,   87,   87,   89,   87,
-       87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
-       87,   90,   90,   90,   90,   90,   90,   90,   87,   91,
-       91,   87,   92,   87,   87,   89,   87,   87,   87,   87,
-       87,   87,   87,   87,   87,   87,   90,   90,   90,   90,
-       90,   90,   90,   90,   90,   87,   91,   87,   87,   93,
-       87,   87,   87,   90,   90,   90,   90,   90,   90,   92,
-       94,   90,   90,   90,   95,   96,    0,   87,   87,   87,
-       87,   87,   87,   87,   87,   87
+       95,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+       96,   96,   95,   95,   95,   95,   95,   95,   97,   95,
+       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
+       95,   98,   98,   98,   98,   98,   98,   98,   98,   95,
+       99,   99,   95,  100,   95,   95,   97,   95,   95,   95,
+       95,   95,   95,   95,   95,   95,   95,   98,   98,   98,
+       98,   98,   98,   98,   98,   98,   98,   95,   99,   95,
+       95,  101,   95,   95,   95,   98,   98,   98,   98,   98,
+       98,   98,  100,  102,   98,   98,   98,   98,  103,   98,
+      104,   98,   98,   98,    0,   95,   95,   95,   95,   95,
 
+       95,   95,   95,   95
     } ;
 
-static yyconst flex_int16_t yy_nxt[190] =
+static yyconst flex_int16_t yy_nxt[199] =
     {   0,
        14,   15,   16,   14,   17,   18,   19,   20,   21,   22,
        23,   24,   20,   25,   26,   27,   28,   20,   20,   29,
        30,   31,   32,   32,   21,   14,   22,   32,   33,   34,
-       35,   32,   32,   36,   32,   32,   37,   32,   32,   38,
-       32,   21,   39,   22,   41,   41,   69,   42,   42,   44,
-       44,   44,   44,   49,   49,   49,   49,   52,   58,   50,
-       76,   59,   53,   51,   49,   77,   49,   43,   43,   87,
-       51,   61,   62,   51,   44,   44,   80,   49,   70,   49,
-       51,   80,   71,   80,   71,   84,   51,   72,   83,   82,
-       72,   72,   80,   51,   80,   79,   78,   75,   74,   73,
+       35,   36,   32,   32,   37,   32,   32,   38,   32,   32,
+       39,   32,   21,   40,   22,   42,   42,   71,   43,   43,
+       45,   45,   45,   45,   50,   50,   50,   50,   53,   59,
+       51,   79,   60,   54,   52,   50,   80,   50,   44,   44,
+       63,   64,   52,   95,   52,   45,   45,   50,   94,   50,
+       72,   93,   52,   73,   83,   73,   52,   92,   74,   83,
+       90,   83,   88,   87,   52,   86,   85,   74,   74,   83,
+
+       83,   82,   81,   78,   77,   76,   72,   41,   41,   41,
+       41,   41,   41,   47,   75,   47,   47,   47,   47,   58,
+       68,   58,   69,   69,   67,   69,   66,   69,   70,   70,
+       70,   70,   70,   70,   84,   84,   89,   89,   91,   91,
+       70,   70,   65,   62,   61,   57,   56,   55,   49,   48,
+       46,   95,   13,   95,   95,   95,   95,   95,   95,   95,
+       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
+       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
+       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
+       95,   95,   95,   95,   95,   95,   95,   95
 
-       66,   70,   40,   40,   40,   40,   40,   40,   46,   65,
-       46,   46,   46,   46,   57,   64,   57,   67,   67,   63,
-       67,   60,   67,   68,   68,   68,   68,   68,   68,   81,
-       81,   85,   85,   86,   86,   68,   68,   56,   55,   54,
-       48,   47,   45,   87,   13,   87,   87,   87,   87,   87,
-       87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
-       87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
-       87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
-       87,   87,   87,   87,   87,   87,   87,   87,   87
     } ;
 
-static yyconst flex_int16_t yy_chk[190] =
+static yyconst flex_int16_t yy_chk[199] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,   11,   12,   43,   11,   12,   15,
-       15,   16,   16,   25,   26,   25,   26,   27,   33,   25,
-       61,   33,   27,   26,   28,   61,   28,   11,   12,   80,
-       26,   35,   35,   28,   44,   44,   86,   49,   43,   49,
-       28,   85,   51,   81,   51,   79,   49,   51,   77,   76,
-       72,   71,   70,   49,   68,   65,   62,   60,   58,   52,
+        1,    1,    1,    1,    1,   11,   12,   44,   11,   12,
+       15,   15,   16,   16,   25,   26,   25,   26,   27,   33,
+       25,   63,   33,   27,   26,   28,   63,   28,   11,   12,
+       36,   36,   26,   83,   28,   45,   45,   50,   93,   50,
+       44,   92,   28,   52,   91,   52,   50,   90,   52,   89,
+       85,   84,   82,   80,   50,   79,   77,   74,   73,   72,
+
+       70,   67,   64,   62,   61,   59,   83,   96,   96,   96,
+       96,   96,   96,   97,   53,   97,   97,   97,   97,   98,
+       40,   98,   99,   99,   39,   99,   38,   99,  100,  100,
+      100,  100,  100,  100,  101,  101,  102,  102,  103,  103,
+      104,  104,   37,   35,   34,   31,   30,   29,   24,   23,
+       17,   13,   95,   95,   95,   95,   95,   95,   95,   95,
+       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
+       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
+       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
+       95,   95,   95,   95,   95,   95,   95,   95
 
-       39,   80,   88,   88,   88,   88,   88,   88,   89,   38,
-       89,   89,   89,   89,   90,   37,   90,   91,   91,   36,
-       91,   34,   91,   92,   92,   92,   92,   92,   92,   93,
-       93,   94,   94,   95,   95,   96,   96,   31,   30,   29,
-       24,   23,   17,   13,   87,   87,   87,   87,   87,   87,
-       87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
-       87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
-       87,   87,   87,   87,   87,   87,   87,   87,   87,   87,
-       87,   87,   87,   87,   87,   87,   87,   87,   87
     } ;
 
 /* The intent behind this definition is that it'll catch
@@ -522,7 +538,7 @@ struct lexer_param;
   static int enter(int opening, int state, yyscan_t yyscanner);
   static int try_exit(int closing, int state, yyscan_t yyscanner);
 #define YY_NO_INPUT 1
-#line 526 "lexer.gen.c"
+#line 542 "lexer.gen.c"
 
 #define INITIAL 0
 #define IN_PAREN 1
@@ -554,8 +570,8 @@ struct yyguts_t
     size_t yy_buffer_stack_max; /**< capacity of stack. */
     YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
     char yy_hold_char;
-    yy_size_t yy_n_chars;
-    yy_size_t yyleng_r;
+    int yy_n_chars;
+    int yyleng_r;
     char *yy_c_buf_p;
     int yy_init;
     int yy_start;
@@ -612,7 +628,7 @@ FILE *jq_yyget_out (yyscan_t yyscanner );
 
 void jq_yyset_out  (FILE * out_str ,yyscan_t yyscanner );
 
-yy_size_t jq_yyget_leng (yyscan_t yyscanner );
+int jq_yyget_leng (yyscan_t yyscanner );
 
 char *jq_yyget_text (yyscan_t yyscanner );
 
@@ -620,10 +636,6 @@ int jq_yyget_lineno (yyscan_t yyscanner );
 
 void jq_yyset_lineno (int line_number ,yyscan_t yyscanner );
 
-int jq_yyget_column  (yyscan_t yyscanner );
-
-void jq_yyset_column (int column_no ,yyscan_t yyscanner );
-
 YYSTYPE * jq_yyget_lval (yyscan_t yyscanner );
 
 void jq_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
@@ -670,7 +682,12 @@ static int input (yyscan_t yyscanner );
     
 /* Amount of stuff to slurp up with each read. */
 #ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
 #define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
 #endif
 
 /* Copy whatever the last rule matched to the standard output. */
@@ -777,7 +794,7 @@ YY_DECL
 #line 35 "lexer.l"
 
 
-#line 781 "lexer.gen.c"
+#line 798 "lexer.gen.c"
 
     yylval = yylval_param;
 
@@ -834,13 +851,13 @@ yy_match:
 			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 				{
 				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 88 )
+				if ( yy_current_state >= 96 )
 					yy_c = yy_meta[(unsigned int) yy_c];
 				}
 			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 			++yy_cp;
 			}
-		while ( yy_base[yy_current_state] != 145 );
+		while ( yy_base[yy_current_state] != 153 );
 
 yy_find_action:
 		yy_act = yy_accept[yy_current_state];
@@ -972,57 +989,62 @@ YY_RULE_SETUP
 case 22:
 YY_RULE_SETUP
 #line 59 "lexer.l"
-{ return yytext[0];}
+{ return CONTAINS; }
 	YY_BREAK
 case 23:
 YY_RULE_SETUP
-#line 61 "lexer.l"
+#line 60 "lexer.l"
+{ return yytext[0];}
+	YY_BREAK
+case 24:
+YY_RULE_SETUP
+#line 62 "lexer.l"
 {
   return enter(yytext[0], YY_START, yyscanner);
 }
 	YY_BREAK
-case 24:
+case 25:
 YY_RULE_SETUP
-#line 65 "lexer.l"
+#line 66 "lexer.l"
 {
   return try_exit(yytext[0], YY_START, yyscanner);
 }
 	YY_BREAK
-case 25:
+case 26:
 YY_RULE_SETUP
-#line 70 "lexer.l"
+#line 71 "lexer.l"
 { 
    yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; 
 }
 	YY_BREAK
-case 26:
+case 27:
 YY_RULE_SETUP
-#line 74 "lexer.l"
+#line 75 "lexer.l"
 {
   yy_push_state(IN_QQSTRING, yyscanner);
   return QQSTRING_START;
 }
 	YY_BREAK
 
-case 27:
+case 28:
 YY_RULE_SETUP
-#line 80 "lexer.l"
+#line 81 "lexer.l"
 {
     return enter(QQSTRING_INTERP_START, YY_START, yyscanner);
   }
 	YY_BREAK
-case 28:
+case 29:
 YY_RULE_SETUP
-#line 83 "lexer.l"
+#line 84 "lexer.l"
 {
     yy_pop_state(yyscanner);
     return QQSTRING_END;
   }
 	YY_BREAK
-case 29:
-/* rule 29 can match eol */
+case 30:
+/* rule 30 can match eol */
 YY_RULE_SETUP
-#line 87 "lexer.l"
+#line 88 "lexer.l"
 {
     /* pass escapes to the json parser */
     jv escapes = jv_string_fmt("\"%.*s\"", yyleng, yytext);
@@ -1031,45 +1053,45 @@ YY_RULE_SETUP
     return QQSTRING_TEXT;
   }
 	YY_BREAK
-case 30:
-/* rule 30 can match eol */
+case 31:
+/* rule 31 can match eol */
 YY_RULE_SETUP
-#line 94 "lexer.l"
+#line 95 "lexer.l"
 {
     yylval->literal = jv_string_sized(yytext, yyleng);
     return QQSTRING_TEXT;
   }
 	YY_BREAK
-case 31:
+case 32:
 YY_RULE_SETUP
-#line 98 "lexer.l"
+#line 99 "lexer.l"
 {
     return INVALID_CHARACTER;
   }
 	YY_BREAK
 
-case 32:
+case 33:
 YY_RULE_SETUP
-#line 104 "lexer.l"
+#line 105 "lexer.l"
 { yylval->literal = jv_string(yytext); return IDENT;}
 	YY_BREAK
-case 33:
-/* rule 33 can match eol */
-YY_RULE_SETUP
-#line 106 "lexer.l"
-{}
-	YY_BREAK
 case 34:
+/* rule 34 can match eol */
 YY_RULE_SETUP
-#line 108 "lexer.l"
-{ return INVALID_CHARACTER; }
+#line 107 "lexer.l"
+{}
 	YY_BREAK
 case 35:
 YY_RULE_SETUP
-#line 110 "lexer.l"
+#line 109 "lexer.l"
+{ return INVALID_CHARACTER; }
+	YY_BREAK
+case 36:
+YY_RULE_SETUP
+#line 111 "lexer.l"
 YY_FATAL_ERROR( "flex scanner jammed" );
 	YY_BREAK
-#line 1073 "lexer.gen.c"
+#line 1095 "lexer.gen.c"
 case YY_STATE_EOF(INITIAL):
 case YY_STATE_EOF(IN_PAREN):
 case YY_STATE_EOF(IN_BRACKET):
@@ -1261,21 +1283,21 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 
 	else
 		{
-			yy_size_t num_to_read =
+			int num_to_read =
 			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
 
 		while ( num_to_read <= 0 )
 			{ /* Not enough room in the buffer - grow it. */
 
 			/* just a shorter name for the current buffer */
-			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
+			YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
 
 			int yy_c_buf_p_offset =
 				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);
 
 			if ( b->yy_is_our_buffer )
 				{
-				yy_size_t new_size = b->yy_buf_size * 2;
+				int new_size = b->yy_buf_size * 2;
 
 				if ( new_size <= 0 )
 					b->yy_buf_size += b->yy_buf_size / 8;
@@ -1306,7 +1328,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 
 		/* Read in more data. */
 		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
-			yyg->yy_n_chars, num_to_read );
+			yyg->yy_n_chars, (size_t) num_to_read );
 
 		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
 		}
@@ -1368,7 +1390,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 			{
 			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 88 )
+			if ( yy_current_state >= 96 )
 				yy_c = yy_meta[(unsigned int) yy_c];
 			}
 		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
@@ -1397,13 +1419,12 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 		{
 		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 88 )
+		if ( yy_current_state >= 96 )
 			yy_c = yy_meta[(unsigned int) yy_c];
 		}
 	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-	yy_is_jam = (yy_current_state == 87);
+	yy_is_jam = (yy_current_state == 95);
 
-	(void)yyg;
 	return yy_is_jam ? 0 : yy_current_state;
 }
 
@@ -1432,7 +1453,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 
 		else
 			{ /* need more input */
-			yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
+			int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
 			++yyg->yy_c_buf_p;
 
 			switch ( yy_get_next_buffer( yyscanner ) )
@@ -1596,6 +1617,10 @@ static void jq_yy_load_buffer_state  (yyscan_t yyscanner)
 	jq_yyfree((void *) b ,yyscanner );
 }
 
+#ifndef __cplusplus
+extern int isatty (int );
+#endif /* __cplusplus */
+    
 /* Initializes or reinitializes a buffer.
  * This function is sometimes called more than once on the same buffer,
  * such as during a jq_yyrestart() or at EOF.
@@ -1712,7 +1737,7 @@ void jq_yypop_buffer_state (yyscan_t yyscanner)
  */
 static void jq_yyensure_buffer_stack (yyscan_t yyscanner)
 {
-	yy_size_t num_to_alloc;
+	int num_to_alloc;
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
 	if (!yyg->yy_buffer_stack) {
@@ -1810,7 +1835,7 @@ YY_BUFFER_STATE jq_yy_scan_string (yyconst char * yystr , yyscan_t yyscanner)
  * @param yyscanner The scanner object.
  * @return the newly allocated buffer state object.
  */
-YY_BUFFER_STATE jq_yy_scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len , yyscan_t yyscanner)
+YY_BUFFER_STATE jq_yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
 {
 	YY_BUFFER_STATE b;
 	char *buf;
@@ -1965,7 +1990,7 @@ FILE *jq_yyget_out  (yyscan_t yyscanner)
 /** Get the length of the current token.
  * @param yyscanner The scanner object.
  */
-yy_size_t jq_yyget_leng  (yyscan_t yyscanner)
+int jq_yyget_leng  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     return yyleng;
@@ -2001,7 +2026,7 @@ void jq_yyset_lineno (int  line_number , yyscan_t yyscanner)
 
         /* lineno is only valid if an input buffer exists. */
         if (! YY_CURRENT_BUFFER )
-           YY_FATAL_ERROR( "jq_yyset_lineno called with no buffer" );
+           yy_fatal_error( "jq_yyset_lineno called with no buffer" , yyscanner); 
     
     yylineno = line_number;
 }
@@ -2016,7 +2041,7 @@ void jq_yyset_column (int  column_no , yyscan_t yyscanner)
 
         /* column is only valid if an input buffer exists. */
         if (! YY_CURRENT_BUFFER )
-           YY_FATAL_ERROR( "jq_yyset_column called with no buffer" );
+           yy_fatal_error( "jq_yyset_column called with no buffer" , yyscanner); 
     
     yycolumn = column_no;
 }
@@ -2252,7 +2277,7 @@ void jq_yyfree (void * ptr , yyscan_t yyscanner)
 
 #define YYTABLES_NAME "yytables"
 
-#line 110 "lexer.l"
+#line 111 "lexer.l"
 
 
 /* perhaps these should be calls... */
diff --git a/lexer.gen.h b/lexer.gen.h
index e22ddb29..9249586d 100644
--- a/lexer.gen.h
+++ b/lexer.gen.h
@@ -13,7 +13,7 @@
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 5
-#define YY_FLEX_SUBMINOR_VERSION 37
+#define YY_FLEX_SUBMINOR_VERSION 35
 #if YY_FLEX_SUBMINOR_VERSION > 0
 #define FLEX_BETA
 #endif
@@ -132,7 +132,15 @@ typedef void* yyscan_t;
 
 /* Size of default input buffer. */
 #ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
 #define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
 #endif
 
 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
@@ -162,7 +170,7 @@ struct yy_buffer_state
 	/* Number of characters read into yy_ch_buf, not including EOB
 	 * characters.
 	 */
-	yy_size_t yy_n_chars;
+	int yy_n_chars;
 
 	/* Whether we "own" the buffer - i.e., we know we created it,
 	 * and can realloc() it to grow it, and should free() it to
@@ -206,7 +214,7 @@ void jq_yypop_buffer_state (yyscan_t yyscanner );
 
 YY_BUFFER_STATE jq_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
 YY_BUFFER_STATE jq_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
-YY_BUFFER_STATE jq_yy_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner );
+YY_BUFFER_STATE jq_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
 
 void *jq_yyalloc (yy_size_t ,yyscan_t yyscanner );
 void *jq_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
@@ -214,7 +222,7 @@ void jq_yyfree (void * ,yyscan_t yyscanner );
 
 /* Begin user sect3 */
 
-#define jq_yywrap(yyscanner) 1
+#define jq_yywrap(n) 1
 #define YY_SKIP_YYWRAP
 
 #define yytext_ptr yytext_r
@@ -264,7 +272,7 @@ FILE *jq_yyget_out (yyscan_t yyscanner );
 
 void jq_yyset_out  (FILE * out_str ,yyscan_t yyscanner );
 
-yy_size_t jq_yyget_leng (yyscan_t yyscanner );
+int jq_yyget_leng (yyscan_t yyscanner );
 
 char *jq_yyget_text (yyscan_t yyscanner );
 
@@ -272,10 +280,6 @@ int jq_yyget_lineno (yyscan_t yyscanner );
 
 void jq_yyset_lineno (int line_number ,yyscan_t yyscanner );
 
-int jq_yyget_column  (yyscan_t yyscanner );
-
-void jq_yyset_column (int column_no ,yyscan_t yyscanner );
-
 YYSTYPE * jq_yyget_lval (yyscan_t yyscanner );
 
 void jq_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
@@ -310,7 +314,12 @@ static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
 
 /* Amount of stuff to slurp up with each read. */
 #ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
 #define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
 #endif
 
 /* Number of entries by which start-condition stack grows. */
@@ -345,9 +354,9 @@ extern int jq_yylex \
 #undef YY_DECL
 #endif
 
-#line 110 "lexer.l"
+#line 111 "lexer.l"
 
 
-#line 352 "lexer.gen.h"
+#line 361 "lexer.gen.h"
 #undef jq_yyIN_HEADER
 #endif /* jq_yyHEADER_H */
diff --git a/lexer.l b/lexer.l
index e0bb2b7b..368d4989 100644
--- a/lexer.l
+++ b/lexer.l
@@ -56,6 +56,7 @@ struct lexer_param;
 "//=" { return SETDEFINEDOR; }
 "<=" { return LESSEQ; }
 ">=" { return GREATEREQ; }
+"contains" { return CONTAINS; }
 "."|"="|";"|","|":"|"|"|"+"|"-"|"*"|"/"|"\$"|"<"|">" { return yytext[0];}
 
 "["|"{"|"(" {
diff --git a/parser.gen.c b/parser.gen.c
index 32a2a205..3c157f48 100644
--- a/parser.gen.c
+++ b/parser.gen.c
@@ -1,8 +1,8 @@
-/* A Bison parser, made by GNU Bison 2.6.2.  */
+/* A Bison parser, made by GNU Bison 2.5.  */
 
 /* Bison implementation for Yacc-like parsers in C
    
-      Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc.
+      Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -44,7 +44,7 @@
 #define YYBISON 1
 
 /* Bison version.  */
-#define YYBISON_VERSION "2.6.2"
+#define YYBISON_VERSION "2.5"
 
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"
@@ -58,11 +58,14 @@
 /* Pull parsers.  */
 #define YYPULL 1
 
+/* Using locations.  */
+#define YYLSP_NEEDED 1
 
 
 
 /* Copy the first part of user declarations.  */
-/* Line 336 of yacc.c  */
+
+/* Line 268 of yacc.c  */
 #line 1 "parser.y"
 
 #include <stdio.h>
@@ -72,16 +75,14 @@
 struct lexer_param;
 
 
-/* Line 336 of yacc.c  */
-#line 77 "parser.gen.c"
 
-# ifndef YY_NULL
-#  if defined __cplusplus && 201103L <= __cplusplus
-#   define YY_NULL nullptr
-#  else
-#   define YY_NULL 0
-#  endif
-# endif
+/* Line 268 of yacc.c  */
+#line 81 "parser.gen.c"
+
+/* Enabling traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
 
 /* Enabling verbose error messages.  */
 #ifdef YYERROR_VERBOSE
@@ -91,19 +92,14 @@ struct lexer_param;
 # define YYERROR_VERBOSE 1
 #endif
 
-/* In a future release of Bison, this section will be replaced
-   by #include "parser.gen.h".  */
-#ifndef YY_PARSER_GEN_H
-# define YY_PARSER_GEN_H
-/* Enabling traces.  */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-#if YYDEBUG
-extern int yydebug;
+/* Enabling the token table.  */
+#ifndef YYTOKEN_TABLE
+# define YYTOKEN_TABLE 0
 #endif
+
 /* "%code requires" blocks.  */
-/* Line 350 of yacc.c  */
+
+/* Line 288 of yacc.c  */
 #line 9 "parser.y"
 
 #include "locfile.h"
@@ -120,8 +116,9 @@ extern int yydebug;
   } while (0)
  
 
-/* Line 350 of yacc.c  */
-#line 125 "parser.gen.c"
+
+/* Line 288 of yacc.c  */
+#line 122 "parser.gen.c"
 
 /* Tokens.  */
 #ifndef YYTOKENTYPE
@@ -152,27 +149,31 @@ extern int yydebug;
      SETDEFINEDOR = 278,
      LESSEQ = 279,
      GREATEREQ = 280,
-     QQSTRING_START = 281,
-     QQSTRING_TEXT = 282,
-     QQSTRING_INTERP_START = 283,
-     QQSTRING_INTERP_END = 284,
-     QQSTRING_END = 285
+     CONTAINS = 281,
+     QQSTRING_START = 282,
+     QQSTRING_TEXT = 283,
+     QQSTRING_INTERP_START = 284,
+     QQSTRING_INTERP_END = 285,
+     QQSTRING_END = 286
    };
 #endif
 
 
+
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 typedef union YYSTYPE
 {
-/* Line 350 of yacc.c  */
+
+/* Line 293 of yacc.c  */
 #line 27 "parser.y"
 
   jv literal;
   block blk;
 
 
-/* Line 350 of yacc.c  */
-#line 176 "parser.gen.c"
+
+/* Line 293 of yacc.c  */
+#line 177 "parser.gen.c"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
@@ -193,25 +194,10 @@ typedef struct YYLTYPE
 #endif
 
 
-#ifdef YYPARSE_PARAM
-#if defined __STDC__ || defined __cplusplus
-int yyparse (void *YYPARSE_PARAM);
-#else
-int yyparse ();
-#endif
-#else /* ! YYPARSE_PARAM */
-#if defined __STDC__ || defined __cplusplus
-int yyparse (block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr);
-#else
-int yyparse ();
-#endif
-#endif /* ! YYPARSE_PARAM */
-
-#endif /* !YY_PARSER_GEN_H  */
-
 /* Copy the second part of user declarations.  */
-/* Line 353 of yacc.c  */
-#line 89 "parser.y"
+
+/* Line 343 of yacc.c  */
+#line 90 "parser.y"
 
 #include "lexer.gen.h"
 struct lexer_param {
@@ -278,6 +264,7 @@ static block gen_binop(block a, block b, int op) {
   case '>': funcname = "_greater"; break;
   case LESSEQ: funcname = "_lesseq"; break;
   case GREATEREQ: funcname = "_greatereq"; break;
+  case CONTAINS: funcname = "_contains"; break;
   }
   assert(funcname);
 
@@ -303,8 +290,9 @@ static block gen_update(block a, block op, int optype) {
 }
 
 
-/* Line 353 of yacc.c  */
-#line 308 "parser.gen.c"
+
+/* Line 343 of yacc.c  */
+#line 296 "parser.gen.c"
 
 #ifdef short
 # undef short
@@ -410,7 +398,6 @@ YYID (yyi)
 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
 #     ifndef EXIT_SUCCESS
 #      define EXIT_SUCCESS 0
 #     endif
@@ -504,20 +491,20 @@ union yyalloc
 #endif
 
 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
-/* Copy COUNT objects from SRC to DST.  The source and destination do
+/* Copy COUNT objects from FROM to TO.  The source and destination do
    not overlap.  */
 # ifndef YYCOPY
 #  if defined __GNUC__ && 1 < __GNUC__
-#   define YYCOPY(Dst, Src, Count) \
-      __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
+#   define YYCOPY(To, From, Count) \
+      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 #  else
-#   define YYCOPY(Dst, Src, Count)              \
-      do                                        \
-        {                                       \
-          YYSIZE_T yyi;                         \
-          for (yyi = 0; yyi < (Count); yyi++)   \
-            (Dst)[yyi] = (Src)[yyi];            \
-        }                                       \
+#   define YYCOPY(To, From, Count)		\
+      do					\
+	{					\
+	  YYSIZE_T yyi;				\
+	  for (yyi = 0; yyi < (Count); yyi++)	\
+	    (To)[yyi] = (From)[yyi];		\
+	}					\
       while (YYID (0))
 #  endif
 # endif
@@ -526,20 +513,20 @@ union yyalloc
 /* YYFINAL -- State number of the termination state.  */
 #define YYFINAL  35
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   831
+#define YYLAST   854
 
 /* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  50
+#define YYNTOKENS  51
 /* YYNNTS -- Number of nonterminals.  */
 #define YYNNTS  12
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  69
+#define YYNRULES  70
 /* YYNRULES -- Number of states.  */
-#define YYNSTATES  149
+#define YYNSTATES  151
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 #define YYUNDEFTOK  2
-#define YYMAXUTOK   285
+#define YYMAXUTOK   286
 
 #define YYTRANSLATE(YYX)						\
   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
@@ -550,16 +537,16 @@ static const yytype_uint8 yytranslate[] =
        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,    41,     2,     2,     2,
-      43,    44,    39,    37,    33,    38,    45,    40,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,    42,    31,
-      35,    34,    36,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,    42,     2,     2,     2,
+      44,    45,    40,    38,    34,    39,    46,    41,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,    43,    32,
+      36,    35,    37,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,    46,     2,    47,     2,     2,     2,     2,     2,     2,
+       2,    47,     2,    48,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,    48,    32,    49,     2,     2,     2,     2,
+       2,     2,     2,    49,    33,    50,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
@@ -575,7 +562,7 @@ static const yytype_uint8 yytranslate[] =
        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30
+      25,    26,    27,    28,    29,    30,    31
 };
 
 #if YYDEBUG
@@ -586,58 +573,60 @@ static const yytype_uint16 yyprhs[] =
        0,     0,     3,     5,     7,     8,    11,    14,    21,    27,
       31,    35,    39,    43,    47,    51,    55,    59,    63,    67,
       71,    75,    79,    83,    87,    91,    95,    99,   103,   107,
-     111,   115,   119,   121,   123,   127,   133,   142,   143,   146,
-     151,   157,   161,   165,   167,   169,   173,   176,   181,   185,
-     187,   191,   195,   198,   202,   205,   207,   212,   216,   220,
-     225,   229,   230,   232,   236,   240,   244,   248,   250,   256
+     111,   115,   119,   123,   125,   127,   131,   137,   146,   147,
+     150,   155,   161,   165,   169,   171,   173,   177,   180,   185,
+     189,   191,   195,   199,   202,   206,   209,   211,   216,   220,
+     224,   229,   233,   234,   236,   240,   244,   248,   252,   254,
+     260
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 static const yytype_int8 yyrhs[] =
 {
-      51,     0,    -1,    53,    -1,    52,    -1,    -1,    55,    52,
-      -1,    55,    53,    -1,    59,     9,    41,     4,    32,    53,
-      -1,    11,    53,    12,    53,    57,    -1,    11,    53,     1,
-      -1,    53,    34,    53,    -1,    53,    17,    53,    -1,    53,
-      16,    53,    -1,    53,     8,    53,    -1,    53,    23,    53,
-      -1,    53,    18,    53,    -1,    53,    32,    53,    -1,    53,
-      33,    53,    -1,    53,    37,    53,    -1,    53,    19,    53,
-      -1,    53,    38,    53,    -1,    53,    20,    53,    -1,    53,
-      39,    53,    -1,    53,    21,    53,    -1,    53,    40,    53,
-      -1,    53,    22,    53,    -1,    53,     6,    53,    -1,    53,
-       7,    53,    -1,    53,    35,    53,    -1,    53,    36,    53,
-      -1,    53,    24,    53,    -1,    53,    25,    53,    -1,    54,
-      -1,    59,    -1,    26,    56,    30,    -1,    10,     4,    42,
-      53,    31,    -1,    10,     4,    43,     4,    44,    42,    53,
-      31,    -1,    -1,    56,    27,    -1,    56,    28,    53,    29,
-      -1,    14,    53,    12,    53,    57,    -1,    13,    53,    15,
-      -1,    58,    32,    58,    -1,    59,    -1,    45,    -1,    59,
-      45,     4,    -1,    45,     4,    -1,    59,    46,    53,    47,
-      -1,    59,    46,    47,    -1,     5,    -1,    43,    53,    44,
-      -1,    46,    53,    47,    -1,    46,    47,    -1,    48,    60,
-      49,    -1,    41,     4,    -1,     4,    -1,     4,    43,    53,
-      44,    -1,    43,     1,    44,    -1,    46,     1,    47,    -1,
-      59,    46,     1,    47,    -1,    48,     1,    49,    -1,    -1,
-      61,    -1,    61,    33,    60,    -1,     1,    33,    60,    -1,
-       4,    42,    58,    -1,    54,    42,    58,    -1,     4,    -1,
-      43,    53,    44,    42,    58,    -1,    43,     1,    44,    42,
-      58,    -1
+      52,     0,    -1,    54,    -1,    53,    -1,    -1,    56,    53,
+      -1,    56,    54,    -1,    60,     9,    42,     4,    33,    54,
+      -1,    11,    54,    12,    54,    58,    -1,    11,    54,     1,
+      -1,    54,    35,    54,    -1,    54,    17,    54,    -1,    54,
+      16,    54,    -1,    54,     8,    54,    -1,    54,    23,    54,
+      -1,    54,    18,    54,    -1,    54,    33,    54,    -1,    54,
+      34,    54,    -1,    54,    38,    54,    -1,    54,    19,    54,
+      -1,    54,    39,    54,    -1,    54,    20,    54,    -1,    54,
+      40,    54,    -1,    54,    21,    54,    -1,    54,    41,    54,
+      -1,    54,    22,    54,    -1,    54,     6,    54,    -1,    54,
+       7,    54,    -1,    54,    36,    54,    -1,    54,    37,    54,
+      -1,    54,    24,    54,    -1,    54,    25,    54,    -1,    54,
+      26,    54,    -1,    55,    -1,    60,    -1,    27,    57,    31,
+      -1,    10,     4,    43,    54,    32,    -1,    10,     4,    44,
+       4,    45,    43,    54,    32,    -1,    -1,    57,    28,    -1,
+      57,    29,    54,    30,    -1,    14,    54,    12,    54,    58,
+      -1,    13,    54,    15,    -1,    59,    33,    59,    -1,    60,
+      -1,    46,    -1,    60,    46,     4,    -1,    46,     4,    -1,
+      60,    47,    54,    48,    -1,    60,    47,    48,    -1,     5,
+      -1,    44,    54,    45,    -1,    47,    54,    48,    -1,    47,
+      48,    -1,    49,    61,    50,    -1,    42,     4,    -1,     4,
+      -1,     4,    44,    54,    45,    -1,    44,     1,    45,    -1,
+      47,     1,    48,    -1,    60,    47,     1,    48,    -1,    49,
+       1,    50,    -1,    -1,    62,    -1,    62,    34,    61,    -1,
+       1,    34,    61,    -1,     4,    43,    59,    -1,    55,    43,
+      59,    -1,     4,    -1,    44,    54,    45,    43,    59,    -1,
+      44,     1,    45,    43,    59,    -1
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 static const yytype_uint16 yyrline[] =
 {
-       0,   183,   183,   186,   191,   194,   199,   203,   210,   213,
-     218,   227,   231,   235,   239,   243,   247,   251,   255,   259,
-     263,   267,   271,   275,   279,   283,   287,   291,   295,   299,
-     303,   307,   311,   315,   320,   325,   331,   339,   342,   345,
-     351,   354,   359,   363,   369,   372,   375,   379,   382,   385,
-     388,   391,   394,   397,   402,   406,   410,   420,   421,   422,
-     423,   426,   429,   430,   431,   434,   437,   440,   444,   447
+       0,   185,   185,   188,   193,   196,   201,   205,   212,   215,
+     220,   229,   233,   237,   241,   245,   249,   253,   257,   261,
+     265,   269,   273,   277,   281,   285,   289,   293,   297,   301,
+     305,   309,   313,   317,   321,   326,   331,   337,   345,   348,
+     351,   357,   360,   365,   369,   375,   378,   381,   385,   388,
+     391,   394,   397,   400,   403,   408,   412,   416,   426,   427,
+     428,   429,   432,   435,   436,   437,   440,   443,   446,   450,
+     453
 };
 #endif
 
-#if YYDEBUG || YYERROR_VERBOSE || 1
+#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 static const char *const yytname[] =
@@ -646,12 +635,12 @@ static const char *const yytname[] =
   "\"==\"", "\"!=\"", "\"//\"", "\"as\"", "\"def\"", "\"if\"", "\"then\"",
   "\"else\"", "\"elif\"", "\"end\"", "\"and\"", "\"or\"", "\"|=\"",
   "\"+=\"", "\"-=\"", "\"*=\"", "\"/=\"", "\"//=\"", "\"<=\"", "\">=\"",
-  "QQSTRING_START", "QQSTRING_TEXT", "QQSTRING_INTERP_START",
-  "QQSTRING_INTERP_END", "QQSTRING_END", "';'", "'|'", "','", "'='", "'<'",
-  "'>'", "'+'", "'-'", "'*'", "'/'", "'$'", "':'", "'('", "')'", "'.'",
-  "'['", "']'", "'{'", "'}'", "$accept", "TopLevel", "FuncDefs", "Exp",
-  "String", "FuncDef", "QQString", "ElseBody", "ExpD", "Term", "MkDict",
-  "MkDictPair", YY_NULL
+  "\"contains\"", "QQSTRING_START", "QQSTRING_TEXT",
+  "QQSTRING_INTERP_START", "QQSTRING_INTERP_END", "QQSTRING_END", "';'",
+  "'|'", "','", "'='", "'<'", "'>'", "'+'", "'-'", "'*'", "'/'", "'$'",
+  "':'", "'('", "')'", "'.'", "'['", "']'", "'{'", "'}'", "$accept",
+  "TopLevel", "FuncDefs", "Exp", "String", "FuncDef", "QQString",
+  "ElseBody", "ExpD", "Term", "MkDict", "MkDictPair", 0
 };
 #endif
 
@@ -663,21 +652,23 @@ static const yytype_uint16 yytoknum[] =
        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,    59,   124,    44,    61,    60,    62,    43,    45,    42,
-      47,    36,    58,    40,    41,    46,    91,    93,   123,   125
+     285,   286,    59,   124,    44,    61,    60,    62,    43,    45,
+      42,    47,    36,    58,    40,    41,    46,    91,    93,   123,
+     125
 };
 # endif
 
 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 static const yytype_uint8 yyr1[] =
 {
-       0,    50,    51,    51,    52,    52,    53,    53,    53,    53,
-      53,    53,    53,    53,    53,    53,    53,    53,    53,    53,
-      53,    53,    53,    53,    53,    53,    53,    53,    53,    53,
-      53,    53,    53,    53,    54,    55,    55,    56,    56,    56,
-      57,    57,    58,    58,    59,    59,    59,    59,    59,    59,
-      59,    59,    59,    59,    59,    59,    59,    59,    59,    59,
-      59,    60,    60,    60,    60,    61,    61,    61,    61,    61
+       0,    51,    52,    52,    53,    53,    54,    54,    54,    54,
+      54,    54,    54,    54,    54,    54,    54,    54,    54,    54,
+      54,    54,    54,    54,    54,    54,    54,    54,    54,    54,
+      54,    54,    54,    54,    54,    55,    56,    56,    57,    57,
+      57,    58,    58,    59,    59,    60,    60,    60,    60,    60,
+      60,    60,    60,    60,    60,    60,    60,    60,    60,    60,
+      60,    60,    61,    61,    61,    61,    62,    62,    62,    62,
+      62
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
@@ -686,10 +677,11 @@ static const yytype_uint8 yyr2[] =
        0,     2,     1,     1,     0,     2,     2,     6,     5,     3,
        3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
        3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-       3,     3,     1,     1,     3,     5,     8,     0,     2,     4,
-       5,     3,     3,     1,     1,     3,     2,     4,     3,     1,
-       3,     3,     2,     3,     2,     1,     4,     3,     3,     4,
-       3,     0,     1,     3,     3,     3,     3,     1,     5,     5
+       3,     3,     3,     1,     1,     3,     5,     8,     0,     2,
+       4,     5,     3,     3,     1,     1,     3,     2,     4,     3,
+       1,     3,     3,     2,     3,     2,     1,     4,     3,     3,
+       4,     3,     0,     1,     3,     3,     3,     3,     1,     5,
+       5
 };
 
 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
@@ -697,264 +689,271 @@ static const yytype_uint8 yyr2[] =
    means the default is an error.  */
 static const yytype_uint8 yydefact[] =
 {
-       4,    55,    49,     0,     0,    37,     0,     0,    44,     0,
-       0,     0,     3,     2,    32,     4,    33,     0,     0,     0,
-       0,     0,    54,     0,     0,    46,     0,    52,     0,     0,
-      67,     0,     0,     0,    62,     1,     0,     0,     0,     0,
+       4,    56,    50,     0,     0,    38,     0,     0,    45,     0,
+       0,     0,     3,     2,    33,     4,    34,     0,     0,     0,
+       0,     0,    55,     0,     0,    47,     0,    53,     0,     0,
+      68,     0,     0,     0,    63,     1,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     5,     6,
-       0,     0,     0,     0,     0,     0,     9,     0,    38,     0,
-      34,    57,    50,    58,    51,     0,    60,     0,     0,     0,
-       0,    53,     0,    26,    27,    13,    12,    11,    15,    19,
-      21,    23,    25,    14,    30,    31,    16,    17,    10,    28,
-      29,    18,    20,    22,    24,     0,    45,     0,    48,     0,
-      56,     0,     0,     0,     0,     0,    64,    65,    43,     0,
-       0,    66,    63,     0,    59,    47,    35,     0,     0,     0,
-       8,    39,     0,     0,     0,     0,     0,     0,     0,    42,
-      69,    68,     7,     0,    41,     0,    36,     0,    40
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
+       6,     0,     0,     0,     0,     0,     0,     9,     0,    39,
+       0,    35,    58,    51,    59,    52,     0,    61,     0,     0,
+       0,     0,    54,     0,    26,    27,    13,    12,    11,    15,
+      19,    21,    23,    25,    14,    30,    31,    32,    16,    17,
+      10,    28,    29,    18,    20,    22,    24,     0,    46,     0,
+      49,     0,    57,     0,     0,     0,     0,     0,    65,    66,
+      44,     0,     0,    67,    64,     0,    60,    48,    36,     0,
+       0,     0,     8,    40,     0,     0,     0,     0,     0,     0,
+       0,    43,    70,    69,     7,     0,    42,     0,    37,     0,
+      41
 };
 
 /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int16 yydefgoto[] =
 {
-      -1,    11,    12,    59,    14,    20,    21,   130,   117,    16,
+      -1,    11,    12,    60,    14,    20,    21,   132,   119,    16,
       33,    34
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
-#define YYPACT_NINF -75
+#define YYPACT_NINF -76
 static const yytype_int16 yypact[] =
 {
-     175,   -41,   -75,    10,   175,   -75,    16,   129,    18,    78,
-      64,    28,   -75,   645,   -75,   175,    52,   175,   -27,   295,
-     175,   -17,   -75,   -14,   330,   -75,   -18,   -75,   218,   -28,
-     -10,   152,    -8,   -16,     2,   -75,   175,   175,   175,   175,
-     175,   175,   175,   175,   175,   175,   175,   175,   175,   175,
-     175,   175,   175,   175,   175,   175,   175,   175,   -75,   645,
-      22,    71,   101,   365,   175,    72,   -75,   175,   -75,   175,
-     -75,   -75,   -75,   -75,   -75,    73,   -75,   146,    34,   400,
-     146,   -75,    73,   785,   785,   715,   791,   765,   740,   740,
-     740,   740,   740,   740,   785,   785,   680,   715,   740,   785,
-     785,   -15,   -15,   -75,   -75,    76,   -75,    37,   -75,   253,
-     -75,   470,    41,   435,   505,    48,   -75,    54,   -19,    45,
-      49,    54,   -75,    60,   -75,   -75,   -75,    51,   175,   175,
-     -75,   -75,   146,   146,   146,   175,   175,   540,   575,   -75,
-      54,    54,   680,   610,   -75,   175,   -75,   435,   -75
+     179,   -42,   -76,    10,   179,   -76,    16,   131,    18,    79,
+      65,    28,   -76,   662,   -76,   179,    53,   179,   -28,   302,
+     179,   -18,   -76,   -15,   338,   -76,   -19,   -76,   223,   -29,
+     -11,   155,   -10,    14,     1,   -76,   179,   179,   179,   179,
+     179,   179,   179,   179,   179,   179,   179,   179,   179,   179,
+     179,   179,   179,   179,   179,   179,   179,   179,   179,   -76,
+     662,    -8,    72,   106,   374,   179,    73,   -76,   179,   -76,
+     179,   -76,   -76,   -76,   -76,   -76,    74,   -76,   163,    34,
+     410,   163,   -76,    74,   807,   807,   734,   813,   786,   760,
+     760,   760,   760,   760,   760,   807,   807,   807,   698,   734,
+     760,   807,   807,   -16,   -16,   -76,   -76,    77,   -76,    37,
+     -76,   259,   -76,   482,    41,   446,   518,    48,   -76,    54,
+     -20,    45,    50,    54,   -76,    58,   -76,   -76,   -76,    51,
+     179,   179,   -76,   -76,   163,   163,   163,   179,   179,   554,
+     590,   -76,    54,    54,   698,   626,   -76,   179,   -76,   446,
+     -76
 };
 
 /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int8 yypgoto[] =
 {
-     -75,   -75,    79,     0,    -9,     8,   -75,   -52,   -62,   -74,
-     -63,   -75
+     -76,   -76,    80,     0,    -9,     8,   -76,   -53,   -63,   -75,
+     -64,   -76
 };
 
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If YYTABLE_NINF, syntax error.  */
-#define YYTABLE_NINF -62
+#define YYTABLE_NINF -63
 static const yytype_int16 yytable[] =
 {
-      13,    32,    17,   118,    19,    75,   118,    24,    15,    28,
-      68,    69,   116,    70,    18,    64,    65,    63,   121,   122,
-      22,    76,    25,    15,    56,    57,    61,    62,    35,    73,
-      71,    79,    77,    81,    80,    82,    83,    84,    85,    86,
-      87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
-      97,    98,    99,   100,   101,   102,   103,   104,   118,   118,
-     118,    60,   109,   105,   111,    29,    32,   113,    30,   114,
-     139,   140,   141,    32,   115,   106,   112,    30,   119,    26,
-     123,    75,     1,     2,   124,   127,   132,   133,     3,     4,
-       5,   134,   135,   136,    58,   148,     0,    61,    62,     5,
-       0,     0,   107,     0,     5,     1,     2,    31,     0,     0,
-       0,     3,     4,   -61,     0,     0,    31,     0,     0,     6,
-       0,     7,   -61,     8,     9,    27,    10,     5,   137,   138,
-      23,     0,     0,     1,     2,   142,   143,     0,     0,     3,
-       4,     0,     6,     0,     7,   147,     8,     9,   108,    10,
-       1,     2,     0,    78,     0,     5,     1,     2,     0,     0,
-       0,     0,     3,     4,     0,     0,     0,     0,     0,     0,
-       6,     0,     7,     0,     8,     9,     0,    10,     5,     1,
-       2,     0,     0,     0,     0,     3,     4,     6,     0,     7,
-       0,     8,     9,     6,    10,     7,     0,     8,     9,     0,
-      10,     5,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     6,     0,     7,     0,
-       8,     9,     0,    10,    36,    37,    38,     0,     0,     0,
+      13,    32,    17,   120,    19,    76,   120,    24,    15,    28,
+      69,    70,   118,    71,    18,    65,    66,    64,   123,   124,
+      22,    77,    25,    15,    57,    58,    62,    63,    35,    74,
+      72,    80,    78,    81,   107,    83,    84,    85,    86,    87,
+      88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
+      98,    99,   100,   101,   102,   103,   104,   105,   106,   120,
+     120,   120,    61,   111,    82,   113,    29,    32,   115,    30,
+     116,   141,   142,   143,    32,   117,   108,   114,    30,   121,
+      26,   125,    76,     1,     2,   126,   129,   134,   135,     3,
+       4,   137,     5,   136,   138,    59,   150,     0,     0,    62,
+      63,     5,     0,     0,     0,     0,     5,   109,     0,    31,
+       1,     2,     0,     0,     0,   -62,     3,     4,    31,     0,
+       0,     6,     0,     7,   -62,     8,     9,    27,    10,     0,
+     139,   140,    23,     5,     0,     1,     2,   144,   145,     0,
+       0,     3,     4,     0,     0,     0,     0,   149,     6,     0,
+       7,     0,     8,     9,   110,    10,    79,     0,     5,     1,
+       2,     0,     0,     0,     0,     3,     4,     1,     2,     0,
+       0,     0,     0,     6,     0,     7,     0,     8,     9,     0,
+      10,     0,     5,     1,     2,     0,     0,     0,     0,     3,
+       4,     0,     0,     0,     0,     0,     0,     6,     0,     7,
+       0,     8,     9,     0,    10,     6,     5,     7,     0,     8,
+       9,     0,    10,     0,     0,     0,     0,     0,     0,     0,
+       0,     6,     0,     7,     0,     8,     9,     0,    10,    36,
+      37,    38,     0,     0,     0,     0,     0,     0,     0,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+       0,     0,     0,     0,     0,     0,    50,    51,    52,    53,
+      54,    55,    56,    57,    58,    36,    37,    38,     0,     0,
+       0,    75,     0,     0,     0,    39,    40,    41,    42,    43,
+      44,    45,    46,    47,    48,    49,     0,     0,     0,     0,
+       0,     0,    50,    51,    52,    53,    54,    55,    56,    57,
+      58,     0,     0,    67,     0,     0,     0,   127,    36,    37,
+      38,     0,     0,     0,    68,     0,     0,     0,    39,    40,
+      41,    42,    43,    44,    45,    46,    47,    48,    49,     0,
+       0,     0,     0,     0,     0,    50,    51,    52,    53,    54,
+      55,    56,    57,    58,    36,    37,    38,     0,     0,     0,
        0,     0,     0,     0,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,     0,     0,     0,     0,     0,     0,
-      49,    50,    51,    52,    53,    54,    55,    56,    57,    36,
-      37,    38,     0,     0,     0,    74,     0,     0,     0,    39,
-      40,    41,    42,    43,    44,    45,    46,    47,    48,     0,
-       0,     0,     0,     0,     0,    49,    50,    51,    52,    53,
-      54,    55,    56,    57,     0,     0,    66,     0,     0,     0,
-     125,    36,    37,    38,     0,     0,     0,    67,     0,     0,
-       0,    39,    40,    41,    42,    43,    44,    45,    46,    47,
-      48,     0,     0,     0,     0,     0,     0,    49,    50,    51,
-      52,    53,    54,    55,    56,    57,    36,    37,    38,     0,
+      45,    46,    47,    48,    49,     0,     0,     0,     0,     0,
+       0,    50,    51,    52,    53,    54,    55,    56,    57,    58,
+      36,    37,    38,    73,     0,     0,     0,     0,     0,     0,
+      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
+      49,     0,     0,     0,     0,     0,     0,    50,    51,    52,
+      53,    54,    55,    56,    57,    58,    36,    37,    38,   112,
        0,     0,     0,     0,     0,     0,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,     0,     0,     0,     0,
-       0,     0,    49,    50,    51,    52,    53,    54,    55,    56,
-      57,    36,    37,    38,    72,     0,     0,     0,     0,     0,
-       0,    39,    40,    41,    42,    43,    44,    45,    46,    47,
-      48,     0,     0,     0,     0,     0,     0,    49,    50,    51,
-      52,    53,    54,    55,    56,    57,    36,    37,    38,   110,
-       0,     0,     0,     0,     0,     0,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,     0,     0,     0,     0,
-       0,     0,    49,    50,    51,    52,    53,    54,    55,    56,
-      57,    36,    37,    38,   120,     0,     0,     0,   128,   129,
-       0,    39,    40,    41,    42,    43,    44,    45,    46,    47,
-      48,     0,     0,     0,     0,     0,     0,    49,    50,    51,
-      52,    53,    54,    55,    56,    57,    36,    37,    38,     0,
-       0,     0,     0,     0,     0,     0,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,     0,     0,     0,     0,
-       0,   126,    49,    50,    51,    52,    53,    54,    55,    56,
-      57,    36,    37,    38,     0,     0,     0,     0,     0,     0,
-       0,    39,    40,    41,    42,    43,    44,    45,    46,    47,
-      48,     0,     0,     0,   131,     0,     0,    49,    50,    51,
-      52,    53,    54,    55,    56,    57,    36,    37,    38,     0,
-       0,     0,     0,     0,     0,   144,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,     0,     0,     0,     0,
-       0,     0,    49,    50,    51,    52,    53,    54,    55,    56,
-      57,    36,    37,    38,     0,     0,     0,   145,     0,     0,
-       0,    39,    40,    41,    42,    43,    44,    45,    46,    47,
-      48,     0,     0,     0,     0,     0,     0,    49,    50,    51,
-      52,    53,    54,    55,    56,    57,    36,    37,    38,     0,
-       0,     0,     0,     0,     0,     0,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,     0,     0,     0,     0,
-       0,   146,    49,    50,    51,    52,    53,    54,    55,    56,
-      57,    36,    37,    38,     0,     0,     0,     0,     0,     0,
-       0,    39,    40,    41,    42,    43,    44,    45,    46,    47,
-      48,     0,     0,     0,     0,     0,     0,    49,    50,    51,
-      52,    53,    54,    55,    56,    57,    36,    37,    38,     0,
-       0,     0,     0,     0,     0,     0,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,     0,     0,     0,     0,
+      43,    44,    45,    46,    47,    48,    49,     0,     0,     0,
        0,     0,     0,    50,    51,    52,    53,    54,    55,    56,
-      57,    36,    37,    38,     0,     0,     0,     0,     0,     0,
-       0,    39,    40,    41,    42,    43,    44,    45,    46,    47,
-      48,     0,     0,     0,     0,     0,    36,    37,     0,    51,
-      52,    53,    54,    55,    56,    57,    39,    40,   -62,   -62,
-     -62,   -62,   -62,   -62,    47,    48,     0,     0,     0,     0,
-       0,    36,    37,     0,   -62,    52,    53,    54,    55,    56,
-      57,    39,     0,     0,     0,     0,     0,     0,     0,    47,
-      48,   -62,   -62,     0,     0,     0,     0,    36,    37,     0,
-      52,    53,    54,    55,    56,    57,     0,     0,     0,   -62,
-     -62,     0,     0,     0,     0,    47,    48,     0,     0,     0,
-     -62,   -62,    54,    55,    56,    57,    52,    53,    54,    55,
-      56,    57
+      57,    58,    36,    37,    38,   122,     0,     0,     0,   130,
+     131,     0,    39,    40,    41,    42,    43,    44,    45,    46,
+      47,    48,    49,     0,     0,     0,     0,     0,     0,    50,
+      51,    52,    53,    54,    55,    56,    57,    58,    36,    37,
+      38,     0,     0,     0,     0,     0,     0,     0,    39,    40,
+      41,    42,    43,    44,    45,    46,    47,    48,    49,     0,
+       0,     0,     0,     0,   128,    50,    51,    52,    53,    54,
+      55,    56,    57,    58,    36,    37,    38,     0,     0,     0,
+       0,     0,     0,     0,    39,    40,    41,    42,    43,    44,
+      45,    46,    47,    48,    49,     0,     0,     0,   133,     0,
+       0,    50,    51,    52,    53,    54,    55,    56,    57,    58,
+      36,    37,    38,     0,     0,     0,     0,     0,     0,   146,
+      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
+      49,     0,     0,     0,     0,     0,     0,    50,    51,    52,
+      53,    54,    55,    56,    57,    58,    36,    37,    38,     0,
+       0,     0,   147,     0,     0,     0,    39,    40,    41,    42,
+      43,    44,    45,    46,    47,    48,    49,     0,     0,     0,
+       0,     0,     0,    50,    51,    52,    53,    54,    55,    56,
+      57,    58,    36,    37,    38,     0,     0,     0,     0,     0,
+       0,     0,    39,    40,    41,    42,    43,    44,    45,    46,
+      47,    48,    49,     0,     0,     0,     0,     0,   148,    50,
+      51,    52,    53,    54,    55,    56,    57,    58,    36,    37,
+      38,     0,     0,     0,     0,     0,     0,     0,    39,    40,
+      41,    42,    43,    44,    45,    46,    47,    48,    49,     0,
+       0,     0,     0,     0,     0,    50,    51,    52,    53,    54,
+      55,    56,    57,    58,    36,    37,    38,     0,     0,     0,
+       0,     0,     0,     0,    39,    40,    41,    42,    43,    44,
+      45,    46,    47,    48,    49,     0,     0,     0,     0,     0,
+       0,     0,    51,    52,    53,    54,    55,    56,    57,    58,
+      36,    37,    38,     0,     0,     0,     0,     0,     0,     0,
+      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
+      49,     0,     0,     0,     0,     0,    36,    37,     0,    52,
+      53,    54,    55,    56,    57,    58,    39,    40,   -63,   -63,
+     -63,   -63,   -63,   -63,    47,    48,    49,     0,     0,     0,
+       0,     0,    36,    37,     0,   -63,    53,    54,    55,    56,
+      57,    58,    39,     0,     0,     0,     0,     0,     0,     0,
+      47,    48,    49,   -63,   -63,     0,     0,     0,     0,    36,
+      37,     0,    53,    54,    55,    56,    57,    58,     0,     0,
+       0,   -63,   -63,   -63,     0,     0,     0,    47,    48,    49,
+       0,     0,     0,   -63,   -63,    55,    56,    57,    58,    53,
+      54,    55,    56,    57,    58
 };
 
 #define yypact_value_is_default(yystate) \
-  ((yystate) == (-75))
+  ((yystate) == (-76))
 
 #define yytable_value_is_error(yytable_value) \
-  ((yytable_value) == (-62))
+  ((yytable_value) == (-63))
 
 static const yytype_int16 yycheck[] =
 {
-       0,    10,    43,    77,     4,    33,    80,     7,     0,     9,
-      27,    28,    75,    30,     4,    42,    43,    17,    80,    82,
-       4,    49,     4,    15,    39,    40,    45,    46,     0,    47,
-      44,    31,    42,    49,    42,    33,    36,    37,    38,    39,
+       0,    10,    44,    78,     4,    34,    81,     7,     0,     9,
+      28,    29,    76,    31,     4,    43,    44,    17,    81,    83,
+       4,    50,     4,    15,    40,    41,    46,    47,     0,    48,
+      45,    31,    43,    43,    42,    34,    36,    37,    38,    39,
       40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    57,   132,   133,
-     134,     9,    62,    41,    64,     1,    75,    67,     4,    69,
-     132,   133,   134,    82,     1,     4,     4,     4,    44,     1,
-       4,    33,     4,     5,    47,    44,    32,    42,    10,    11,
-      26,    42,    32,    42,    15,   147,    -1,    45,    46,    26,
-      -1,    -1,     1,    -1,    26,     4,     5,    43,    -1,    -1,
-      -1,    10,    11,    49,    -1,    -1,    43,    -1,    -1,    41,
-      -1,    43,    49,    45,    46,    47,    48,    26,   128,   129,
-       1,    -1,    -1,     4,     5,   135,   136,    -1,    -1,    10,
-      11,    -1,    41,    -1,    43,   145,    45,    46,    47,    48,
-       4,     5,    -1,     1,    -1,    26,     4,     5,    -1,    -1,
-      -1,    -1,    10,    11,    -1,    -1,    -1,    -1,    -1,    -1,
-      41,    -1,    43,    -1,    45,    46,    -1,    48,    26,     4,
-       5,    -1,    -1,    -1,    -1,    10,    11,    41,    -1,    43,
-      -1,    45,    46,    41,    48,    43,    -1,    45,    46,    -1,
-      48,    26,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    41,    -1,    43,    -1,
-      45,    46,    -1,    48,     6,     7,     8,    -1,    -1,    -1,
+      50,    51,    52,    53,    54,    55,    56,    57,    58,   134,
+     135,   136,     9,    63,    50,    65,     1,    76,    68,     4,
+      70,   134,   135,   136,    83,     1,     4,     4,     4,    45,
+       1,     4,    34,     4,     5,    48,    45,    33,    43,    10,
+      11,    33,    27,    43,    43,    15,   149,    -1,    -1,    46,
+      47,    27,    -1,    -1,    -1,    -1,    27,     1,    -1,    44,
+       4,     5,    -1,    -1,    -1,    50,    10,    11,    44,    -1,
+      -1,    42,    -1,    44,    50,    46,    47,    48,    49,    -1,
+     130,   131,     1,    27,    -1,     4,     5,   137,   138,    -1,
+      -1,    10,    11,    -1,    -1,    -1,    -1,   147,    42,    -1,
+      44,    -1,    46,    47,    48,    49,     1,    -1,    27,     4,
+       5,    -1,    -1,    -1,    -1,    10,    11,     4,     5,    -1,
+      -1,    -1,    -1,    42,    -1,    44,    -1,    46,    47,    -1,
+      49,    -1,    27,     4,     5,    -1,    -1,    -1,    -1,    10,
+      11,    -1,    -1,    -1,    -1,    -1,    -1,    42,    -1,    44,
+      -1,    46,    47,    -1,    49,    42,    27,    44,    -1,    46,
+      47,    -1,    49,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    42,    -1,    44,    -1,    46,    47,    -1,    49,     6,
+       7,     8,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      -1,    -1,    -1,    -1,    -1,    -1,    33,    34,    35,    36,
+      37,    38,    39,    40,    41,     6,     7,     8,    -1,    -1,
+      -1,    48,    -1,    -1,    -1,    16,    17,    18,    19,    20,
+      21,    22,    23,    24,    25,    26,    -1,    -1,    -1,    -1,
+      -1,    -1,    33,    34,    35,    36,    37,    38,    39,    40,
+      41,    -1,    -1,     1,    -1,    -1,    -1,    48,     6,     7,
+       8,    -1,    -1,    -1,    12,    -1,    -1,    -1,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
+      -1,    -1,    -1,    -1,    -1,    33,    34,    35,    36,    37,
+      38,    39,    40,    41,     6,     7,     8,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    -1,    -1,    -1,    -1,    -1,    -1,
-      32,    33,    34,    35,    36,    37,    38,    39,    40,     6,
-       7,     8,    -1,    -1,    -1,    47,    -1,    -1,    -1,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    -1,
-      -1,    -1,    -1,    -1,    -1,    32,    33,    34,    35,    36,
-      37,    38,    39,    40,    -1,    -1,     1,    -1,    -1,    -1,
-      47,     6,     7,     8,    -1,    -1,    -1,    12,    -1,    -1,
-      -1,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    -1,    -1,    -1,    -1,    -1,    -1,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,     6,     7,     8,    -1,
+      22,    23,    24,    25,    26,    -1,    -1,    -1,    -1,    -1,
+      -1,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+       6,     7,     8,    45,    -1,    -1,    -1,    -1,    -1,    -1,
+      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+      26,    -1,    -1,    -1,    -1,    -1,    -1,    33,    34,    35,
+      36,    37,    38,    39,    40,    41,     6,     7,     8,    45,
       -1,    -1,    -1,    -1,    -1,    -1,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    -1,    -1,    -1,    -1,
-      -1,    -1,    32,    33,    34,    35,    36,    37,    38,    39,
-      40,     6,     7,     8,    44,    -1,    -1,    -1,    -1,    -1,
-      -1,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    -1,    -1,    -1,    -1,    -1,    -1,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,     6,     7,     8,    44,
-      -1,    -1,    -1,    -1,    -1,    -1,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    -1,    -1,    -1,    -1,
-      -1,    -1,    32,    33,    34,    35,    36,    37,    38,    39,
-      40,     6,     7,     8,    44,    -1,    -1,    -1,    13,    14,
-      -1,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    -1,    -1,    -1,    -1,    -1,    -1,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,     6,     7,     8,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    -1,    -1,    -1,    -1,
-      -1,    31,    32,    33,    34,    35,    36,    37,    38,    39,
-      40,     6,     7,     8,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    -1,    -1,    -1,    29,    -1,    -1,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,     6,     7,     8,    -1,
-      -1,    -1,    -1,    -1,    -1,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    -1,    -1,    -1,    -1,
-      -1,    -1,    32,    33,    34,    35,    36,    37,    38,    39,
-      40,     6,     7,     8,    -1,    -1,    -1,    12,    -1,    -1,
-      -1,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    -1,    -1,    -1,    -1,    -1,    -1,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,     6,     7,     8,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    -1,    -1,    -1,    -1,
-      -1,    31,    32,    33,    34,    35,    36,    37,    38,    39,
-      40,     6,     7,     8,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    -1,    -1,    -1,    -1,    -1,    -1,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,     6,     7,     8,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    -1,    -1,    -1,    -1,
+      20,    21,    22,    23,    24,    25,    26,    -1,    -1,    -1,
       -1,    -1,    -1,    33,    34,    35,    36,    37,    38,    39,
-      40,     6,     7,     8,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    -1,    -1,    -1,    -1,    -1,     6,     7,    -1,    34,
-      35,    36,    37,    38,    39,    40,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    -1,    -1,    -1,    -1,
-      -1,     6,     7,    -1,    34,    35,    36,    37,    38,    39,
-      40,    16,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    24,
-      25,     6,     7,    -1,    -1,    -1,    -1,     6,     7,    -1,
-      35,    36,    37,    38,    39,    40,    -1,    -1,    -1,    24,
-      25,    -1,    -1,    -1,    -1,    24,    25,    -1,    -1,    -1,
-      35,    36,    37,    38,    39,    40,    35,    36,    37,    38,
-      39,    40
+      40,    41,     6,     7,     8,    45,    -1,    -1,    -1,    13,
+      14,    -1,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    -1,    -1,    -1,    -1,    -1,    -1,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,     6,     7,
+       8,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
+      -1,    -1,    -1,    -1,    32,    33,    34,    35,    36,    37,
+      38,    39,    40,    41,     6,     7,     8,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    -1,    -1,    -1,    30,    -1,
+      -1,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+       6,     7,     8,    -1,    -1,    -1,    -1,    -1,    -1,    15,
+      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+      26,    -1,    -1,    -1,    -1,    -1,    -1,    33,    34,    35,
+      36,    37,    38,    39,    40,    41,     6,     7,     8,    -1,
+      -1,    -1,    12,    -1,    -1,    -1,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    -1,    -1,    -1,
+      -1,    -1,    -1,    33,    34,    35,    36,    37,    38,    39,
+      40,    41,     6,     7,     8,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    -1,    -1,    -1,    -1,    -1,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,     6,     7,
+       8,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
+      -1,    -1,    -1,    -1,    -1,    33,    34,    35,    36,    37,
+      38,    39,    40,    41,     6,     7,     8,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    34,    35,    36,    37,    38,    39,    40,    41,
+       6,     7,     8,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+      26,    -1,    -1,    -1,    -1,    -1,     6,     7,    -1,    35,
+      36,    37,    38,    39,    40,    41,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    -1,    -1,    -1,
+      -1,    -1,     6,     7,    -1,    35,    36,    37,    38,    39,
+      40,    41,    16,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      24,    25,    26,     6,     7,    -1,    -1,    -1,    -1,     6,
+       7,    -1,    36,    37,    38,    39,    40,    41,    -1,    -1,
+      -1,    24,    25,    26,    -1,    -1,    -1,    24,    25,    26,
+      -1,    -1,    -1,    36,    37,    38,    39,    40,    41,    36,
+      37,    38,    39,    40,    41
 };
 
 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
    symbol of state STATE-NUM.  */
 static const yytype_uint8 yystos[] =
 {
-       0,     4,     5,    10,    11,    26,    41,    43,    45,    46,
-      48,    51,    52,    53,    54,    55,    59,    43,     4,    53,
-      55,    56,     4,     1,    53,     4,     1,    47,    53,     1,
-       4,    43,    54,    60,    61,     0,     6,     7,     8,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    32,
-      33,    34,    35,    36,    37,    38,    39,    40,    52,    53,
-       9,    45,    46,    53,    42,    43,     1,    12,    27,    28,
-      30,    44,    44,    47,    47,    33,    49,    42,     1,    53,
-      42,    49,    33,    53,    53,    53,    53,    53,    53,    53,
-      53,    53,    53,    53,    53,    53,    53,    53,    53,    53,
-      53,    53,    53,    53,    53,    41,     4,     1,    47,    53,
-      44,    53,     4,    53,    53,     1,    60,    58,    59,    44,
-      44,    58,    60,     4,    47,    47,    31,    44,    13,    14,
-      57,    29,    32,    42,    42,    32,    42,    53,    53,    58,
-      58,    58,    53,    53,    15,    12,    31,    53,    57
+       0,     4,     5,    10,    11,    27,    42,    44,    46,    47,
+      49,    52,    53,    54,    55,    56,    60,    44,     4,    54,
+      56,    57,     4,     1,    54,     4,     1,    48,    54,     1,
+       4,    44,    55,    61,    62,     0,     6,     7,     8,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      33,    34,    35,    36,    37,    38,    39,    40,    41,    53,
+      54,     9,    46,    47,    54,    43,    44,     1,    12,    28,
+      29,    31,    45,    45,    48,    48,    34,    50,    43,     1,
+      54,    43,    50,    34,    54,    54,    54,    54,    54,    54,
+      54,    54,    54,    54,    54,    54,    54,    54,    54,    54,
+      54,    54,    54,    54,    54,    54,    54,    42,     4,     1,
+      48,    54,    45,    54,     4,    54,    54,     1,    61,    59,
+      60,    45,    45,    59,    61,     4,    48,    48,    32,    45,
+      13,    14,    58,    30,    33,    43,    43,    33,    43,    54,
+      54,    59,    59,    59,    54,    54,    15,    12,    32,    54,
+      58
 };
 
 #define yyerrok		(yyerrstatus = 0)
@@ -984,18 +983,17 @@ static const yytype_uint8 yystos[] =
 
 #define YYRECOVERING()  (!!yyerrstatus)
 
-#define YYBACKUP(Token, Value)                                  \
-do                                                              \
-  if (yychar == YYEMPTY)                                        \
-    {                                                           \
-      yychar = (Token);                                         \
-      yylval = (Value);                                         \
-      YYPOPSTACK (yylen);                                       \
-      yystate = *yyssp;                                         \
-      goto yybackup;                                            \
-    }                                                           \
-  else                                                          \
-    {                                                           \
+#define YYBACKUP(Token, Value)					\
+do								\
+  if (yychar == YYEMPTY && yylen == 1)				\
+    {								\
+      yychar = (Token);						\
+      yylval = (Value);						\
+      YYPOPSTACK (1);						\
+      goto yybackup;						\
+    }								\
+  else								\
+    {								\
       yyerror (&yylloc, answer, errors, locations, lexer_param_ptr, YY_("syntax error: cannot back up")); \
       YYERROR;							\
     }								\
@@ -1005,33 +1003,32 @@ while (YYID (0))
 #define YYTERROR	1
 #define YYERRCODE	256
 
+
 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
    If N is 0, then set CURRENT to the empty location which ends
    the previous symbol: RHS[0] (always defined).  */
 
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])
 #ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
-    do                                                                  \
-      if (YYID (N))                                                     \
-        {                                                               \
-          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
-          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
-          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
-          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
-        }                                                               \
-      else                                                              \
-        {                                                               \
-          (Current).first_line   = (Current).last_line   =              \
-            YYRHSLOC (Rhs, 0).last_line;                                \
-          (Current).first_column = (Current).last_column =              \
-            YYRHSLOC (Rhs, 0).last_column;                              \
-        }                                                               \
+# define YYLLOC_DEFAULT(Current, Rhs, N)				\
+    do									\
+      if (YYID (N))                                                    \
+	{								\
+	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
+	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
+	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
+	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
+	}								\
+      else								\
+	{								\
+	  (Current).first_line   = (Current).last_line   =		\
+	    YYRHSLOC (Rhs, 0).last_line;				\
+	  (Current).first_column = (Current).last_column =		\
+	    YYRHSLOC (Rhs, 0).last_column;				\
+	}								\
     while (YYID (0))
 #endif
 
-#define YYRHSLOC(Rhs, K) ((Rhs)[K])
-
-
 
 /* YY_LOCATION_PRINT -- Print the location on the stream.
    This macro was not mandated originally: define only if we know
@@ -1105,8 +1102,6 @@ yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors,
     struct lexer_param* lexer_param_ptr;
 #endif
 {
-  FILE *yyo = yyoutput;
-  YYUSE (yyo);
   if (!yyvaluep)
     return;
   YYUSE (yylocationp);
@@ -1375,12 +1370,12 @@ static int
 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
                 yytype_int16 *yyssp, int yytoken)
 {
-  YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
+  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
   YYSIZE_T yysize = yysize0;
   YYSIZE_T yysize1;
   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
   /* Internationalized format string. */
-  const char *yyformat = YY_NULL;
+  const char *yyformat = 0;
   /* Arguments of yyformat. */
   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
   /* Number of reported tokens (one for the "unexpected", one per
@@ -1440,7 +1435,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
                     break;
                   }
                 yyarg[yycount++] = yytname[yyx];
-                yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
+                yysize1 = yysize + yytnamerr (0, yytname[yyx]);
                 if (! (yysize <= yysize1
                        && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
                   return 2;
@@ -1535,96 +1530,122 @@ yydestruct (yymsg, yytype, yyvaluep, yylocationp, answer, errors, locations, lex
 
   switch (yytype)
     {
-      case 4: /* IDENT */
-/* Line 1381 of yacc.c  */
+      case 4: /* "IDENT" */
+
+/* Line 1391 of yacc.c  */
 #line 32 "parser.y"
-	{ jv_free(((*yyvaluep).literal)); };
-/* Line 1381 of yacc.c  */
-#line 1544 "parser.gen.c"
+	{ jv_free((yyvaluep->literal)); };
+
+/* Line 1391 of yacc.c  */
+#line 1541 "parser.gen.c"
 	break;
-      case 5: /* LITERAL */
-/* Line 1381 of yacc.c  */
+      case 5: /* "LITERAL" */
+
+/* Line 1391 of yacc.c  */
 #line 32 "parser.y"
-	{ jv_free(((*yyvaluep).literal)); };
-/* Line 1381 of yacc.c  */
-#line 1551 "parser.gen.c"
+	{ jv_free((yyvaluep->literal)); };
+
+/* Line 1391 of yacc.c  */
+#line 1550 "parser.gen.c"
 	break;
-      case 27: /* QQSTRING_TEXT */
-/* Line 1381 of yacc.c  */
+      case 28: /* "QQSTRING_TEXT" */
+
+/* Line 1391 of yacc.c  */
 #line 32 "parser.y"
-	{ jv_free(((*yyvaluep).literal)); };
-/* Line 1381 of yacc.c  */
-#line 1558 "parser.gen.c"
+	{ jv_free((yyvaluep->literal)); };
+
+/* Line 1391 of yacc.c  */
+#line 1559 "parser.gen.c"
 	break;
-      case 52: /* FuncDefs */
-/* Line 1381 of yacc.c  */
+      case 53: /* "FuncDefs" */
+
+/* Line 1391 of yacc.c  */
 #line 33 "parser.y"
-	{ block_free(((*yyvaluep).blk)); };
-/* Line 1381 of yacc.c  */
-#line 1565 "parser.gen.c"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1568 "parser.gen.c"
 	break;
-      case 53: /* Exp */
-/* Line 1381 of yacc.c  */
+      case 54: /* "Exp" */
+
+/* Line 1391 of yacc.c  */
 #line 33 "parser.y"
-	{ block_free(((*yyvaluep).blk)); };
-/* Line 1381 of yacc.c  */
-#line 1572 "parser.gen.c"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1577 "parser.gen.c"
 	break;
-      case 54: /* String */
-/* Line 1381 of yacc.c  */
+      case 55: /* "String" */
+
+/* Line 1391 of yacc.c  */
 #line 33 "parser.y"
-	{ block_free(((*yyvaluep).blk)); };
-/* Line 1381 of yacc.c  */
-#line 1579 "parser.gen.c"
-	break;
-      case 55: /* FuncDef */
-/* Line 1381 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free(((*yyvaluep).blk)); };
-/* Line 1381 of yacc.c  */
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
 #line 1586 "parser.gen.c"
 	break;
-      case 56: /* QQString */
-/* Line 1381 of yacc.c  */
+      case 56: /* "FuncDef" */
+
+/* Line 1391 of yacc.c  */
 #line 33 "parser.y"
-	{ block_free(((*yyvaluep).blk)); };
-/* Line 1381 of yacc.c  */
-#line 1593 "parser.gen.c"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1595 "parser.gen.c"
 	break;
-      case 57: /* ElseBody */
-/* Line 1381 of yacc.c  */
+      case 57: /* "QQString" */
+
+/* Line 1391 of yacc.c  */
 #line 33 "parser.y"
-	{ block_free(((*yyvaluep).blk)); };
-/* Line 1381 of yacc.c  */
-#line 1600 "parser.gen.c"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1604 "parser.gen.c"
 	break;
-      case 58: /* ExpD */
-/* Line 1381 of yacc.c  */
+      case 58: /* "ElseBody" */
+
+/* Line 1391 of yacc.c  */
 #line 33 "parser.y"
-	{ block_free(((*yyvaluep).blk)); };
-/* Line 1381 of yacc.c  */
-#line 1607 "parser.gen.c"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1613 "parser.gen.c"
 	break;
-      case 59: /* Term */
-/* Line 1381 of yacc.c  */
+      case 59: /* "ExpD" */
+
+/* Line 1391 of yacc.c  */
 #line 33 "parser.y"
-	{ block_free(((*yyvaluep).blk)); };
-/* Line 1381 of yacc.c  */
-#line 1614 "parser.gen.c"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1622 "parser.gen.c"
 	break;
-      case 60: /* MkDict */
-/* Line 1381 of yacc.c  */
+      case 60: /* "Term" */
+
+/* Line 1391 of yacc.c  */
 #line 33 "parser.y"
-	{ block_free(((*yyvaluep).blk)); };
-/* Line 1381 of yacc.c  */
-#line 1621 "parser.gen.c"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1631 "parser.gen.c"
 	break;
-      case 61: /* MkDictPair */
-/* Line 1381 of yacc.c  */
+      case 61: /* "MkDict" */
+
+/* Line 1391 of yacc.c  */
 #line 33 "parser.y"
-	{ block_free(((*yyvaluep).blk)); };
-/* Line 1381 of yacc.c  */
-#line 1628 "parser.gen.c"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1640 "parser.gen.c"
+	break;
+      case 62: /* "MkDictPair" */
+
+/* Line 1391 of yacc.c  */
+#line 33 "parser.y"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1649 "parser.gen.c"
 	break;
 
       default:
@@ -1633,6 +1654,20 @@ yydestruct (yymsg, yytype, yyvaluep, yylocationp, answer, errors, locations, lex
 }
 
 
+/* Prevent warnings from -Wmissing-prototypes.  */
+#ifdef YYPARSE_PARAM
+#if defined __STDC__ || defined __cplusplus
+int yyparse (void *YYPARSE_PARAM);
+#else
+int yyparse ();
+#endif
+#else /* ! YYPARSE_PARAM */
+#if defined __STDC__ || defined __cplusplus
+int yyparse (block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr);
+#else
+int yyparse ();
+#endif
+#endif /* ! YYPARSE_PARAM */
 
 
 /*----------.
@@ -1685,7 +1720,7 @@ YYLTYPE yylloc;
        `yyvs': related to semantic values.
        `yyls': related to locations.
 
-       Refer to the stacks through separate pointers, to allow yyoverflow
+       Refer to the stacks thru separate pointers, to allow yyoverflow
        to reallocate them elsewhere.  */
 
     /* The state stack.  */
@@ -1756,6 +1791,7 @@ YYLTYPE yylloc;
   yylloc.first_line   = yylloc.last_line   = 1;
   yylloc.first_column = yylloc.last_column = 1;
 #endif
+
   goto yysetstate;
 
 /*------------------------------------------------------------.
@@ -1939,48 +1975,54 @@ yyreduce:
   switch (yyn)
     {
         case 2:
-/* Line 1787 of yacc.c  */
-#line 183 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 185 "parser.y"
     {
   *answer = (yyvsp[(1) - (1)].blk);
 }
     break;
 
   case 3:
-/* Line 1787 of yacc.c  */
-#line 186 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 188 "parser.y"
     {
   *answer = (yyvsp[(1) - (1)].blk);
 }
     break;
 
   case 4:
-/* Line 1787 of yacc.c  */
-#line 191 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 193 "parser.y"
     {
   (yyval.blk) = gen_noop();
 }
     break;
 
   case 5:
-/* Line 1787 of yacc.c  */
-#line 194 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 196 "parser.y"
     {
   (yyval.blk) = block_join((yyvsp[(1) - (2)].blk), (yyvsp[(2) - (2)].blk));
 }
     break;
 
   case 6:
-/* Line 1787 of yacc.c  */
-#line 199 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 201 "parser.y"
     {
   (yyval.blk) = block_bind((yyvsp[(1) - (2)].blk), (yyvsp[(2) - (2)].blk), OP_IS_CALL_PSEUDO);
 }
     break;
 
   case 7:
-/* Line 1787 of yacc.c  */
-#line 203 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 205 "parser.y"
     {
   (yyval.blk) = gen_op_simple(DUP);
   block_append(&(yyval.blk), (yyvsp[(1) - (6)].blk));
@@ -1990,16 +2032,18 @@ yyreduce:
     break;
 
   case 8:
-/* Line 1787 of yacc.c  */
-#line 210 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 212 "parser.y"
     {
   (yyval.blk) = gen_cond((yyvsp[(2) - (5)].blk), (yyvsp[(4) - (5)].blk), (yyvsp[(5) - (5)].blk));
 }
     break;
 
   case 9:
-/* Line 1787 of yacc.c  */
-#line 213 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 215 "parser.y"
     {
   FAIL((yyloc), "Possibly unterminated 'if' statment");
   (yyval.blk) = (yyvsp[(2) - (3)].blk);
@@ -2007,8 +2051,9 @@ yyreduce:
     break;
 
   case 10:
-/* Line 1787 of yacc.c  */
-#line 218 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 220 "parser.y"
     {
   block assign = gen_op_simple(DUP);
   block_append(&assign, (yyvsp[(3) - (3)].blk));
@@ -2020,200 +2065,234 @@ yyreduce:
     break;
 
   case 11:
-/* Line 1787 of yacc.c  */
-#line 227 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 229 "parser.y"
     {
   (yyval.blk) = gen_or((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
 }
     break;
 
   case 12:
-/* Line 1787 of yacc.c  */
-#line 231 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 233 "parser.y"
     {
   (yyval.blk) = gen_and((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
 }
     break;
 
   case 13:
-/* Line 1787 of yacc.c  */
-#line 235 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 237 "parser.y"
     {
   (yyval.blk) = gen_definedor((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
 }
     break;
 
   case 14:
-/* Line 1787 of yacc.c  */
-#line 239 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 241 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), gen_definedor(gen_noop(), (yyvsp[(3) - (3)].blk)), 0);
 }
     break;
 
   case 15:
-/* Line 1787 of yacc.c  */
-#line 243 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 245 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), 0);
 }
     break;
 
   case 16:
-/* Line 1787 of yacc.c  */
-#line 247 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 249 "parser.y"
     { 
   (yyval.blk) = block_join((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk)); 
 }
     break;
 
   case 17:
-/* Line 1787 of yacc.c  */
-#line 251 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 253 "parser.y"
     { 
   (yyval.blk) = gen_both((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk)); 
 }
     break;
 
   case 18:
-/* Line 1787 of yacc.c  */
-#line 255 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 257 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '+');
 }
     break;
 
   case 19:
-/* Line 1787 of yacc.c  */
-#line 259 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 261 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '+');
 }
     break;
 
   case 20:
-/* Line 1787 of yacc.c  */
-#line 263 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 265 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '-');
 }
     break;
 
   case 21:
-/* Line 1787 of yacc.c  */
-#line 267 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 269 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '-');
 }
     break;
 
   case 22:
-/* Line 1787 of yacc.c  */
-#line 271 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 273 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '*');
 }
     break;
 
   case 23:
-/* Line 1787 of yacc.c  */
-#line 275 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 277 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '*');
 }
     break;
 
   case 24:
-/* Line 1787 of yacc.c  */
-#line 279 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 281 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '/');
 }
     break;
 
   case 25:
-/* Line 1787 of yacc.c  */
-#line 283 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 285 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '/');
 }
     break;
 
   case 26:
-/* Line 1787 of yacc.c  */
-#line 287 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 289 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), EQ);
 }
     break;
 
   case 27:
-/* Line 1787 of yacc.c  */
-#line 291 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 293 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), NEQ);
 }
     break;
 
   case 28:
-/* Line 1787 of yacc.c  */
-#line 295 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 297 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '<');
 }
     break;
 
   case 29:
-/* Line 1787 of yacc.c  */
-#line 299 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 301 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '>');
 }
     break;
 
   case 30:
-/* Line 1787 of yacc.c  */
-#line 303 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 305 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), LESSEQ);
 }
     break;
 
   case 31:
-/* Line 1787 of yacc.c  */
-#line 307 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 309 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), GREATEREQ);
 }
     break;
 
   case 32:
-/* Line 1787 of yacc.c  */
-#line 311 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 313 "parser.y"
+    {
+  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), CONTAINS);
+}
+    break;
+
+  case 33:
+
+/* Line 1806 of yacc.c  */
+#line 317 "parser.y"
     {
   (yyval.blk) = (yyvsp[(1) - (1)].blk);
 }
     break;
 
-  case 33:
-/* Line 1787 of yacc.c  */
-#line 315 "parser.y"
+  case 34:
+
+/* Line 1806 of yacc.c  */
+#line 321 "parser.y"
     { 
   (yyval.blk) = (yyvsp[(1) - (1)].blk); 
 }
     break;
 
-  case 34:
-/* Line 1787 of yacc.c  */
-#line 320 "parser.y"
+  case 35:
+
+/* Line 1806 of yacc.c  */
+#line 326 "parser.y"
     {
   (yyval.blk) = (yyvsp[(2) - (3)].blk);
 }
     break;
 
-  case 35:
-/* Line 1787 of yacc.c  */
-#line 325 "parser.y"
+  case 36:
+
+/* Line 1806 of yacc.c  */
+#line 331 "parser.y"
     {
   block body = block_join((yyvsp[(4) - (5)].blk), gen_op_simple(RET));
   (yyval.blk) = gen_op_block_defn_rec(CLOSURE_CREATE, jv_string_value((yyvsp[(2) - (5)].literal)), body);
@@ -2221,9 +2300,10 @@ yyreduce:
 }
     break;
 
-  case 36:
-/* Line 1787 of yacc.c  */
-#line 331 "parser.y"
+  case 37:
+
+/* Line 1806 of yacc.c  */
+#line 337 "parser.y"
     {
   block body = block_bind(gen_op_block_unbound(CLOSURE_PARAM, jv_string_value((yyvsp[(4) - (8)].literal))), block_join((yyvsp[(7) - (8)].blk), gen_op_simple(RET)), OP_IS_CALL_PSEUDO);
   (yyval.blk) = gen_op_block_defn_rec(CLOSURE_CREATE, jv_string_value((yyvsp[(2) - (8)].literal)), body);
@@ -2232,137 +2312,154 @@ yyreduce:
 }
     break;
 
-  case 37:
-/* Line 1787 of yacc.c  */
-#line 339 "parser.y"
+  case 38:
+
+/* Line 1806 of yacc.c  */
+#line 345 "parser.y"
     {
   (yyval.blk) = gen_op_const(LOADK, jv_string(""));
 }
     break;
 
-  case 38:
-/* Line 1787 of yacc.c  */
-#line 342 "parser.y"
+  case 39:
+
+/* Line 1806 of yacc.c  */
+#line 348 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (2)].blk), gen_op_const(LOADK, (yyvsp[(2) - (2)].literal)), '+');
 }
     break;
 
-  case 39:
-/* Line 1787 of yacc.c  */
-#line 345 "parser.y"
+  case 40:
+
+/* Line 1806 of yacc.c  */
+#line 351 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (4)].blk), gen_format((yyvsp[(3) - (4)].blk)), '+');
 }
     break;
 
-  case 40:
-/* Line 1787 of yacc.c  */
-#line 351 "parser.y"
+  case 41:
+
+/* Line 1806 of yacc.c  */
+#line 357 "parser.y"
     {
   (yyval.blk) = gen_cond((yyvsp[(2) - (5)].blk), (yyvsp[(4) - (5)].blk), (yyvsp[(5) - (5)].blk));
 }
     break;
 
-  case 41:
-/* Line 1787 of yacc.c  */
-#line 354 "parser.y"
+  case 42:
+
+/* Line 1806 of yacc.c  */
+#line 360 "parser.y"
     {
   (yyval.blk) = (yyvsp[(2) - (3)].blk);
 }
     break;
 
-  case 42:
-/* Line 1787 of yacc.c  */
-#line 359 "parser.y"
+  case 43:
+
+/* Line 1806 of yacc.c  */
+#line 365 "parser.y"
     { 
   (yyval.blk) = block_join((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
 }
     break;
 
-  case 43:
-/* Line 1787 of yacc.c  */
-#line 363 "parser.y"
+  case 44:
+
+/* Line 1806 of yacc.c  */
+#line 369 "parser.y"
     {
   (yyval.blk) = (yyvsp[(1) - (1)].blk);
 }
     break;
 
-  case 44:
-/* Line 1787 of yacc.c  */
-#line 369 "parser.y"
+  case 45:
+
+/* Line 1806 of yacc.c  */
+#line 375 "parser.y"
     {
   (yyval.blk) = gen_noop(); 
 }
     break;
 
-  case 45:
-/* Line 1787 of yacc.c  */
-#line 372 "parser.y"
+  case 46:
+
+/* Line 1806 of yacc.c  */
+#line 378 "parser.y"
     {
   (yyval.blk) = gen_index((yyvsp[(1) - (3)].blk), gen_op_const(LOADK, (yyvsp[(3) - (3)].literal))); 
 }
     break;
 
-  case 46:
-/* Line 1787 of yacc.c  */
-#line 375 "parser.y"
+  case 47:
+
+/* Line 1806 of yacc.c  */
+#line 381 "parser.y"
     { 
   (yyval.blk) = gen_index(gen_noop(), gen_op_const(LOADK, (yyvsp[(2) - (2)].literal))); 
 }
     break;
 
-  case 47:
-/* Line 1787 of yacc.c  */
-#line 379 "parser.y"
+  case 48:
+
+/* Line 1806 of yacc.c  */
+#line 385 "parser.y"
     {
   (yyval.blk) = gen_index((yyvsp[(1) - (4)].blk), (yyvsp[(3) - (4)].blk)); 
 }
     break;
 
-  case 48:
-/* Line 1787 of yacc.c  */
-#line 382 "parser.y"
+  case 49:
+
+/* Line 1806 of yacc.c  */
+#line 388 "parser.y"
     {
   (yyval.blk) = block_join((yyvsp[(1) - (3)].blk), gen_op_simple(EACH)); 
 }
     break;
 
-  case 49:
-/* Line 1787 of yacc.c  */
-#line 385 "parser.y"
+  case 50:
+
+/* Line 1806 of yacc.c  */
+#line 391 "parser.y"
     {
   (yyval.blk) = gen_op_const(LOADK, (yyvsp[(1) - (1)].literal)); 
 }
     break;
 
-  case 50:
-/* Line 1787 of yacc.c  */
-#line 388 "parser.y"
+  case 51:
+
+/* Line 1806 of yacc.c  */
+#line 394 "parser.y"
     { 
   (yyval.blk) = (yyvsp[(2) - (3)].blk); 
 }
     break;
 
-  case 51:
-/* Line 1787 of yacc.c  */
-#line 391 "parser.y"
+  case 52:
+
+/* Line 1806 of yacc.c  */
+#line 397 "parser.y"
     { 
   (yyval.blk) = gen_collect((yyvsp[(2) - (3)].blk)); 
 }
     break;
 
-  case 52:
-/* Line 1787 of yacc.c  */
-#line 394 "parser.y"
+  case 53:
+
+/* Line 1806 of yacc.c  */
+#line 400 "parser.y"
     { 
   (yyval.blk) = gen_op_const(LOADK, jv_array()); 
 }
     break;
 
-  case 53:
-/* Line 1787 of yacc.c  */
-#line 397 "parser.y"
+  case 54:
+
+/* Line 1806 of yacc.c  */
+#line 403 "parser.y"
     { 
   (yyval.blk) = gen_subexp(gen_op_const(LOADK, jv_object()));
   block_append(&(yyval.blk), (yyvsp[(2) - (3)].blk));
@@ -2370,27 +2467,30 @@ yyreduce:
 }
     break;
 
-  case 54:
-/* Line 1787 of yacc.c  */
-#line 402 "parser.y"
+  case 55:
+
+/* Line 1806 of yacc.c  */
+#line 408 "parser.y"
     {
   (yyval.blk) = gen_location((yyloc), gen_op_var_unbound(LOADV, jv_string_value((yyvsp[(2) - (2)].literal))));
   jv_free((yyvsp[(2) - (2)].literal));
 }
     break;
 
-  case 55:
-/* Line 1787 of yacc.c  */
-#line 406 "parser.y"
+  case 56:
+
+/* Line 1806 of yacc.c  */
+#line 412 "parser.y"
     {
   (yyval.blk) = gen_location((yyloc), gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, jv_string_value((yyvsp[(1) - (1)].literal)))));
   jv_free((yyvsp[(1) - (1)].literal));
 }
     break;
 
-  case 56:
-/* Line 1787 of yacc.c  */
-#line 410 "parser.y"
+  case 57:
+
+/* Line 1806 of yacc.c  */
+#line 416 "parser.y"
     {
   (yyval.blk) = gen_op_call(CALL_1_1, 
                    block_join(gen_op_block_unbound(CLOSURE_REF, jv_string_value((yyvsp[(1) - (4)].literal))),
@@ -2403,98 +2503,112 @@ yyreduce:
 }
     break;
 
-  case 57:
-/* Line 1787 of yacc.c  */
-#line 420 "parser.y"
-    { (yyval.blk) = gen_noop(); }
-    break;
-
   case 58:
-/* Line 1787 of yacc.c  */
-#line 421 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 426 "parser.y"
     { (yyval.blk) = gen_noop(); }
     break;
 
   case 59:
-/* Line 1787 of yacc.c  */
-#line 422 "parser.y"
-    { (yyval.blk) = (yyvsp[(1) - (4)].blk); }
-    break;
 
-  case 60:
-/* Line 1787 of yacc.c  */
-#line 423 "parser.y"
+/* Line 1806 of yacc.c  */
+#line 427 "parser.y"
     { (yyval.blk) = gen_noop(); }
     break;
 
+  case 60:
+
+/* Line 1806 of yacc.c  */
+#line 428 "parser.y"
+    { (yyval.blk) = (yyvsp[(1) - (4)].blk); }
+    break;
+
   case 61:
-/* Line 1787 of yacc.c  */
-#line 426 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 429 "parser.y"
+    { (yyval.blk) = gen_noop(); }
+    break;
+
+  case 62:
+
+/* Line 1806 of yacc.c  */
+#line 432 "parser.y"
     { 
   (yyval.blk)=gen_noop(); 
 }
     break;
 
-  case 62:
-/* Line 1787 of yacc.c  */
-#line 429 "parser.y"
+  case 63:
+
+/* Line 1806 of yacc.c  */
+#line 435 "parser.y"
     { (yyval.blk) = (yyvsp[(1) - (1)].blk); }
     break;
 
-  case 63:
-/* Line 1787 of yacc.c  */
-#line 430 "parser.y"
+  case 64:
+
+/* Line 1806 of yacc.c  */
+#line 436 "parser.y"
     { (yyval.blk)=block_join((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk)); }
     break;
 
-  case 64:
-/* Line 1787 of yacc.c  */
-#line 431 "parser.y"
+  case 65:
+
+/* Line 1806 of yacc.c  */
+#line 437 "parser.y"
     { (yyval.blk) = (yyvsp[(3) - (3)].blk); }
     break;
 
-  case 65:
-/* Line 1787 of yacc.c  */
-#line 434 "parser.y"
+  case 66:
+
+/* Line 1806 of yacc.c  */
+#line 440 "parser.y"
     { 
   (yyval.blk) = gen_dictpair(gen_op_const(LOADK, (yyvsp[(1) - (3)].literal)), (yyvsp[(3) - (3)].blk));
  }
     break;
 
-  case 66:
-/* Line 1787 of yacc.c  */
-#line 437 "parser.y"
+  case 67:
+
+/* Line 1806 of yacc.c  */
+#line 443 "parser.y"
     {
   (yyval.blk) = gen_dictpair((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
   }
     break;
 
-  case 67:
-/* Line 1787 of yacc.c  */
-#line 440 "parser.y"
+  case 68:
+
+/* Line 1806 of yacc.c  */
+#line 446 "parser.y"
     {
   (yyval.blk) = gen_dictpair(gen_op_const(LOADK, jv_copy((yyvsp[(1) - (1)].literal))),
                     gen_index(gen_noop(), gen_op_const(LOADK, (yyvsp[(1) - (1)].literal))));
   }
     break;
 
-  case 68:
-/* Line 1787 of yacc.c  */
-#line 444 "parser.y"
+  case 69:
+
+/* Line 1806 of yacc.c  */
+#line 450 "parser.y"
     {
   (yyval.blk) = gen_dictpair((yyvsp[(2) - (5)].blk), (yyvsp[(5) - (5)].blk));
   }
     break;
 
-  case 69:
-/* Line 1787 of yacc.c  */
-#line 447 "parser.y"
+  case 70:
+
+/* Line 1806 of yacc.c  */
+#line 453 "parser.y"
     { (yyval.blk) = (yyvsp[(5) - (5)].blk); }
     break;
 
 
-/* Line 1787 of yacc.c  */
-#line 2498 "parser.gen.c"
+
+/* Line 1806 of yacc.c  */
+#line 2612 "parser.gen.c"
       default: break;
     }
   /* User semantic actions sometimes alter yychar, and that requires
@@ -2688,7 +2802,7 @@ yyabortlab:
   yyresult = 1;
   goto yyreturn;
 
-#if !defined yyoverflow || YYERROR_VERBOSE
+#if !defined(yyoverflow) || YYERROR_VERBOSE
 /*-------------------------------------------------.
 | yyexhaustedlab -- memory exhaustion comes here.  |
 `-------------------------------------------------*/
@@ -2730,8 +2844,9 @@ yyreturn:
 }
 
 
-/* Line 2048 of yacc.c  */
-#line 448 "parser.y"
+
+/* Line 2067 of yacc.c  */
+#line 454 "parser.y"
 
 
 int jq_parse(struct locfile* locations, block* answer) {
@@ -2760,3 +2875,4 @@ int jq_parse_library(struct locfile* locations, block* answer) {
   }
   return 0;
 }
+
diff --git a/parser.gen.h b/parser.gen.h
index 0e5c8007..bf9f9f8c 100644
--- a/parser.gen.h
+++ b/parser.gen.h
@@ -1,8 +1,8 @@
-/* A Bison parser, made by GNU Bison 2.6.2.  */
+/* A Bison parser, made by GNU Bison 2.5.  */
 
 /* Bison interface for Yacc-like parsers in C
    
-      Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc.
+      Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -30,17 +30,9 @@
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 
-#ifndef YY_PARSER_GEN_H
-# define YY_PARSER_GEN_H
-/* Enabling traces.  */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-#if YYDEBUG
-extern int yydebug;
-#endif
 /* "%code requires" blocks.  */
-/* Line 2049 of yacc.c  */
+
+/* Line 2068 of yacc.c  */
 #line 9 "parser.y"
 
 #include "locfile.h"
@@ -57,8 +49,9 @@ extern int yydebug;
   } while (0)
  
 
-/* Line 2049 of yacc.c  */
-#line 62 "parser.gen.h"
+
+/* Line 2068 of yacc.c  */
+#line 55 "parser.gen.h"
 
 /* Tokens.  */
 #ifndef YYTOKENTYPE
@@ -89,33 +82,39 @@ extern int yydebug;
      SETDEFINEDOR = 278,
      LESSEQ = 279,
      GREATEREQ = 280,
-     QQSTRING_START = 281,
-     QQSTRING_TEXT = 282,
-     QQSTRING_INTERP_START = 283,
-     QQSTRING_INTERP_END = 284,
-     QQSTRING_END = 285
+     CONTAINS = 281,
+     QQSTRING_START = 282,
+     QQSTRING_TEXT = 283,
+     QQSTRING_INTERP_START = 284,
+     QQSTRING_INTERP_END = 285,
+     QQSTRING_END = 286
    };
 #endif
 
 
+
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 typedef union YYSTYPE
 {
-/* Line 2049 of yacc.c  */
+
+/* Line 2068 of yacc.c  */
 #line 27 "parser.y"
 
   jv literal;
   block blk;
 
 
-/* Line 2049 of yacc.c  */
-#line 113 "parser.gen.h"
+
+/* Line 2068 of yacc.c  */
+#line 110 "parser.gen.h"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 # define YYSTYPE_IS_DECLARED 1
 #endif
 
+
+
 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
 typedef struct YYLTYPE
 {
@@ -130,18 +129,4 @@ typedef struct YYLTYPE
 #endif
 
 
-#ifdef YYPARSE_PARAM
-#if defined __STDC__ || defined __cplusplus
-int yyparse (void *YYPARSE_PARAM);
-#else
-int yyparse ();
-#endif
-#else /* ! YYPARSE_PARAM */
-#if defined __STDC__ || defined __cplusplus
-int yyparse (block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr);
-#else
-int yyparse ();
-#endif
-#endif /* ! YYPARSE_PARAM */
 
-#endif /* !YY_PARSER_GEN_H  */
diff --git a/parser.gen.info b/parser.gen.info
index d2fb1fdf..b5718b63 100644
--- a/parser.gen.info
+++ b/parser.gen.info
@@ -1,16 +1,16 @@
-Terminaux inutilisés dans la grammaire
+Terminals unused in grammar
 
    INVALID_CHARACTER
 
 
-Grammaire
+Grammar
 
     0 $accept: TopLevel $end
 
     1 TopLevel: Exp
     2         | FuncDefs
 
-    3 FuncDefs: /* vide */
+    3 FuncDefs: /* empty */
     4         | FuncDef FuncDefs
 
     5 Exp: FuncDef Exp
@@ -39,90 +39,91 @@ Grammaire
    28    | Exp '>' Exp
    29    | Exp "<=" Exp
    30    | Exp ">=" Exp
-   31    | String
-   32    | Term
+   31    | Exp "contains" Exp
+   32    | String
+   33    | Term
 
-   33 String: QQSTRING_START QQString QQSTRING_END
+   34 String: QQSTRING_START QQString QQSTRING_END
 
-   34 FuncDef: "def" IDENT ':' Exp ';'
-   35        | "def" IDENT '(' IDENT ')' ':' Exp ';'
+   35 FuncDef: "def" IDENT ':' Exp ';'
+   36        | "def" IDENT '(' IDENT ')' ':' Exp ';'
 
-   36 QQString: /* vide */
-   37         | QQString QQSTRING_TEXT
-   38         | QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END
+   37 QQString: /* empty */
+   38         | QQString QQSTRING_TEXT
+   39         | QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END
 
-   39 ElseBody: "elif" Exp "then" Exp ElseBody
-   40         | "else" Exp "end"
+   40 ElseBody: "elif" Exp "then" Exp ElseBody
+   41         | "else" Exp "end"
 
-   41 ExpD: ExpD '|' ExpD
-   42     | Term
+   42 ExpD: ExpD '|' ExpD
+   43     | Term
 
-   43 Term: '.'
-   44     | Term '.' IDENT
-   45     | '.' IDENT
-   46     | Term '[' Exp ']'
-   47     | Term '[' ']'
-   48     | LITERAL
-   49     | '(' Exp ')'
-   50     | '[' Exp ']'
-   51     | '[' ']'
-   52     | '{' MkDict '}'
-   53     | '$' IDENT
-   54     | IDENT
-   55     | IDENT '(' Exp ')'
-   56     | '(' error ')'
-   57     | '[' error ']'
-   58     | Term '[' error ']'
-   59     | '{' error '}'
+   44 Term: '.'
+   45     | Term '.' IDENT
+   46     | '.' IDENT
+   47     | Term '[' Exp ']'
+   48     | Term '[' ']'
+   49     | LITERAL
+   50     | '(' Exp ')'
+   51     | '[' Exp ']'
+   52     | '[' ']'
+   53     | '{' MkDict '}'
+   54     | '$' IDENT
+   55     | IDENT
+   56     | IDENT '(' Exp ')'
+   57     | '(' error ')'
+   58     | '[' error ']'
+   59     | Term '[' error ']'
+   60     | '{' error '}'
 
-   60 MkDict: /* vide */
-   61       | MkDictPair
-   62       | MkDictPair ',' MkDict
-   63       | error ',' MkDict
+   61 MkDict: /* empty */
+   62       | MkDictPair
+   63       | MkDictPair ',' MkDict
+   64       | error ',' MkDict
 
-   64 MkDictPair: IDENT ':' ExpD
-   65           | String ':' ExpD
-   66           | IDENT
-   67           | '(' Exp ')' ':' ExpD
-   68           | '(' error ')' ':' ExpD
+   65 MkDictPair: IDENT ':' ExpD
+   66           | String ':' ExpD
+   67           | IDENT
+   68           | '(' Exp ')' ':' ExpD
+   69           | '(' error ')' ':' ExpD
 
 
-Terminaux, suivis des règles où ils apparaissent
+Terminals, with rules where they appear
 
 $end (0) 0
-'$' (36) 6 53
-'(' (40) 35 49 55 56 67 68
-')' (41) 35 49 55 56 67 68
+'$' (36) 6 54
+'(' (40) 36 50 56 57 68 69
+')' (41) 36 50 56 57 68 69
 '*' (42) 21
 '+' (43) 17
-',' (44) 16 62 63
+',' (44) 16 63 64
 '-' (45) 19
-'.' (46) 43 44 45
+'.' (46) 44 45 46
 '/' (47) 23
-':' (58) 34 35 64 65 67 68
-';' (59) 34 35
+':' (58) 35 36 65 66 68 69
+';' (59) 35 36
 '<' (60) 27
 '=' (61) 9
 '>' (62) 28
-'[' (91) 46 47 50 51 57 58
-']' (93) 46 47 50 51 57 58
-'{' (123) 52 59
-'|' (124) 6 15 41
-'}' (125) 52 59
-error (256) 8 56 57 58 59 63 68
+'[' (91) 47 48 51 52 58 59
+']' (93) 47 48 51 52 58 59
+'{' (123) 53 60
+'|' (124) 6 15 42
+'}' (125) 53 60
+error (256) 8 57 58 59 60 64 69
 INVALID_CHARACTER (258)
-IDENT (259) 6 34 35 44 45 53 54 55 64 66
-LITERAL (260) 48
+IDENT (259) 6 35 36 45 46 54 55 56 65 67
+LITERAL (260) 49
 "==" (261) 25
 "!=" (262) 26
 "//" (263) 12
 "as" (264) 6
-"def" (265) 34 35
+"def" (265) 35 36
 "if" (266) 7 8
-"then" (267) 7 39
-"else" (268) 40
-"elif" (269) 39
-"end" (270) 40
+"then" (267) 7 40
+"else" (268) 41
+"elif" (269) 40
+"end" (270) 41
 "and" (271) 11
 "or" (272) 10
 "|=" (273) 14
@@ -133,223 +134,224 @@ LITERAL (260) 48
 "//=" (278) 13
 "<=" (279) 29
 ">=" (280) 30
-QQSTRING_START (281) 33
-QQSTRING_TEXT (282) 37
-QQSTRING_INTERP_START (283) 38
-QQSTRING_INTERP_END (284) 38
-QQSTRING_END (285) 33
+"contains" (281) 31
+QQSTRING_START (282) 34
+QQSTRING_TEXT (283) 38
+QQSTRING_INTERP_START (284) 39
+QQSTRING_INTERP_END (285) 39
+QQSTRING_END (286) 34
 
 
-Non-terminaux, suivis des règles où ils apparaissent
+Nonterminals, with rules where they appear
 
-$accept (50)
-    à gauche: 0
-TopLevel (51)
-    à gauche: 1 2, à droite: 0
-FuncDefs (52)
-    à gauche: 3 4, à droite: 2 4
-Exp (53)
-    à gauche: 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
-    24 25 26 27 28 29 30 31 32, à droite: 1 5 6 7 8 9 10 11 12 13
-    14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 34 35 38 39
-    40 46 49 50 55 67
-String (54)
-    à gauche: 33, à droite: 31 65
-FuncDef (55)
-    à gauche: 34 35, à droite: 4 5
-QQString (56)
-    à gauche: 36 37 38, à droite: 33 37 38
-ElseBody (57)
-    à gauche: 39 40, à droite: 7 39
-ExpD (58)
-    à gauche: 41 42, à droite: 41 64 65 67 68
-Term (59)
-    à gauche: 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59,
-    à droite: 6 32 42 44 46 47 58
-MkDict (60)
-    à gauche: 60 61 62 63, à droite: 52 62 63
-MkDictPair (61)
-    à gauche: 64 65 66 67 68, à droite: 61 62
+$accept (51)
+    on left: 0
+TopLevel (52)
+    on left: 1 2, on right: 0
+FuncDefs (53)
+    on left: 3 4, on right: 2 4
+Exp (54)
+    on left: 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
+    25 26 27 28 29 30 31 32 33, on right: 1 5 6 7 8 9 10 11 12 13 14
+    15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 35 36 39 40
+    41 47 50 51 56 68
+String (55)
+    on left: 34, on right: 32 66
+FuncDef (56)
+    on left: 35 36, on right: 4 5
+QQString (57)
+    on left: 37 38 39, on right: 34 38 39
+ElseBody (58)
+    on left: 40 41, on right: 7 40
+ExpD (59)
+    on left: 42 43, on right: 42 65 66 68 69
+Term (60)
+    on left: 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60, on right:
+    6 33 43 45 47 48 59
+MkDict (61)
+    on left: 61 62 63 64, on right: 53 63 64
+MkDictPair (62)
+    on left: 65 66 67 68 69, on right: 62 63
 
 
-état 0
+state 0
 
     0 $accept: . TopLevel $end
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    $défaut  réduction par utilisation de la règle 3 (FuncDefs)
+    $default  reduce using rule 3 (FuncDefs)
 
-    TopLevel  aller à l'état 11
-    FuncDefs  aller à l'état 12
-    Exp       aller à l'état 13
-    String    aller à l'état 14
-    FuncDef   aller à l'état 15
-    Term      aller à l'état 16
+    TopLevel  go to state 11
+    FuncDefs  go to state 12
+    Exp       go to state 13
+    String    go to state 14
+    FuncDef   go to state 15
+    Term      go to state 16
 
 
-état 1
+state 1
 
-   54 Term: IDENT .
-   55     | IDENT . '(' Exp ')'
+   55 Term: IDENT .
+   56     | IDENT . '(' Exp ')'
 
-    '('  décalage et aller à l'état 17
+    '('  shift, and go to state 17
 
-    $défaut  réduction par utilisation de la règle 54 (Term)
+    $default  reduce using rule 55 (Term)
 
 
-état 2
+state 2
 
-   48 Term: LITERAL .
+   49 Term: LITERAL .
 
-    $défaut  réduction par utilisation de la règle 48 (Term)
+    $default  reduce using rule 49 (Term)
 
 
-état 3
+state 3
 
-   34 FuncDef: "def" . IDENT ':' Exp ';'
-   35        | "def" . IDENT '(' IDENT ')' ':' Exp ';'
+   35 FuncDef: "def" . IDENT ':' Exp ';'
+   36        | "def" . IDENT '(' IDENT ')' ':' Exp ';'
 
-    IDENT  décalage et aller à l'état 18
+    IDENT  shift, and go to state 18
 
 
-état 4
+state 4
 
     7 Exp: "if" . Exp "then" Exp ElseBody
     8    | "if" . Exp error
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 19
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 19
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 5
+state 5
 
-   33 String: QQSTRING_START . QQString QQSTRING_END
+   34 String: QQSTRING_START . QQString QQSTRING_END
 
-    $défaut  réduction par utilisation de la règle 36 (QQString)
+    $default  reduce using rule 37 (QQString)
 
-    QQString  aller à l'état 21
+    QQString  go to state 21
 
 
-état 6
+state 6
 
-   53 Term: '$' . IDENT
+   54 Term: '$' . IDENT
 
-    IDENT  décalage et aller à l'état 22
+    IDENT  shift, and go to state 22
 
 
-état 7
+state 7
 
-   49 Term: '(' . Exp ')'
-   56     | '(' . error ')'
+   50 Term: '(' . Exp ')'
+   57     | '(' . error ')'
 
-    error           décalage et aller à l'état 23
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    error           shift, and go to state 23
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 24
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 24
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 8
+state 8
 
-   43 Term: '.' .
-   45     | '.' . IDENT
+   44 Term: '.' .
+   46     | '.' . IDENT
 
-    IDENT  décalage et aller à l'état 25
+    IDENT  shift, and go to state 25
 
-    $défaut  réduction par utilisation de la règle 43 (Term)
+    $default  reduce using rule 44 (Term)
 
 
-état 9
+state 9
 
-   50 Term: '[' . Exp ']'
-   51     | '[' . ']'
-   57     | '[' . error ']'
+   51 Term: '[' . Exp ']'
+   52     | '[' . ']'
+   58     | '[' . error ']'
 
-    error           décalage et aller à l'état 26
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    ']'             décalage et aller à l'état 27
-    '{'             décalage et aller à l'état 10
+    error           shift, and go to state 26
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    ']'             shift, and go to state 27
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 28
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 28
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 10
+state 10
 
-   52 Term: '{' . MkDict '}'
-   59     | '{' . error '}'
+   53 Term: '{' . MkDict '}'
+   60     | '{' . error '}'
 
-    error           décalage et aller à l'état 29
-    IDENT           décalage et aller à l'état 30
-    QQSTRING_START  décalage et aller à l'état 5
-    '('             décalage et aller à l'état 31
+    error           shift, and go to state 29
+    IDENT           shift, and go to state 30
+    QQSTRING_START  shift, and go to state 5
+    '('             shift, and go to state 31
 
-    '}'  réduction par utilisation de la règle 60 (MkDict)
+    '}'  reduce using rule 61 (MkDict)
 
-    String      aller à l'état 32
-    MkDict      aller à l'état 33
-    MkDictPair  aller à l'état 34
+    String      go to state 32
+    MkDict      go to state 33
+    MkDictPair  go to state 34
 
 
-état 11
+state 11
 
     0 $accept: TopLevel . $end
 
-    $end  décalage et aller à l'état 35
+    $end  shift, and go to state 35
 
 
-état 12
+state 12
 
     2 TopLevel: FuncDefs .
 
-    $défaut  réduction par utilisation de la règle 2 (TopLevel)
+    $default  reduce using rule 2 (TopLevel)
 
 
-état 13
+state 13
 
     1 TopLevel: Exp .
     9 Exp: Exp . '=' Exp
@@ -374,112 +376,114 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '|'    décalage et aller à l'état 49
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "//"        shift, and go to state 38
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "|="        shift, and go to state 41
+    "+="        shift, and go to state 42
+    "-="        shift, and go to state 43
+    "*="        shift, and go to state 44
+    "/="        shift, and go to state 45
+    "//="       shift, and go to state 46
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '|'         shift, and go to state 50
+    ','         shift, and go to state 51
+    '='         shift, and go to state 52
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
-    $défaut  réduction par utilisation de la règle 1 (TopLevel)
+    $default  reduce using rule 1 (TopLevel)
 
 
-état 14
+state 14
 
-   31 Exp: String .
+   32 Exp: String .
 
-    $défaut  réduction par utilisation de la règle 31 (Exp)
+    $default  reduce using rule 32 (Exp)
 
 
-état 15
+state 15
 
     4 FuncDefs: FuncDef . FuncDefs
     5 Exp: FuncDef . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    $défaut  réduction par utilisation de la règle 3 (FuncDefs)
+    $default  reduce using rule 3 (FuncDefs)
 
-    FuncDefs  aller à l'état 58
-    Exp       aller à l'état 59
-    String    aller à l'état 14
-    FuncDef   aller à l'état 15
-    Term      aller à l'état 16
+    FuncDefs  go to state 59
+    Exp       go to state 60
+    String    go to state 14
+    FuncDef   go to state 15
+    Term      go to state 16
 
 
-état 16
+state 16
 
     6 Exp: Term . "as" '$' IDENT '|' Exp
-   32    | Term .
-   44 Term: Term . '.' IDENT
-   46     | Term . '[' Exp ']'
-   47     | Term . '[' ']'
-   58     | Term . '[' error ']'
+   33    | Term .
+   45 Term: Term . '.' IDENT
+   47     | Term . '[' Exp ']'
+   48     | Term . '[' ']'
+   59     | Term . '[' error ']'
 
-    "as"  décalage et aller à l'état 60
-    '.'   décalage et aller à l'état 61
-    '['   décalage et aller à l'état 62
+    "as"  shift, and go to state 61
+    '.'   shift, and go to state 62
+    '['   shift, and go to state 63
 
-    $défaut  réduction par utilisation de la règle 32 (Exp)
+    $default  reduce using rule 33 (Exp)
 
 
-état 17
+state 17
 
-   55 Term: IDENT '(' . Exp ')'
+   56 Term: IDENT '(' . Exp ')'
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 63
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 64
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 18
+state 18
 
-   34 FuncDef: "def" IDENT . ':' Exp ';'
-   35        | "def" IDENT . '(' IDENT ')' ':' Exp ';'
+   35 FuncDef: "def" IDENT . ':' Exp ';'
+   36        | "def" IDENT . '(' IDENT ')' ':' Exp ';'
 
-    ':'  décalage et aller à l'état 64
-    '('  décalage et aller à l'état 65
+    ':'  shift, and go to state 65
+    '('  shift, and go to state 66
 
 
-état 19
+state 19
 
     7 Exp: "if" Exp . "then" Exp ElseBody
     8    | "if" Exp . error
@@ -505,80 +509,82 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    error   décalage et aller à l'état 66
-    "=="    décalage et aller à l'état 36
-    "!="    décalage et aller à l'état 37
-    "//"    décalage et aller à l'état 38
-    "then"  décalage et aller à l'état 67
-    "and"   décalage et aller à l'état 39
-    "or"    décalage et aller à l'état 40
-    "|="    décalage et aller à l'état 41
-    "+="    décalage et aller à l'état 42
-    "-="    décalage et aller à l'état 43
-    "*="    décalage et aller à l'état 44
-    "/="    décalage et aller à l'état 45
-    "//="   décalage et aller à l'état 46
-    "<="    décalage et aller à l'état 47
-    ">="    décalage et aller à l'état 48
-    '|'     décalage et aller à l'état 49
-    ','     décalage et aller à l'état 50
-    '='     décalage et aller à l'état 51
-    '<'     décalage et aller à l'état 52
-    '>'     décalage et aller à l'état 53
-    '+'     décalage et aller à l'état 54
-    '-'     décalage et aller à l'état 55
-    '*'     décalage et aller à l'état 56
-    '/'     décalage et aller à l'état 57
+    error       shift, and go to state 67
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "//"        shift, and go to state 38
+    "then"      shift, and go to state 68
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "|="        shift, and go to state 41
+    "+="        shift, and go to state 42
+    "-="        shift, and go to state 43
+    "*="        shift, and go to state 44
+    "/="        shift, and go to state 45
+    "//="       shift, and go to state 46
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '|'         shift, and go to state 50
+    ','         shift, and go to state 51
+    '='         shift, and go to state 52
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
 
-état 20
+state 20
 
     5 Exp: FuncDef . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 59
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 60
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 21
+state 21
 
-   33 String: QQSTRING_START QQString . QQSTRING_END
-   37 QQString: QQString . QQSTRING_TEXT
-   38         | QQString . QQSTRING_INTERP_START Exp QQSTRING_INTERP_END
+   34 String: QQSTRING_START QQString . QQSTRING_END
+   38 QQString: QQString . QQSTRING_TEXT
+   39         | QQString . QQSTRING_INTERP_START Exp QQSTRING_INTERP_END
 
-    QQSTRING_TEXT          décalage et aller à l'état 68
-    QQSTRING_INTERP_START  décalage et aller à l'état 69
-    QQSTRING_END           décalage et aller à l'état 70
+    QQSTRING_TEXT          shift, and go to state 69
+    QQSTRING_INTERP_START  shift, and go to state 70
+    QQSTRING_END           shift, and go to state 71
 
 
-état 22
+state 22
 
-   53 Term: '$' IDENT .
+   54 Term: '$' IDENT .
 
-    $défaut  réduction par utilisation de la règle 53 (Term)
+    $default  reduce using rule 54 (Term)
 
 
-état 23
+state 23
 
-   56 Term: '(' error . ')'
+   57 Term: '(' error . ')'
 
-    ')'  décalage et aller à l'état 71
+    ')'  shift, and go to state 72
 
 
-état 24
+state 24
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -602,55 +608,57 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
-   49 Term: '(' Exp . ')'
+   31    | Exp . "contains" Exp
+   50 Term: '(' Exp . ')'
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '|'    décalage et aller à l'état 49
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
-    ')'    décalage et aller à l'état 72
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "//"        shift, and go to state 38
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "|="        shift, and go to state 41
+    "+="        shift, and go to state 42
+    "-="        shift, and go to state 43
+    "*="        shift, and go to state 44
+    "/="        shift, and go to state 45
+    "//="       shift, and go to state 46
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '|'         shift, and go to state 50
+    ','         shift, and go to state 51
+    '='         shift, and go to state 52
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
+    ')'         shift, and go to state 73
 
 
-état 25
+state 25
 
-   45 Term: '.' IDENT .
+   46 Term: '.' IDENT .
 
-    $défaut  réduction par utilisation de la règle 45 (Term)
+    $default  reduce using rule 46 (Term)
 
 
-état 26
+state 26
 
-   57 Term: '[' error . ']'
+   58 Term: '[' error . ']'
 
-    ']'  décalage et aller à l'état 73
+    ']'  shift, and go to state 74
 
 
-état 27
+state 27
 
-   51 Term: '[' ']' .
+   52 Term: '[' ']' .
 
-    $défaut  réduction par utilisation de la règle 51 (Term)
+    $default  reduce using rule 52 (Term)
 
 
-état 28
+state 28
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -674,576 +682,599 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
-   50 Term: '[' Exp . ']'
+   31    | Exp . "contains" Exp
+   51 Term: '[' Exp . ']'
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '|'    décalage et aller à l'état 49
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
-    ']'    décalage et aller à l'état 74
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "//"        shift, and go to state 38
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "|="        shift, and go to state 41
+    "+="        shift, and go to state 42
+    "-="        shift, and go to state 43
+    "*="        shift, and go to state 44
+    "/="        shift, and go to state 45
+    "//="       shift, and go to state 46
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '|'         shift, and go to state 50
+    ','         shift, and go to state 51
+    '='         shift, and go to state 52
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
+    ']'         shift, and go to state 75
 
 
-état 29
+state 29
 
-   59 Term: '{' error . '}'
-   63 MkDict: error . ',' MkDict
+   60 Term: '{' error . '}'
+   64 MkDict: error . ',' MkDict
 
-    ','  décalage et aller à l'état 75
-    '}'  décalage et aller à l'état 76
+    ','  shift, and go to state 76
+    '}'  shift, and go to state 77
 
 
-état 30
+state 30
 
-   64 MkDictPair: IDENT . ':' ExpD
-   66           | IDENT .
+   65 MkDictPair: IDENT . ':' ExpD
+   67           | IDENT .
 
-    ':'  décalage et aller à l'état 77
+    ':'  shift, and go to state 78
 
-    $défaut  réduction par utilisation de la règle 66 (MkDictPair)
+    $default  reduce using rule 67 (MkDictPair)
 
 
-état 31
+state 31
 
-   67 MkDictPair: '(' . Exp ')' ':' ExpD
-   68           | '(' . error ')' ':' ExpD
+   68 MkDictPair: '(' . Exp ')' ':' ExpD
+   69           | '(' . error ')' ':' ExpD
 
-    error           décalage et aller à l'état 78
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    error           shift, and go to state 79
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 79
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 80
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 32
+state 32
 
-   65 MkDictPair: String . ':' ExpD
+   66 MkDictPair: String . ':' ExpD
 
-    ':'  décalage et aller à l'état 80
+    ':'  shift, and go to state 81
 
 
-état 33
+state 33
 
-   52 Term: '{' MkDict . '}'
+   53 Term: '{' MkDict . '}'
 
-    '}'  décalage et aller à l'état 81
+    '}'  shift, and go to state 82
 
 
-état 34
+state 34
 
-   61 MkDict: MkDictPair .
-   62       | MkDictPair . ',' MkDict
+   62 MkDict: MkDictPair .
+   63       | MkDictPair . ',' MkDict
 
-    ','  décalage et aller à l'état 82
+    ','  shift, and go to state 83
 
-    $défaut  réduction par utilisation de la règle 61 (MkDict)
+    $default  reduce using rule 62 (MkDict)
 
 
-état 35
+state 35
 
     0 $accept: TopLevel $end .
 
-    $défaut  accepter
+    $default  accept
 
 
-état 36
+state 36
 
    25 Exp: Exp "==" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 83
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 84
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 37
+state 37
 
    26 Exp: Exp "!=" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 84
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 85
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 38
+state 38
 
    12 Exp: Exp "//" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 85
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 86
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 39
+state 39
 
    11 Exp: Exp "and" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 86
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 87
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 40
+state 40
 
    10 Exp: Exp "or" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 87
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 88
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 41
+state 41
 
    14 Exp: Exp "|=" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 88
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 89
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 42
+state 42
 
    18 Exp: Exp "+=" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 89
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 90
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 43
+state 43
 
    20 Exp: Exp "-=" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 90
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 91
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 44
+state 44
 
    22 Exp: Exp "*=" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 91
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 92
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 45
+state 45
 
    24 Exp: Exp "/=" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 92
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 93
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 46
+state 46
 
    13 Exp: Exp "//=" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 93
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 94
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 47
+state 47
 
    29 Exp: Exp "<=" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 94
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 95
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 48
+state 48
 
    30 Exp: Exp ">=" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 95
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 96
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 49
+state 49
+
+   31 Exp: Exp "contains" . Exp
+
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
+
+    Exp      go to state 97
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
+
+
+state 50
 
    15 Exp: Exp '|' . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 96
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 98
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 50
+state 51
 
    16 Exp: Exp ',' . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 97
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 99
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 51
+state 52
 
     9 Exp: Exp '=' . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 98
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 100
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 52
+state 53
 
    27 Exp: Exp '<' . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 99
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 101
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 53
+state 54
 
    28 Exp: Exp '>' . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 100
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 102
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 54
+state 55
 
    17 Exp: Exp '+' . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 101
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 103
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 55
+state 56
 
    19 Exp: Exp '-' . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 102
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 104
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 56
+state 57
 
    21 Exp: Exp '*' . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 103
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 105
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 57
+state 58
 
    23 Exp: Exp '/' . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 104
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 106
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 58
+state 59
 
     4 FuncDefs: FuncDef FuncDefs .
 
-    $défaut  réduction par utilisation de la règle 4 (FuncDefs)
+    $default  reduce using rule 4 (FuncDefs)
 
 
-état 59
+state 60
 
     5 Exp: FuncDef Exp .
     9    | Exp . '=' Exp
@@ -1268,73 +1299,75 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '|'    décalage et aller à l'état 49
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "//"        shift, and go to state 38
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "|="        shift, and go to state 41
+    "+="        shift, and go to state 42
+    "-="        shift, and go to state 43
+    "*="        shift, and go to state 44
+    "/="        shift, and go to state 45
+    "//="       shift, and go to state 46
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '|'         shift, and go to state 50
+    ','         shift, and go to state 51
+    '='         shift, and go to state 52
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
-    $défaut  réduction par utilisation de la règle 5 (Exp)
+    $default  reduce using rule 5 (Exp)
 
 
-état 60
+state 61
 
     6 Exp: Term "as" . '$' IDENT '|' Exp
 
-    '$'  décalage et aller à l'état 105
+    '$'  shift, and go to state 107
 
 
-état 61
+state 62
 
-   44 Term: Term '.' . IDENT
+   45 Term: Term '.' . IDENT
 
-    IDENT  décalage et aller à l'état 106
+    IDENT  shift, and go to state 108
 
 
-état 62
+state 63
 
-   46 Term: Term '[' . Exp ']'
-   47     | Term '[' . ']'
-   58     | Term '[' . error ']'
+   47 Term: Term '[' . Exp ']'
+   48     | Term '[' . ']'
+   59     | Term '[' . error ']'
 
-    error           décalage et aller à l'état 107
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    ']'             décalage et aller à l'état 108
-    '{'             décalage et aller à l'état 10
+    error           shift, and go to state 109
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    ']'             shift, and go to state 110
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 109
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 111
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 63
+state 64
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1358,199 +1391,201 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
-   55 Term: IDENT '(' Exp . ')'
+   31    | Exp . "contains" Exp
+   56 Term: IDENT '(' Exp . ')'
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '|'    décalage et aller à l'état 49
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
-    ')'    décalage et aller à l'état 110
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "//"        shift, and go to state 38
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "|="        shift, and go to state 41
+    "+="        shift, and go to state 42
+    "-="        shift, and go to state 43
+    "*="        shift, and go to state 44
+    "/="        shift, and go to state 45
+    "//="       shift, and go to state 46
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '|'         shift, and go to state 50
+    ','         shift, and go to state 51
+    '='         shift, and go to state 52
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
+    ')'         shift, and go to state 112
 
 
-état 64
+state 65
 
-   34 FuncDef: "def" IDENT ':' . Exp ';'
+   35 FuncDef: "def" IDENT ':' . Exp ';'
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 111
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 113
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 65
+state 66
 
-   35 FuncDef: "def" IDENT '(' . IDENT ')' ':' Exp ';'
+   36 FuncDef: "def" IDENT '(' . IDENT ')' ':' Exp ';'
 
-    IDENT  décalage et aller à l'état 112
+    IDENT  shift, and go to state 114
 
 
-état 66
+state 67
 
     8 Exp: "if" Exp error .
 
-    $défaut  réduction par utilisation de la règle 8 (Exp)
+    $default  reduce using rule 8 (Exp)
 
 
-état 67
+state 68
 
     7 Exp: "if" Exp "then" . Exp ElseBody
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 113
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 115
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 68
+state 69
 
-   37 QQString: QQString QQSTRING_TEXT .
+   38 QQString: QQString QQSTRING_TEXT .
 
-    $défaut  réduction par utilisation de la règle 37 (QQString)
+    $default  reduce using rule 38 (QQString)
 
 
-état 69
+state 70
 
-   38 QQString: QQString QQSTRING_INTERP_START . Exp QQSTRING_INTERP_END
+   39 QQString: QQString QQSTRING_INTERP_START . Exp QQSTRING_INTERP_END
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 114
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 116
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 70
+state 71
 
-   33 String: QQSTRING_START QQString QQSTRING_END .
+   34 String: QQSTRING_START QQString QQSTRING_END .
 
-    $défaut  réduction par utilisation de la règle 33 (String)
+    $default  reduce using rule 34 (String)
 
 
-état 71
+state 72
 
-   56 Term: '(' error ')' .
+   57 Term: '(' error ')' .
 
-    $défaut  réduction par utilisation de la règle 56 (Term)
+    $default  reduce using rule 57 (Term)
 
 
-état 72
+state 73
 
-   49 Term: '(' Exp ')' .
+   50 Term: '(' Exp ')' .
 
-    $défaut  réduction par utilisation de la règle 49 (Term)
+    $default  reduce using rule 50 (Term)
 
 
-état 73
+state 74
 
-   57 Term: '[' error ']' .
+   58 Term: '[' error ']' .
 
-    $défaut  réduction par utilisation de la règle 57 (Term)
+    $default  reduce using rule 58 (Term)
 
 
-état 74
+state 75
 
-   50 Term: '[' Exp ']' .
+   51 Term: '[' Exp ']' .
 
-    $défaut  réduction par utilisation de la règle 50 (Term)
+    $default  reduce using rule 51 (Term)
 
 
-état 75
+state 76
 
-   63 MkDict: error ',' . MkDict
+   64 MkDict: error ',' . MkDict
 
-    error           décalage et aller à l'état 115
-    IDENT           décalage et aller à l'état 30
-    QQSTRING_START  décalage et aller à l'état 5
-    '('             décalage et aller à l'état 31
+    error           shift, and go to state 117
+    IDENT           shift, and go to state 30
+    QQSTRING_START  shift, and go to state 5
+    '('             shift, and go to state 31
 
-    '}'  réduction par utilisation de la règle 60 (MkDict)
+    '}'  reduce using rule 61 (MkDict)
 
-    String      aller à l'état 32
-    MkDict      aller à l'état 116
-    MkDictPair  aller à l'état 34
+    String      go to state 32
+    MkDict      go to state 118
+    MkDictPair  go to state 34
 
 
-état 76
+state 77
 
-   59 Term: '{' error '}' .
+   60 Term: '{' error '}' .
 
-    $défaut  réduction par utilisation de la règle 59 (Term)
+    $default  reduce using rule 60 (Term)
 
 
-état 77
+state 78
 
-   64 MkDictPair: IDENT ':' . ExpD
+   65 MkDictPair: IDENT ':' . ExpD
 
-    IDENT    décalage et aller à l'état 1
-    LITERAL  décalage et aller à l'état 2
-    '$'      décalage et aller à l'état 6
-    '('      décalage et aller à l'état 7
-    '.'      décalage et aller à l'état 8
-    '['      décalage et aller à l'état 9
-    '{'      décalage et aller à l'état 10
+    IDENT    shift, and go to state 1
+    LITERAL  shift, and go to state 2
+    '$'      shift, and go to state 6
+    '('      shift, and go to state 7
+    '.'      shift, and go to state 8
+    '['      shift, and go to state 9
+    '{'      shift, and go to state 10
 
-    ExpD  aller à l'état 117
-    Term  aller à l'état 118
+    ExpD  go to state 119
+    Term  go to state 120
 
 
-état 78
+state 79
 
-   68 MkDictPair: '(' error . ')' ':' ExpD
+   69 MkDictPair: '(' error . ')' ':' ExpD
 
-    ')'  décalage et aller à l'état 119
+    ')'  shift, and go to state 121
 
 
-état 79
+state 80
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1574,73 +1609,75 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
-   67 MkDictPair: '(' Exp . ')' ':' ExpD
+   31    | Exp . "contains" Exp
+   68 MkDictPair: '(' Exp . ')' ':' ExpD
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '|'    décalage et aller à l'état 49
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
-    ')'    décalage et aller à l'état 120
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "//"        shift, and go to state 38
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "|="        shift, and go to state 41
+    "+="        shift, and go to state 42
+    "-="        shift, and go to state 43
+    "*="        shift, and go to state 44
+    "/="        shift, and go to state 45
+    "//="       shift, and go to state 46
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '|'         shift, and go to state 50
+    ','         shift, and go to state 51
+    '='         shift, and go to state 52
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
+    ')'         shift, and go to state 122
 
 
-état 80
+state 81
 
-   65 MkDictPair: String ':' . ExpD
+   66 MkDictPair: String ':' . ExpD
 
-    IDENT    décalage et aller à l'état 1
-    LITERAL  décalage et aller à l'état 2
-    '$'      décalage et aller à l'état 6
-    '('      décalage et aller à l'état 7
-    '.'      décalage et aller à l'état 8
-    '['      décalage et aller à l'état 9
-    '{'      décalage et aller à l'état 10
+    IDENT    shift, and go to state 1
+    LITERAL  shift, and go to state 2
+    '$'      shift, and go to state 6
+    '('      shift, and go to state 7
+    '.'      shift, and go to state 8
+    '['      shift, and go to state 9
+    '{'      shift, and go to state 10
 
-    ExpD  aller à l'état 121
-    Term  aller à l'état 118
+    ExpD  go to state 123
+    Term  go to state 120
 
 
-état 81
+state 82
 
-   52 Term: '{' MkDict '}' .
+   53 Term: '{' MkDict '}' .
 
-    $défaut  réduction par utilisation de la règle 52 (Term)
+    $default  reduce using rule 53 (Term)
 
 
-état 82
+state 83
 
-   62 MkDict: MkDictPair ',' . MkDict
+   63 MkDict: MkDictPair ',' . MkDict
 
-    error           décalage et aller à l'état 115
-    IDENT           décalage et aller à l'état 30
-    QQSTRING_START  décalage et aller à l'état 5
-    '('             décalage et aller à l'état 31
+    error           shift, and go to state 117
+    IDENT           shift, and go to state 30
+    QQSTRING_START  shift, and go to state 5
+    '('             shift, and go to state 31
 
-    '}'  réduction par utilisation de la règle 60 (MkDict)
+    '}'  reduce using rule 61 (MkDict)
 
-    String      aller à l'état 32
-    MkDict      aller à l'état 122
-    MkDictPair  aller à l'état 34
+    String      go to state 32
+    MkDict      go to state 124
+    MkDictPair  go to state 34
 
 
-état 83
+state 84
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1665,23 +1702,25 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    '+'  décalage et aller à l'état 54
-    '-'  décalage et aller à l'état 55
-    '*'  décalage et aller à l'état 56
-    '/'  décalage et aller à l'état 57
+    '+'  shift, and go to state 55
+    '-'  shift, and go to state 56
+    '*'  shift, and go to state 57
+    '/'  shift, and go to state 58
 
-    "=="  erreur (non-associative)
-    "!="  erreur (non-associative)
-    "<="  erreur (non-associative)
-    ">="  erreur (non-associative)
-    '<'   erreur (non-associative)
-    '>'   erreur (non-associative)
+    "=="        error (nonassociative)
+    "!="        error (nonassociative)
+    "<="        error (nonassociative)
+    ">="        error (nonassociative)
+    "contains"  error (nonassociative)
+    '<'         error (nonassociative)
+    '>'         error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 25 (Exp)
+    $default  reduce using rule 25 (Exp)
 
 
-état 84
+state 85
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1706,23 +1745,25 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    '+'  décalage et aller à l'état 54
-    '-'  décalage et aller à l'état 55
-    '*'  décalage et aller à l'état 56
-    '/'  décalage et aller à l'état 57
+    '+'  shift, and go to state 55
+    '-'  shift, and go to state 56
+    '*'  shift, and go to state 57
+    '/'  shift, and go to state 58
 
-    "=="  erreur (non-associative)
-    "!="  erreur (non-associative)
-    "<="  erreur (non-associative)
-    ">="  erreur (non-associative)
-    '<'   erreur (non-associative)
-    '>'   erreur (non-associative)
+    "=="        error (nonassociative)
+    "!="        error (nonassociative)
+    "<="        error (nonassociative)
+    ">="        error (nonassociative)
+    "contains"  error (nonassociative)
+    '<'         error (nonassociative)
+    '>'         error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 26 (Exp)
+    $default  reduce using rule 26 (Exp)
 
 
-état 85
+state 86
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1747,32 +1788,34 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "//"        shift, and go to state 38
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "|="        shift, and go to state 41
+    "+="        shift, and go to state 42
+    "-="        shift, and go to state 43
+    "*="        shift, and go to state 44
+    "/="        shift, and go to state 45
+    "//="       shift, and go to state 46
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '='         shift, and go to state 52
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
-    $défaut  réduction par utilisation de la règle 12 (Exp)
+    $default  reduce using rule 12 (Exp)
 
 
-état 86
+state 87
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1797,22 +1840,24 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    "=="  décalage et aller à l'état 36
-    "!="  décalage et aller à l'état 37
-    "<="  décalage et aller à l'état 47
-    ">="  décalage et aller à l'état 48
-    '<'   décalage et aller à l'état 52
-    '>'   décalage et aller à l'état 53
-    '+'   décalage et aller à l'état 54
-    '-'   décalage et aller à l'état 55
-    '*'   décalage et aller à l'état 56
-    '/'   décalage et aller à l'état 57
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
-    $défaut  réduction par utilisation de la règle 11 (Exp)
+    $default  reduce using rule 11 (Exp)
 
 
-état 87
+state 88
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1837,23 +1882,25 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "and"  décalage et aller à l'état 39
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "and"       shift, and go to state 39
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
-    $défaut  réduction par utilisation de la règle 10 (Exp)
+    $default  reduce using rule 10 (Exp)
 
 
-état 88
+state 89
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1878,32 +1925,34 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
-    "|="   erreur (non-associative)
-    "+="   erreur (non-associative)
-    "-="   erreur (non-associative)
-    "*="   erreur (non-associative)
-    "/="   erreur (non-associative)
-    "//="  erreur (non-associative)
-    '='    erreur (non-associative)
+    "|="   error (nonassociative)
+    "+="   error (nonassociative)
+    "-="   error (nonassociative)
+    "*="   error (nonassociative)
+    "/="   error (nonassociative)
+    "//="  error (nonassociative)
+    '='    error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 14 (Exp)
+    $default  reduce using rule 14 (Exp)
 
 
-état 89
+state 90
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1928,32 +1977,34 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
-    "|="   erreur (non-associative)
-    "+="   erreur (non-associative)
-    "-="   erreur (non-associative)
-    "*="   erreur (non-associative)
-    "/="   erreur (non-associative)
-    "//="  erreur (non-associative)
-    '='    erreur (non-associative)
+    "|="   error (nonassociative)
+    "+="   error (nonassociative)
+    "-="   error (nonassociative)
+    "*="   error (nonassociative)
+    "/="   error (nonassociative)
+    "//="  error (nonassociative)
+    '='    error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 18 (Exp)
+    $default  reduce using rule 18 (Exp)
 
 
-état 90
+state 91
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1978,32 +2029,34 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
-    "|="   erreur (non-associative)
-    "+="   erreur (non-associative)
-    "-="   erreur (non-associative)
-    "*="   erreur (non-associative)
-    "/="   erreur (non-associative)
-    "//="  erreur (non-associative)
-    '='    erreur (non-associative)
+    "|="   error (nonassociative)
+    "+="   error (nonassociative)
+    "-="   error (nonassociative)
+    "*="   error (nonassociative)
+    "/="   error (nonassociative)
+    "//="  error (nonassociative)
+    '='    error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 20 (Exp)
+    $default  reduce using rule 20 (Exp)
 
 
-état 91
+state 92
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2028,32 +2081,34 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
-    "|="   erreur (non-associative)
-    "+="   erreur (non-associative)
-    "-="   erreur (non-associative)
-    "*="   erreur (non-associative)
-    "/="   erreur (non-associative)
-    "//="  erreur (non-associative)
-    '='    erreur (non-associative)
+    "|="   error (nonassociative)
+    "+="   error (nonassociative)
+    "-="   error (nonassociative)
+    "*="   error (nonassociative)
+    "/="   error (nonassociative)
+    "//="  error (nonassociative)
+    '='    error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 22 (Exp)
+    $default  reduce using rule 22 (Exp)
 
 
-état 92
+state 93
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2078,32 +2133,34 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
-    "|="   erreur (non-associative)
-    "+="   erreur (non-associative)
-    "-="   erreur (non-associative)
-    "*="   erreur (non-associative)
-    "/="   erreur (non-associative)
-    "//="  erreur (non-associative)
-    '='    erreur (non-associative)
+    "|="   error (nonassociative)
+    "+="   error (nonassociative)
+    "-="   error (nonassociative)
+    "*="   error (nonassociative)
+    "/="   error (nonassociative)
+    "//="  error (nonassociative)
+    '='    error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 24 (Exp)
+    $default  reduce using rule 24 (Exp)
 
 
-état 93
+state 94
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2128,32 +2185,34 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
-    "|="   erreur (non-associative)
-    "+="   erreur (non-associative)
-    "-="   erreur (non-associative)
-    "*="   erreur (non-associative)
-    "/="   erreur (non-associative)
-    "//="  erreur (non-associative)
-    '='    erreur (non-associative)
+    "|="   error (nonassociative)
+    "+="   error (nonassociative)
+    "-="   error (nonassociative)
+    "*="   error (nonassociative)
+    "/="   error (nonassociative)
+    "//="  error (nonassociative)
+    '='    error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 13 (Exp)
+    $default  reduce using rule 13 (Exp)
 
 
-état 94
+state 95
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2178,23 +2237,25 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    29    | Exp "<=" Exp .
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    '+'  décalage et aller à l'état 54
-    '-'  décalage et aller à l'état 55
-    '*'  décalage et aller à l'état 56
-    '/'  décalage et aller à l'état 57
+    '+'  shift, and go to state 55
+    '-'  shift, and go to state 56
+    '*'  shift, and go to state 57
+    '/'  shift, and go to state 58
 
-    "=="  erreur (non-associative)
-    "!="  erreur (non-associative)
-    "<="  erreur (non-associative)
-    ">="  erreur (non-associative)
-    '<'   erreur (non-associative)
-    '>'   erreur (non-associative)
+    "=="        error (nonassociative)
+    "!="        error (nonassociative)
+    "<="        error (nonassociative)
+    ">="        error (nonassociative)
+    "contains"  error (nonassociative)
+    '<'         error (nonassociative)
+    '>'         error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 29 (Exp)
+    $default  reduce using rule 29 (Exp)
 
 
-état 95
+state 96
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2219,23 +2280,68 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
    30    | Exp ">=" Exp .
+   31    | Exp . "contains" Exp
 
-    '+'  décalage et aller à l'état 54
-    '-'  décalage et aller à l'état 55
-    '*'  décalage et aller à l'état 56
-    '/'  décalage et aller à l'état 57
+    '+'  shift, and go to state 55
+    '-'  shift, and go to state 56
+    '*'  shift, and go to state 57
+    '/'  shift, and go to state 58
 
-    "=="  erreur (non-associative)
-    "!="  erreur (non-associative)
-    "<="  erreur (non-associative)
-    ">="  erreur (non-associative)
-    '<'   erreur (non-associative)
-    '>'   erreur (non-associative)
+    "=="        error (nonassociative)
+    "!="        error (nonassociative)
+    "<="        error (nonassociative)
+    ">="        error (nonassociative)
+    "contains"  error (nonassociative)
+    '<'         error (nonassociative)
+    '>'         error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 30 (Exp)
+    $default  reduce using rule 30 (Exp)
 
 
-état 96
+state 97
+
+    9 Exp: Exp . '=' Exp
+   10    | Exp . "or" Exp
+   11    | Exp . "and" Exp
+   12    | Exp . "//" Exp
+   13    | Exp . "//=" Exp
+   14    | Exp . "|=" Exp
+   15    | Exp . '|' Exp
+   16    | Exp . ',' Exp
+   17    | Exp . '+' Exp
+   18    | Exp . "+=" Exp
+   19    | Exp . '-' Exp
+   20    | Exp . "-=" Exp
+   21    | Exp . '*' Exp
+   22    | Exp . "*=" Exp
+   23    | Exp . '/' Exp
+   24    | Exp . "/=" Exp
+   25    | Exp . "==" Exp
+   26    | Exp . "!=" Exp
+   27    | Exp . '<' Exp
+   28    | Exp . '>' Exp
+   29    | Exp . "<=" Exp
+   30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
+   31    | Exp "contains" Exp .
+
+    '+'  shift, and go to state 55
+    '-'  shift, and go to state 56
+    '*'  shift, and go to state 57
+    '/'  shift, and go to state 58
+
+    "=="        error (nonassociative)
+    "!="        error (nonassociative)
+    "<="        error (nonassociative)
+    ">="        error (nonassociative)
+    "contains"  error (nonassociative)
+    '<'         error (nonassociative)
+    '>'         error (nonassociative)
+
+    $default  reduce using rule 31 (Exp)
+
+
+state 98
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2260,33 +2366,35 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "//"        shift, and go to state 38
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "|="        shift, and go to state 41
+    "+="        shift, and go to state 42
+    "-="        shift, and go to state 43
+    "*="        shift, and go to state 44
+    "/="        shift, and go to state 45
+    "//="       shift, and go to state 46
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    ','         shift, and go to state 51
+    '='         shift, and go to state 52
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
-    $défaut  réduction par utilisation de la règle 15 (Exp)
+    $default  reduce using rule 15 (Exp)
 
 
-état 97
+state 99
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2311,32 +2419,34 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "//"        shift, and go to state 38
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "|="        shift, and go to state 41
+    "+="        shift, and go to state 42
+    "-="        shift, and go to state 43
+    "*="        shift, and go to state 44
+    "/="        shift, and go to state 45
+    "//="       shift, and go to state 46
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '='         shift, and go to state 52
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
-    $défaut  réduction par utilisation de la règle 16 (Exp)
+    $default  reduce using rule 16 (Exp)
 
 
-état 98
+state 100
 
     9 Exp: Exp . '=' Exp
     9    | Exp '=' Exp .
@@ -2361,32 +2471,34 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
-    "|="   erreur (non-associative)
-    "+="   erreur (non-associative)
-    "-="   erreur (non-associative)
-    "*="   erreur (non-associative)
-    "/="   erreur (non-associative)
-    "//="  erreur (non-associative)
-    '='    erreur (non-associative)
+    "|="   error (nonassociative)
+    "+="   error (nonassociative)
+    "-="   error (nonassociative)
+    "*="   error (nonassociative)
+    "/="   error (nonassociative)
+    "//="  error (nonassociative)
+    '='    error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 9 (Exp)
+    $default  reduce using rule 9 (Exp)
 
 
-état 99
+state 101
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2411,23 +2523,25 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    '+'  décalage et aller à l'état 54
-    '-'  décalage et aller à l'état 55
-    '*'  décalage et aller à l'état 56
-    '/'  décalage et aller à l'état 57
+    '+'  shift, and go to state 55
+    '-'  shift, and go to state 56
+    '*'  shift, and go to state 57
+    '/'  shift, and go to state 58
 
-    "=="  erreur (non-associative)
-    "!="  erreur (non-associative)
-    "<="  erreur (non-associative)
-    ">="  erreur (non-associative)
-    '<'   erreur (non-associative)
-    '>'   erreur (non-associative)
+    "=="        error (nonassociative)
+    "!="        error (nonassociative)
+    "<="        error (nonassociative)
+    ">="        error (nonassociative)
+    "contains"  error (nonassociative)
+    '<'         error (nonassociative)
+    '>'         error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 27 (Exp)
+    $default  reduce using rule 27 (Exp)
 
 
-état 100
+state 102
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2452,23 +2566,25 @@ MkDictPair (61)
    28    | Exp '>' Exp .
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    '+'  décalage et aller à l'état 54
-    '-'  décalage et aller à l'état 55
-    '*'  décalage et aller à l'état 56
-    '/'  décalage et aller à l'état 57
+    '+'  shift, and go to state 55
+    '-'  shift, and go to state 56
+    '*'  shift, and go to state 57
+    '/'  shift, and go to state 58
 
-    "=="  erreur (non-associative)
-    "!="  erreur (non-associative)
-    "<="  erreur (non-associative)
-    ">="  erreur (non-associative)
-    '<'   erreur (non-associative)
-    '>'   erreur (non-associative)
+    "=="        error (nonassociative)
+    "!="        error (nonassociative)
+    "<="        error (nonassociative)
+    ">="        error (nonassociative)
+    "contains"  error (nonassociative)
+    '<'         error (nonassociative)
+    '>'         error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 28 (Exp)
+    $default  reduce using rule 28 (Exp)
 
 
-état 101
+state 103
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2493,14 +2609,15 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    '*'  décalage et aller à l'état 56
-    '/'  décalage et aller à l'état 57
+    '*'  shift, and go to state 57
+    '/'  shift, and go to state 58
 
-    $défaut  réduction par utilisation de la règle 17 (Exp)
+    $default  reduce using rule 17 (Exp)
 
 
-état 102
+state 104
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2525,14 +2642,15 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    '*'  décalage et aller à l'état 56
-    '/'  décalage et aller à l'état 57
+    '*'  shift, and go to state 57
+    '/'  shift, and go to state 58
 
-    $défaut  réduction par utilisation de la règle 19 (Exp)
+    $default  reduce using rule 19 (Exp)
 
 
-état 103
+state 105
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2557,11 +2675,12 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    $défaut  réduction par utilisation de la règle 21 (Exp)
+    $default  reduce using rule 21 (Exp)
 
 
-état 104
+state 106
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2586,39 +2705,40 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    $défaut  réduction par utilisation de la règle 23 (Exp)
+    $default  reduce using rule 23 (Exp)
 
 
-état 105
+state 107
 
     6 Exp: Term "as" '$' . IDENT '|' Exp
 
-    IDENT  décalage et aller à l'état 123
+    IDENT  shift, and go to state 125
 
 
-état 106
+state 108
 
-   44 Term: Term '.' IDENT .
+   45 Term: Term '.' IDENT .
 
-    $défaut  réduction par utilisation de la règle 44 (Term)
+    $default  reduce using rule 45 (Term)
 
 
-état 107
+state 109
 
-   58 Term: Term '[' error . ']'
+   59 Term: Term '[' error . ']'
 
-    ']'  décalage et aller à l'état 124
+    ']'  shift, and go to state 126
 
 
-état 108
+state 110
 
-   47 Term: Term '[' ']' .
+   48 Term: Term '[' ']' .
 
-    $défaut  réduction par utilisation de la règle 47 (Term)
+    $default  reduce using rule 48 (Term)
 
 
-état 109
+state 111
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2642,41 +2762,43 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
-   46 Term: Term '[' Exp . ']'
+   31    | Exp . "contains" Exp
+   47 Term: Term '[' Exp . ']'
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '|'    décalage et aller à l'état 49
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
-    ']'    décalage et aller à l'état 125
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "//"        shift, and go to state 38
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "|="        shift, and go to state 41
+    "+="        shift, and go to state 42
+    "-="        shift, and go to state 43
+    "*="        shift, and go to state 44
+    "/="        shift, and go to state 45
+    "//="       shift, and go to state 46
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '|'         shift, and go to state 50
+    ','         shift, and go to state 51
+    '='         shift, and go to state 52
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
+    ']'         shift, and go to state 127
 
 
-état 110
+state 112
 
-   55 Term: IDENT '(' Exp ')' .
+   56 Term: IDENT '(' Exp ')' .
 
-    $défaut  réduction par utilisation de la règle 55 (Term)
+    $default  reduce using rule 56 (Term)
 
 
-état 111
+state 113
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2700,41 +2822,43 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
-   34 FuncDef: "def" IDENT ':' Exp . ';'
+   31    | Exp . "contains" Exp
+   35 FuncDef: "def" IDENT ':' Exp . ';'
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    ';'    décalage et aller à l'état 126
-    '|'    décalage et aller à l'état 49
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "//"        shift, and go to state 38
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "|="        shift, and go to state 41
+    "+="        shift, and go to state 42
+    "-="        shift, and go to state 43
+    "*="        shift, and go to state 44
+    "/="        shift, and go to state 45
+    "//="       shift, and go to state 46
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    ';'         shift, and go to state 128
+    '|'         shift, and go to state 50
+    ','         shift, and go to state 51
+    '='         shift, and go to state 52
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
 
-état 112
+state 114
 
-   35 FuncDef: "def" IDENT '(' IDENT . ')' ':' Exp ';'
+   36 FuncDef: "def" IDENT '(' IDENT . ')' ':' Exp ';'
 
-    ')'  décalage et aller à l'état 127
+    ')'  shift, and go to state 129
 
 
-état 113
+state 115
 
     7 Exp: "if" Exp "then" Exp . ElseBody
     9    | Exp . '=' Exp
@@ -2759,36 +2883,38 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    "=="    décalage et aller à l'état 36
-    "!="    décalage et aller à l'état 37
-    "//"    décalage et aller à l'état 38
-    "else"  décalage et aller à l'état 128
-    "elif"  décalage et aller à l'état 129
-    "and"   décalage et aller à l'état 39
-    "or"    décalage et aller à l'état 40
-    "|="    décalage et aller à l'état 41
-    "+="    décalage et aller à l'état 42
-    "-="    décalage et aller à l'état 43
-    "*="    décalage et aller à l'état 44
-    "/="    décalage et aller à l'état 45
-    "//="   décalage et aller à l'état 46
-    "<="    décalage et aller à l'état 47
-    ">="    décalage et aller à l'état 48
-    '|'     décalage et aller à l'état 49
-    ','     décalage et aller à l'état 50
-    '='     décalage et aller à l'état 51
-    '<'     décalage et aller à l'état 52
-    '>'     décalage et aller à l'état 53
-    '+'     décalage et aller à l'état 54
-    '-'     décalage et aller à l'état 55
-    '*'     décalage et aller à l'état 56
-    '/'     décalage et aller à l'état 57
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "//"        shift, and go to state 38
+    "else"      shift, and go to state 130
+    "elif"      shift, and go to state 131
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "|="        shift, and go to state 41
+    "+="        shift, and go to state 42
+    "-="        shift, and go to state 43
+    "*="        shift, and go to state 44
+    "/="        shift, and go to state 45
+    "//="       shift, and go to state 46
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '|'         shift, and go to state 50
+    ','         shift, and go to state 51
+    '='         shift, and go to state 52
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
-    ElseBody  aller à l'état 130
+    ElseBody  go to state 132
 
 
-état 114
+state 116
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2812,284 +2938,286 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
-   38 QQString: QQString QQSTRING_INTERP_START Exp . QQSTRING_INTERP_END
+   31    | Exp . "contains" Exp
+   39 QQString: QQString QQSTRING_INTERP_START Exp . QQSTRING_INTERP_END
 
-    "=="                 décalage et aller à l'état 36
-    "!="                 décalage et aller à l'état 37
-    "//"                 décalage et aller à l'état 38
-    "and"                décalage et aller à l'état 39
-    "or"                 décalage et aller à l'état 40
-    "|="                 décalage et aller à l'état 41
-    "+="                 décalage et aller à l'état 42
-    "-="                 décalage et aller à l'état 43
-    "*="                 décalage et aller à l'état 44
-    "/="                 décalage et aller à l'état 45
-    "//="                décalage et aller à l'état 46
-    "<="                 décalage et aller à l'état 47
-    ">="                 décalage et aller à l'état 48
-    QQSTRING_INTERP_END  décalage et aller à l'état 131
-    '|'                  décalage et aller à l'état 49
-    ','                  décalage et aller à l'état 50
-    '='                  décalage et aller à l'état 51
-    '<'                  décalage et aller à l'état 52
-    '>'                  décalage et aller à l'état 53
-    '+'                  décalage et aller à l'état 54
-    '-'                  décalage et aller à l'état 55
-    '*'                  décalage et aller à l'état 56
-    '/'                  décalage et aller à l'état 57
+    "=="                 shift, and go to state 36
+    "!="                 shift, and go to state 37
+    "//"                 shift, and go to state 38
+    "and"                shift, and go to state 39
+    "or"                 shift, and go to state 40
+    "|="                 shift, and go to state 41
+    "+="                 shift, and go to state 42
+    "-="                 shift, and go to state 43
+    "*="                 shift, and go to state 44
+    "/="                 shift, and go to state 45
+    "//="                shift, and go to state 46
+    "<="                 shift, and go to state 47
+    ">="                 shift, and go to state 48
+    "contains"           shift, and go to state 49
+    QQSTRING_INTERP_END  shift, and go to state 133
+    '|'                  shift, and go to state 50
+    ','                  shift, and go to state 51
+    '='                  shift, and go to state 52
+    '<'                  shift, and go to state 53
+    '>'                  shift, and go to state 54
+    '+'                  shift, and go to state 55
+    '-'                  shift, and go to state 56
+    '*'                  shift, and go to state 57
+    '/'                  shift, and go to state 58
 
 
-état 115
+state 117
 
-   63 MkDict: error . ',' MkDict
+   64 MkDict: error . ',' MkDict
 
-    ','  décalage et aller à l'état 75
+    ','  shift, and go to state 76
 
 
-état 116
+state 118
 
-   63 MkDict: error ',' MkDict .
+   64 MkDict: error ',' MkDict .
 
-    $défaut  réduction par utilisation de la règle 63 (MkDict)
+    $default  reduce using rule 64 (MkDict)
 
 
-état 117
+state 119
 
-   41 ExpD: ExpD . '|' ExpD
-   64 MkDictPair: IDENT ':' ExpD .
+   42 ExpD: ExpD . '|' ExpD
+   65 MkDictPair: IDENT ':' ExpD .
 
-    '|'  décalage et aller à l'état 132
+    '|'  shift, and go to state 134
 
-    $défaut  réduction par utilisation de la règle 64 (MkDictPair)
+    $default  reduce using rule 65 (MkDictPair)
 
 
-état 118
+state 120
 
-   42 ExpD: Term .
-   44 Term: Term . '.' IDENT
-   46     | Term . '[' Exp ']'
-   47     | Term . '[' ']'
-   58     | Term . '[' error ']'
+   43 ExpD: Term .
+   45 Term: Term . '.' IDENT
+   47     | Term . '[' Exp ']'
+   48     | Term . '[' ']'
+   59     | Term . '[' error ']'
 
-    '.'  décalage et aller à l'état 61
-    '['  décalage et aller à l'état 62
+    '.'  shift, and go to state 62
+    '['  shift, and go to state 63
 
-    $défaut  réduction par utilisation de la règle 42 (ExpD)
+    $default  reduce using rule 43 (ExpD)
 
 
-état 119
+state 121
 
-   68 MkDictPair: '(' error ')' . ':' ExpD
+   69 MkDictPair: '(' error ')' . ':' ExpD
 
-    ':'  décalage et aller à l'état 133
+    ':'  shift, and go to state 135
 
 
-état 120
+state 122
 
-   67 MkDictPair: '(' Exp ')' . ':' ExpD
+   68 MkDictPair: '(' Exp ')' . ':' ExpD
 
-    ':'  décalage et aller à l'état 134
+    ':'  shift, and go to state 136
 
 
-état 121
+state 123
 
-   41 ExpD: ExpD . '|' ExpD
-   65 MkDictPair: String ':' ExpD .
+   42 ExpD: ExpD . '|' ExpD
+   66 MkDictPair: String ':' ExpD .
 
-    '|'  décalage et aller à l'état 132
+    '|'  shift, and go to state 134
 
-    $défaut  réduction par utilisation de la règle 65 (MkDictPair)
+    $default  reduce using rule 66 (MkDictPair)
 
 
-état 122
+state 124
 
-   62 MkDict: MkDictPair ',' MkDict .
+   63 MkDict: MkDictPair ',' MkDict .
 
-    $défaut  réduction par utilisation de la règle 62 (MkDict)
+    $default  reduce using rule 63 (MkDict)
 
 
-état 123
+state 125
 
     6 Exp: Term "as" '$' IDENT . '|' Exp
 
-    '|'  décalage et aller à l'état 135
+    '|'  shift, and go to state 137
 
 
-état 124
+state 126
 
-   58 Term: Term '[' error ']' .
+   59 Term: Term '[' error ']' .
 
-    $défaut  réduction par utilisation de la règle 58 (Term)
+    $default  reduce using rule 59 (Term)
 
 
-état 125
+state 127
 
-   46 Term: Term '[' Exp ']' .
+   47 Term: Term '[' Exp ']' .
 
-    $défaut  réduction par utilisation de la règle 46 (Term)
+    $default  reduce using rule 47 (Term)
 
 
-état 126
+state 128
 
-   34 FuncDef: "def" IDENT ':' Exp ';' .
+   35 FuncDef: "def" IDENT ':' Exp ';' .
 
-    $défaut  réduction par utilisation de la règle 34 (FuncDef)
+    $default  reduce using rule 35 (FuncDef)
 
 
-état 127
+state 129
 
-   35 FuncDef: "def" IDENT '(' IDENT ')' . ':' Exp ';'
+   36 FuncDef: "def" IDENT '(' IDENT ')' . ':' Exp ';'
 
-    ':'  décalage et aller à l'état 136
+    ':'  shift, and go to state 138
 
 
-état 128
+state 130
 
-   40 ElseBody: "else" . Exp "end"
+   41 ElseBody: "else" . Exp "end"
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 137
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 139
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 129
+state 131
 
-   39 ElseBody: "elif" . Exp "then" Exp ElseBody
+   40 ElseBody: "elif" . Exp "then" Exp ElseBody
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 138
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 140
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 130
+state 132
 
     7 Exp: "if" Exp "then" Exp ElseBody .
 
-    $défaut  réduction par utilisation de la règle 7 (Exp)
+    $default  reduce using rule 7 (Exp)
 
 
-état 131
+state 133
 
-   38 QQString: QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END .
+   39 QQString: QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END .
 
-    $défaut  réduction par utilisation de la règle 38 (QQString)
+    $default  reduce using rule 39 (QQString)
 
 
-état 132
+state 134
 
-   41 ExpD: ExpD '|' . ExpD
+   42 ExpD: ExpD '|' . ExpD
 
-    IDENT    décalage et aller à l'état 1
-    LITERAL  décalage et aller à l'état 2
-    '$'      décalage et aller à l'état 6
-    '('      décalage et aller à l'état 7
-    '.'      décalage et aller à l'état 8
-    '['      décalage et aller à l'état 9
-    '{'      décalage et aller à l'état 10
+    IDENT    shift, and go to state 1
+    LITERAL  shift, and go to state 2
+    '$'      shift, and go to state 6
+    '('      shift, and go to state 7
+    '.'      shift, and go to state 8
+    '['      shift, and go to state 9
+    '{'      shift, and go to state 10
 
-    ExpD  aller à l'état 139
-    Term  aller à l'état 118
+    ExpD  go to state 141
+    Term  go to state 120
 
 
-état 133
+state 135
 
-   68 MkDictPair: '(' error ')' ':' . ExpD
+   69 MkDictPair: '(' error ')' ':' . ExpD
 
-    IDENT    décalage et aller à l'état 1
-    LITERAL  décalage et aller à l'état 2
-    '$'      décalage et aller à l'état 6
-    '('      décalage et aller à l'état 7
-    '.'      décalage et aller à l'état 8
-    '['      décalage et aller à l'état 9
-    '{'      décalage et aller à l'état 10
+    IDENT    shift, and go to state 1
+    LITERAL  shift, and go to state 2
+    '$'      shift, and go to state 6
+    '('      shift, and go to state 7
+    '.'      shift, and go to state 8
+    '['      shift, and go to state 9
+    '{'      shift, and go to state 10
 
-    ExpD  aller à l'état 140
-    Term  aller à l'état 118
+    ExpD  go to state 142
+    Term  go to state 120
 
 
-état 134
+state 136
 
-   67 MkDictPair: '(' Exp ')' ':' . ExpD
+   68 MkDictPair: '(' Exp ')' ':' . ExpD
 
-    IDENT    décalage et aller à l'état 1
-    LITERAL  décalage et aller à l'état 2
-    '$'      décalage et aller à l'état 6
-    '('      décalage et aller à l'état 7
-    '.'      décalage et aller à l'état 8
-    '['      décalage et aller à l'état 9
-    '{'      décalage et aller à l'état 10
+    IDENT    shift, and go to state 1
+    LITERAL  shift, and go to state 2
+    '$'      shift, and go to state 6
+    '('      shift, and go to state 7
+    '.'      shift, and go to state 8
+    '['      shift, and go to state 9
+    '{'      shift, and go to state 10
 
-    ExpD  aller à l'état 141
-    Term  aller à l'état 118
+    ExpD  go to state 143
+    Term  go to state 120
 
 
-état 135
+state 137
 
     6 Exp: Term "as" '$' IDENT '|' . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 142
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 144
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 136
+state 138
 
-   35 FuncDef: "def" IDENT '(' IDENT ')' ':' . Exp ';'
+   36 FuncDef: "def" IDENT '(' IDENT ')' ':' . Exp ';'
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 143
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 145
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 137
+state 139
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -3113,34 +3241,36 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
-   40 ElseBody: "else" Exp . "end"
+   31    | Exp . "contains" Exp
+   41 ElseBody: "else" Exp . "end"
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "end"  décalage et aller à l'état 144
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '|'    décalage et aller à l'état 49
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "//"        shift, and go to state 38
+    "end"       shift, and go to state 146
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "|="        shift, and go to state 41
+    "+="        shift, and go to state 42
+    "-="        shift, and go to state 43
+    "*="        shift, and go to state 44
+    "/="        shift, and go to state 45
+    "//="       shift, and go to state 46
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '|'         shift, and go to state 50
+    ','         shift, and go to state 51
+    '='         shift, and go to state 52
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
 
-état 138
+state 140
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -3164,62 +3294,64 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
-   39 ElseBody: "elif" Exp . "then" Exp ElseBody
+   31    | Exp . "contains" Exp
+   40 ElseBody: "elif" Exp . "then" Exp ElseBody
 
-    "=="    décalage et aller à l'état 36
-    "!="    décalage et aller à l'état 37
-    "//"    décalage et aller à l'état 38
-    "then"  décalage et aller à l'état 145
-    "and"   décalage et aller à l'état 39
-    "or"    décalage et aller à l'état 40
-    "|="    décalage et aller à l'état 41
-    "+="    décalage et aller à l'état 42
-    "-="    décalage et aller à l'état 43
-    "*="    décalage et aller à l'état 44
-    "/="    décalage et aller à l'état 45
-    "//="   décalage et aller à l'état 46
-    "<="    décalage et aller à l'état 47
-    ">="    décalage et aller à l'état 48
-    '|'     décalage et aller à l'état 49
-    ','     décalage et aller à l'état 50
-    '='     décalage et aller à l'état 51
-    '<'     décalage et aller à l'état 52
-    '>'     décalage et aller à l'état 53
-    '+'     décalage et aller à l'état 54
-    '-'     décalage et aller à l'état 55
-    '*'     décalage et aller à l'état 56
-    '/'     décalage et aller à l'état 57
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "//"        shift, and go to state 38
+    "then"      shift, and go to state 147
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "|="        shift, and go to state 41
+    "+="        shift, and go to state 42
+    "-="        shift, and go to state 43
+    "*="        shift, and go to state 44
+    "/="        shift, and go to state 45
+    "//="       shift, and go to state 46
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '|'         shift, and go to state 50
+    ','         shift, and go to state 51
+    '='         shift, and go to state 52
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
 
-état 139
+state 141
 
-   41 ExpD: ExpD . '|' ExpD
-   41     | ExpD '|' ExpD .
+   42 ExpD: ExpD . '|' ExpD
+   42     | ExpD '|' ExpD .
 
-    $défaut  réduction par utilisation de la règle 41 (ExpD)
+    $default  reduce using rule 42 (ExpD)
 
 
-état 140
+state 142
 
-   41 ExpD: ExpD . '|' ExpD
-   68 MkDictPair: '(' error ')' ':' ExpD .
+   42 ExpD: ExpD . '|' ExpD
+   69 MkDictPair: '(' error ')' ':' ExpD .
 
-    '|'  décalage et aller à l'état 132
+    '|'  shift, and go to state 134
 
-    $défaut  réduction par utilisation de la règle 68 (MkDictPair)
+    $default  reduce using rule 69 (MkDictPair)
 
 
-état 141
+state 143
 
-   41 ExpD: ExpD . '|' ExpD
-   67 MkDictPair: '(' Exp ')' ':' ExpD .
+   42 ExpD: ExpD . '|' ExpD
+   68 MkDictPair: '(' Exp ')' ':' ExpD .
 
-    '|'  décalage et aller à l'état 132
+    '|'  shift, and go to state 134
 
-    $défaut  réduction par utilisation de la règle 67 (MkDictPair)
+    $default  reduce using rule 68 (MkDictPair)
 
 
-état 142
+state 144
 
     6 Exp: Term "as" '$' IDENT '|' Exp .
     9    | Exp . '=' Exp
@@ -3244,33 +3376,35 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
+   31    | Exp . "contains" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "//"        shift, and go to state 38
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "|="        shift, and go to state 41
+    "+="        shift, and go to state 42
+    "-="        shift, and go to state 43
+    "*="        shift, and go to state 44
+    "/="        shift, and go to state 45
+    "//="       shift, and go to state 46
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    ','         shift, and go to state 51
+    '='         shift, and go to state 52
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
-    $défaut  réduction par utilisation de la règle 6 (Exp)
+    $default  reduce using rule 6 (Exp)
 
 
-état 143
+state 145
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -3294,69 +3428,71 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
-   35 FuncDef: "def" IDENT '(' IDENT ')' ':' Exp . ';'
+   31    | Exp . "contains" Exp
+   36 FuncDef: "def" IDENT '(' IDENT ')' ':' Exp . ';'
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    ';'    décalage et aller à l'état 146
-    '|'    décalage et aller à l'état 49
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "//"        shift, and go to state 38
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "|="        shift, and go to state 41
+    "+="        shift, and go to state 42
+    "-="        shift, and go to state 43
+    "*="        shift, and go to state 44
+    "/="        shift, and go to state 45
+    "//="       shift, and go to state 46
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    ';'         shift, and go to state 148
+    '|'         shift, and go to state 50
+    ','         shift, and go to state 51
+    '='         shift, and go to state 52
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
 
-état 144
+state 146
 
-   40 ElseBody: "else" Exp "end" .
+   41 ElseBody: "else" Exp "end" .
 
-    $défaut  réduction par utilisation de la règle 40 (ElseBody)
+    $default  reduce using rule 41 (ElseBody)
 
 
-état 145
+state 147
 
-   39 ElseBody: "elif" Exp "then" . Exp ElseBody
+   40 ElseBody: "elif" Exp "then" . Exp ElseBody
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 147
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 149
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 146
+state 148
 
-   35 FuncDef: "def" IDENT '(' IDENT ')' ':' Exp ';' .
+   36 FuncDef: "def" IDENT '(' IDENT ')' ':' Exp ';' .
 
-    $défaut  réduction par utilisation de la règle 35 (FuncDef)
+    $default  reduce using rule 36 (FuncDef)
 
 
-état 147
+state 149
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -3380,38 +3516,40 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
-   39 ElseBody: "elif" Exp "then" Exp . ElseBody
+   31    | Exp . "contains" Exp
+   40 ElseBody: "elif" Exp "then" Exp . ElseBody
 
-    "=="    décalage et aller à l'état 36
-    "!="    décalage et aller à l'état 37
-    "//"    décalage et aller à l'état 38
-    "else"  décalage et aller à l'état 128
-    "elif"  décalage et aller à l'état 129
-    "and"   décalage et aller à l'état 39
-    "or"    décalage et aller à l'état 40
-    "|="    décalage et aller à l'état 41
-    "+="    décalage et aller à l'état 42
-    "-="    décalage et aller à l'état 43
-    "*="    décalage et aller à l'état 44
-    "/="    décalage et aller à l'état 45
-    "//="   décalage et aller à l'état 46
-    "<="    décalage et aller à l'état 47
-    ">="    décalage et aller à l'état 48
-    '|'     décalage et aller à l'état 49
-    ','     décalage et aller à l'état 50
-    '='     décalage et aller à l'état 51
-    '<'     décalage et aller à l'état 52
-    '>'     décalage et aller à l'état 53
-    '+'     décalage et aller à l'état 54
-    '-'     décalage et aller à l'état 55
-    '*'     décalage et aller à l'état 56
-    '/'     décalage et aller à l'état 57
+    "=="        shift, and go to state 36
+    "!="        shift, and go to state 37
+    "//"        shift, and go to state 38
+    "else"      shift, and go to state 130
+    "elif"      shift, and go to state 131
+    "and"       shift, and go to state 39
+    "or"        shift, and go to state 40
+    "|="        shift, and go to state 41
+    "+="        shift, and go to state 42
+    "-="        shift, and go to state 43
+    "*="        shift, and go to state 44
+    "/="        shift, and go to state 45
+    "//="       shift, and go to state 46
+    "<="        shift, and go to state 47
+    ">="        shift, and go to state 48
+    "contains"  shift, and go to state 49
+    '|'         shift, and go to state 50
+    ','         shift, and go to state 51
+    '='         shift, and go to state 52
+    '<'         shift, and go to state 53
+    '>'         shift, and go to state 54
+    '+'         shift, and go to state 55
+    '-'         shift, and go to state 56
+    '*'         shift, and go to state 57
+    '/'         shift, and go to state 58
 
-    ElseBody  aller à l'état 148
+    ElseBody  go to state 150
 
 
-état 148
+state 150
 
-   39 ElseBody: "elif" Exp "then" Exp ElseBody .
+   40 ElseBody: "elif" Exp "then" Exp ElseBody .
 
-    $défaut  réduction par utilisation de la règle 39 (ElseBody)
+    $default  reduce using rule 40 (ElseBody)
diff --git a/parser.y b/parser.y
index e2e591df..ddc41c5e 100644
--- a/parser.y
+++ b/parser.y
@@ -65,6 +65,7 @@ struct lexer_param;
 %token SETDEFINEDOR "//="
 %token LESSEQ "<="
 %token GREATEREQ ">="
+%token CONTAINS "contains"
 
 %token QQSTRING_START
 %token <literal> QQSTRING_TEXT
@@ -80,7 +81,7 @@ struct lexer_param;
 %nonassoc '=' SETPIPE SETPLUS SETMINUS SETMULT SETDIV SETDEFINEDOR
 %left OR
 %left AND
-%nonassoc NEQ EQ '<' '>' LESSEQ GREATEREQ
+%nonassoc NEQ EQ '<' '>' LESSEQ GREATEREQ CONTAINS
 %left '+' '-'
 %left '*' '/'
 
@@ -152,6 +153,7 @@ static block gen_binop(block a, block b, int op) {
   case '>': funcname = "_greater"; break;
   case LESSEQ: funcname = "_lesseq"; break;
   case GREATEREQ: funcname = "_greatereq"; break;
+  case CONTAINS: funcname = "_contains"; break;
   }
   assert(funcname);
 
@@ -308,6 +310,10 @@ Exp ">=" Exp {
   $$ = gen_binop($1, $3, GREATEREQ);
 } |
 
+Exp "contains" Exp {
+  $$ = gen_binop($1, $3, CONTAINS);
+} |
+
 String {
   $$ = $1;
 } |
diff --git a/testdata b/testdata
index 8cd5e27c..ce330112 100644
--- a/testdata
+++ b/testdata
@@ -395,3 +395,28 @@ def inc(x): x |= .+1; inc(.[].a)
 [{"foo":[1,2,{"bar":18},"world"]} == {"foo":[1,2,{"bar":18},"world"]},{"foo":[1,2,{"bar":18},"world"]} == {"foo":[1,2,{"bar":19},"world"]}]
 {}
 [true,false]
+
+# containment operator
+["foo" contains "foo", "foobar" contains "foo", "foo" contains "foobar"]
+{}
+[true, true, false]
+
+[[] contains [], [1,2,3] contains [1,2], [1,2,3] contains [3,1], [1,2,3] contains [4], [1,2,3] contains [1,4]]
+{}
+[true, true, true, false, false]
+
+[["foobar", "foobaz"] contains ["baz", "bar"], ["foobar", "foobaz"] contains ["foo"], ["foobar", "foobaz"] contains ["blap"]]
+{}
+[true, true, false]
+
+[{foo: 12, bar:13} contains {foo: 12}, {foo: 12} contains {}, {foo: 12, bar:13} contains {baz:14}]
+{}
+[true, true, false]
+
+{foo: {baz: 12, blap: {bar: 13}}, bar: 14} contains {bar: 14, foo: {blap: {}}}
+{}
+true
+
+{foo: {baz: 12, blap: {bar: 13}}, bar: 14} contains {bar: 14, foo: {blap: {bar: 14}}}
+{}
+false
\ No newline at end of file

From 72691b490943bcaa921a53375585cac83327c432 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 25 Oct 2012 00:13:39 +0100
Subject: [PATCH 137/284] Fix a bug in string parsing. Closes #35

---
 lexer.gen.c     |   72 +-
 lexer.gen.h     |   29 +-
 parser.gen.c    |  765 ++++++-----
 parser.gen.h    |   46 +-
 parser.gen.info | 3304 ++++++++++++++++++++++++-----------------------
 parser.y        |    7 +-
 6 files changed, 2165 insertions(+), 2058 deletions(-)

diff --git a/lexer.gen.c b/lexer.gen.c
index dbaf0abc..c78730e3 100644
--- a/lexer.gen.c
+++ b/lexer.gen.c
@@ -9,7 +9,7 @@
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 5
-#define YY_FLEX_SUBMINOR_VERSION 37
+#define YY_FLEX_SUBMINOR_VERSION 35
 #if YY_FLEX_SUBMINOR_VERSION > 0
 #define FLEX_BETA
 #endif
@@ -159,7 +159,15 @@ typedef void* yyscan_t;
 
 /* Size of default input buffer. */
 #ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
 #define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
 #endif
 
 /* The state buf must be large enough to hold one state per character in the main buffer.
@@ -171,11 +179,6 @@ typedef void* yyscan_t;
 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 #endif
 
-#ifndef YY_TYPEDEF_YY_SIZE_T
-#define YY_TYPEDEF_YY_SIZE_T
-typedef size_t yy_size_t;
-#endif
-
 #define EOB_ACT_CONTINUE_SCAN 0
 #define EOB_ACT_END_OF_FILE 1
 #define EOB_ACT_LAST_MATCH 2
@@ -198,6 +201,11 @@ typedef size_t yy_size_t;
 
 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
 
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
 #ifndef YY_STRUCT_YY_BUFFER_STATE
 #define YY_STRUCT_YY_BUFFER_STATE
 struct yy_buffer_state
@@ -215,7 +223,7 @@ struct yy_buffer_state
 	/* Number of characters read into yy_ch_buf, not including EOB
 	 * characters.
 	 */
-	yy_size_t yy_n_chars;
+	int yy_n_chars;
 
 	/* Whether we "own" the buffer - i.e., we know we created it,
 	 * and can realloc() it to grow it, and should free() it to
@@ -294,7 +302,7 @@ static void jq_yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner
 
 YY_BUFFER_STATE jq_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
 YY_BUFFER_STATE jq_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
-YY_BUFFER_STATE jq_yy_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner );
+YY_BUFFER_STATE jq_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
 
 void *jq_yyalloc (yy_size_t ,yyscan_t yyscanner );
 void *jq_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
@@ -326,7 +334,7 @@ void jq_yyfree (void * ,yyscan_t yyscanner );
 
 /* Begin user sect3 */
 
-#define jq_yywrap(yyscanner) 1
+#define jq_yywrap(n) 1
 #define YY_SKIP_YYWRAP
 
 typedef unsigned char YY_CHAR;
@@ -522,7 +530,7 @@ struct lexer_param;
   static int enter(int opening, int state, yyscan_t yyscanner);
   static int try_exit(int closing, int state, yyscan_t yyscanner);
 #define YY_NO_INPUT 1
-#line 526 "lexer.gen.c"
+#line 534 "lexer.gen.c"
 
 #define INITIAL 0
 #define IN_PAREN 1
@@ -554,8 +562,8 @@ struct yyguts_t
     size_t yy_buffer_stack_max; /**< capacity of stack. */
     YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
     char yy_hold_char;
-    yy_size_t yy_n_chars;
-    yy_size_t yyleng_r;
+    int yy_n_chars;
+    int yyleng_r;
     char *yy_c_buf_p;
     int yy_init;
     int yy_start;
@@ -612,7 +620,7 @@ FILE *jq_yyget_out (yyscan_t yyscanner );
 
 void jq_yyset_out  (FILE * out_str ,yyscan_t yyscanner );
 
-yy_size_t jq_yyget_leng (yyscan_t yyscanner );
+int jq_yyget_leng (yyscan_t yyscanner );
 
 char *jq_yyget_text (yyscan_t yyscanner );
 
@@ -620,10 +628,6 @@ int jq_yyget_lineno (yyscan_t yyscanner );
 
 void jq_yyset_lineno (int line_number ,yyscan_t yyscanner );
 
-int jq_yyget_column  (yyscan_t yyscanner );
-
-void jq_yyset_column (int column_no ,yyscan_t yyscanner );
-
 YYSTYPE * jq_yyget_lval (yyscan_t yyscanner );
 
 void jq_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
@@ -670,7 +674,12 @@ static int input (yyscan_t yyscanner );
     
 /* Amount of stuff to slurp up with each read. */
 #ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
 #define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
 #endif
 
 /* Copy whatever the last rule matched to the standard output. */
@@ -777,7 +786,7 @@ YY_DECL
 #line 35 "lexer.l"
 
 
-#line 781 "lexer.gen.c"
+#line 790 "lexer.gen.c"
 
     yylval = yylval_param;
 
@@ -1069,7 +1078,7 @@ YY_RULE_SETUP
 #line 110 "lexer.l"
 YY_FATAL_ERROR( "flex scanner jammed" );
 	YY_BREAK
-#line 1073 "lexer.gen.c"
+#line 1082 "lexer.gen.c"
 case YY_STATE_EOF(INITIAL):
 case YY_STATE_EOF(IN_PAREN):
 case YY_STATE_EOF(IN_BRACKET):
@@ -1261,21 +1270,21 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 
 	else
 		{
-			yy_size_t num_to_read =
+			int num_to_read =
 			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
 
 		while ( num_to_read <= 0 )
 			{ /* Not enough room in the buffer - grow it. */
 
 			/* just a shorter name for the current buffer */
-			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
+			YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
 
 			int yy_c_buf_p_offset =
 				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);
 
 			if ( b->yy_is_our_buffer )
 				{
-				yy_size_t new_size = b->yy_buf_size * 2;
+				int new_size = b->yy_buf_size * 2;
 
 				if ( new_size <= 0 )
 					b->yy_buf_size += b->yy_buf_size / 8;
@@ -1306,7 +1315,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 
 		/* Read in more data. */
 		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
-			yyg->yy_n_chars, num_to_read );
+			yyg->yy_n_chars, (size_t) num_to_read );
 
 		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
 		}
@@ -1403,7 +1412,6 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 	yy_is_jam = (yy_current_state == 87);
 
-	(void)yyg;
 	return yy_is_jam ? 0 : yy_current_state;
 }
 
@@ -1432,7 +1440,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 
 		else
 			{ /* need more input */
-			yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
+			int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
 			++yyg->yy_c_buf_p;
 
 			switch ( yy_get_next_buffer( yyscanner ) )
@@ -1596,6 +1604,10 @@ static void jq_yy_load_buffer_state  (yyscan_t yyscanner)
 	jq_yyfree((void *) b ,yyscanner );
 }
 
+#ifndef __cplusplus
+extern int isatty (int );
+#endif /* __cplusplus */
+    
 /* Initializes or reinitializes a buffer.
  * This function is sometimes called more than once on the same buffer,
  * such as during a jq_yyrestart() or at EOF.
@@ -1712,7 +1724,7 @@ void jq_yypop_buffer_state (yyscan_t yyscanner)
  */
 static void jq_yyensure_buffer_stack (yyscan_t yyscanner)
 {
-	yy_size_t num_to_alloc;
+	int num_to_alloc;
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
 	if (!yyg->yy_buffer_stack) {
@@ -1810,7 +1822,7 @@ YY_BUFFER_STATE jq_yy_scan_string (yyconst char * yystr , yyscan_t yyscanner)
  * @param yyscanner The scanner object.
  * @return the newly allocated buffer state object.
  */
-YY_BUFFER_STATE jq_yy_scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len , yyscan_t yyscanner)
+YY_BUFFER_STATE jq_yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
 {
 	YY_BUFFER_STATE b;
 	char *buf;
@@ -1965,7 +1977,7 @@ FILE *jq_yyget_out  (yyscan_t yyscanner)
 /** Get the length of the current token.
  * @param yyscanner The scanner object.
  */
-yy_size_t jq_yyget_leng  (yyscan_t yyscanner)
+int jq_yyget_leng  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     return yyleng;
@@ -2001,7 +2013,7 @@ void jq_yyset_lineno (int  line_number , yyscan_t yyscanner)
 
         /* lineno is only valid if an input buffer exists. */
         if (! YY_CURRENT_BUFFER )
-           YY_FATAL_ERROR( "jq_yyset_lineno called with no buffer" );
+           yy_fatal_error( "jq_yyset_lineno called with no buffer" , yyscanner); 
     
     yylineno = line_number;
 }
@@ -2016,7 +2028,7 @@ void jq_yyset_column (int  column_no , yyscan_t yyscanner)
 
         /* column is only valid if an input buffer exists. */
         if (! YY_CURRENT_BUFFER )
-           YY_FATAL_ERROR( "jq_yyset_column called with no buffer" );
+           yy_fatal_error( "jq_yyset_column called with no buffer" , yyscanner); 
     
     yycolumn = column_no;
 }
diff --git a/lexer.gen.h b/lexer.gen.h
index e22ddb29..84a71abb 100644
--- a/lexer.gen.h
+++ b/lexer.gen.h
@@ -13,7 +13,7 @@
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 5
-#define YY_FLEX_SUBMINOR_VERSION 37
+#define YY_FLEX_SUBMINOR_VERSION 35
 #if YY_FLEX_SUBMINOR_VERSION > 0
 #define FLEX_BETA
 #endif
@@ -132,7 +132,15 @@ typedef void* yyscan_t;
 
 /* Size of default input buffer. */
 #ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
 #define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
 #endif
 
 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
@@ -162,7 +170,7 @@ struct yy_buffer_state
 	/* Number of characters read into yy_ch_buf, not including EOB
 	 * characters.
 	 */
-	yy_size_t yy_n_chars;
+	int yy_n_chars;
 
 	/* Whether we "own" the buffer - i.e., we know we created it,
 	 * and can realloc() it to grow it, and should free() it to
@@ -206,7 +214,7 @@ void jq_yypop_buffer_state (yyscan_t yyscanner );
 
 YY_BUFFER_STATE jq_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
 YY_BUFFER_STATE jq_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
-YY_BUFFER_STATE jq_yy_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner );
+YY_BUFFER_STATE jq_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
 
 void *jq_yyalloc (yy_size_t ,yyscan_t yyscanner );
 void *jq_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
@@ -214,7 +222,7 @@ void jq_yyfree (void * ,yyscan_t yyscanner );
 
 /* Begin user sect3 */
 
-#define jq_yywrap(yyscanner) 1
+#define jq_yywrap(n) 1
 #define YY_SKIP_YYWRAP
 
 #define yytext_ptr yytext_r
@@ -264,7 +272,7 @@ FILE *jq_yyget_out (yyscan_t yyscanner );
 
 void jq_yyset_out  (FILE * out_str ,yyscan_t yyscanner );
 
-yy_size_t jq_yyget_leng (yyscan_t yyscanner );
+int jq_yyget_leng (yyscan_t yyscanner );
 
 char *jq_yyget_text (yyscan_t yyscanner );
 
@@ -272,10 +280,6 @@ int jq_yyget_lineno (yyscan_t yyscanner );
 
 void jq_yyset_lineno (int line_number ,yyscan_t yyscanner );
 
-int jq_yyget_column  (yyscan_t yyscanner );
-
-void jq_yyset_column (int column_no ,yyscan_t yyscanner );
-
 YYSTYPE * jq_yyget_lval (yyscan_t yyscanner );
 
 void jq_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
@@ -310,7 +314,12 @@ static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
 
 /* Amount of stuff to slurp up with each read. */
 #ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
 #define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
 #endif
 
 /* Number of entries by which start-condition stack grows. */
@@ -348,6 +357,6 @@ extern int jq_yylex \
 #line 110 "lexer.l"
 
 
-#line 352 "lexer.gen.h"
+#line 361 "lexer.gen.h"
 #undef jq_yyIN_HEADER
 #endif /* jq_yyHEADER_H */
diff --git a/parser.gen.c b/parser.gen.c
index 32a2a205..4abc81e7 100644
--- a/parser.gen.c
+++ b/parser.gen.c
@@ -1,8 +1,8 @@
-/* A Bison parser, made by GNU Bison 2.6.2.  */
+/* A Bison parser, made by GNU Bison 2.5.  */
 
 /* Bison implementation for Yacc-like parsers in C
    
-      Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc.
+      Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -44,7 +44,7 @@
 #define YYBISON 1
 
 /* Bison version.  */
-#define YYBISON_VERSION "2.6.2"
+#define YYBISON_VERSION "2.5"
 
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"
@@ -58,11 +58,14 @@
 /* Pull parsers.  */
 #define YYPULL 1
 
+/* Using locations.  */
+#define YYLSP_NEEDED 1
 
 
 
 /* Copy the first part of user declarations.  */
-/* Line 336 of yacc.c  */
+
+/* Line 268 of yacc.c  */
 #line 1 "parser.y"
 
 #include <stdio.h>
@@ -72,16 +75,14 @@
 struct lexer_param;
 
 
-/* Line 336 of yacc.c  */
-#line 77 "parser.gen.c"
 
-# ifndef YY_NULL
-#  if defined __cplusplus && 201103L <= __cplusplus
-#   define YY_NULL nullptr
-#  else
-#   define YY_NULL 0
-#  endif
-# endif
+/* Line 268 of yacc.c  */
+#line 81 "parser.gen.c"
+
+/* Enabling traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
 
 /* Enabling verbose error messages.  */
 #ifdef YYERROR_VERBOSE
@@ -91,19 +92,14 @@ struct lexer_param;
 # define YYERROR_VERBOSE 1
 #endif
 
-/* In a future release of Bison, this section will be replaced
-   by #include "parser.gen.h".  */
-#ifndef YY_PARSER_GEN_H
-# define YY_PARSER_GEN_H
-/* Enabling traces.  */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-#if YYDEBUG
-extern int yydebug;
+/* Enabling the token table.  */
+#ifndef YYTOKEN_TABLE
+# define YYTOKEN_TABLE 0
 #endif
+
 /* "%code requires" blocks.  */
-/* Line 350 of yacc.c  */
+
+/* Line 288 of yacc.c  */
 #line 9 "parser.y"
 
 #include "locfile.h"
@@ -120,8 +116,9 @@ extern int yydebug;
   } while (0)
  
 
-/* Line 350 of yacc.c  */
-#line 125 "parser.gen.c"
+
+/* Line 288 of yacc.c  */
+#line 122 "parser.gen.c"
 
 /* Tokens.  */
 #ifndef YYTOKENTYPE
@@ -161,17 +158,20 @@ extern int yydebug;
 #endif
 
 
+
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 typedef union YYSTYPE
 {
-/* Line 350 of yacc.c  */
+
+/* Line 293 of yacc.c  */
 #line 27 "parser.y"
 
   jv literal;
   block blk;
 
 
-/* Line 350 of yacc.c  */
+
+/* Line 293 of yacc.c  */
 #line 176 "parser.gen.c"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
@@ -193,24 +193,9 @@ typedef struct YYLTYPE
 #endif
 
 
-#ifdef YYPARSE_PARAM
-#if defined __STDC__ || defined __cplusplus
-int yyparse (void *YYPARSE_PARAM);
-#else
-int yyparse ();
-#endif
-#else /* ! YYPARSE_PARAM */
-#if defined __STDC__ || defined __cplusplus
-int yyparse (block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr);
-#else
-int yyparse ();
-#endif
-#endif /* ! YYPARSE_PARAM */
-
-#endif /* !YY_PARSER_GEN_H  */
-
 /* Copy the second part of user declarations.  */
-/* Line 353 of yacc.c  */
+
+/* Line 343 of yacc.c  */
 #line 89 "parser.y"
 
 #include "lexer.gen.h"
@@ -303,8 +288,9 @@ static block gen_update(block a, block op, int optype) {
 }
 
 
-/* Line 353 of yacc.c  */
-#line 308 "parser.gen.c"
+
+/* Line 343 of yacc.c  */
+#line 294 "parser.gen.c"
 
 #ifdef short
 # undef short
@@ -410,7 +396,6 @@ YYID (yyi)
 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
 #     ifndef EXIT_SUCCESS
 #      define EXIT_SUCCESS 0
 #     endif
@@ -504,20 +489,20 @@ union yyalloc
 #endif
 
 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
-/* Copy COUNT objects from SRC to DST.  The source and destination do
+/* Copy COUNT objects from FROM to TO.  The source and destination do
    not overlap.  */
 # ifndef YYCOPY
 #  if defined __GNUC__ && 1 < __GNUC__
-#   define YYCOPY(Dst, Src, Count) \
-      __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
+#   define YYCOPY(To, From, Count) \
+      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 #  else
-#   define YYCOPY(Dst, Src, Count)              \
-      do                                        \
-        {                                       \
-          YYSIZE_T yyi;                         \
-          for (yyi = 0; yyi < (Count); yyi++)   \
-            (Dst)[yyi] = (Src)[yyi];            \
-        }                                       \
+#   define YYCOPY(To, From, Count)		\
+      do					\
+	{					\
+	  YYSIZE_T yyi;				\
+	  for (yyi = 0; yyi < (Count); yyi++)	\
+	    (To)[yyi] = (From)[yyi];		\
+	}					\
       while (YYID (0))
 #  endif
 # endif
@@ -586,8 +571,8 @@ static const yytype_uint16 yyprhs[] =
        0,     0,     3,     5,     7,     8,    11,    14,    21,    27,
       31,    35,    39,    43,    47,    51,    55,    59,    63,    67,
       71,    75,    79,    83,    87,    91,    95,    99,   103,   107,
-     111,   115,   119,   121,   123,   127,   133,   142,   143,   146,
-     151,   157,   161,   165,   167,   169,   173,   176,   181,   185,
+     111,   115,   119,   121,   125,   131,   140,   141,   144,   149,
+     155,   159,   163,   165,   167,   171,   174,   179,   183,   185,
      187,   191,   195,   198,   202,   205,   207,   212,   216,   220,
      225,   229,   230,   232,   236,   240,   244,   248,   250,   256
 };
@@ -606,14 +591,14 @@ static const yytype_int8 yyrhs[] =
       39,    53,    -1,    53,    21,    53,    -1,    53,    40,    53,
       -1,    53,    22,    53,    -1,    53,     6,    53,    -1,    53,
        7,    53,    -1,    53,    35,    53,    -1,    53,    36,    53,
-      -1,    53,    24,    53,    -1,    53,    25,    53,    -1,    54,
-      -1,    59,    -1,    26,    56,    30,    -1,    10,     4,    42,
-      53,    31,    -1,    10,     4,    43,     4,    44,    42,    53,
-      31,    -1,    -1,    56,    27,    -1,    56,    28,    53,    29,
-      -1,    14,    53,    12,    53,    57,    -1,    13,    53,    15,
-      -1,    58,    32,    58,    -1,    59,    -1,    45,    -1,    59,
-      45,     4,    -1,    45,     4,    -1,    59,    46,    53,    47,
-      -1,    59,    46,    47,    -1,     5,    -1,    43,    53,    44,
+      -1,    53,    24,    53,    -1,    53,    25,    53,    -1,    59,
+      -1,    26,    56,    30,    -1,    10,     4,    42,    53,    31,
+      -1,    10,     4,    43,     4,    44,    42,    53,    31,    -1,
+      -1,    56,    27,    -1,    56,    28,    53,    29,    -1,    14,
+      53,    12,    53,    57,    -1,    13,    53,    15,    -1,    58,
+      32,    58,    -1,    59,    -1,    45,    -1,    59,    45,     4,
+      -1,    45,     4,    -1,    59,    46,    53,    47,    -1,    59,
+      46,    47,    -1,     5,    -1,    54,    -1,    43,    53,    44,
       -1,    46,    53,    47,    -1,    46,    47,    -1,    48,    60,
       49,    -1,    41,     4,    -1,     4,    -1,     4,    43,    53,
       44,    -1,    43,     1,    44,    -1,    46,     1,    47,    -1,
@@ -630,14 +615,14 @@ static const yytype_uint16 yyrline[] =
        0,   183,   183,   186,   191,   194,   199,   203,   210,   213,
      218,   227,   231,   235,   239,   243,   247,   251,   255,   259,
      263,   267,   271,   275,   279,   283,   287,   291,   295,   299,
-     303,   307,   311,   315,   320,   325,   331,   339,   342,   345,
-     351,   354,   359,   363,   369,   372,   375,   379,   382,   385,
-     388,   391,   394,   397,   402,   406,   410,   420,   421,   422,
-     423,   426,   429,   430,   431,   434,   437,   440,   444,   447
+     303,   307,   311,   316,   321,   327,   335,   338,   341,   347,
+     350,   355,   359,   365,   368,   371,   375,   378,   381,   384,
+     387,   390,   393,   396,   401,   405,   409,   419,   420,   421,
+     422,   425,   428,   429,   430,   433,   436,   439,   443,   446
 };
 #endif
 
-#if YYDEBUG || YYERROR_VERBOSE || 1
+#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 static const char *const yytname[] =
@@ -651,7 +636,7 @@ static const char *const yytname[] =
   "'>'", "'+'", "'-'", "'*'", "'/'", "'$'", "':'", "'('", "')'", "'.'",
   "'['", "']'", "'{'", "'}'", "$accept", "TopLevel", "FuncDefs", "Exp",
   "String", "FuncDef", "QQString", "ElseBody", "ExpD", "Term", "MkDict",
-  "MkDictPair", YY_NULL
+  "MkDictPair", 0
 };
 #endif
 
@@ -674,8 +659,8 @@ static const yytype_uint8 yyr1[] =
        0,    50,    51,    51,    52,    52,    53,    53,    53,    53,
       53,    53,    53,    53,    53,    53,    53,    53,    53,    53,
       53,    53,    53,    53,    53,    53,    53,    53,    53,    53,
-      53,    53,    53,    53,    54,    55,    55,    56,    56,    56,
-      57,    57,    58,    58,    59,    59,    59,    59,    59,    59,
+      53,    53,    53,    54,    55,    55,    56,    56,    56,    57,
+      57,    58,    58,    59,    59,    59,    59,    59,    59,    59,
       59,    59,    59,    59,    59,    59,    59,    59,    59,    59,
       59,    60,    60,    60,    60,    61,    61,    61,    61,    61
 };
@@ -686,8 +671,8 @@ static const yytype_uint8 yyr2[] =
        0,     2,     1,     1,     0,     2,     2,     6,     5,     3,
        3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
        3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-       3,     3,     1,     1,     3,     5,     8,     0,     2,     4,
-       5,     3,     3,     1,     1,     3,     2,     4,     3,     1,
+       3,     3,     1,     3,     5,     8,     0,     2,     4,     5,
+       3,     3,     1,     1,     3,     2,     4,     3,     1,     1,
        3,     3,     2,     3,     2,     1,     4,     3,     3,     4,
        3,     0,     1,     3,     3,     3,     3,     1,     5,     5
 };
@@ -697,21 +682,21 @@ static const yytype_uint8 yyr2[] =
    means the default is an error.  */
 static const yytype_uint8 yydefact[] =
 {
-       4,    55,    49,     0,     0,    37,     0,     0,    44,     0,
-       0,     0,     3,     2,    32,     4,    33,     0,     0,     0,
-       0,     0,    54,     0,     0,    46,     0,    52,     0,     0,
+       4,    55,    48,     0,     0,    36,     0,     0,    43,     0,
+       0,     0,     3,     2,    49,     4,    32,     0,     0,     0,
+       0,     0,    54,     0,     0,    45,     0,    52,     0,     0,
       67,     0,     0,     0,    62,     1,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     5,     6,
-       0,     0,     0,     0,     0,     0,     9,     0,    38,     0,
-      34,    57,    50,    58,    51,     0,    60,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     9,     0,    37,     0,
+      33,    57,    50,    58,    51,     0,    60,     0,     0,     0,
        0,    53,     0,    26,    27,    13,    12,    11,    15,    19,
       21,    23,    25,    14,    30,    31,    16,    17,    10,    28,
-      29,    18,    20,    22,    24,     0,    45,     0,    48,     0,
-      56,     0,     0,     0,     0,     0,    64,    65,    43,     0,
-       0,    66,    63,     0,    59,    47,    35,     0,     0,     0,
-       8,    39,     0,     0,     0,     0,     0,     0,     0,    42,
-      69,    68,     7,     0,    41,     0,    36,     0,    40
+      29,    18,    20,    22,    24,     0,    44,     0,    47,     0,
+      56,     0,     0,     0,     0,     0,    64,    65,    42,     0,
+       0,    66,    63,     0,    59,    46,    34,     0,     0,     0,
+       8,    38,     0,     0,     0,     0,     0,     0,     0,    41,
+      69,    68,     7,     0,    40,     0,    35,     0,    39
 };
 
 /* YYDEFGOTO[NTERM-NUM].  */
@@ -733,13 +718,13 @@ static const yytype_int16 yypact[] =
      175,   175,   175,   175,   175,   175,   175,   175,   175,   175,
      175,   175,   175,   175,   175,   175,   175,   175,   -75,   645,
       22,    71,   101,   365,   175,    72,   -75,   175,   -75,   175,
-     -75,   -75,   -75,   -75,   -75,    73,   -75,   146,    34,   400,
-     146,   -75,    73,   785,   785,   715,   791,   765,   740,   740,
+     -75,   -75,   -75,   -75,   -75,    73,   -75,   161,    34,   400,
+     161,   -75,    73,   785,   785,   715,   791,   765,   740,   740,
      740,   740,   740,   740,   785,   785,   680,   715,   740,   785,
      785,   -15,   -15,   -75,   -75,    76,   -75,    37,   -75,   253,
      -75,   470,    41,   435,   505,    48,   -75,    54,   -19,    45,
       49,    54,   -75,    60,   -75,   -75,   -75,    51,   175,   175,
-     -75,   -75,   146,   146,   146,   175,   175,   540,   575,   -75,
+     -75,   -75,   161,   161,   161,   175,   175,   540,   575,   -75,
       54,    54,   680,   610,   -75,   175,   -75,   435,   -75
 };
 
@@ -771,12 +756,12 @@ static const yytype_int16 yytable[] =
        0,     7,   -61,     8,     9,    27,    10,     5,   137,   138,
       23,     0,     0,     1,     2,   142,   143,     0,     0,     3,
        4,     0,     6,     0,     7,   147,     8,     9,   108,    10,
-       1,     2,     0,    78,     0,     5,     1,     2,     0,     0,
-       0,     0,     3,     4,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    78,     0,     5,     1,     2,     0,     0,
+       0,     0,     3,     4,     0,     1,     2,     0,     0,     0,
        6,     0,     7,     0,     8,     9,     0,    10,     5,     1,
-       2,     0,     0,     0,     0,     3,     4,     6,     0,     7,
-       0,     8,     9,     6,    10,     7,     0,     8,     9,     0,
-      10,     5,     0,     0,     0,     0,     0,     0,     0,     0,
+       2,     0,     0,     0,     0,     3,     4,     5,     0,     0,
+       0,     0,     0,     6,     0,     7,     0,     8,     9,     0,
+      10,     5,     6,     0,     7,     0,     8,     9,     0,    10,
        0,     0,     0,     0,     0,     0,     6,     0,     7,     0,
        8,     9,     0,    10,    36,    37,    38,     0,     0,     0,
        0,     0,     0,     0,    39,    40,    41,    42,    43,    44,
@@ -865,12 +850,12 @@ static const yytype_int16 yycheck[] =
       -1,    43,    49,    45,    46,    47,    48,    26,   128,   129,
        1,    -1,    -1,     4,     5,   135,   136,    -1,    -1,    10,
       11,    -1,    41,    -1,    43,   145,    45,    46,    47,    48,
-       4,     5,    -1,     1,    -1,    26,     4,     5,    -1,    -1,
-      -1,    -1,    10,    11,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,     1,    -1,    26,     4,     5,    -1,    -1,
+      -1,    -1,    10,    11,    -1,     4,     5,    -1,    -1,    -1,
       41,    -1,    43,    -1,    45,    46,    -1,    48,    26,     4,
-       5,    -1,    -1,    -1,    -1,    10,    11,    41,    -1,    43,
-      -1,    45,    46,    41,    48,    43,    -1,    45,    46,    -1,
-      48,    26,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+       5,    -1,    -1,    -1,    -1,    10,    11,    26,    -1,    -1,
+      -1,    -1,    -1,    41,    -1,    43,    -1,    45,    46,    -1,
+      48,    26,    41,    -1,    43,    -1,    45,    46,    -1,    48,
       -1,    -1,    -1,    -1,    -1,    -1,    41,    -1,    43,    -1,
       45,    46,    -1,    48,     6,     7,     8,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    16,    17,    18,    19,    20,    21,
@@ -984,18 +969,17 @@ static const yytype_uint8 yystos[] =
 
 #define YYRECOVERING()  (!!yyerrstatus)
 
-#define YYBACKUP(Token, Value)                                  \
-do                                                              \
-  if (yychar == YYEMPTY)                                        \
-    {                                                           \
-      yychar = (Token);                                         \
-      yylval = (Value);                                         \
-      YYPOPSTACK (yylen);                                       \
-      yystate = *yyssp;                                         \
-      goto yybackup;                                            \
-    }                                                           \
-  else                                                          \
-    {                                                           \
+#define YYBACKUP(Token, Value)					\
+do								\
+  if (yychar == YYEMPTY && yylen == 1)				\
+    {								\
+      yychar = (Token);						\
+      yylval = (Value);						\
+      YYPOPSTACK (1);						\
+      goto yybackup;						\
+    }								\
+  else								\
+    {								\
       yyerror (&yylloc, answer, errors, locations, lexer_param_ptr, YY_("syntax error: cannot back up")); \
       YYERROR;							\
     }								\
@@ -1005,33 +989,32 @@ while (YYID (0))
 #define YYTERROR	1
 #define YYERRCODE	256
 
+
 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
    If N is 0, then set CURRENT to the empty location which ends
    the previous symbol: RHS[0] (always defined).  */
 
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])
 #ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
-    do                                                                  \
-      if (YYID (N))                                                     \
-        {                                                               \
-          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
-          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
-          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
-          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
-        }                                                               \
-      else                                                              \
-        {                                                               \
-          (Current).first_line   = (Current).last_line   =              \
-            YYRHSLOC (Rhs, 0).last_line;                                \
-          (Current).first_column = (Current).last_column =              \
-            YYRHSLOC (Rhs, 0).last_column;                              \
-        }                                                               \
+# define YYLLOC_DEFAULT(Current, Rhs, N)				\
+    do									\
+      if (YYID (N))                                                    \
+	{								\
+	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
+	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
+	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
+	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
+	}								\
+      else								\
+	{								\
+	  (Current).first_line   = (Current).last_line   =		\
+	    YYRHSLOC (Rhs, 0).last_line;				\
+	  (Current).first_column = (Current).last_column =		\
+	    YYRHSLOC (Rhs, 0).last_column;				\
+	}								\
     while (YYID (0))
 #endif
 
-#define YYRHSLOC(Rhs, K) ((Rhs)[K])
-
-
 
 /* YY_LOCATION_PRINT -- Print the location on the stream.
    This macro was not mandated originally: define only if we know
@@ -1105,8 +1088,6 @@ yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors,
     struct lexer_param* lexer_param_ptr;
 #endif
 {
-  FILE *yyo = yyoutput;
-  YYUSE (yyo);
   if (!yyvaluep)
     return;
   YYUSE (yylocationp);
@@ -1375,12 +1356,12 @@ static int
 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
                 yytype_int16 *yyssp, int yytoken)
 {
-  YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
+  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
   YYSIZE_T yysize = yysize0;
   YYSIZE_T yysize1;
   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
   /* Internationalized format string. */
-  const char *yyformat = YY_NULL;
+  const char *yyformat = 0;
   /* Arguments of yyformat. */
   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
   /* Number of reported tokens (one for the "unexpected", one per
@@ -1440,7 +1421,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
                     break;
                   }
                 yyarg[yycount++] = yytname[yyx];
-                yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
+                yysize1 = yysize + yytnamerr (0, yytname[yyx]);
                 if (! (yysize <= yysize1
                        && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
                   return 2;
@@ -1535,96 +1516,122 @@ yydestruct (yymsg, yytype, yyvaluep, yylocationp, answer, errors, locations, lex
 
   switch (yytype)
     {
-      case 4: /* IDENT */
-/* Line 1381 of yacc.c  */
+      case 4: /* "IDENT" */
+
+/* Line 1391 of yacc.c  */
 #line 32 "parser.y"
-	{ jv_free(((*yyvaluep).literal)); };
-/* Line 1381 of yacc.c  */
-#line 1544 "parser.gen.c"
+	{ jv_free((yyvaluep->literal)); };
+
+/* Line 1391 of yacc.c  */
+#line 1527 "parser.gen.c"
 	break;
-      case 5: /* LITERAL */
-/* Line 1381 of yacc.c  */
+      case 5: /* "LITERAL" */
+
+/* Line 1391 of yacc.c  */
 #line 32 "parser.y"
-	{ jv_free(((*yyvaluep).literal)); };
-/* Line 1381 of yacc.c  */
-#line 1551 "parser.gen.c"
+	{ jv_free((yyvaluep->literal)); };
+
+/* Line 1391 of yacc.c  */
+#line 1536 "parser.gen.c"
 	break;
-      case 27: /* QQSTRING_TEXT */
-/* Line 1381 of yacc.c  */
+      case 27: /* "QQSTRING_TEXT" */
+
+/* Line 1391 of yacc.c  */
 #line 32 "parser.y"
-	{ jv_free(((*yyvaluep).literal)); };
-/* Line 1381 of yacc.c  */
-#line 1558 "parser.gen.c"
+	{ jv_free((yyvaluep->literal)); };
+
+/* Line 1391 of yacc.c  */
+#line 1545 "parser.gen.c"
 	break;
-      case 52: /* FuncDefs */
-/* Line 1381 of yacc.c  */
+      case 52: /* "FuncDefs" */
+
+/* Line 1391 of yacc.c  */
 #line 33 "parser.y"
-	{ block_free(((*yyvaluep).blk)); };
-/* Line 1381 of yacc.c  */
-#line 1565 "parser.gen.c"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1554 "parser.gen.c"
 	break;
-      case 53: /* Exp */
-/* Line 1381 of yacc.c  */
+      case 53: /* "Exp" */
+
+/* Line 1391 of yacc.c  */
 #line 33 "parser.y"
-	{ block_free(((*yyvaluep).blk)); };
-/* Line 1381 of yacc.c  */
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1563 "parser.gen.c"
+	break;
+      case 54: /* "String" */
+
+/* Line 1391 of yacc.c  */
+#line 33 "parser.y"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
 #line 1572 "parser.gen.c"
 	break;
-      case 54: /* String */
-/* Line 1381 of yacc.c  */
+      case 55: /* "FuncDef" */
+
+/* Line 1391 of yacc.c  */
 #line 33 "parser.y"
-	{ block_free(((*yyvaluep).blk)); };
-/* Line 1381 of yacc.c  */
-#line 1579 "parser.gen.c"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1581 "parser.gen.c"
 	break;
-      case 55: /* FuncDef */
-/* Line 1381 of yacc.c  */
+      case 56: /* "QQString" */
+
+/* Line 1391 of yacc.c  */
 #line 33 "parser.y"
-	{ block_free(((*yyvaluep).blk)); };
-/* Line 1381 of yacc.c  */
-#line 1586 "parser.gen.c"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1590 "parser.gen.c"
 	break;
-      case 56: /* QQString */
-/* Line 1381 of yacc.c  */
+      case 57: /* "ElseBody" */
+
+/* Line 1391 of yacc.c  */
 #line 33 "parser.y"
-	{ block_free(((*yyvaluep).blk)); };
-/* Line 1381 of yacc.c  */
-#line 1593 "parser.gen.c"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1599 "parser.gen.c"
 	break;
-      case 57: /* ElseBody */
-/* Line 1381 of yacc.c  */
+      case 58: /* "ExpD" */
+
+/* Line 1391 of yacc.c  */
 #line 33 "parser.y"
-	{ block_free(((*yyvaluep).blk)); };
-/* Line 1381 of yacc.c  */
-#line 1600 "parser.gen.c"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1608 "parser.gen.c"
 	break;
-      case 58: /* ExpD */
-/* Line 1381 of yacc.c  */
+      case 59: /* "Term" */
+
+/* Line 1391 of yacc.c  */
 #line 33 "parser.y"
-	{ block_free(((*yyvaluep).blk)); };
-/* Line 1381 of yacc.c  */
-#line 1607 "parser.gen.c"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1617 "parser.gen.c"
 	break;
-      case 59: /* Term */
-/* Line 1381 of yacc.c  */
+      case 60: /* "MkDict" */
+
+/* Line 1391 of yacc.c  */
 #line 33 "parser.y"
-	{ block_free(((*yyvaluep).blk)); };
-/* Line 1381 of yacc.c  */
-#line 1614 "parser.gen.c"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1626 "parser.gen.c"
 	break;
-      case 60: /* MkDict */
-/* Line 1381 of yacc.c  */
+      case 61: /* "MkDictPair" */
+
+/* Line 1391 of yacc.c  */
 #line 33 "parser.y"
-	{ block_free(((*yyvaluep).blk)); };
-/* Line 1381 of yacc.c  */
-#line 1621 "parser.gen.c"
-	break;
-      case 61: /* MkDictPair */
-/* Line 1381 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free(((*yyvaluep).blk)); };
-/* Line 1381 of yacc.c  */
-#line 1628 "parser.gen.c"
+	{ block_free((yyvaluep->blk)); };
+
+/* Line 1391 of yacc.c  */
+#line 1635 "parser.gen.c"
 	break;
 
       default:
@@ -1633,6 +1640,20 @@ yydestruct (yymsg, yytype, yyvaluep, yylocationp, answer, errors, locations, lex
 }
 
 
+/* Prevent warnings from -Wmissing-prototypes.  */
+#ifdef YYPARSE_PARAM
+#if defined __STDC__ || defined __cplusplus
+int yyparse (void *YYPARSE_PARAM);
+#else
+int yyparse ();
+#endif
+#else /* ! YYPARSE_PARAM */
+#if defined __STDC__ || defined __cplusplus
+int yyparse (block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr);
+#else
+int yyparse ();
+#endif
+#endif /* ! YYPARSE_PARAM */
 
 
 /*----------.
@@ -1685,7 +1706,7 @@ YYLTYPE yylloc;
        `yyvs': related to semantic values.
        `yyls': related to locations.
 
-       Refer to the stacks through separate pointers, to allow yyoverflow
+       Refer to the stacks thru separate pointers, to allow yyoverflow
        to reallocate them elsewhere.  */
 
     /* The state stack.  */
@@ -1756,6 +1777,7 @@ YYLTYPE yylloc;
   yylloc.first_line   = yylloc.last_line   = 1;
   yylloc.first_column = yylloc.last_column = 1;
 #endif
+
   goto yysetstate;
 
 /*------------------------------------------------------------.
@@ -1939,7 +1961,8 @@ yyreduce:
   switch (yyn)
     {
         case 2:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 183 "parser.y"
     {
   *answer = (yyvsp[(1) - (1)].blk);
@@ -1947,7 +1970,8 @@ yyreduce:
     break;
 
   case 3:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 186 "parser.y"
     {
   *answer = (yyvsp[(1) - (1)].blk);
@@ -1955,7 +1979,8 @@ yyreduce:
     break;
 
   case 4:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 191 "parser.y"
     {
   (yyval.blk) = gen_noop();
@@ -1963,7 +1988,8 @@ yyreduce:
     break;
 
   case 5:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 194 "parser.y"
     {
   (yyval.blk) = block_join((yyvsp[(1) - (2)].blk), (yyvsp[(2) - (2)].blk));
@@ -1971,7 +1997,8 @@ yyreduce:
     break;
 
   case 6:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 199 "parser.y"
     {
   (yyval.blk) = block_bind((yyvsp[(1) - (2)].blk), (yyvsp[(2) - (2)].blk), OP_IS_CALL_PSEUDO);
@@ -1979,7 +2006,8 @@ yyreduce:
     break;
 
   case 7:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 203 "parser.y"
     {
   (yyval.blk) = gen_op_simple(DUP);
@@ -1990,7 +2018,8 @@ yyreduce:
     break;
 
   case 8:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 210 "parser.y"
     {
   (yyval.blk) = gen_cond((yyvsp[(2) - (5)].blk), (yyvsp[(4) - (5)].blk), (yyvsp[(5) - (5)].blk));
@@ -1998,7 +2027,8 @@ yyreduce:
     break;
 
   case 9:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 213 "parser.y"
     {
   FAIL((yyloc), "Possibly unterminated 'if' statment");
@@ -2007,7 +2037,8 @@ yyreduce:
     break;
 
   case 10:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 218 "parser.y"
     {
   block assign = gen_op_simple(DUP);
@@ -2020,7 +2051,8 @@ yyreduce:
     break;
 
   case 11:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 227 "parser.y"
     {
   (yyval.blk) = gen_or((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
@@ -2028,7 +2060,8 @@ yyreduce:
     break;
 
   case 12:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 231 "parser.y"
     {
   (yyval.blk) = gen_and((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
@@ -2036,7 +2069,8 @@ yyreduce:
     break;
 
   case 13:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 235 "parser.y"
     {
   (yyval.blk) = gen_definedor((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
@@ -2044,7 +2078,8 @@ yyreduce:
     break;
 
   case 14:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 239 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), gen_definedor(gen_noop(), (yyvsp[(3) - (3)].blk)), 0);
@@ -2052,7 +2087,8 @@ yyreduce:
     break;
 
   case 15:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 243 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), 0);
@@ -2060,7 +2096,8 @@ yyreduce:
     break;
 
   case 16:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 247 "parser.y"
     { 
   (yyval.blk) = block_join((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk)); 
@@ -2068,7 +2105,8 @@ yyreduce:
     break;
 
   case 17:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 251 "parser.y"
     { 
   (yyval.blk) = gen_both((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk)); 
@@ -2076,7 +2114,8 @@ yyreduce:
     break;
 
   case 18:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 255 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '+');
@@ -2084,7 +2123,8 @@ yyreduce:
     break;
 
   case 19:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 259 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '+');
@@ -2092,7 +2132,8 @@ yyreduce:
     break;
 
   case 20:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 263 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '-');
@@ -2100,7 +2141,8 @@ yyreduce:
     break;
 
   case 21:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 267 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '-');
@@ -2108,7 +2150,8 @@ yyreduce:
     break;
 
   case 22:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 271 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '*');
@@ -2116,7 +2159,8 @@ yyreduce:
     break;
 
   case 23:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 275 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '*');
@@ -2124,7 +2168,8 @@ yyreduce:
     break;
 
   case 24:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 279 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '/');
@@ -2132,7 +2177,8 @@ yyreduce:
     break;
 
   case 25:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 283 "parser.y"
     {
   (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '/');
@@ -2140,7 +2186,8 @@ yyreduce:
     break;
 
   case 26:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 287 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), EQ);
@@ -2148,7 +2195,8 @@ yyreduce:
     break;
 
   case 27:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 291 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), NEQ);
@@ -2156,7 +2204,8 @@ yyreduce:
     break;
 
   case 28:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 295 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '<');
@@ -2164,7 +2213,8 @@ yyreduce:
     break;
 
   case 29:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 299 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '>');
@@ -2172,7 +2222,8 @@ yyreduce:
     break;
 
   case 30:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 303 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), LESSEQ);
@@ -2180,7 +2231,8 @@ yyreduce:
     break;
 
   case 31:
-/* Line 1787 of yacc.c  */
+
+/* Line 1806 of yacc.c  */
 #line 307 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), GREATEREQ);
@@ -2188,32 +2240,27 @@ yyreduce:
     break;
 
   case 32:
-/* Line 1787 of yacc.c  */
-#line 311 "parser.y"
-    {
-  (yyval.blk) = (yyvsp[(1) - (1)].blk);
-}
-    break;
 
-  case 33:
-/* Line 1787 of yacc.c  */
-#line 315 "parser.y"
+/* Line 1806 of yacc.c  */
+#line 311 "parser.y"
     { 
   (yyval.blk) = (yyvsp[(1) - (1)].blk); 
 }
     break;
 
-  case 34:
-/* Line 1787 of yacc.c  */
-#line 320 "parser.y"
+  case 33:
+
+/* Line 1806 of yacc.c  */
+#line 316 "parser.y"
     {
   (yyval.blk) = (yyvsp[(2) - (3)].blk);
 }
     break;
 
-  case 35:
-/* Line 1787 of yacc.c  */
-#line 325 "parser.y"
+  case 34:
+
+/* Line 1806 of yacc.c  */
+#line 321 "parser.y"
     {
   block body = block_join((yyvsp[(4) - (5)].blk), gen_op_simple(RET));
   (yyval.blk) = gen_op_block_defn_rec(CLOSURE_CREATE, jv_string_value((yyvsp[(2) - (5)].literal)), body);
@@ -2221,9 +2268,10 @@ yyreduce:
 }
     break;
 
-  case 36:
-/* Line 1787 of yacc.c  */
-#line 331 "parser.y"
+  case 35:
+
+/* Line 1806 of yacc.c  */
+#line 327 "parser.y"
     {
   block body = block_bind(gen_op_block_unbound(CLOSURE_PARAM, jv_string_value((yyvsp[(4) - (8)].literal))), block_join((yyvsp[(7) - (8)].blk), gen_op_simple(RET)), OP_IS_CALL_PSEUDO);
   (yyval.blk) = gen_op_block_defn_rec(CLOSURE_CREATE, jv_string_value((yyvsp[(2) - (8)].literal)), body);
@@ -2232,137 +2280,163 @@ yyreduce:
 }
     break;
 
-  case 37:
-/* Line 1787 of yacc.c  */
-#line 339 "parser.y"
+  case 36:
+
+/* Line 1806 of yacc.c  */
+#line 335 "parser.y"
     {
   (yyval.blk) = gen_op_const(LOADK, jv_string(""));
 }
     break;
 
-  case 38:
-/* Line 1787 of yacc.c  */
-#line 342 "parser.y"
+  case 37:
+
+/* Line 1806 of yacc.c  */
+#line 338 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (2)].blk), gen_op_const(LOADK, (yyvsp[(2) - (2)].literal)), '+');
 }
     break;
 
-  case 39:
-/* Line 1787 of yacc.c  */
-#line 345 "parser.y"
+  case 38:
+
+/* Line 1806 of yacc.c  */
+#line 341 "parser.y"
     {
   (yyval.blk) = gen_binop((yyvsp[(1) - (4)].blk), gen_format((yyvsp[(3) - (4)].blk)), '+');
 }
     break;
 
-  case 40:
-/* Line 1787 of yacc.c  */
-#line 351 "parser.y"
+  case 39:
+
+/* Line 1806 of yacc.c  */
+#line 347 "parser.y"
     {
   (yyval.blk) = gen_cond((yyvsp[(2) - (5)].blk), (yyvsp[(4) - (5)].blk), (yyvsp[(5) - (5)].blk));
 }
     break;
 
-  case 41:
-/* Line 1787 of yacc.c  */
-#line 354 "parser.y"
+  case 40:
+
+/* Line 1806 of yacc.c  */
+#line 350 "parser.y"
     {
   (yyval.blk) = (yyvsp[(2) - (3)].blk);
 }
     break;
 
-  case 42:
-/* Line 1787 of yacc.c  */
-#line 359 "parser.y"
+  case 41:
+
+/* Line 1806 of yacc.c  */
+#line 355 "parser.y"
     { 
   (yyval.blk) = block_join((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
 }
     break;
 
-  case 43:
-/* Line 1787 of yacc.c  */
-#line 363 "parser.y"
+  case 42:
+
+/* Line 1806 of yacc.c  */
+#line 359 "parser.y"
     {
   (yyval.blk) = (yyvsp[(1) - (1)].blk);
 }
     break;
 
-  case 44:
-/* Line 1787 of yacc.c  */
-#line 369 "parser.y"
+  case 43:
+
+/* Line 1806 of yacc.c  */
+#line 365 "parser.y"
     {
   (yyval.blk) = gen_noop(); 
 }
     break;
 
-  case 45:
-/* Line 1787 of yacc.c  */
-#line 372 "parser.y"
+  case 44:
+
+/* Line 1806 of yacc.c  */
+#line 368 "parser.y"
     {
   (yyval.blk) = gen_index((yyvsp[(1) - (3)].blk), gen_op_const(LOADK, (yyvsp[(3) - (3)].literal))); 
 }
     break;
 
-  case 46:
-/* Line 1787 of yacc.c  */
-#line 375 "parser.y"
+  case 45:
+
+/* Line 1806 of yacc.c  */
+#line 371 "parser.y"
     { 
   (yyval.blk) = gen_index(gen_noop(), gen_op_const(LOADK, (yyvsp[(2) - (2)].literal))); 
 }
     break;
 
-  case 47:
-/* Line 1787 of yacc.c  */
-#line 379 "parser.y"
+  case 46:
+
+/* Line 1806 of yacc.c  */
+#line 375 "parser.y"
     {
   (yyval.blk) = gen_index((yyvsp[(1) - (4)].blk), (yyvsp[(3) - (4)].blk)); 
 }
     break;
 
-  case 48:
-/* Line 1787 of yacc.c  */
-#line 382 "parser.y"
+  case 47:
+
+/* Line 1806 of yacc.c  */
+#line 378 "parser.y"
     {
   (yyval.blk) = block_join((yyvsp[(1) - (3)].blk), gen_op_simple(EACH)); 
 }
     break;
 
-  case 49:
-/* Line 1787 of yacc.c  */
-#line 385 "parser.y"
+  case 48:
+
+/* Line 1806 of yacc.c  */
+#line 381 "parser.y"
     {
   (yyval.blk) = gen_op_const(LOADK, (yyvsp[(1) - (1)].literal)); 
 }
     break;
 
+  case 49:
+
+/* Line 1806 of yacc.c  */
+#line 384 "parser.y"
+    {
+  (yyval.blk) = (yyvsp[(1) - (1)].blk);
+}
+    break;
+
   case 50:
-/* Line 1787 of yacc.c  */
-#line 388 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 387 "parser.y"
     { 
   (yyval.blk) = (yyvsp[(2) - (3)].blk); 
 }
     break;
 
   case 51:
-/* Line 1787 of yacc.c  */
-#line 391 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 390 "parser.y"
     { 
   (yyval.blk) = gen_collect((yyvsp[(2) - (3)].blk)); 
 }
     break;
 
   case 52:
-/* Line 1787 of yacc.c  */
-#line 394 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 393 "parser.y"
     { 
   (yyval.blk) = gen_op_const(LOADK, jv_array()); 
 }
     break;
 
   case 53:
-/* Line 1787 of yacc.c  */
-#line 397 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 396 "parser.y"
     { 
   (yyval.blk) = gen_subexp(gen_op_const(LOADK, jv_object()));
   block_append(&(yyval.blk), (yyvsp[(2) - (3)].blk));
@@ -2371,8 +2445,9 @@ yyreduce:
     break;
 
   case 54:
-/* Line 1787 of yacc.c  */
-#line 402 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 401 "parser.y"
     {
   (yyval.blk) = gen_location((yyloc), gen_op_var_unbound(LOADV, jv_string_value((yyvsp[(2) - (2)].literal))));
   jv_free((yyvsp[(2) - (2)].literal));
@@ -2380,8 +2455,9 @@ yyreduce:
     break;
 
   case 55:
-/* Line 1787 of yacc.c  */
-#line 406 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 405 "parser.y"
     {
   (yyval.blk) = gen_location((yyloc), gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, jv_string_value((yyvsp[(1) - (1)].literal)))));
   jv_free((yyvsp[(1) - (1)].literal));
@@ -2389,8 +2465,9 @@ yyreduce:
     break;
 
   case 56:
-/* Line 1787 of yacc.c  */
-#line 410 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 409 "parser.y"
     {
   (yyval.blk) = gen_op_call(CALL_1_1, 
                    block_join(gen_op_block_unbound(CLOSURE_REF, jv_string_value((yyvsp[(1) - (4)].literal))),
@@ -2404,74 +2481,85 @@ yyreduce:
     break;
 
   case 57:
-/* Line 1787 of yacc.c  */
-#line 420 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 419 "parser.y"
     { (yyval.blk) = gen_noop(); }
     break;
 
   case 58:
-/* Line 1787 of yacc.c  */
-#line 421 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 420 "parser.y"
     { (yyval.blk) = gen_noop(); }
     break;
 
   case 59:
-/* Line 1787 of yacc.c  */
-#line 422 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 421 "parser.y"
     { (yyval.blk) = (yyvsp[(1) - (4)].blk); }
     break;
 
   case 60:
-/* Line 1787 of yacc.c  */
-#line 423 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 422 "parser.y"
     { (yyval.blk) = gen_noop(); }
     break;
 
   case 61:
-/* Line 1787 of yacc.c  */
-#line 426 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 425 "parser.y"
     { 
   (yyval.blk)=gen_noop(); 
 }
     break;
 
   case 62:
-/* Line 1787 of yacc.c  */
-#line 429 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 428 "parser.y"
     { (yyval.blk) = (yyvsp[(1) - (1)].blk); }
     break;
 
   case 63:
-/* Line 1787 of yacc.c  */
-#line 430 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 429 "parser.y"
     { (yyval.blk)=block_join((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk)); }
     break;
 
   case 64:
-/* Line 1787 of yacc.c  */
-#line 431 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 430 "parser.y"
     { (yyval.blk) = (yyvsp[(3) - (3)].blk); }
     break;
 
   case 65:
-/* Line 1787 of yacc.c  */
-#line 434 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 433 "parser.y"
     { 
   (yyval.blk) = gen_dictpair(gen_op_const(LOADK, (yyvsp[(1) - (3)].literal)), (yyvsp[(3) - (3)].blk));
  }
     break;
 
   case 66:
-/* Line 1787 of yacc.c  */
-#line 437 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 436 "parser.y"
     {
   (yyval.blk) = gen_dictpair((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
   }
     break;
 
   case 67:
-/* Line 1787 of yacc.c  */
-#line 440 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 439 "parser.y"
     {
   (yyval.blk) = gen_dictpair(gen_op_const(LOADK, jv_copy((yyvsp[(1) - (1)].literal))),
                     gen_index(gen_noop(), gen_op_const(LOADK, (yyvsp[(1) - (1)].literal))));
@@ -2479,22 +2567,25 @@ yyreduce:
     break;
 
   case 68:
-/* Line 1787 of yacc.c  */
-#line 444 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 443 "parser.y"
     {
   (yyval.blk) = gen_dictpair((yyvsp[(2) - (5)].blk), (yyvsp[(5) - (5)].blk));
   }
     break;
 
   case 69:
-/* Line 1787 of yacc.c  */
-#line 447 "parser.y"
+
+/* Line 1806 of yacc.c  */
+#line 446 "parser.y"
     { (yyval.blk) = (yyvsp[(5) - (5)].blk); }
     break;
 
 
-/* Line 1787 of yacc.c  */
-#line 2498 "parser.gen.c"
+
+/* Line 1806 of yacc.c  */
+#line 2589 "parser.gen.c"
       default: break;
     }
   /* User semantic actions sometimes alter yychar, and that requires
@@ -2688,7 +2779,7 @@ yyabortlab:
   yyresult = 1;
   goto yyreturn;
 
-#if !defined yyoverflow || YYERROR_VERBOSE
+#if !defined(yyoverflow) || YYERROR_VERBOSE
 /*-------------------------------------------------.
 | yyexhaustedlab -- memory exhaustion comes here.  |
 `-------------------------------------------------*/
@@ -2730,8 +2821,9 @@ yyreturn:
 }
 
 
-/* Line 2048 of yacc.c  */
-#line 448 "parser.y"
+
+/* Line 2067 of yacc.c  */
+#line 447 "parser.y"
 
 
 int jq_parse(struct locfile* locations, block* answer) {
@@ -2760,3 +2852,4 @@ int jq_parse_library(struct locfile* locations, block* answer) {
   }
   return 0;
 }
+
diff --git a/parser.gen.h b/parser.gen.h
index 0e5c8007..f5471c26 100644
--- a/parser.gen.h
+++ b/parser.gen.h
@@ -1,8 +1,8 @@
-/* A Bison parser, made by GNU Bison 2.6.2.  */
+/* A Bison parser, made by GNU Bison 2.5.  */
 
 /* Bison interface for Yacc-like parsers in C
    
-      Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc.
+      Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -30,17 +30,9 @@
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 
-#ifndef YY_PARSER_GEN_H
-# define YY_PARSER_GEN_H
-/* Enabling traces.  */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-#if YYDEBUG
-extern int yydebug;
-#endif
 /* "%code requires" blocks.  */
-/* Line 2049 of yacc.c  */
+
+/* Line 2068 of yacc.c  */
 #line 9 "parser.y"
 
 #include "locfile.h"
@@ -57,8 +49,9 @@ extern int yydebug;
   } while (0)
  
 
-/* Line 2049 of yacc.c  */
-#line 62 "parser.gen.h"
+
+/* Line 2068 of yacc.c  */
+#line 55 "parser.gen.h"
 
 /* Tokens.  */
 #ifndef YYTOKENTYPE
@@ -98,24 +91,29 @@ extern int yydebug;
 #endif
 
 
+
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 typedef union YYSTYPE
 {
-/* Line 2049 of yacc.c  */
+
+/* Line 2068 of yacc.c  */
 #line 27 "parser.y"
 
   jv literal;
   block blk;
 
 
-/* Line 2049 of yacc.c  */
-#line 113 "parser.gen.h"
+
+/* Line 2068 of yacc.c  */
+#line 109 "parser.gen.h"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 # define YYSTYPE_IS_DECLARED 1
 #endif
 
+
+
 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
 typedef struct YYLTYPE
 {
@@ -130,18 +128,4 @@ typedef struct YYLTYPE
 #endif
 
 
-#ifdef YYPARSE_PARAM
-#if defined __STDC__ || defined __cplusplus
-int yyparse (void *YYPARSE_PARAM);
-#else
-int yyparse ();
-#endif
-#else /* ! YYPARSE_PARAM */
-#if defined __STDC__ || defined __cplusplus
-int yyparse (block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr);
-#else
-int yyparse ();
-#endif
-#endif /* ! YYPARSE_PARAM */
 
-#endif /* !YY_PARSER_GEN_H  */
diff --git a/parser.gen.info b/parser.gen.info
index d2fb1fdf..4a90d13c 100644
--- a/parser.gen.info
+++ b/parser.gen.info
@@ -1,16 +1,16 @@
-Terminaux inutilisés dans la grammaire
+Terminals unused in grammar
 
    INVALID_CHARACTER
 
 
-Grammaire
+Grammar
 
     0 $accept: TopLevel $end
 
     1 TopLevel: Exp
     2         | FuncDefs
 
-    3 FuncDefs: /* vide */
+    3 FuncDefs: /* empty */
     4         | FuncDef FuncDefs
 
     5 Exp: FuncDef Exp
@@ -39,30 +39,30 @@ Grammaire
    28    | Exp '>' Exp
    29    | Exp "<=" Exp
    30    | Exp ">=" Exp
-   31    | String
-   32    | Term
+   31    | Term
 
-   33 String: QQSTRING_START QQString QQSTRING_END
+   32 String: QQSTRING_START QQString QQSTRING_END
 
-   34 FuncDef: "def" IDENT ':' Exp ';'
-   35        | "def" IDENT '(' IDENT ')' ':' Exp ';'
+   33 FuncDef: "def" IDENT ':' Exp ';'
+   34        | "def" IDENT '(' IDENT ')' ':' Exp ';'
 
-   36 QQString: /* vide */
-   37         | QQString QQSTRING_TEXT
-   38         | QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END
+   35 QQString: /* empty */
+   36         | QQString QQSTRING_TEXT
+   37         | QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END
 
-   39 ElseBody: "elif" Exp "then" Exp ElseBody
-   40         | "else" Exp "end"
+   38 ElseBody: "elif" Exp "then" Exp ElseBody
+   39         | "else" Exp "end"
 
-   41 ExpD: ExpD '|' ExpD
-   42     | Term
+   40 ExpD: ExpD '|' ExpD
+   41     | Term
 
-   43 Term: '.'
-   44     | Term '.' IDENT
-   45     | '.' IDENT
-   46     | Term '[' Exp ']'
-   47     | Term '[' ']'
-   48     | LITERAL
+   42 Term: '.'
+   43     | Term '.' IDENT
+   44     | '.' IDENT
+   45     | Term '[' Exp ']'
+   46     | Term '[' ']'
+   47     | LITERAL
+   48     | String
    49     | '(' Exp ')'
    50     | '[' Exp ']'
    51     | '[' ']'
@@ -75,7 +75,7 @@ Grammaire
    58     | Term '[' error ']'
    59     | '{' error '}'
 
-   60 MkDict: /* vide */
+   60 MkDict: /* empty */
    61       | MkDictPair
    62       | MkDictPair ',' MkDict
    63       | error ',' MkDict
@@ -87,42 +87,42 @@ Grammaire
    68           | '(' error ')' ':' ExpD
 
 
-Terminaux, suivis des règles où ils apparaissent
+Terminals, with rules where they appear
 
 $end (0) 0
 '$' (36) 6 53
-'(' (40) 35 49 55 56 67 68
-')' (41) 35 49 55 56 67 68
+'(' (40) 34 49 55 56 67 68
+')' (41) 34 49 55 56 67 68
 '*' (42) 21
 '+' (43) 17
 ',' (44) 16 62 63
 '-' (45) 19
-'.' (46) 43 44 45
+'.' (46) 42 43 44
 '/' (47) 23
-':' (58) 34 35 64 65 67 68
-';' (59) 34 35
+':' (58) 33 34 64 65 67 68
+';' (59) 33 34
 '<' (60) 27
 '=' (61) 9
 '>' (62) 28
-'[' (91) 46 47 50 51 57 58
-']' (93) 46 47 50 51 57 58
+'[' (91) 45 46 50 51 57 58
+']' (93) 45 46 50 51 57 58
 '{' (123) 52 59
-'|' (124) 6 15 41
+'|' (124) 6 15 40
 '}' (125) 52 59
 error (256) 8 56 57 58 59 63 68
 INVALID_CHARACTER (258)
-IDENT (259) 6 34 35 44 45 53 54 55 64 66
-LITERAL (260) 48
+IDENT (259) 6 33 34 43 44 53 54 55 64 66
+LITERAL (260) 47
 "==" (261) 25
 "!=" (262) 26
 "//" (263) 12
 "as" (264) 6
-"def" (265) 34 35
+"def" (265) 33 34
 "if" (266) 7 8
-"then" (267) 7 39
-"else" (268) 40
-"elif" (269) 39
-"end" (270) 40
+"then" (267) 7 38
+"else" (268) 39
+"elif" (269) 38
+"end" (270) 39
 "and" (271) 11
 "or" (272) 10
 "|=" (273) 14
@@ -133,223 +133,223 @@ LITERAL (260) 48
 "//=" (278) 13
 "<=" (279) 29
 ">=" (280) 30
-QQSTRING_START (281) 33
-QQSTRING_TEXT (282) 37
-QQSTRING_INTERP_START (283) 38
-QQSTRING_INTERP_END (284) 38
-QQSTRING_END (285) 33
+QQSTRING_START (281) 32
+QQSTRING_TEXT (282) 36
+QQSTRING_INTERP_START (283) 37
+QQSTRING_INTERP_END (284) 37
+QQSTRING_END (285) 32
 
 
-Non-terminaux, suivis des règles où ils apparaissent
+Nonterminals, with rules where they appear
 
 $accept (50)
-    à gauche: 0
+    on left: 0
 TopLevel (51)
-    à gauche: 1 2, à droite: 0
+    on left: 1 2, on right: 0
 FuncDefs (52)
-    à gauche: 3 4, à droite: 2 4
+    on left: 3 4, on right: 2 4
 Exp (53)
-    à gauche: 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
-    24 25 26 27 28 29 30 31 32, à droite: 1 5 6 7 8 9 10 11 12 13
-    14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 34 35 38 39
-    40 46 49 50 55 67
+    on left: 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
+    25 26 27 28 29 30 31, on right: 1 5 6 7 8 9 10 11 12 13 14 15 16
+    17 18 19 20 21 22 23 24 25 26 27 28 29 30 33 34 37 38 39 45 49
+    50 55 67
 String (54)
-    à gauche: 33, à droite: 31 65
+    on left: 32, on right: 48 65
 FuncDef (55)
-    à gauche: 34 35, à droite: 4 5
+    on left: 33 34, on right: 4 5
 QQString (56)
-    à gauche: 36 37 38, à droite: 33 37 38
+    on left: 35 36 37, on right: 32 36 37
 ElseBody (57)
-    à gauche: 39 40, à droite: 7 39
+    on left: 38 39, on right: 7 38
 ExpD (58)
-    à gauche: 41 42, à droite: 41 64 65 67 68
+    on left: 40 41, on right: 40 64 65 67 68
 Term (59)
-    à gauche: 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59,
-    à droite: 6 32 42 44 46 47 58
+    on left: 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59,
+    on right: 6 31 41 43 45 46 58
 MkDict (60)
-    à gauche: 60 61 62 63, à droite: 52 62 63
+    on left: 60 61 62 63, on right: 52 62 63
 MkDictPair (61)
-    à gauche: 64 65 66 67 68, à droite: 61 62
+    on left: 64 65 66 67 68, on right: 61 62
 
 
-état 0
+state 0
 
     0 $accept: . TopLevel $end
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    $défaut  réduction par utilisation de la règle 3 (FuncDefs)
+    $default  reduce using rule 3 (FuncDefs)
 
-    TopLevel  aller à l'état 11
-    FuncDefs  aller à l'état 12
-    Exp       aller à l'état 13
-    String    aller à l'état 14
-    FuncDef   aller à l'état 15
-    Term      aller à l'état 16
+    TopLevel  go to state 11
+    FuncDefs  go to state 12
+    Exp       go to state 13
+    String    go to state 14
+    FuncDef   go to state 15
+    Term      go to state 16
 
 
-état 1
+state 1
 
    54 Term: IDENT .
    55     | IDENT . '(' Exp ')'
 
-    '('  décalage et aller à l'état 17
+    '('  shift, and go to state 17
 
-    $défaut  réduction par utilisation de la règle 54 (Term)
+    $default  reduce using rule 54 (Term)
 
 
-état 2
+state 2
 
-   48 Term: LITERAL .
+   47 Term: LITERAL .
 
-    $défaut  réduction par utilisation de la règle 48 (Term)
+    $default  reduce using rule 47 (Term)
 
 
-état 3
+state 3
 
-   34 FuncDef: "def" . IDENT ':' Exp ';'
-   35        | "def" . IDENT '(' IDENT ')' ':' Exp ';'
+   33 FuncDef: "def" . IDENT ':' Exp ';'
+   34        | "def" . IDENT '(' IDENT ')' ':' Exp ';'
 
-    IDENT  décalage et aller à l'état 18
+    IDENT  shift, and go to state 18
 
 
-état 4
+state 4
 
     7 Exp: "if" . Exp "then" Exp ElseBody
     8    | "if" . Exp error
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 19
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 19
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 5
+state 5
 
-   33 String: QQSTRING_START . QQString QQSTRING_END
+   32 String: QQSTRING_START . QQString QQSTRING_END
 
-    $défaut  réduction par utilisation de la règle 36 (QQString)
+    $default  reduce using rule 35 (QQString)
 
-    QQString  aller à l'état 21
+    QQString  go to state 21
 
 
-état 6
+state 6
 
    53 Term: '$' . IDENT
 
-    IDENT  décalage et aller à l'état 22
+    IDENT  shift, and go to state 22
 
 
-état 7
+state 7
 
    49 Term: '(' . Exp ')'
    56     | '(' . error ')'
 
-    error           décalage et aller à l'état 23
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    error           shift, and go to state 23
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 24
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 24
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 8
+state 8
 
-   43 Term: '.' .
-   45     | '.' . IDENT
+   42 Term: '.' .
+   44     | '.' . IDENT
 
-    IDENT  décalage et aller à l'état 25
+    IDENT  shift, and go to state 25
 
-    $défaut  réduction par utilisation de la règle 43 (Term)
+    $default  reduce using rule 42 (Term)
 
 
-état 9
+state 9
 
    50 Term: '[' . Exp ']'
    51     | '[' . ']'
    57     | '[' . error ']'
 
-    error           décalage et aller à l'état 26
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    ']'             décalage et aller à l'état 27
-    '{'             décalage et aller à l'état 10
+    error           shift, and go to state 26
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    ']'             shift, and go to state 27
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 28
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 28
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 10
+state 10
 
    52 Term: '{' . MkDict '}'
    59     | '{' . error '}'
 
-    error           décalage et aller à l'état 29
-    IDENT           décalage et aller à l'état 30
-    QQSTRING_START  décalage et aller à l'état 5
-    '('             décalage et aller à l'état 31
+    error           shift, and go to state 29
+    IDENT           shift, and go to state 30
+    QQSTRING_START  shift, and go to state 5
+    '('             shift, and go to state 31
 
-    '}'  réduction par utilisation de la règle 60 (MkDict)
+    '}'  reduce using rule 60 (MkDict)
 
-    String      aller à l'état 32
-    MkDict      aller à l'état 33
-    MkDictPair  aller à l'état 34
+    String      go to state 32
+    MkDict      go to state 33
+    MkDictPair  go to state 34
 
 
-état 11
+state 11
 
     0 $accept: TopLevel . $end
 
-    $end  décalage et aller à l'état 35
+    $end  shift, and go to state 35
 
 
-état 12
+state 12
 
     2 TopLevel: FuncDefs .
 
-    $défaut  réduction par utilisation de la règle 2 (TopLevel)
+    $default  reduce using rule 2 (TopLevel)
 
 
-état 13
+state 13
 
     1 TopLevel: Exp .
     9 Exp: Exp . '=' Exp
@@ -375,111 +375,111 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '|'    décalage et aller à l'état 49
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "//"   shift, and go to state 38
+    "and"  shift, and go to state 39
+    "or"   shift, and go to state 40
+    "|="   shift, and go to state 41
+    "+="   shift, and go to state 42
+    "-="   shift, and go to state 43
+    "*="   shift, and go to state 44
+    "/="   shift, and go to state 45
+    "//="  shift, and go to state 46
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    '|'    shift, and go to state 49
+    ','    shift, and go to state 50
+    '='    shift, and go to state 51
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
 
-    $défaut  réduction par utilisation de la règle 1 (TopLevel)
+    $default  reduce using rule 1 (TopLevel)
 
 
-état 14
+state 14
 
-   31 Exp: String .
+   48 Term: String .
 
-    $défaut  réduction par utilisation de la règle 31 (Exp)
+    $default  reduce using rule 48 (Term)
 
 
-état 15
+state 15
 
     4 FuncDefs: FuncDef . FuncDefs
     5 Exp: FuncDef . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    $défaut  réduction par utilisation de la règle 3 (FuncDefs)
+    $default  reduce using rule 3 (FuncDefs)
 
-    FuncDefs  aller à l'état 58
-    Exp       aller à l'état 59
-    String    aller à l'état 14
-    FuncDef   aller à l'état 15
-    Term      aller à l'état 16
+    FuncDefs  go to state 58
+    Exp       go to state 59
+    String    go to state 14
+    FuncDef   go to state 15
+    Term      go to state 16
 
 
-état 16
+state 16
 
     6 Exp: Term . "as" '$' IDENT '|' Exp
-   32    | Term .
-   44 Term: Term . '.' IDENT
-   46     | Term . '[' Exp ']'
-   47     | Term . '[' ']'
+   31    | Term .
+   43 Term: Term . '.' IDENT
+   45     | Term . '[' Exp ']'
+   46     | Term . '[' ']'
    58     | Term . '[' error ']'
 
-    "as"  décalage et aller à l'état 60
-    '.'   décalage et aller à l'état 61
-    '['   décalage et aller à l'état 62
+    "as"  shift, and go to state 60
+    '.'   shift, and go to state 61
+    '['   shift, and go to state 62
 
-    $défaut  réduction par utilisation de la règle 32 (Exp)
+    $default  reduce using rule 31 (Exp)
 
 
-état 17
+state 17
 
    55 Term: IDENT '(' . Exp ')'
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 63
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 63
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 18
+state 18
 
-   34 FuncDef: "def" IDENT . ':' Exp ';'
-   35        | "def" IDENT . '(' IDENT ')' ':' Exp ';'
+   33 FuncDef: "def" IDENT . ':' Exp ';'
+   34        | "def" IDENT . '(' IDENT ')' ':' Exp ';'
 
-    ':'  décalage et aller à l'état 64
-    '('  décalage et aller à l'état 65
+    ':'  shift, and go to state 64
+    '('  shift, and go to state 65
 
 
-état 19
+state 19
 
     7 Exp: "if" Exp . "then" Exp ElseBody
     8    | "if" Exp . error
@@ -506,79 +506,79 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    error   décalage et aller à l'état 66
-    "=="    décalage et aller à l'état 36
-    "!="    décalage et aller à l'état 37
-    "//"    décalage et aller à l'état 38
-    "then"  décalage et aller à l'état 67
-    "and"   décalage et aller à l'état 39
-    "or"    décalage et aller à l'état 40
-    "|="    décalage et aller à l'état 41
-    "+="    décalage et aller à l'état 42
-    "-="    décalage et aller à l'état 43
-    "*="    décalage et aller à l'état 44
-    "/="    décalage et aller à l'état 45
-    "//="   décalage et aller à l'état 46
-    "<="    décalage et aller à l'état 47
-    ">="    décalage et aller à l'état 48
-    '|'     décalage et aller à l'état 49
-    ','     décalage et aller à l'état 50
-    '='     décalage et aller à l'état 51
-    '<'     décalage et aller à l'état 52
-    '>'     décalage et aller à l'état 53
-    '+'     décalage et aller à l'état 54
-    '-'     décalage et aller à l'état 55
-    '*'     décalage et aller à l'état 56
-    '/'     décalage et aller à l'état 57
+    error   shift, and go to state 66
+    "=="    shift, and go to state 36
+    "!="    shift, and go to state 37
+    "//"    shift, and go to state 38
+    "then"  shift, and go to state 67
+    "and"   shift, and go to state 39
+    "or"    shift, and go to state 40
+    "|="    shift, and go to state 41
+    "+="    shift, and go to state 42
+    "-="    shift, and go to state 43
+    "*="    shift, and go to state 44
+    "/="    shift, and go to state 45
+    "//="   shift, and go to state 46
+    "<="    shift, and go to state 47
+    ">="    shift, and go to state 48
+    '|'     shift, and go to state 49
+    ','     shift, and go to state 50
+    '='     shift, and go to state 51
+    '<'     shift, and go to state 52
+    '>'     shift, and go to state 53
+    '+'     shift, and go to state 54
+    '-'     shift, and go to state 55
+    '*'     shift, and go to state 56
+    '/'     shift, and go to state 57
 
 
-état 20
+state 20
 
     5 Exp: FuncDef . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 59
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 59
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 21
+state 21
 
-   33 String: QQSTRING_START QQString . QQSTRING_END
-   37 QQString: QQString . QQSTRING_TEXT
-   38         | QQString . QQSTRING_INTERP_START Exp QQSTRING_INTERP_END
+   32 String: QQSTRING_START QQString . QQSTRING_END
+   36 QQString: QQString . QQSTRING_TEXT
+   37         | QQString . QQSTRING_INTERP_START Exp QQSTRING_INTERP_END
 
-    QQSTRING_TEXT          décalage et aller à l'état 68
-    QQSTRING_INTERP_START  décalage et aller à l'état 69
-    QQSTRING_END           décalage et aller à l'état 70
+    QQSTRING_TEXT          shift, and go to state 68
+    QQSTRING_INTERP_START  shift, and go to state 69
+    QQSTRING_END           shift, and go to state 70
 
 
-état 22
+state 22
 
    53 Term: '$' IDENT .
 
-    $défaut  réduction par utilisation de la règle 53 (Term)
+    $default  reduce using rule 53 (Term)
 
 
-état 23
+state 23
 
    56 Term: '(' error . ')'
 
-    ')'  décalage et aller à l'état 71
+    ')'  shift, and go to state 71
 
 
-état 24
+state 24
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -604,53 +604,53 @@ MkDictPair (61)
    30    | Exp . ">=" Exp
    49 Term: '(' Exp . ')'
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '|'    décalage et aller à l'état 49
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
-    ')'    décalage et aller à l'état 72
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "//"   shift, and go to state 38
+    "and"  shift, and go to state 39
+    "or"   shift, and go to state 40
+    "|="   shift, and go to state 41
+    "+="   shift, and go to state 42
+    "-="   shift, and go to state 43
+    "*="   shift, and go to state 44
+    "/="   shift, and go to state 45
+    "//="  shift, and go to state 46
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    '|'    shift, and go to state 49
+    ','    shift, and go to state 50
+    '='    shift, and go to state 51
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
+    ')'    shift, and go to state 72
 
 
-état 25
+state 25
 
-   45 Term: '.' IDENT .
+   44 Term: '.' IDENT .
 
-    $défaut  réduction par utilisation de la règle 45 (Term)
+    $default  reduce using rule 44 (Term)
 
 
-état 26
+state 26
 
    57 Term: '[' error . ']'
 
-    ']'  décalage et aller à l'état 73
+    ']'  shift, and go to state 73
 
 
-état 27
+state 27
 
    51 Term: '[' ']' .
 
-    $défaut  réduction par utilisation de la règle 51 (Term)
+    $default  reduce using rule 51 (Term)
 
 
-état 28
+state 28
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -676,574 +676,574 @@ MkDictPair (61)
    30    | Exp . ">=" Exp
    50 Term: '[' Exp . ']'
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '|'    décalage et aller à l'état 49
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
-    ']'    décalage et aller à l'état 74
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "//"   shift, and go to state 38
+    "and"  shift, and go to state 39
+    "or"   shift, and go to state 40
+    "|="   shift, and go to state 41
+    "+="   shift, and go to state 42
+    "-="   shift, and go to state 43
+    "*="   shift, and go to state 44
+    "/="   shift, and go to state 45
+    "//="  shift, and go to state 46
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    '|'    shift, and go to state 49
+    ','    shift, and go to state 50
+    '='    shift, and go to state 51
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
+    ']'    shift, and go to state 74
 
 
-état 29
+state 29
 
    59 Term: '{' error . '}'
    63 MkDict: error . ',' MkDict
 
-    ','  décalage et aller à l'état 75
-    '}'  décalage et aller à l'état 76
+    ','  shift, and go to state 75
+    '}'  shift, and go to state 76
 
 
-état 30
+state 30
 
    64 MkDictPair: IDENT . ':' ExpD
    66           | IDENT .
 
-    ':'  décalage et aller à l'état 77
+    ':'  shift, and go to state 77
 
-    $défaut  réduction par utilisation de la règle 66 (MkDictPair)
+    $default  reduce using rule 66 (MkDictPair)
 
 
-état 31
+state 31
 
    67 MkDictPair: '(' . Exp ')' ':' ExpD
    68           | '(' . error ')' ':' ExpD
 
-    error           décalage et aller à l'état 78
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    error           shift, and go to state 78
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 79
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 79
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 32
+state 32
 
    65 MkDictPair: String . ':' ExpD
 
-    ':'  décalage et aller à l'état 80
+    ':'  shift, and go to state 80
 
 
-état 33
+state 33
 
    52 Term: '{' MkDict . '}'
 
-    '}'  décalage et aller à l'état 81
+    '}'  shift, and go to state 81
 
 
-état 34
+state 34
 
    61 MkDict: MkDictPair .
    62       | MkDictPair . ',' MkDict
 
-    ','  décalage et aller à l'état 82
+    ','  shift, and go to state 82
 
-    $défaut  réduction par utilisation de la règle 61 (MkDict)
+    $default  reduce using rule 61 (MkDict)
 
 
-état 35
+state 35
 
     0 $accept: TopLevel $end .
 
-    $défaut  accepter
+    $default  accept
 
 
-état 36
+state 36
 
    25 Exp: Exp "==" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 83
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 83
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 37
+state 37
 
    26 Exp: Exp "!=" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 84
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 84
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 38
+state 38
 
    12 Exp: Exp "//" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 85
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 85
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 39
+state 39
 
    11 Exp: Exp "and" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 86
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 86
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 40
+state 40
 
    10 Exp: Exp "or" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 87
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 87
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 41
+state 41
 
    14 Exp: Exp "|=" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 88
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 88
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 42
+state 42
 
    18 Exp: Exp "+=" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 89
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 89
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 43
+state 43
 
    20 Exp: Exp "-=" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 90
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 90
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 44
+state 44
 
    22 Exp: Exp "*=" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 91
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 91
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 45
+state 45
 
    24 Exp: Exp "/=" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 92
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 92
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 46
+state 46
 
    13 Exp: Exp "//=" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 93
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 93
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 47
+state 47
 
    29 Exp: Exp "<=" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 94
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 94
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 48
+state 48
 
    30 Exp: Exp ">=" . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 95
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 95
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 49
+state 49
 
    15 Exp: Exp '|' . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 96
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 96
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 50
+state 50
 
    16 Exp: Exp ',' . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 97
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 97
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 51
+state 51
 
     9 Exp: Exp '=' . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 98
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 98
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 52
+state 52
 
    27 Exp: Exp '<' . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 99
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 99
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 53
+state 53
 
    28 Exp: Exp '>' . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 100
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 100
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 54
+state 54
 
    17 Exp: Exp '+' . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 101
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 101
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 55
+state 55
 
    19 Exp: Exp '-' . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 102
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 102
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 56
+state 56
 
    21 Exp: Exp '*' . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 103
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 103
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 57
+state 57
 
    23 Exp: Exp '/' . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 104
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 104
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 58
+state 58
 
     4 FuncDefs: FuncDef FuncDefs .
 
-    $défaut  réduction par utilisation de la règle 4 (FuncDefs)
+    $default  reduce using rule 4 (FuncDefs)
 
 
-état 59
+state 59
 
     5 Exp: FuncDef Exp .
     9    | Exp . '=' Exp
@@ -1269,72 +1269,72 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '|'    décalage et aller à l'état 49
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "//"   shift, and go to state 38
+    "and"  shift, and go to state 39
+    "or"   shift, and go to state 40
+    "|="   shift, and go to state 41
+    "+="   shift, and go to state 42
+    "-="   shift, and go to state 43
+    "*="   shift, and go to state 44
+    "/="   shift, and go to state 45
+    "//="  shift, and go to state 46
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    '|'    shift, and go to state 49
+    ','    shift, and go to state 50
+    '='    shift, and go to state 51
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
 
-    $défaut  réduction par utilisation de la règle 5 (Exp)
+    $default  reduce using rule 5 (Exp)
 
 
-état 60
+state 60
 
     6 Exp: Term "as" . '$' IDENT '|' Exp
 
-    '$'  décalage et aller à l'état 105
+    '$'  shift, and go to state 105
 
 
-état 61
+state 61
 
-   44 Term: Term '.' . IDENT
+   43 Term: Term '.' . IDENT
 
-    IDENT  décalage et aller à l'état 106
+    IDENT  shift, and go to state 106
 
 
-état 62
+state 62
 
-   46 Term: Term '[' . Exp ']'
-   47     | Term '[' . ']'
+   45 Term: Term '[' . Exp ']'
+   46     | Term '[' . ']'
    58     | Term '[' . error ']'
 
-    error           décalage et aller à l'état 107
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    ']'             décalage et aller à l'état 108
-    '{'             décalage et aller à l'état 10
+    error           shift, and go to state 107
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    ']'             shift, and go to state 108
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 109
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 109
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 63
+state 63
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1360,197 +1360,199 @@ MkDictPair (61)
    30    | Exp . ">=" Exp
    55 Term: IDENT '(' Exp . ')'
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '|'    décalage et aller à l'état 49
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
-    ')'    décalage et aller à l'état 110
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "//"   shift, and go to state 38
+    "and"  shift, and go to state 39
+    "or"   shift, and go to state 40
+    "|="   shift, and go to state 41
+    "+="   shift, and go to state 42
+    "-="   shift, and go to state 43
+    "*="   shift, and go to state 44
+    "/="   shift, and go to state 45
+    "//="  shift, and go to state 46
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    '|'    shift, and go to state 49
+    ','    shift, and go to state 50
+    '='    shift, and go to state 51
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
+    ')'    shift, and go to state 110
 
 
-état 64
+state 64
 
-   34 FuncDef: "def" IDENT ':' . Exp ';'
+   33 FuncDef: "def" IDENT ':' . Exp ';'
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 111
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 111
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 65
+state 65
 
-   35 FuncDef: "def" IDENT '(' . IDENT ')' ':' Exp ';'
+   34 FuncDef: "def" IDENT '(' . IDENT ')' ':' Exp ';'
 
-    IDENT  décalage et aller à l'état 112
+    IDENT  shift, and go to state 112
 
 
-état 66
+state 66
 
     8 Exp: "if" Exp error .
 
-    $défaut  réduction par utilisation de la règle 8 (Exp)
+    $default  reduce using rule 8 (Exp)
 
 
-état 67
+state 67
 
     7 Exp: "if" Exp "then" . Exp ElseBody
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 113
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 113
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 68
+state 68
 
-   37 QQString: QQString QQSTRING_TEXT .
+   36 QQString: QQString QQSTRING_TEXT .
 
-    $défaut  réduction par utilisation de la règle 37 (QQString)
+    $default  reduce using rule 36 (QQString)
 
 
-état 69
+state 69
 
-   38 QQString: QQString QQSTRING_INTERP_START . Exp QQSTRING_INTERP_END
+   37 QQString: QQString QQSTRING_INTERP_START . Exp QQSTRING_INTERP_END
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 114
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 114
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 70
+state 70
 
-   33 String: QQSTRING_START QQString QQSTRING_END .
+   32 String: QQSTRING_START QQString QQSTRING_END .
 
-    $défaut  réduction par utilisation de la règle 33 (String)
+    $default  reduce using rule 32 (String)
 
 
-état 71
+state 71
 
    56 Term: '(' error ')' .
 
-    $défaut  réduction par utilisation de la règle 56 (Term)
+    $default  reduce using rule 56 (Term)
 
 
-état 72
+state 72
 
    49 Term: '(' Exp ')' .
 
-    $défaut  réduction par utilisation de la règle 49 (Term)
+    $default  reduce using rule 49 (Term)
 
 
-état 73
+state 73
 
    57 Term: '[' error ']' .
 
-    $défaut  réduction par utilisation de la règle 57 (Term)
+    $default  reduce using rule 57 (Term)
 
 
-état 74
+state 74
 
    50 Term: '[' Exp ']' .
 
-    $défaut  réduction par utilisation de la règle 50 (Term)
+    $default  reduce using rule 50 (Term)
 
 
-état 75
+state 75
 
    63 MkDict: error ',' . MkDict
 
-    error           décalage et aller à l'état 115
-    IDENT           décalage et aller à l'état 30
-    QQSTRING_START  décalage et aller à l'état 5
-    '('             décalage et aller à l'état 31
+    error           shift, and go to state 115
+    IDENT           shift, and go to state 30
+    QQSTRING_START  shift, and go to state 5
+    '('             shift, and go to state 31
 
-    '}'  réduction par utilisation de la règle 60 (MkDict)
+    '}'  reduce using rule 60 (MkDict)
 
-    String      aller à l'état 32
-    MkDict      aller à l'état 116
-    MkDictPair  aller à l'état 34
+    String      go to state 32
+    MkDict      go to state 116
+    MkDictPair  go to state 34
 
 
-état 76
+state 76
 
    59 Term: '{' error '}' .
 
-    $défaut  réduction par utilisation de la règle 59 (Term)
+    $default  reduce using rule 59 (Term)
 
 
-état 77
+state 77
 
    64 MkDictPair: IDENT ':' . ExpD
 
-    IDENT    décalage et aller à l'état 1
-    LITERAL  décalage et aller à l'état 2
-    '$'      décalage et aller à l'état 6
-    '('      décalage et aller à l'état 7
-    '.'      décalage et aller à l'état 8
-    '['      décalage et aller à l'état 9
-    '{'      décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    ExpD  aller à l'état 117
-    Term  aller à l'état 118
+    String  go to state 14
+    ExpD    go to state 117
+    Term    go to state 118
 
 
-état 78
+state 78
 
    68 MkDictPair: '(' error . ')' ':' ExpD
 
-    ')'  décalage et aller à l'état 119
+    ')'  shift, and go to state 119
 
 
-état 79
+state 79
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1576,71 +1578,73 @@ MkDictPair (61)
    30    | Exp . ">=" Exp
    67 MkDictPair: '(' Exp . ')' ':' ExpD
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '|'    décalage et aller à l'état 49
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
-    ')'    décalage et aller à l'état 120
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "//"   shift, and go to state 38
+    "and"  shift, and go to state 39
+    "or"   shift, and go to state 40
+    "|="   shift, and go to state 41
+    "+="   shift, and go to state 42
+    "-="   shift, and go to state 43
+    "*="   shift, and go to state 44
+    "/="   shift, and go to state 45
+    "//="  shift, and go to state 46
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    '|'    shift, and go to state 49
+    ','    shift, and go to state 50
+    '='    shift, and go to state 51
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
+    ')'    shift, and go to state 120
 
 
-état 80
+state 80
 
    65 MkDictPair: String ':' . ExpD
 
-    IDENT    décalage et aller à l'état 1
-    LITERAL  décalage et aller à l'état 2
-    '$'      décalage et aller à l'état 6
-    '('      décalage et aller à l'état 7
-    '.'      décalage et aller à l'état 8
-    '['      décalage et aller à l'état 9
-    '{'      décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    ExpD  aller à l'état 121
-    Term  aller à l'état 118
+    String  go to state 14
+    ExpD    go to state 121
+    Term    go to state 118
 
 
-état 81
+state 81
 
    52 Term: '{' MkDict '}' .
 
-    $défaut  réduction par utilisation de la règle 52 (Term)
+    $default  reduce using rule 52 (Term)
 
 
-état 82
+state 82
 
    62 MkDict: MkDictPair ',' . MkDict
 
-    error           décalage et aller à l'état 115
-    IDENT           décalage et aller à l'état 30
-    QQSTRING_START  décalage et aller à l'état 5
-    '('             décalage et aller à l'état 31
+    error           shift, and go to state 115
+    IDENT           shift, and go to state 30
+    QQSTRING_START  shift, and go to state 5
+    '('             shift, and go to state 31
 
-    '}'  réduction par utilisation de la règle 60 (MkDict)
+    '}'  reduce using rule 60 (MkDict)
 
-    String      aller à l'état 32
-    MkDict      aller à l'état 122
-    MkDictPair  aller à l'état 34
+    String      go to state 32
+    MkDict      go to state 122
+    MkDictPair  go to state 34
 
 
-état 83
+state 83
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1666,22 +1670,22 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    '+'  décalage et aller à l'état 54
-    '-'  décalage et aller à l'état 55
-    '*'  décalage et aller à l'état 56
-    '/'  décalage et aller à l'état 57
+    '+'  shift, and go to state 54
+    '-'  shift, and go to state 55
+    '*'  shift, and go to state 56
+    '/'  shift, and go to state 57
 
-    "=="  erreur (non-associative)
-    "!="  erreur (non-associative)
-    "<="  erreur (non-associative)
-    ">="  erreur (non-associative)
-    '<'   erreur (non-associative)
-    '>'   erreur (non-associative)
+    "=="  error (nonassociative)
+    "!="  error (nonassociative)
+    "<="  error (nonassociative)
+    ">="  error (nonassociative)
+    '<'   error (nonassociative)
+    '>'   error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 25 (Exp)
+    $default  reduce using rule 25 (Exp)
 
 
-état 84
+state 84
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1707,22 +1711,22 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    '+'  décalage et aller à l'état 54
-    '-'  décalage et aller à l'état 55
-    '*'  décalage et aller à l'état 56
-    '/'  décalage et aller à l'état 57
+    '+'  shift, and go to state 54
+    '-'  shift, and go to state 55
+    '*'  shift, and go to state 56
+    '/'  shift, and go to state 57
 
-    "=="  erreur (non-associative)
-    "!="  erreur (non-associative)
-    "<="  erreur (non-associative)
-    ">="  erreur (non-associative)
-    '<'   erreur (non-associative)
-    '>'   erreur (non-associative)
+    "=="  error (nonassociative)
+    "!="  error (nonassociative)
+    "<="  error (nonassociative)
+    ">="  error (nonassociative)
+    '<'   error (nonassociative)
+    '>'   error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 26 (Exp)
+    $default  reduce using rule 26 (Exp)
 
 
-état 85
+state 85
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1748,31 +1752,31 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "//"   shift, and go to state 38
+    "and"  shift, and go to state 39
+    "or"   shift, and go to state 40
+    "|="   shift, and go to state 41
+    "+="   shift, and go to state 42
+    "-="   shift, and go to state 43
+    "*="   shift, and go to state 44
+    "/="   shift, and go to state 45
+    "//="  shift, and go to state 46
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    '='    shift, and go to state 51
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
 
-    $défaut  réduction par utilisation de la règle 12 (Exp)
+    $default  reduce using rule 12 (Exp)
 
 
-état 86
+state 86
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1798,21 +1802,21 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    "=="  décalage et aller à l'état 36
-    "!="  décalage et aller à l'état 37
-    "<="  décalage et aller à l'état 47
-    ">="  décalage et aller à l'état 48
-    '<'   décalage et aller à l'état 52
-    '>'   décalage et aller à l'état 53
-    '+'   décalage et aller à l'état 54
-    '-'   décalage et aller à l'état 55
-    '*'   décalage et aller à l'état 56
-    '/'   décalage et aller à l'état 57
+    "=="  shift, and go to state 36
+    "!="  shift, and go to state 37
+    "<="  shift, and go to state 47
+    ">="  shift, and go to state 48
+    '<'   shift, and go to state 52
+    '>'   shift, and go to state 53
+    '+'   shift, and go to state 54
+    '-'   shift, and go to state 55
+    '*'   shift, and go to state 56
+    '/'   shift, and go to state 57
 
-    $défaut  réduction par utilisation de la règle 11 (Exp)
+    $default  reduce using rule 11 (Exp)
 
 
-état 87
+state 87
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1838,22 +1842,22 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "and"  décalage et aller à l'état 39
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "and"  shift, and go to state 39
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
 
-    $défaut  réduction par utilisation de la règle 10 (Exp)
+    $default  reduce using rule 10 (Exp)
 
 
-état 88
+state 88
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1879,31 +1883,31 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "and"  shift, and go to state 39
+    "or"   shift, and go to state 40
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
 
-    "|="   erreur (non-associative)
-    "+="   erreur (non-associative)
-    "-="   erreur (non-associative)
-    "*="   erreur (non-associative)
-    "/="   erreur (non-associative)
-    "//="  erreur (non-associative)
-    '='    erreur (non-associative)
+    "|="   error (nonassociative)
+    "+="   error (nonassociative)
+    "-="   error (nonassociative)
+    "*="   error (nonassociative)
+    "/="   error (nonassociative)
+    "//="  error (nonassociative)
+    '='    error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 14 (Exp)
+    $default  reduce using rule 14 (Exp)
 
 
-état 89
+state 89
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1929,31 +1933,31 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "and"  shift, and go to state 39
+    "or"   shift, and go to state 40
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
 
-    "|="   erreur (non-associative)
-    "+="   erreur (non-associative)
-    "-="   erreur (non-associative)
-    "*="   erreur (non-associative)
-    "/="   erreur (non-associative)
-    "//="  erreur (non-associative)
-    '='    erreur (non-associative)
+    "|="   error (nonassociative)
+    "+="   error (nonassociative)
+    "-="   error (nonassociative)
+    "*="   error (nonassociative)
+    "/="   error (nonassociative)
+    "//="  error (nonassociative)
+    '='    error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 18 (Exp)
+    $default  reduce using rule 18 (Exp)
 
 
-état 90
+state 90
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -1979,31 +1983,31 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "and"  shift, and go to state 39
+    "or"   shift, and go to state 40
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
 
-    "|="   erreur (non-associative)
-    "+="   erreur (non-associative)
-    "-="   erreur (non-associative)
-    "*="   erreur (non-associative)
-    "/="   erreur (non-associative)
-    "//="  erreur (non-associative)
-    '='    erreur (non-associative)
+    "|="   error (nonassociative)
+    "+="   error (nonassociative)
+    "-="   error (nonassociative)
+    "*="   error (nonassociative)
+    "/="   error (nonassociative)
+    "//="  error (nonassociative)
+    '='    error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 20 (Exp)
+    $default  reduce using rule 20 (Exp)
 
 
-état 91
+state 91
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2029,31 +2033,31 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "and"  shift, and go to state 39
+    "or"   shift, and go to state 40
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
 
-    "|="   erreur (non-associative)
-    "+="   erreur (non-associative)
-    "-="   erreur (non-associative)
-    "*="   erreur (non-associative)
-    "/="   erreur (non-associative)
-    "//="  erreur (non-associative)
-    '='    erreur (non-associative)
+    "|="   error (nonassociative)
+    "+="   error (nonassociative)
+    "-="   error (nonassociative)
+    "*="   error (nonassociative)
+    "/="   error (nonassociative)
+    "//="  error (nonassociative)
+    '='    error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 22 (Exp)
+    $default  reduce using rule 22 (Exp)
 
 
-état 92
+state 92
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2079,31 +2083,31 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "and"  shift, and go to state 39
+    "or"   shift, and go to state 40
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
 
-    "|="   erreur (non-associative)
-    "+="   erreur (non-associative)
-    "-="   erreur (non-associative)
-    "*="   erreur (non-associative)
-    "/="   erreur (non-associative)
-    "//="  erreur (non-associative)
-    '='    erreur (non-associative)
+    "|="   error (nonassociative)
+    "+="   error (nonassociative)
+    "-="   error (nonassociative)
+    "*="   error (nonassociative)
+    "/="   error (nonassociative)
+    "//="  error (nonassociative)
+    '='    error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 24 (Exp)
+    $default  reduce using rule 24 (Exp)
 
 
-état 93
+state 93
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2129,31 +2133,31 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "and"  shift, and go to state 39
+    "or"   shift, and go to state 40
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
 
-    "|="   erreur (non-associative)
-    "+="   erreur (non-associative)
-    "-="   erreur (non-associative)
-    "*="   erreur (non-associative)
-    "/="   erreur (non-associative)
-    "//="  erreur (non-associative)
-    '='    erreur (non-associative)
+    "|="   error (nonassociative)
+    "+="   error (nonassociative)
+    "-="   error (nonassociative)
+    "*="   error (nonassociative)
+    "/="   error (nonassociative)
+    "//="  error (nonassociative)
+    '='    error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 13 (Exp)
+    $default  reduce using rule 13 (Exp)
 
 
-état 94
+state 94
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2179,22 +2183,22 @@ MkDictPair (61)
    29    | Exp "<=" Exp .
    30    | Exp . ">=" Exp
 
-    '+'  décalage et aller à l'état 54
-    '-'  décalage et aller à l'état 55
-    '*'  décalage et aller à l'état 56
-    '/'  décalage et aller à l'état 57
+    '+'  shift, and go to state 54
+    '-'  shift, and go to state 55
+    '*'  shift, and go to state 56
+    '/'  shift, and go to state 57
 
-    "=="  erreur (non-associative)
-    "!="  erreur (non-associative)
-    "<="  erreur (non-associative)
-    ">="  erreur (non-associative)
-    '<'   erreur (non-associative)
-    '>'   erreur (non-associative)
+    "=="  error (nonassociative)
+    "!="  error (nonassociative)
+    "<="  error (nonassociative)
+    ">="  error (nonassociative)
+    '<'   error (nonassociative)
+    '>'   error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 29 (Exp)
+    $default  reduce using rule 29 (Exp)
 
 
-état 95
+state 95
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2220,22 +2224,22 @@ MkDictPair (61)
    30    | Exp . ">=" Exp
    30    | Exp ">=" Exp .
 
-    '+'  décalage et aller à l'état 54
-    '-'  décalage et aller à l'état 55
-    '*'  décalage et aller à l'état 56
-    '/'  décalage et aller à l'état 57
+    '+'  shift, and go to state 54
+    '-'  shift, and go to state 55
+    '*'  shift, and go to state 56
+    '/'  shift, and go to state 57
 
-    "=="  erreur (non-associative)
-    "!="  erreur (non-associative)
-    "<="  erreur (non-associative)
-    ">="  erreur (non-associative)
-    '<'   erreur (non-associative)
-    '>'   erreur (non-associative)
+    "=="  error (nonassociative)
+    "!="  error (nonassociative)
+    "<="  error (nonassociative)
+    ">="  error (nonassociative)
+    '<'   error (nonassociative)
+    '>'   error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 30 (Exp)
+    $default  reduce using rule 30 (Exp)
 
 
-état 96
+state 96
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2261,32 +2265,32 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "//"   shift, and go to state 38
+    "and"  shift, and go to state 39
+    "or"   shift, and go to state 40
+    "|="   shift, and go to state 41
+    "+="   shift, and go to state 42
+    "-="   shift, and go to state 43
+    "*="   shift, and go to state 44
+    "/="   shift, and go to state 45
+    "//="  shift, and go to state 46
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    ','    shift, and go to state 50
+    '='    shift, and go to state 51
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
 
-    $défaut  réduction par utilisation de la règle 15 (Exp)
+    $default  reduce using rule 15 (Exp)
 
 
-état 97
+state 97
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2312,31 +2316,31 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "//"   shift, and go to state 38
+    "and"  shift, and go to state 39
+    "or"   shift, and go to state 40
+    "|="   shift, and go to state 41
+    "+="   shift, and go to state 42
+    "-="   shift, and go to state 43
+    "*="   shift, and go to state 44
+    "/="   shift, and go to state 45
+    "//="  shift, and go to state 46
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    '='    shift, and go to state 51
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
 
-    $défaut  réduction par utilisation de la règle 16 (Exp)
+    $default  reduce using rule 16 (Exp)
 
 
-état 98
+state 98
 
     9 Exp: Exp . '=' Exp
     9    | Exp '=' Exp .
@@ -2362,31 +2366,31 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "and"  shift, and go to state 39
+    "or"   shift, and go to state 40
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
 
-    "|="   erreur (non-associative)
-    "+="   erreur (non-associative)
-    "-="   erreur (non-associative)
-    "*="   erreur (non-associative)
-    "/="   erreur (non-associative)
-    "//="  erreur (non-associative)
-    '='    erreur (non-associative)
+    "|="   error (nonassociative)
+    "+="   error (nonassociative)
+    "-="   error (nonassociative)
+    "*="   error (nonassociative)
+    "/="   error (nonassociative)
+    "//="  error (nonassociative)
+    '='    error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 9 (Exp)
+    $default  reduce using rule 9 (Exp)
 
 
-état 99
+state 99
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2412,22 +2416,22 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    '+'  décalage et aller à l'état 54
-    '-'  décalage et aller à l'état 55
-    '*'  décalage et aller à l'état 56
-    '/'  décalage et aller à l'état 57
+    '+'  shift, and go to state 54
+    '-'  shift, and go to state 55
+    '*'  shift, and go to state 56
+    '/'  shift, and go to state 57
 
-    "=="  erreur (non-associative)
-    "!="  erreur (non-associative)
-    "<="  erreur (non-associative)
-    ">="  erreur (non-associative)
-    '<'   erreur (non-associative)
-    '>'   erreur (non-associative)
+    "=="  error (nonassociative)
+    "!="  error (nonassociative)
+    "<="  error (nonassociative)
+    ">="  error (nonassociative)
+    '<'   error (nonassociative)
+    '>'   error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 27 (Exp)
+    $default  reduce using rule 27 (Exp)
 
 
-état 100
+state 100
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2453,22 +2457,22 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    '+'  décalage et aller à l'état 54
-    '-'  décalage et aller à l'état 55
-    '*'  décalage et aller à l'état 56
-    '/'  décalage et aller à l'état 57
+    '+'  shift, and go to state 54
+    '-'  shift, and go to state 55
+    '*'  shift, and go to state 56
+    '/'  shift, and go to state 57
 
-    "=="  erreur (non-associative)
-    "!="  erreur (non-associative)
-    "<="  erreur (non-associative)
-    ">="  erreur (non-associative)
-    '<'   erreur (non-associative)
-    '>'   erreur (non-associative)
+    "=="  error (nonassociative)
+    "!="  error (nonassociative)
+    "<="  error (nonassociative)
+    ">="  error (nonassociative)
+    '<'   error (nonassociative)
+    '>'   error (nonassociative)
 
-    $défaut  réduction par utilisation de la règle 28 (Exp)
+    $default  reduce using rule 28 (Exp)
 
 
-état 101
+state 101
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2494,13 +2498,13 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    '*'  décalage et aller à l'état 56
-    '/'  décalage et aller à l'état 57
+    '*'  shift, and go to state 56
+    '/'  shift, and go to state 57
 
-    $défaut  réduction par utilisation de la règle 17 (Exp)
+    $default  reduce using rule 17 (Exp)
 
 
-état 102
+state 102
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2526,13 +2530,13 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    '*'  décalage et aller à l'état 56
-    '/'  décalage et aller à l'état 57
+    '*'  shift, and go to state 56
+    '/'  shift, and go to state 57
 
-    $défaut  réduction par utilisation de la règle 19 (Exp)
+    $default  reduce using rule 19 (Exp)
 
 
-état 103
+state 103
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2558,10 +2562,10 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    $défaut  réduction par utilisation de la règle 21 (Exp)
+    $default  reduce using rule 21 (Exp)
 
 
-état 104
+state 104
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2587,38 +2591,38 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    $défaut  réduction par utilisation de la règle 23 (Exp)
+    $default  reduce using rule 23 (Exp)
 
 
-état 105
+state 105
 
     6 Exp: Term "as" '$' . IDENT '|' Exp
 
-    IDENT  décalage et aller à l'état 123
+    IDENT  shift, and go to state 123
 
 
-état 106
+state 106
 
-   44 Term: Term '.' IDENT .
+   43 Term: Term '.' IDENT .
 
-    $défaut  réduction par utilisation de la règle 44 (Term)
+    $default  reduce using rule 43 (Term)
 
 
-état 107
+state 107
 
    58 Term: Term '[' error . ']'
 
-    ']'  décalage et aller à l'état 124
+    ']'  shift, and go to state 124
 
 
-état 108
+state 108
 
-   47 Term: Term '[' ']' .
+   46 Term: Term '[' ']' .
 
-    $défaut  réduction par utilisation de la règle 47 (Term)
+    $default  reduce using rule 46 (Term)
 
 
-état 109
+state 109
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2642,41 +2646,41 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
-   46 Term: Term '[' Exp . ']'
+   45 Term: Term '[' Exp . ']'
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '|'    décalage et aller à l'état 49
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
-    ']'    décalage et aller à l'état 125
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "//"   shift, and go to state 38
+    "and"  shift, and go to state 39
+    "or"   shift, and go to state 40
+    "|="   shift, and go to state 41
+    "+="   shift, and go to state 42
+    "-="   shift, and go to state 43
+    "*="   shift, and go to state 44
+    "/="   shift, and go to state 45
+    "//="  shift, and go to state 46
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    '|'    shift, and go to state 49
+    ','    shift, and go to state 50
+    '='    shift, and go to state 51
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
+    ']'    shift, and go to state 125
 
 
-état 110
+state 110
 
    55 Term: IDENT '(' Exp ')' .
 
-    $défaut  réduction par utilisation de la règle 55 (Term)
+    $default  reduce using rule 55 (Term)
 
 
-état 111
+state 111
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2700,41 +2704,41 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
-   34 FuncDef: "def" IDENT ':' Exp . ';'
+   33 FuncDef: "def" IDENT ':' Exp . ';'
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    ';'    décalage et aller à l'état 126
-    '|'    décalage et aller à l'état 49
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "//"   shift, and go to state 38
+    "and"  shift, and go to state 39
+    "or"   shift, and go to state 40
+    "|="   shift, and go to state 41
+    "+="   shift, and go to state 42
+    "-="   shift, and go to state 43
+    "*="   shift, and go to state 44
+    "/="   shift, and go to state 45
+    "//="  shift, and go to state 46
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    ';'    shift, and go to state 126
+    '|'    shift, and go to state 49
+    ','    shift, and go to state 50
+    '='    shift, and go to state 51
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
 
 
-état 112
+state 112
 
-   35 FuncDef: "def" IDENT '(' IDENT . ')' ':' Exp ';'
+   34 FuncDef: "def" IDENT '(' IDENT . ')' ':' Exp ';'
 
-    ')'  décalage et aller à l'état 127
+    ')'  shift, and go to state 127
 
 
-état 113
+state 113
 
     7 Exp: "if" Exp "then" Exp . ElseBody
     9    | Exp . '=' Exp
@@ -2760,35 +2764,35 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    "=="    décalage et aller à l'état 36
-    "!="    décalage et aller à l'état 37
-    "//"    décalage et aller à l'état 38
-    "else"  décalage et aller à l'état 128
-    "elif"  décalage et aller à l'état 129
-    "and"   décalage et aller à l'état 39
-    "or"    décalage et aller à l'état 40
-    "|="    décalage et aller à l'état 41
-    "+="    décalage et aller à l'état 42
-    "-="    décalage et aller à l'état 43
-    "*="    décalage et aller à l'état 44
-    "/="    décalage et aller à l'état 45
-    "//="   décalage et aller à l'état 46
-    "<="    décalage et aller à l'état 47
-    ">="    décalage et aller à l'état 48
-    '|'     décalage et aller à l'état 49
-    ','     décalage et aller à l'état 50
-    '='     décalage et aller à l'état 51
-    '<'     décalage et aller à l'état 52
-    '>'     décalage et aller à l'état 53
-    '+'     décalage et aller à l'état 54
-    '-'     décalage et aller à l'état 55
-    '*'     décalage et aller à l'état 56
-    '/'     décalage et aller à l'état 57
+    "=="    shift, and go to state 36
+    "!="    shift, and go to state 37
+    "//"    shift, and go to state 38
+    "else"  shift, and go to state 128
+    "elif"  shift, and go to state 129
+    "and"   shift, and go to state 39
+    "or"    shift, and go to state 40
+    "|="    shift, and go to state 41
+    "+="    shift, and go to state 42
+    "-="    shift, and go to state 43
+    "*="    shift, and go to state 44
+    "/="    shift, and go to state 45
+    "//="   shift, and go to state 46
+    "<="    shift, and go to state 47
+    ">="    shift, and go to state 48
+    '|'     shift, and go to state 49
+    ','     shift, and go to state 50
+    '='     shift, and go to state 51
+    '<'     shift, and go to state 52
+    '>'     shift, and go to state 53
+    '+'     shift, and go to state 54
+    '-'     shift, and go to state 55
+    '*'     shift, and go to state 56
+    '/'     shift, and go to state 57
 
-    ElseBody  aller à l'état 130
+    ElseBody  go to state 130
 
 
-état 114
+state 114
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -2812,284 +2816,290 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
-   38 QQString: QQString QQSTRING_INTERP_START Exp . QQSTRING_INTERP_END
+   37 QQString: QQString QQSTRING_INTERP_START Exp . QQSTRING_INTERP_END
 
-    "=="                 décalage et aller à l'état 36
-    "!="                 décalage et aller à l'état 37
-    "//"                 décalage et aller à l'état 38
-    "and"                décalage et aller à l'état 39
-    "or"                 décalage et aller à l'état 40
-    "|="                 décalage et aller à l'état 41
-    "+="                 décalage et aller à l'état 42
-    "-="                 décalage et aller à l'état 43
-    "*="                 décalage et aller à l'état 44
-    "/="                 décalage et aller à l'état 45
-    "//="                décalage et aller à l'état 46
-    "<="                 décalage et aller à l'état 47
-    ">="                 décalage et aller à l'état 48
-    QQSTRING_INTERP_END  décalage et aller à l'état 131
-    '|'                  décalage et aller à l'état 49
-    ','                  décalage et aller à l'état 50
-    '='                  décalage et aller à l'état 51
-    '<'                  décalage et aller à l'état 52
-    '>'                  décalage et aller à l'état 53
-    '+'                  décalage et aller à l'état 54
-    '-'                  décalage et aller à l'état 55
-    '*'                  décalage et aller à l'état 56
-    '/'                  décalage et aller à l'état 57
+    "=="                 shift, and go to state 36
+    "!="                 shift, and go to state 37
+    "//"                 shift, and go to state 38
+    "and"                shift, and go to state 39
+    "or"                 shift, and go to state 40
+    "|="                 shift, and go to state 41
+    "+="                 shift, and go to state 42
+    "-="                 shift, and go to state 43
+    "*="                 shift, and go to state 44
+    "/="                 shift, and go to state 45
+    "//="                shift, and go to state 46
+    "<="                 shift, and go to state 47
+    ">="                 shift, and go to state 48
+    QQSTRING_INTERP_END  shift, and go to state 131
+    '|'                  shift, and go to state 49
+    ','                  shift, and go to state 50
+    '='                  shift, and go to state 51
+    '<'                  shift, and go to state 52
+    '>'                  shift, and go to state 53
+    '+'                  shift, and go to state 54
+    '-'                  shift, and go to state 55
+    '*'                  shift, and go to state 56
+    '/'                  shift, and go to state 57
 
 
-état 115
+state 115
 
    63 MkDict: error . ',' MkDict
 
-    ','  décalage et aller à l'état 75
+    ','  shift, and go to state 75
 
 
-état 116
+state 116
 
    63 MkDict: error ',' MkDict .
 
-    $défaut  réduction par utilisation de la règle 63 (MkDict)
+    $default  reduce using rule 63 (MkDict)
 
 
-état 117
+state 117
 
-   41 ExpD: ExpD . '|' ExpD
+   40 ExpD: ExpD . '|' ExpD
    64 MkDictPair: IDENT ':' ExpD .
 
-    '|'  décalage et aller à l'état 132
+    '|'  shift, and go to state 132
 
-    $défaut  réduction par utilisation de la règle 64 (MkDictPair)
+    $default  reduce using rule 64 (MkDictPair)
 
 
-état 118
+state 118
 
-   42 ExpD: Term .
-   44 Term: Term . '.' IDENT
-   46     | Term . '[' Exp ']'
-   47     | Term . '[' ']'
+   41 ExpD: Term .
+   43 Term: Term . '.' IDENT
+   45     | Term . '[' Exp ']'
+   46     | Term . '[' ']'
    58     | Term . '[' error ']'
 
-    '.'  décalage et aller à l'état 61
-    '['  décalage et aller à l'état 62
+    '.'  shift, and go to state 61
+    '['  shift, and go to state 62
 
-    $défaut  réduction par utilisation de la règle 42 (ExpD)
+    $default  reduce using rule 41 (ExpD)
 
 
-état 119
+state 119
 
    68 MkDictPair: '(' error ')' . ':' ExpD
 
-    ':'  décalage et aller à l'état 133
+    ':'  shift, and go to state 133
 
 
-état 120
+state 120
 
    67 MkDictPair: '(' Exp ')' . ':' ExpD
 
-    ':'  décalage et aller à l'état 134
+    ':'  shift, and go to state 134
 
 
-état 121
+state 121
 
-   41 ExpD: ExpD . '|' ExpD
+   40 ExpD: ExpD . '|' ExpD
    65 MkDictPair: String ':' ExpD .
 
-    '|'  décalage et aller à l'état 132
+    '|'  shift, and go to state 132
 
-    $défaut  réduction par utilisation de la règle 65 (MkDictPair)
+    $default  reduce using rule 65 (MkDictPair)
 
 
-état 122
+state 122
 
    62 MkDict: MkDictPair ',' MkDict .
 
-    $défaut  réduction par utilisation de la règle 62 (MkDict)
+    $default  reduce using rule 62 (MkDict)
 
 
-état 123
+state 123
 
     6 Exp: Term "as" '$' IDENT . '|' Exp
 
-    '|'  décalage et aller à l'état 135
+    '|'  shift, and go to state 135
 
 
-état 124
+state 124
 
    58 Term: Term '[' error ']' .
 
-    $défaut  réduction par utilisation de la règle 58 (Term)
+    $default  reduce using rule 58 (Term)
 
 
-état 125
+state 125
 
-   46 Term: Term '[' Exp ']' .
+   45 Term: Term '[' Exp ']' .
 
-    $défaut  réduction par utilisation de la règle 46 (Term)
+    $default  reduce using rule 45 (Term)
 
 
-état 126
+state 126
 
-   34 FuncDef: "def" IDENT ':' Exp ';' .
+   33 FuncDef: "def" IDENT ':' Exp ';' .
 
-    $défaut  réduction par utilisation de la règle 34 (FuncDef)
+    $default  reduce using rule 33 (FuncDef)
 
 
-état 127
+state 127
 
-   35 FuncDef: "def" IDENT '(' IDENT ')' . ':' Exp ';'
+   34 FuncDef: "def" IDENT '(' IDENT ')' . ':' Exp ';'
 
-    ':'  décalage et aller à l'état 136
+    ':'  shift, and go to state 136
 
 
-état 128
+state 128
 
-   40 ElseBody: "else" . Exp "end"
+   39 ElseBody: "else" . Exp "end"
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 137
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 137
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 129
+state 129
 
-   39 ElseBody: "elif" . Exp "then" Exp ElseBody
+   38 ElseBody: "elif" . Exp "then" Exp ElseBody
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 138
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 138
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 130
+state 130
 
     7 Exp: "if" Exp "then" Exp ElseBody .
 
-    $défaut  réduction par utilisation de la règle 7 (Exp)
+    $default  reduce using rule 7 (Exp)
 
 
-état 131
+state 131
 
-   38 QQString: QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END .
+   37 QQString: QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END .
 
-    $défaut  réduction par utilisation de la règle 38 (QQString)
+    $default  reduce using rule 37 (QQString)
 
 
-état 132
+state 132
 
-   41 ExpD: ExpD '|' . ExpD
+   40 ExpD: ExpD '|' . ExpD
 
-    IDENT    décalage et aller à l'état 1
-    LITERAL  décalage et aller à l'état 2
-    '$'      décalage et aller à l'état 6
-    '('      décalage et aller à l'état 7
-    '.'      décalage et aller à l'état 8
-    '['      décalage et aller à l'état 9
-    '{'      décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    ExpD  aller à l'état 139
-    Term  aller à l'état 118
+    String  go to state 14
+    ExpD    go to state 139
+    Term    go to state 118
 
 
-état 133
+state 133
 
    68 MkDictPair: '(' error ')' ':' . ExpD
 
-    IDENT    décalage et aller à l'état 1
-    LITERAL  décalage et aller à l'état 2
-    '$'      décalage et aller à l'état 6
-    '('      décalage et aller à l'état 7
-    '.'      décalage et aller à l'état 8
-    '['      décalage et aller à l'état 9
-    '{'      décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    ExpD  aller à l'état 140
-    Term  aller à l'état 118
+    String  go to state 14
+    ExpD    go to state 140
+    Term    go to state 118
 
 
-état 134
+state 134
 
    67 MkDictPair: '(' Exp ')' ':' . ExpD
 
-    IDENT    décalage et aller à l'état 1
-    LITERAL  décalage et aller à l'état 2
-    '$'      décalage et aller à l'état 6
-    '('      décalage et aller à l'état 7
-    '.'      décalage et aller à l'état 8
-    '['      décalage et aller à l'état 9
-    '{'      décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    ExpD  aller à l'état 141
-    Term  aller à l'état 118
+    String  go to state 14
+    ExpD    go to state 141
+    Term    go to state 118
 
 
-état 135
+state 135
 
     6 Exp: Term "as" '$' IDENT '|' . Exp
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 142
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 142
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 136
+state 136
 
-   35 FuncDef: "def" IDENT '(' IDENT ')' ':' . Exp ';'
+   34 FuncDef: "def" IDENT '(' IDENT ')' ':' . Exp ';'
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 143
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 143
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 137
+state 137
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -3113,34 +3123,34 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
-   40 ElseBody: "else" Exp . "end"
+   39 ElseBody: "else" Exp . "end"
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "end"  décalage et aller à l'état 144
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    '|'    décalage et aller à l'état 49
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "//"   shift, and go to state 38
+    "end"  shift, and go to state 144
+    "and"  shift, and go to state 39
+    "or"   shift, and go to state 40
+    "|="   shift, and go to state 41
+    "+="   shift, and go to state 42
+    "-="   shift, and go to state 43
+    "*="   shift, and go to state 44
+    "/="   shift, and go to state 45
+    "//="  shift, and go to state 46
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    '|'    shift, and go to state 49
+    ','    shift, and go to state 50
+    '='    shift, and go to state 51
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
 
 
-état 138
+state 138
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -3164,62 +3174,62 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
-   39 ElseBody: "elif" Exp . "then" Exp ElseBody
+   38 ElseBody: "elif" Exp . "then" Exp ElseBody
 
-    "=="    décalage et aller à l'état 36
-    "!="    décalage et aller à l'état 37
-    "//"    décalage et aller à l'état 38
-    "then"  décalage et aller à l'état 145
-    "and"   décalage et aller à l'état 39
-    "or"    décalage et aller à l'état 40
-    "|="    décalage et aller à l'état 41
-    "+="    décalage et aller à l'état 42
-    "-="    décalage et aller à l'état 43
-    "*="    décalage et aller à l'état 44
-    "/="    décalage et aller à l'état 45
-    "//="   décalage et aller à l'état 46
-    "<="    décalage et aller à l'état 47
-    ">="    décalage et aller à l'état 48
-    '|'     décalage et aller à l'état 49
-    ','     décalage et aller à l'état 50
-    '='     décalage et aller à l'état 51
-    '<'     décalage et aller à l'état 52
-    '>'     décalage et aller à l'état 53
-    '+'     décalage et aller à l'état 54
-    '-'     décalage et aller à l'état 55
-    '*'     décalage et aller à l'état 56
-    '/'     décalage et aller à l'état 57
+    "=="    shift, and go to state 36
+    "!="    shift, and go to state 37
+    "//"    shift, and go to state 38
+    "then"  shift, and go to state 145
+    "and"   shift, and go to state 39
+    "or"    shift, and go to state 40
+    "|="    shift, and go to state 41
+    "+="    shift, and go to state 42
+    "-="    shift, and go to state 43
+    "*="    shift, and go to state 44
+    "/="    shift, and go to state 45
+    "//="   shift, and go to state 46
+    "<="    shift, and go to state 47
+    ">="    shift, and go to state 48
+    '|'     shift, and go to state 49
+    ','     shift, and go to state 50
+    '='     shift, and go to state 51
+    '<'     shift, and go to state 52
+    '>'     shift, and go to state 53
+    '+'     shift, and go to state 54
+    '-'     shift, and go to state 55
+    '*'     shift, and go to state 56
+    '/'     shift, and go to state 57
 
 
-état 139
+state 139
 
-   41 ExpD: ExpD . '|' ExpD
-   41     | ExpD '|' ExpD .
+   40 ExpD: ExpD . '|' ExpD
+   40     | ExpD '|' ExpD .
 
-    $défaut  réduction par utilisation de la règle 41 (ExpD)
+    $default  reduce using rule 40 (ExpD)
 
 
-état 140
+state 140
 
-   41 ExpD: ExpD . '|' ExpD
+   40 ExpD: ExpD . '|' ExpD
    68 MkDictPair: '(' error ')' ':' ExpD .
 
-    '|'  décalage et aller à l'état 132
+    '|'  shift, and go to state 132
 
-    $défaut  réduction par utilisation de la règle 68 (MkDictPair)
+    $default  reduce using rule 68 (MkDictPair)
 
 
-état 141
+state 141
 
-   41 ExpD: ExpD . '|' ExpD
+   40 ExpD: ExpD . '|' ExpD
    67 MkDictPair: '(' Exp ')' ':' ExpD .
 
-    '|'  décalage et aller à l'état 132
+    '|'  shift, and go to state 132
 
-    $défaut  réduction par utilisation de la règle 67 (MkDictPair)
+    $default  reduce using rule 67 (MkDictPair)
 
 
-état 142
+state 142
 
     6 Exp: Term "as" '$' IDENT '|' Exp .
     9    | Exp . '=' Exp
@@ -3245,32 +3255,32 @@ MkDictPair (61)
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "//"   shift, and go to state 38
+    "and"  shift, and go to state 39
+    "or"   shift, and go to state 40
+    "|="   shift, and go to state 41
+    "+="   shift, and go to state 42
+    "-="   shift, and go to state 43
+    "*="   shift, and go to state 44
+    "/="   shift, and go to state 45
+    "//="  shift, and go to state 46
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    ','    shift, and go to state 50
+    '='    shift, and go to state 51
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
 
-    $défaut  réduction par utilisation de la règle 6 (Exp)
+    $default  reduce using rule 6 (Exp)
 
 
-état 143
+state 143
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -3294,69 +3304,69 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
-   35 FuncDef: "def" IDENT '(' IDENT ')' ':' Exp . ';'
+   34 FuncDef: "def" IDENT '(' IDENT ')' ':' Exp . ';'
 
-    "=="   décalage et aller à l'état 36
-    "!="   décalage et aller à l'état 37
-    "//"   décalage et aller à l'état 38
-    "and"  décalage et aller à l'état 39
-    "or"   décalage et aller à l'état 40
-    "|="   décalage et aller à l'état 41
-    "+="   décalage et aller à l'état 42
-    "-="   décalage et aller à l'état 43
-    "*="   décalage et aller à l'état 44
-    "/="   décalage et aller à l'état 45
-    "//="  décalage et aller à l'état 46
-    "<="   décalage et aller à l'état 47
-    ">="   décalage et aller à l'état 48
-    ';'    décalage et aller à l'état 146
-    '|'    décalage et aller à l'état 49
-    ','    décalage et aller à l'état 50
-    '='    décalage et aller à l'état 51
-    '<'    décalage et aller à l'état 52
-    '>'    décalage et aller à l'état 53
-    '+'    décalage et aller à l'état 54
-    '-'    décalage et aller à l'état 55
-    '*'    décalage et aller à l'état 56
-    '/'    décalage et aller à l'état 57
+    "=="   shift, and go to state 36
+    "!="   shift, and go to state 37
+    "//"   shift, and go to state 38
+    "and"  shift, and go to state 39
+    "or"   shift, and go to state 40
+    "|="   shift, and go to state 41
+    "+="   shift, and go to state 42
+    "-="   shift, and go to state 43
+    "*="   shift, and go to state 44
+    "/="   shift, and go to state 45
+    "//="  shift, and go to state 46
+    "<="   shift, and go to state 47
+    ">="   shift, and go to state 48
+    ';'    shift, and go to state 146
+    '|'    shift, and go to state 49
+    ','    shift, and go to state 50
+    '='    shift, and go to state 51
+    '<'    shift, and go to state 52
+    '>'    shift, and go to state 53
+    '+'    shift, and go to state 54
+    '-'    shift, and go to state 55
+    '*'    shift, and go to state 56
+    '/'    shift, and go to state 57
 
 
-état 144
+state 144
 
-   40 ElseBody: "else" Exp "end" .
+   39 ElseBody: "else" Exp "end" .
 
-    $défaut  réduction par utilisation de la règle 40 (ElseBody)
+    $default  reduce using rule 39 (ElseBody)
 
 
-état 145
+state 145
 
-   39 ElseBody: "elif" Exp "then" . Exp ElseBody
+   38 ElseBody: "elif" Exp "then" . Exp ElseBody
 
-    IDENT           décalage et aller à l'état 1
-    LITERAL         décalage et aller à l'état 2
-    "def"           décalage et aller à l'état 3
-    "if"            décalage et aller à l'état 4
-    QQSTRING_START  décalage et aller à l'état 5
-    '$'             décalage et aller à l'état 6
-    '('             décalage et aller à l'état 7
-    '.'             décalage et aller à l'état 8
-    '['             décalage et aller à l'état 9
-    '{'             décalage et aller à l'état 10
+    IDENT           shift, and go to state 1
+    LITERAL         shift, and go to state 2
+    "def"           shift, and go to state 3
+    "if"            shift, and go to state 4
+    QQSTRING_START  shift, and go to state 5
+    '$'             shift, and go to state 6
+    '('             shift, and go to state 7
+    '.'             shift, and go to state 8
+    '['             shift, and go to state 9
+    '{'             shift, and go to state 10
 
-    Exp      aller à l'état 147
-    String   aller à l'état 14
-    FuncDef  aller à l'état 20
-    Term     aller à l'état 16
+    Exp      go to state 147
+    String   go to state 14
+    FuncDef  go to state 20
+    Term     go to state 16
 
 
-état 146
+state 146
 
-   35 FuncDef: "def" IDENT '(' IDENT ')' ':' Exp ';' .
+   34 FuncDef: "def" IDENT '(' IDENT ')' ':' Exp ';' .
 
-    $défaut  réduction par utilisation de la règle 35 (FuncDef)
+    $default  reduce using rule 34 (FuncDef)
 
 
-état 147
+state 147
 
     9 Exp: Exp . '=' Exp
    10    | Exp . "or" Exp
@@ -3380,38 +3390,38 @@ MkDictPair (61)
    28    | Exp . '>' Exp
    29    | Exp . "<=" Exp
    30    | Exp . ">=" Exp
-   39 ElseBody: "elif" Exp "then" Exp . ElseBody
+   38 ElseBody: "elif" Exp "then" Exp . ElseBody
 
-    "=="    décalage et aller à l'état 36
-    "!="    décalage et aller à l'état 37
-    "//"    décalage et aller à l'état 38
-    "else"  décalage et aller à l'état 128
-    "elif"  décalage et aller à l'état 129
-    "and"   décalage et aller à l'état 39
-    "or"    décalage et aller à l'état 40
-    "|="    décalage et aller à l'état 41
-    "+="    décalage et aller à l'état 42
-    "-="    décalage et aller à l'état 43
-    "*="    décalage et aller à l'état 44
-    "/="    décalage et aller à l'état 45
-    "//="   décalage et aller à l'état 46
-    "<="    décalage et aller à l'état 47
-    ">="    décalage et aller à l'état 48
-    '|'     décalage et aller à l'état 49
-    ','     décalage et aller à l'état 50
-    '='     décalage et aller à l'état 51
-    '<'     décalage et aller à l'état 52
-    '>'     décalage et aller à l'état 53
-    '+'     décalage et aller à l'état 54
-    '-'     décalage et aller à l'état 55
-    '*'     décalage et aller à l'état 56
-    '/'     décalage et aller à l'état 57
+    "=="    shift, and go to state 36
+    "!="    shift, and go to state 37
+    "//"    shift, and go to state 38
+    "else"  shift, and go to state 128
+    "elif"  shift, and go to state 129
+    "and"   shift, and go to state 39
+    "or"    shift, and go to state 40
+    "|="    shift, and go to state 41
+    "+="    shift, and go to state 42
+    "-="    shift, and go to state 43
+    "*="    shift, and go to state 44
+    "/="    shift, and go to state 45
+    "//="   shift, and go to state 46
+    "<="    shift, and go to state 47
+    ">="    shift, and go to state 48
+    '|'     shift, and go to state 49
+    ','     shift, and go to state 50
+    '='     shift, and go to state 51
+    '<'     shift, and go to state 52
+    '>'     shift, and go to state 53
+    '+'     shift, and go to state 54
+    '-'     shift, and go to state 55
+    '*'     shift, and go to state 56
+    '/'     shift, and go to state 57
 
-    ElseBody  aller à l'état 148
+    ElseBody  go to state 148
 
 
-état 148
+state 148
 
-   39 ElseBody: "elif" Exp "then" Exp ElseBody .
+   38 ElseBody: "elif" Exp "then" Exp ElseBody .
 
-    $défaut  réduction par utilisation de la règle 39 (ElseBody)
+    $default  reduce using rule 38 (ElseBody)
diff --git a/parser.y b/parser.y
index e2e591df..d64a2ec5 100644
--- a/parser.y
+++ b/parser.y
@@ -308,10 +308,6 @@ Exp ">=" Exp {
   $$ = gen_binop($1, $3, GREATEREQ);
 } |
 
-String {
-  $$ = $1;
-} |
-
 Term { 
   $$ = $1; 
 }
@@ -385,6 +381,9 @@ Term '[' ']' {
 LITERAL {
   $$ = gen_op_const(LOADK, $1); 
 } |
+String {
+  $$ = $1;
+} |
 '(' Exp ')' { 
   $$ = $2; 
 } | 

From ecc8998d38ddd7da5a7f8237b883dae74ffe38cb Mon Sep 17 00:00:00 2001
From: Stephen Roantree <stroantree@gmail.com>
Date: Wed, 24 Oct 2012 18:29:33 -0700
Subject: [PATCH 138/284] Restructure contains methods to use public jv methods

---
 jv.c | 79 ++++++++++++++++++++++++++++++++++++------------------------
 1 file changed, 48 insertions(+), 31 deletions(-)

diff --git a/jv.c b/jv.c
index 8515e7f4..45df882e 100644
--- a/jv.c
+++ b/jv.c
@@ -250,27 +250,6 @@ static int jvp_array_equal(jv_complex* a, jv_complex* b) {
   return 1;
 }
 
-static int jvp_array_contains(jv_complex* a, jv_complex* b) {
-  int r = 1;
-  for (int bi = 0; bi < jvp_array_length(b); bi++) {
-    int ri = 0;
-    jv* bval = jvp_array_read(b, bi);
-    for (int ai = 0; ai < jvp_array_length(a); ai++) {
-      jv aval = jv_copy(*jvp_array_read(a, ai));
-      jv bval_copy = jv_copy(*bval);
-      if (jv_contains(aval, bval_copy)) {
-        ri = 1;
-        break;
-      }
-    }
-    if (!ri) {
-      r = 0;
-      break;
-    }
-  }
-  return r;
-}
-
 static jv_complex jvp_array_slice(jv_complex* a, int start, int end) {
   // FIXME: maybe slice should reallocate if the slice is small enough
   assert(start <= end);
@@ -350,6 +329,28 @@ jv jv_array_slice(jv a, int start, int end) {
   return a;
 }
 
+int jv_array_contains(jv a, jv b) {
+  int r = 1;
+  int a_length = jv_array_length(jv_copy(a));
+  int b_length = jv_array_length(jv_copy(b));
+  for (int bi = 0; bi < b_length; bi++) {
+    int ri = 0;
+    for (int ai = 0; ai < a_length; ai++) {
+      if (jv_contains(jv_array_get(jv_copy(a), ai), jv_array_get(jv_copy(b), bi))) {
+        ri = 1;
+        break;
+      }
+    }
+    if (!ri) {
+      r = 0;
+      break;
+    }
+  }
+  jv_free(a);
+  jv_free(b);
+  return r;
+}
+
 
 /*
  * Strings (internal helpers)
@@ -889,17 +890,33 @@ int jv_object_contains(jv a, jv b) {
   assert(jv_get_kind(b) == JV_KIND_OBJECT);
   int r = 1;
 
-  for (int i=0; i<jvp_object_size(&b.val.complex); i++) {
-    struct object_slot* slotb = jvp_object_get_slot(&b.val.complex, i);
-    if (!slotb->string) continue;
-    jv* slota = jvp_object_read(&a.val.complex, slotb->string);
-    if (!(slota && jv_get_kind(slotb->value) == jv_get_kind(*slota)
-       && jv_contains(jv_copy(*slota), jv_copy(slotb->value)))) {
-      r = 0;
-      break;
-    }
+  int nkeys = jv_object_length(jv_copy(b));
+  jv* keys = malloc(sizeof(jv) * nkeys);
+  int kidx = 0;
+  jv_object_foreach(i, b) {
+    keys[kidx++] = jv_object_iter_key(b, i);
   }
 
+  for (int i=0; i < nkeys; i++) {
+    jv a_val = jv_object_get(jv_copy(a), jv_copy(keys[i]));
+    jv b_val = jv_object_get(jv_copy(b), jv_copy(keys[i]));
+
+    if (!(jv_get_kind(a_val) == jv_get_kind(b_val)
+       && jv_contains(jv_copy(a_val), jv_copy(b_val)))) {
+      r = 0;
+    }
+
+    jv_free(a_val);
+    jv_free(b_val);
+
+    if (!r) break;
+  }
+
+  for (int i=0; i < nkeys; i++) {
+    jv_free(keys[i]);
+  }
+  free(keys);
+
   jv_free(a);
   jv_free(b);
   return r;
@@ -1027,7 +1044,7 @@ int jv_contains(jv a, jv b) {
   } else if (jv_get_kind(a) == JV_KIND_OBJECT) {
     r = jv_object_contains(jv_copy(a), jv_copy(b));
   } else if (jv_get_kind(a) == JV_KIND_ARRAY) {
-    r = jvp_array_contains(&a.val.complex, &b.val.complex);
+    r = jv_array_contains(jv_copy(a), jv_copy(b));
   } else if (jv_get_kind(a) == JV_KIND_STRING) {
     r = strstr(jv_string_value(a), jv_string_value(b)) != 0;
   } else {

From 1b556315afdafde27a935f711efe212d2d988842 Mon Sep 17 00:00:00 2001
From: Stephen Roantree <stroantree@gmail.com>
Date: Thu, 25 Oct 2012 06:29:23 -0700
Subject: [PATCH 139/284] Remove redundant code from jv_object_contains

---
 jv.c | 26 +++++---------------------
 1 file changed, 5 insertions(+), 21 deletions(-)

diff --git a/jv.c b/jv.c
index 45df882e..77937a8d 100644
--- a/jv.c
+++ b/jv.c
@@ -890,33 +890,17 @@ int jv_object_contains(jv a, jv b) {
   assert(jv_get_kind(b) == JV_KIND_OBJECT);
   int r = 1;
 
-  int nkeys = jv_object_length(jv_copy(b));
-  jv* keys = malloc(sizeof(jv) * nkeys);
-  int kidx = 0;
   jv_object_foreach(i, b) {
-    keys[kidx++] = jv_object_iter_key(b, i);
-  }
+    jv key = jv_object_iter_key(b, i);
+    jv a_val = jv_object_get(jv_copy(a), jv_copy(key));
+    jv b_val = jv_object_get(jv_copy(b), jv_copy(key));
 
-  for (int i=0; i < nkeys; i++) {
-    jv a_val = jv_object_get(jv_copy(a), jv_copy(keys[i]));
-    jv b_val = jv_object_get(jv_copy(b), jv_copy(keys[i]));
-
-    if (!(jv_get_kind(a_val) == jv_get_kind(b_val)
-       && jv_contains(jv_copy(a_val), jv_copy(b_val)))) {
-      r = 0;
-    }
-
-    jv_free(a_val);
-    jv_free(b_val);
+    r = jv_contains(a_val, b_val);
+    jv_free(key);
 
     if (!r) break;
   }
 
-  for (int i=0; i < nkeys; i++) {
-    jv_free(keys[i]);
-  }
-  free(keys);
-
   jv_free(a);
   jv_free(b);
   return r;

From 04640aeaebb71a14b943563e240659274393567f Mon Sep 17 00:00:00 2001
From: Anthony Shortland <anthony@dtosolutions.com>
Date: Tue, 30 Oct 2012 10:26:08 -0700
Subject: [PATCH 140/284] Added initial support for packaging jq as an RPM

---
 Makefile          |  7 +++++++
 rpm/SPECS/jq.spec | 42 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 49 insertions(+)
 create mode 100644 rpm/SPECS/jq.spec

diff --git a/Makefile b/Makefile
index 9c5e1635..85f1c2f3 100644
--- a/Makefile
+++ b/Makefile
@@ -54,3 +54,10 @@ uninstall:
 	cd $(prefix)/bin && \
 	rm -f jq
 
+RELEASE ?= 1
+
+rpmbuild: jq
+	@echo "Packaging jq as an RPM ..."
+	mkdir -p rpm/SOURCES rpm/BUILD rpm/BUILDROOT rpm/RPMS
+	tar --transform="s+^+jq-$$(cat VERSION)/bin/+" -zcf rpm/SOURCES/jq-$$(cat VERSION).tgz jq
+	rpmbuild --target $$(uname -m) --buildroot ${PWD}/rpm/BUILDROOT/jq-$$(cat VERSION)-${RELEASE}.noarch --define "_topdir ${PWD}/rpm" --define "version $$(cat VERSION)" --define "release ${RELEASE}" -bb --clean rpm/SPECS/jq.spec
diff --git a/rpm/SPECS/jq.spec b/rpm/SPECS/jq.spec
new file mode 100644
index 00000000..71b3e792
--- /dev/null
+++ b/rpm/SPECS/jq.spec
@@ -0,0 +1,42 @@
+Summary: Command-line JSON processor
+Name: jq
+Version: %{version}
+Release: %{release}
+Source0: jq-%{version}.tgz
+URL: https://github.com/stedolan/jq
+ 
+License: Copyright (C) 2012 Stephen Dolan
+Group: Applications/System
+# Requires:
+
+# Disables debug packages and stripping of binaries:
+%global _enable_debug_package 0
+%global debug_package %{nil}
+%global __os_install_post %{nil}
+ 
+%description
+jq is a command-line JSON processor
+ 
+%prep
+
+%setup
+
+%build
+ 
+%install
+echo "Building in: \"%{buildroot}\""
+rm -rf %{buildroot}
+install -d -m 755 %{buildroot}/usr/bin
+mv %{_builddir}/jq-%{version}/bin/jq %{buildroot}/usr/bin
+
+%clean
+
+%files
+%defattr(-,root,root)
+/usr/bin/jq
+ 
+%changelog
+
+%pre
+
+%post

From a33c6f3df9d84baf7d2e299e2f0441afea2bd2ec Mon Sep 17 00:00:00 2001
From: Anthony Shortland <anthony@dtosolutions.com>
Date: Tue, 30 Oct 2012 14:30:36 -0700
Subject: [PATCH 141/284] Fixed to work under CentOS 5.4

---
 Makefile | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index 85f1c2f3..59111fa1 100644
--- a/Makefile
+++ b/Makefile
@@ -59,5 +59,8 @@ RELEASE ?= 1
 rpmbuild: jq
 	@echo "Packaging jq as an RPM ..."
 	mkdir -p rpm/SOURCES rpm/BUILD rpm/BUILDROOT rpm/RPMS
-	tar --transform="s+^+jq-$$(cat VERSION)/bin/+" -zcf rpm/SOURCES/jq-$$(cat VERSION).tgz jq
+	rm -rf jq-$$(cat VERSION)
+	mkdir -p jq-$$(cat VERSION)/bin
+	cp jq jq-$$(cat VERSION)/bin
+	tar -zcf rpm/SOURCES/jq-$$(cat VERSION).tgz jq-$$(cat VERSION)/bin/jq
 	rpmbuild --target $$(uname -m) --buildroot ${PWD}/rpm/BUILDROOT/jq-$$(cat VERSION)-${RELEASE}.noarch --define "_topdir ${PWD}/rpm" --define "version $$(cat VERSION)" --define "release ${RELEASE}" -bb --clean rpm/SPECS/jq.spec

From f19ba32fdde2bfea89e6c10a9183d130b6de99aa Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 25 Nov 2012 23:07:43 +0000
Subject: [PATCH 142/284] Minor refactor of function call setup to allow for
 multiple arguments.

---
 compile.c     | 122 +++++++++++++++++++++++++++++++++++++++++---------
 opcode.c      |   1 +
 opcode_list.h |   1 +
 3 files changed, 102 insertions(+), 22 deletions(-)

diff --git a/compile.c b/compile.c
index fe50c70a..e0f675f8 100644
--- a/compile.c
+++ b/compile.c
@@ -30,7 +30,9 @@ struct inst {
   // are bound, and even then only for instructions which bind.
   struct inst* bound_by;
   char* symbol;
+
   block subfn;
+  block arglist;
 
   // This instruction is compiled as part of which function?
   // (only used during block_compile)
@@ -47,6 +49,7 @@ static inst* inst_new(opcode op) {
   i->bound_by = 0;
   i->symbol = 0;
   i->subfn = gen_noop();
+  i->arglist = gen_noop();
   i->source = UNKNOWN_LOCATION;
   return i;
 }
@@ -56,6 +59,9 @@ static void inst_free(struct inst* i) {
   if (opcode_describe(i->op)->flags & OP_HAS_BLOCK) {
     block_free(i->subfn);
   }
+  if (opcode_describe(i->op)->flags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
+    block_free(i->arglist);
+  }
   if (opcode_describe(i->op)->flags & OP_HAS_CONSTANT) {
     jv_free(i->imm.constant);
   }
@@ -186,30 +192,11 @@ block gen_op_block_bound(opcode op, block binder) {
 }
 
 block gen_op_call(opcode op, block arglist) {
+  assert(op == CALL_1_1);
   assert(opcode_describe(op)->flags & OP_HAS_VARIABLE_LENGTH_ARGLIST);
   inst* i = inst_new(op);
-  block prelude = gen_noop();
-  block call = inst_block(i);
-  int nargs = 0;
-  inst* curr = 0;
-  while ((curr = block_take(&arglist))) {
-    assert(opcode_describe(curr->op)->flags & OP_IS_CALL_PSEUDO);
-    block bcurr = inst_block(curr);
-    switch (curr->op) {
-    default: assert(0 && "Unknown type of parameter"); break;
-    case CLOSURE_REF:
-      block_append(&call, bcurr);
-      break;
-    case CLOSURE_CREATE:
-      block_append(&prelude, bcurr);
-      block_append(&call, gen_op_block_bound(CLOSURE_REF, bcurr));
-      break;
-    }
-    nargs++;
-  }
-  assert(nargs < 100); //FIXME
-  i->imm.intval = nargs;
-  return block_join(prelude, call);
+  i->arglist = arglist;
+  return block_join(inst_block(i), inst_block(inst_new(CALLSEQ_END)));
 }
 
 static void inst_join(inst* a, inst* b) {
@@ -220,6 +207,32 @@ static void inst_join(inst* a, inst* b) {
   b->prev = a;
 }
 
+static void block_insert_after(inst* i, block b) {
+  if (b.first) {
+    assert(b.last);
+    if (i->next) {
+      inst* j = i->next;
+      i->next = 0;
+      j->prev = 0;
+      inst_join(b.last, j);
+    }
+    inst_join(i, b.first);
+  }
+}
+
+static void block_insert_before(inst* i, block b) {
+  if (b.first) {
+    assert(b.last);
+    if (i->prev) {
+      inst* j = i->prev;
+      i->prev = 0;
+      j->next = 0;
+      inst_join(j, b.first);
+    }
+    inst_join(b.last, i);
+  }
+}
+
 void block_append(block* b, block b2) {
   if (b2.first) {
     if (b->last) {
@@ -266,6 +279,10 @@ static void block_bind_subblock(block binder, block body, int bindflags) {
       // binding recurses into closures
       block_bind_subblock(binder, i->subfn, bindflags);
     }
+    if (flags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
+      // binding recurses into argument list
+      block_bind_subblock(binder, i->arglist, bindflags);
+    }
   }
 }
 
@@ -457,12 +474,70 @@ static int count_cfunctions(block b) {
   return n;
 }
 
+
+// Expands call instructions into a calling sequence
+// Checking for argument count compatibility happens later
+static void expand_call_arglist(struct bytecode* bc, block b) {
+  for (inst* curr = b.first; curr; curr = curr->next) {
+    if (opcode_describe(curr->op)->flags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
+      assert(curr->op == CALL_1_1);
+      assert(curr->next && curr->next->op == CALLSEQ_END);
+      // We expand the argument list as a series of instructions
+      block arglist = curr->arglist;
+      curr->arglist = gen_noop();
+      assert(arglist.first && "zeroth argument (function to call) must be present");
+      inst* function = arglist.first->bound_by;
+      assert(function);
+
+      switch (function->op) {
+      default: assert(0 && "Unknown parameter type"); break;
+      case CLOSURE_CREATE: 
+      case CLOSURE_PARAM: {
+        block prelude = gen_noop();
+        block callargs = gen_noop();
+        int nargs = 0;
+        for (inst* i; (i = block_take(&arglist));) {
+          assert(opcode_describe(i->op)->flags & OP_IS_CALL_PSEUDO);
+          block b = inst_block(i);
+          switch (i->op) {
+          default: assert(0 && "Unknown type of parameter"); break;
+          case CLOSURE_REF:
+            block_append(&callargs, b);
+            break;
+          case CLOSURE_CREATE:
+            block_append(&prelude, b);
+            block_append(&callargs, gen_op_block_bound(CLOSURE_REF, b));
+            break;
+          }
+          nargs++;
+        }
+
+        assert(!arglist.first);
+        block_insert_before(curr, prelude);
+        block_insert_after(curr, callargs);
+        curr->imm.intval = nargs;
+        break;
+      }
+
+      case CLOSURE_CREATE_C:
+        // Arguments to C functions not yet supported
+        assert(block_is_single(arglist));
+        assert(arglist.first->op == CLOSURE_REF);
+        block_insert_after(curr, arglist);
+        curr->imm.intval = 1;
+        break;
+      }
+    }
+  }
+}
+
 static int compile(struct locfile* locations, struct bytecode* bc, block b) {
   int errors = 0;
   int pos = 0;
   int var_frame_idx = 0;
   bc->nsubfunctions = 0;
   bc->nclosures = 0;
+  expand_call_arglist(bc, b);
   for (inst* curr = b.first; curr; curr = curr->next) {
     if (!curr->next) assert(curr == b.last);
     pos += opcode_length(curr->op);
@@ -484,6 +559,7 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
       assert(curr->bound_by == curr);
       curr->imm.intval = bc->nsubfunctions++;
     }
+
     if (curr->op == CLOSURE_PARAM) {
       assert(curr->bound_by == curr);
       curr->imm.intval = bc->nclosures++;
@@ -524,9 +600,11 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
     int opflags = op->flags;
     assert(!(op->flags & OP_IS_CALL_PSEUDO));
     if (opflags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
+      assert(curr->op == CALL_1_1);
       int nargs = curr->imm.intval;
       assert(nargs > 0);
       code[pos++] = (uint16_t)nargs;
+
       int desired_params = 0;
       for (int i=0; i<nargs; i++) {
         curr = curr->next;
diff --git a/opcode.c b/opcode.c
index bc259c22..6e85e709 100644
--- a/opcode.c
+++ b/opcode.c
@@ -7,6 +7,7 @@
 #define BRANCH OP_HAS_BRANCH, 2
 #define CFUNC (OP_HAS_SYMBOL | OP_HAS_CFUNC | OP_HAS_VARIABLE_LENGTH_ARGLIST), 2
 #define UFUNC (OP_HAS_UFUNC | OP_HAS_VARIABLE_LENGTH_ARGLIST), 2
+#define CALLSEQ_END_IMM (OP_IS_CALL_PSEUDO), 0
 #define CLOSURE_PARAM_IMM (OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 0
 #define CLOSURE_CREATE_IMM (OP_HAS_BLOCK | OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 0
 #define CLOSURE_CREATE_C_IMM (OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 0
diff --git a/opcode_list.h b/opcode_list.h
index 306373fb..00817a13 100644
--- a/opcode_list.h
+++ b/opcode_list.h
@@ -24,6 +24,7 @@ OP(CALL_BUILTIN_3_1, CFUNC, 3, 1)
 OP(CALL_1_1, UFUNC, 1, 1)
 OP(RET, NONE, 1, 1)
 
+OP(CALLSEQ_END, CALLSEQ_END_IMM, 0, 0)
 OP(CLOSURE_PARAM, CLOSURE_PARAM_IMM, 0, 0)
 OP(CLOSURE_REF, CLOSURE_REF_IMM, 0, 0)
 OP(CLOSURE_CREATE, CLOSURE_CREATE_IMM, 0, 0)

From 924aeda5043d76296c651d20025881a60161b7d3 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 25 Nov 2012 23:49:57 +0000
Subject: [PATCH 143/284] Add some preprocessor junk to make codegen cleaner.

---
 compile.c | 153 +++++++++++++++++++++---------------------------------
 compile.h |  16 ++++++
 parser.y  |  38 ++++----------
 testdata  |   5 ++
 4 files changed, 91 insertions(+), 121 deletions(-)

diff --git a/compile.c b/compile.c
index e0f675f8..68d3fb92 100644
--- a/compile.c
+++ b/compile.c
@@ -297,150 +297,115 @@ block block_bind(block binder, block body, int bindflags) {
 
 
 block gen_subexp(block a) {
-  block c = gen_noop();
-  block_append(&c, gen_op_simple(DUP));
-  block_append(&c, a);
-  block_append(&c, gen_op_simple(SWAP));
-  return c;
+  return BLOCK(gen_op_simple(DUP), a, gen_op_simple(SWAP));
 }
 
 block gen_both(block a, block b) {
-  block c = gen_noop();
   block jump = gen_op_targetlater(JUMP);
-  block fork = gen_op_targetlater(FORK);
-  block_append(&c, fork);
-  block_append(&c, a);
-  block_append(&c, jump);
-  inst_set_target(fork, c);
-  block_append(&c, b);
+  block fork = gen_op_target(FORK, jump);
+  block c = BLOCK(fork, a, jump, b);
   inst_set_target(jump, c);
   return c;
 }
 
 
 block gen_collect(block expr) {
-  block c = gen_noop();
-  block_append(&c, gen_op_simple(DUP));
-  block_append(&c, gen_op_const(LOADK, jv_array()));
   block array_var = block_bind(gen_op_var_unbound(STOREV, "collect"),
                                gen_noop(), OP_HAS_VARIABLE);
-  block_append(&c, array_var);
+  block c = BLOCK(gen_op_simple(DUP), gen_op_const(LOADK, jv_array()), array_var);
 
-  block tail = {0};
-  block_append(&tail, gen_op_simple(DUP));
-  block_append(&tail, gen_op_var_bound(LOADV, array_var));
-  block_append(&tail, gen_op_simple(SWAP));
-  block_append(&tail, gen_op_simple(APPEND));
-  block_append(&tail, gen_op_var_bound(STOREV, array_var));
-  block_append(&tail, gen_op_simple(BACKTRACK));
+  block tail = BLOCK(gen_op_simple(DUP),
+                     gen_op_var_bound(LOADV, array_var),
+                     gen_op_simple(SWAP),
+                     gen_op_simple(APPEND),
+                     gen_op_var_bound(STOREV, array_var),
+                     gen_op_simple(BACKTRACK));
 
-  block_append(&c, gen_op_target(FORK, tail));
-  block_append(&c, expr);
-  block_append(&c, tail);
-
-  block_append(&c, gen_op_var_bound(LOADV, array_var));
-
-  return c;
+  return BLOCK(c,
+               gen_op_target(FORK, tail),
+               expr, 
+               tail,
+               gen_op_var_bound(LOADV, array_var));
 }
 
 block gen_assign(block expr) {
-  block c = gen_noop();
-  block_append(&c, gen_op_simple(DUP));
   block result_var = block_bind(gen_op_var_unbound(STOREV, "result"),
                                 gen_noop(), OP_HAS_VARIABLE);
-  block_append(&c, result_var);
 
-  block loop = gen_noop();
-  block_append(&loop, gen_op_simple(DUP));
-  block_append(&loop, expr);
-  block_append(&loop, gen_op_var_bound(ASSIGN, result_var));
-  block_append(&loop, gen_op_simple(BACKTRACK));
+  block loop = BLOCK(gen_op_simple(DUP),
+                     expr,
+                     gen_op_var_bound(ASSIGN, result_var),
+                     gen_op_simple(BACKTRACK));
 
-  block_append(&c, gen_op_target(FORK, loop));
-  block_append(&c, loop);
-  block_append(&c, gen_op_var_bound(LOADV, result_var));
-  return c;
+  return BLOCK(gen_op_simple(DUP),
+               result_var,
+               gen_op_target(FORK, loop),
+               loop,
+               gen_op_var_bound(LOADV, result_var));
 }
 
 block gen_definedor(block a, block b) {
   // var found := false
-  block c = gen_op_simple(DUP);
-  block_append(&c, gen_op_const(LOADK, jv_false()));
   block found_var = block_bind(gen_op_var_unbound(STOREV, "found"),
                                gen_noop(), OP_HAS_VARIABLE);
-  block_append(&c, found_var);
+  block init = BLOCK(gen_op_simple(DUP), gen_op_const(LOADK, jv_false()), found_var);
 
   // if found, backtrack. Otherwise execute b
-  block tail = gen_op_simple(DUP);
-  block_append(&tail, gen_op_var_bound(LOADV, found_var));
   block backtrack = gen_op_simple(BACKTRACK);
-  block_append(&tail, gen_op_target(JUMP_F, backtrack));
-  block_append(&tail, backtrack);
-  block_append(&tail, gen_op_simple(POP));
-  block_append(&tail, b);
+  block tail = BLOCK(gen_op_simple(DUP),
+                     gen_op_var_bound(LOADV, found_var),
+                     gen_op_target(JUMP_F, backtrack),
+                     backtrack,
+                     gen_op_simple(POP),
+                     b);
 
   // try again
   block if_notfound = gen_op_simple(BACKTRACK);
 
   // found := true, produce result
-  block if_found = gen_op_simple(DUP);
-  block_append(&if_found, gen_op_const(LOADK, jv_true()));
-  block_append(&if_found, gen_op_var_bound(STOREV, found_var));
-  block_append(&if_found, gen_op_target(JUMP, tail));
+  block if_found = BLOCK(gen_op_simple(DUP),
+                         gen_op_const(LOADK, jv_true()),
+                         gen_op_var_bound(STOREV, found_var),
+                         gen_op_target(JUMP, tail));
 
-  block_append(&c, gen_op_target(FORK, if_notfound));
-  block_append(&c, a);
-  block_append(&c, gen_op_target(JUMP_F, if_found));
-  block_append(&c, if_found);
-  block_append(&c, if_notfound);
-  block_append(&c, tail);
-
-  return c;
+  return BLOCK(init,
+               gen_op_target(FORK, if_notfound),
+               a,
+               gen_op_target(JUMP_F, if_found),
+               if_found,
+               if_notfound,
+               tail);
 }
 
 block gen_condbranch(block iftrue, block iffalse) {
-  block b = gen_noop();
-  block_append(&iftrue, gen_op_target(JUMP, iffalse));
-  block_append(&b, gen_op_target(JUMP_F, iftrue));
-  block_append(&b, iftrue);
-  block_append(&b, iffalse);
-  return b;
+  iftrue = BLOCK(iftrue, gen_op_target(JUMP, iffalse));
+  return BLOCK(gen_op_target(JUMP_F, iftrue), iftrue, iffalse);
 }
 
 block gen_and(block a, block b) {
   // a and b = if a then (if b then true else false) else false
-  block code = gen_op_simple(DUP);
-  block_append(&code, a);
-
-  block if_a_true = gen_op_simple(POP);
-  block_append(&if_a_true, b);
-  block_append(&if_a_true, gen_condbranch(gen_op_const(LOADK, jv_true()),
-                                          gen_op_const(LOADK, jv_false())));
-  block_append(&code, gen_condbranch(if_a_true,
-                                     block_join(gen_op_simple(POP), gen_op_const(LOADK, jv_false()))));
-  return code;
+  return BLOCK(gen_op_simple(DUP), a, 
+               gen_condbranch(BLOCK(gen_op_simple(POP),
+                                    b,
+                                    gen_condbranch(gen_op_const(LOADK, jv_true()),
+                                                   gen_op_const(LOADK, jv_false()))),
+                              BLOCK(gen_op_simple(POP), gen_op_const(LOADK, jv_false()))));
 }
 
 block gen_or(block a, block b) {
   // a or b = if a then true else (if b then true else false)
-  block code = gen_op_simple(DUP);
-  block_append(&code, a);
-
-  block if_a_false = gen_op_simple(POP);
-  block_append(&if_a_false, b);
-  block_append(&if_a_false, gen_condbranch(gen_op_const(LOADK, jv_true()),
-                                           gen_op_const(LOADK, jv_false())));
-  block_append(&code, gen_condbranch(block_join(gen_op_simple(POP), gen_op_const(LOADK, jv_true())),
-                                     if_a_false));
-  return code;
+  return BLOCK(gen_op_simple(DUP), a,
+               gen_condbranch(BLOCK(gen_op_simple(POP), gen_op_const(LOADK, jv_true())),
+                              BLOCK(gen_op_simple(POP),
+                                    b,
+                                    gen_condbranch(gen_op_const(LOADK, jv_true()),
+                                                   gen_op_const(LOADK, jv_false())))));
 }
 
 block gen_cond(block cond, block iftrue, block iffalse) {
-  block b = gen_op_simple(DUP);
-  block_append(&b, cond);
-  block_append(&b, gen_condbranch(block_join(gen_op_simple(POP), iftrue),
-                                  block_join(gen_op_simple(POP), iffalse)));
-  return b;
+  return BLOCK(gen_op_simple(DUP), cond, 
+               gen_condbranch(BLOCK(gen_op_simple(POP), iftrue),
+                              BLOCK(gen_op_simple(POP), iffalse)));
 }
 
 block gen_cbinding(struct symbol_table* t, block code) {
diff --git a/compile.h b/compile.h
index 5390420b..9a5f92e5 100644
--- a/compile.h
+++ b/compile.h
@@ -52,4 +52,20 @@ void block_free(block);
 
 
 
+// Here's some horrible preprocessor gunk so that code
+// sequences can be contructed as BLOCK(block1, block2, block3)
+
+#define BLOCK_1(b1) (b1)
+#define BLOCK_2(b1,b2) (block_join((b1),(b2)))
+#define BLOCK_3(b1,b2,b3) (block_join(BLOCK_2(b1,b2),(b3)))
+#define BLOCK_4(b1,b2,b3,b4) (block_join(BLOCK_3(b1,b2,b3),(b4)))
+#define BLOCK_5(b1,b2,b3,b4,b5) (block_join(BLOCK_4(b1,b2,b3,b4),(b5)))
+#define BLOCK_6(b1,b2,b3,b4,b5,b6) (block_join(BLOCK_5(b1,b2,b3,b4,b5),(b6)))
+#define BLOCK_7(b1,b2,b3,b4,b5,b6,b7) (block_join(BLOCK_6(b1,b2,b3,b4,b5,b6),(b7)))
+
+#define BLOCK_IDX(_1,_2,_3,_4,_5,_6,_7,NAME,...) NAME
+#define BLOCK(...) \
+  BLOCK_IDX(__VA_ARGS__, BLOCK_7, BLOCK_6, BLOCK_5, BLOCK_4, BLOCK_3, BLOCK_2, BLOCK_1)(__VA_ARGS__)
+
+
 #endif
diff --git a/parser.y b/parser.y
index d64a2ec5..73943c38 100644
--- a/parser.y
+++ b/parser.y
@@ -129,14 +129,11 @@ int yylex(YYSTYPE* yylval, YYLTYPE* yylloc, block* answer, int* errors,
 }
 
 static block gen_dictpair(block k, block v) {
-  block b = gen_subexp(k);
-  block_append(&b, gen_subexp(v));
-  block_append(&b, gen_op_simple(INSERT));
-  return b;
+  return BLOCK(gen_subexp(k), gen_subexp(v), gen_op_simple(INSERT));
 }
 
 static block gen_index(block obj, block key) {
-  return block_join(obj, block_join(gen_subexp(key), gen_op_simple(INDEX)));
+  return BLOCK(obj, gen_subexp(key), gen_op_simple(INDEX));
 }
 
 static block gen_binop(block a, block b, int op) {
@@ -155,25 +152,19 @@ static block gen_binop(block a, block b, int op) {
   }
   assert(funcname);
 
-  block c = gen_noop();
-  block_append(&c, gen_subexp(a));
-  block_append(&c, gen_subexp(b));
-  block_append(&c, gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, funcname)));
-  return c;
+  return BLOCK(gen_subexp(a), gen_subexp(b), 
+               gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, funcname)));
 }
 
 static block gen_format(block a) {
-  return block_join(a, gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, "tostring")));
+  return BLOCK(a, gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, "tostring")));
 }
  
 static block gen_update(block a, block op, int optype) {
-  block assign = a;
-  block_append(&assign, gen_op_simple(DUP));
   if (optype) {
     op = gen_binop(gen_noop(), op, optype);
   }
-  block_append(&assign, op);
-  return gen_assign(assign);
+  return gen_assign(BLOCK(a, gen_op_simple(DUP), op));
 }
 
 %}
@@ -201,9 +192,9 @@ FuncDef Exp %prec ';' {
 } |
 
 Term "as" '$' IDENT '|' Exp {
-  $$ = gen_op_simple(DUP);
-  block_append(&$$, $1);
-  block_append(&$$, block_bind(gen_op_var_unbound(STOREV, jv_string_value($4)), $6, OP_HAS_VARIABLE));
+  $$ = BLOCK(gen_op_simple(DUP), $1, 
+             block_bind(gen_op_var_unbound(STOREV, jv_string_value($4)), 
+                        $6, OP_HAS_VARIABLE));
   jv_free($4);
 } |
 
@@ -216,12 +207,7 @@ Term "as" '$' IDENT '|' Exp {
 } |
 
 Exp '=' Exp {
-  block assign = gen_op_simple(DUP);
-  block_append(&assign, $3);
-  block_append(&assign, gen_op_simple(SWAP));
-  block_append(&assign, $1);
-  block_append(&assign, gen_op_simple(SWAP));
-  $$ = gen_assign(assign);
+  $$ = gen_assign(BLOCK(gen_op_simple(DUP), $3, gen_op_simple(SWAP), $1, gen_op_simple(SWAP)));
 } |
 
 Exp "or" Exp {
@@ -394,9 +380,7 @@ String {
   $$ = gen_op_const(LOADK, jv_array()); 
 } |
 '{' MkDict '}' { 
-  $$ = gen_subexp(gen_op_const(LOADK, jv_object()));
-  block_append(&$$, $2);
-  block_append(&$$, gen_op_simple(POP));
+  $$ = BLOCK(gen_subexp(gen_op_const(LOADK, jv_object())), $2, gen_op_simple(POP));
 } |
 '$' IDENT {
   $$ = gen_location(@$, gen_op_var_unbound(LOADV, jv_string_value($2)));
diff --git a/testdata b/testdata
index 8cd5e27c..4fff7167 100644
--- a/testdata
+++ b/testdata
@@ -97,6 +97,11 @@ null
 1
 1
 
+1,.
+[]
+1
+[]
+
 [.]
 [2]
 [[2]]

From 3e3fe5195947a0af711959e2dedc9c84a697c5fb Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 26 Nov 2012 00:39:01 +0000
Subject: [PATCH 144/284] Clean up function creation API and epilogue
 generation.

---
 builtin.c | 20 ++++++--------------
 compile.c | 50 +++++++++++++++++++++++++++-----------------------
 compile.h |  3 +--
 execute.c |  1 -
 parser.y  | 11 ++++-------
 5 files changed, 38 insertions(+), 47 deletions(-)

diff --git a/builtin.c b/builtin.c
index 3d726854..e1144e3d 100644
--- a/builtin.c
+++ b/builtin.c
@@ -252,32 +252,24 @@ static void f_type(jv input[], jv output[]) {
 }
 
 static block j_empty() {
-  return gen_op_block_defn(CLOSURE_CREATE, "empty", gen_op_simple(BACKTRACK));
+  return gen_function("empty", gen_op_simple(BACKTRACK));
 }
 
 static block j_false() {
-  return gen_op_block_defn(CLOSURE_CREATE, "false",
-                           block_join(gen_op_const(LOADK, jv_false()),
-                                      gen_op_simple(RET)));
+  return gen_function("false", gen_op_const(LOADK, jv_false()));
 }
 
 static block j_true() {
-  return gen_op_block_defn(CLOSURE_CREATE, "true",
-                           block_join(gen_op_const(LOADK, jv_true()),
-                                      gen_op_simple(RET)));
+  return gen_function("true", gen_op_const(LOADK, jv_true()));
 }
 
 static block j_null() {
-  return gen_op_block_defn(CLOSURE_CREATE, "null",
-                           block_join(gen_op_const(LOADK, jv_null()),
-                                      gen_op_simple(RET)));
+  return gen_function("null", gen_op_const(LOADK, jv_null()));
 }
 
 static block j_not() {
-  return gen_op_block_defn(CLOSURE_CREATE, "not",
-                           block_join(gen_condbranch(gen_op_const(LOADK, jv_false()),
-                                                     gen_op_const(LOADK, jv_true())),
-                                      gen_op_simple(RET)));
+  return gen_function("not", gen_condbranch(gen_op_const(LOADK, jv_false()),
+                                            gen_op_const(LOADK, jv_true())));
 }
 
 static struct cfunction function_list[] = {
diff --git a/compile.c b/compile.c
index 68d3fb92..b2878b1a 100644
--- a/compile.c
+++ b/compile.c
@@ -161,22 +161,6 @@ block gen_op_symbol(opcode op, const char* sym) {
   return inst_block(i);
 }
 
-block gen_op_block_defn(opcode op, const char* name, block block) {
-  assert(opcode_describe(op)->flags & OP_IS_CALL_PSEUDO);
-  assert(opcode_describe(op)->flags & OP_HAS_BLOCK);
-  inst* i = inst_new(op);
-  i->subfn = block;
-  i->symbol = strdup(name);
-  return inst_block(i);
-}
-
-static void block_bind_subblock(block binder, block body, int bindflags);
-block gen_op_block_defn_rec(opcode op, const char* name, block blk) {
-  block b = gen_op_block_defn(op, name, blk);
-  block_bind_subblock(b, b, OP_IS_CALL_PSEUDO | OP_HAS_BINDING);
-  return b;
-}
-
 block gen_op_block_unbound(opcode op, const char* name) {
   assert(opcode_describe(op)->flags & OP_IS_CALL_PSEUDO);
   inst* i = inst_new(op);
@@ -296,6 +280,16 @@ block block_bind(block binder, block body, int bindflags) {
 }
 
 
+block gen_function(const char* name, block body) {
+  inst* i = inst_new(CLOSURE_CREATE);
+  i->subfn = body;
+  i->symbol = strdup(name);
+  block b = inst_block(i);
+  block_bind_subblock(b, b, OP_IS_CALL_PSEUDO | OP_HAS_BINDING);
+  return b;
+}
+
+
 block gen_subexp(block a) {
   return BLOCK(gen_op_simple(DUP), a, gen_op_simple(SWAP));
 }
@@ -442,11 +436,13 @@ static int count_cfunctions(block b) {
 
 // Expands call instructions into a calling sequence
 // Checking for argument count compatibility happens later
-static void expand_call_arglist(struct bytecode* bc, block b) {
-  for (inst* curr = b.first; curr; curr = curr->next) {
+static block expand_call_arglist(struct bytecode* bc, block b) {
+  block ret = gen_noop();
+  for (inst* curr; (curr = block_take(&b));) {
     if (opcode_describe(curr->op)->flags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
       assert(curr->op == CALL_1_1);
-      assert(curr->next && curr->next->op == CALLSEQ_END);
+      inst* seq_end = block_take(&b);
+      assert(seq_end && seq_end->op == CALLSEQ_END);
       // We expand the argument list as a series of instructions
       block arglist = curr->arglist;
       curr->arglist = gen_noop();
@@ -478,9 +474,8 @@ static void expand_call_arglist(struct bytecode* bc, block b) {
         }
 
         assert(!arglist.first);
-        block_insert_before(curr, prelude);
-        block_insert_after(curr, callargs);
         curr->imm.intval = nargs;
+        ret = BLOCK(ret, prelude, inst_block(curr), callargs, inst_block(seq_end));
         break;
       }
 
@@ -488,12 +483,21 @@ static void expand_call_arglist(struct bytecode* bc, block b) {
         // Arguments to C functions not yet supported
         assert(block_is_single(arglist));
         assert(arglist.first->op == CLOSURE_REF);
-        block_insert_after(curr, arglist);
         curr->imm.intval = 1;
+        ret = BLOCK(ret, inst_block(curr), arglist, inst_block(seq_end));
         break;
       }
+    } else {
+      ret = BLOCK(ret, inst_block(curr));
     }
   }
+  if (bc->parent) {
+    // functions should end in a return
+    return BLOCK(ret, gen_op_simple(RET));
+  } else {
+    // the toplevel should YIELD;BACKTRACK; when it finds an answer
+    return BLOCK(ret, gen_op_simple(YIELD), gen_op_simple(BACKTRACK));
+  }
 }
 
 static int compile(struct locfile* locations, struct bytecode* bc, block b) {
@@ -502,7 +506,7 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
   int var_frame_idx = 0;
   bc->nsubfunctions = 0;
   bc->nclosures = 0;
-  expand_call_arglist(bc, b);
+  b = expand_call_arglist(bc, b);
   for (inst* curr = b.first; curr; curr = curr->next) {
     if (!curr->next) assert(curr == b.last);
     pos += opcode_length(curr->op);
diff --git a/compile.h b/compile.h
index 9a5f92e5..d9ed654e 100644
--- a/compile.h
+++ b/compile.h
@@ -22,12 +22,11 @@ block gen_op_const(opcode op, jv constant);
 block gen_op_target(opcode op, block target);
 block gen_op_var_unbound(opcode op, const char* name);
 block gen_op_var_bound(opcode op, block binder);
-block gen_op_block_defn(opcode op, const char* name, block block);
-block gen_op_block_defn_rec(opcode op, const char* name, block block);
 block gen_op_block_unbound(opcode op, const char* name);
 block gen_op_call(opcode op, block arglist);
 block gen_op_symbol(opcode op, const char* name);
 
+block gen_function(const char* name, block body);
 block gen_subexp(block a);
 block gen_both(block a, block b);
 block gen_collect(block expr);
diff --git a/execute.c b/execute.c
index 93aefc0e..605db552 100644
--- a/execute.c
+++ b/execute.c
@@ -512,7 +512,6 @@ struct bytecode* jq_compile(const char* str) {
   struct bytecode* bc = 0;
   int nerrors = jq_parse(&locations, &program);
   if (nerrors == 0) {
-    block_append(&program, block_join(gen_op_simple(YIELD), gen_op_simple(BACKTRACK)));
     program = builtins_bind(program);
     nerrors = block_compile(program, &locations, &bc);
     block_free(program);
diff --git a/parser.y b/parser.y
index 73943c38..e8cbf6d8 100644
--- a/parser.y
+++ b/parser.y
@@ -305,14 +305,13 @@ QQSTRING_START QQString QQSTRING_END {
 
 FuncDef:
 "def" IDENT ':' Exp ';' {
-  block body = block_join($4, gen_op_simple(RET));
-  $$ = gen_op_block_defn_rec(CLOSURE_CREATE, jv_string_value($2), body);
+  $$ = gen_function(jv_string_value($2), $4);
   jv_free($2);
 } |
 
 "def" IDENT '(' IDENT ')' ':' Exp ';' {
-  block body = block_bind(gen_op_block_unbound(CLOSURE_PARAM, jv_string_value($4)), block_join($7, gen_op_simple(RET)), OP_IS_CALL_PSEUDO);
-  $$ = gen_op_block_defn_rec(CLOSURE_CREATE, jv_string_value($2), body);
+  block body = block_bind(gen_op_block_unbound(CLOSURE_PARAM, jv_string_value($4)), $7, OP_IS_CALL_PSEUDO);
+  $$ = gen_function(jv_string_value($2), body);
   jv_free($2);
   jv_free($4);
 }
@@ -393,9 +392,7 @@ IDENT {
 IDENT '(' Exp ')' {
   $$ = gen_op_call(CALL_1_1, 
                    block_join(gen_op_block_unbound(CLOSURE_REF, jv_string_value($1)),
-                              block_bind(gen_op_block_defn(CLOSURE_CREATE,
-                                                "lambda",
-                                                           block_join($3, gen_op_simple(RET))),
+                              block_bind(gen_function("@lambda", $3),
                                          gen_noop(), OP_IS_CALL_PSEUDO)));
   $$ = gen_location(@1, $$);
   jv_free($1);

From 4747f8681b3442af8b7916ac5bdfec712662c49b Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 26 Nov 2012 01:36:55 +0000
Subject: [PATCH 145/284] Transparent handling for CBV arguments to C
 functions.

C function arguments closures are inlined before the call.
---
 compile.c | 63 +++++++++++++++++++++++++++++++++++--------------------
 compile.h |  3 ++-
 execute.c |  1 -
 parser.y  | 12 ++++-------
 4 files changed, 46 insertions(+), 33 deletions(-)

diff --git a/compile.c b/compile.c
index b2878b1a..46e5dd88 100644
--- a/compile.c
+++ b/compile.c
@@ -175,14 +175,6 @@ block gen_op_block_bound(opcode op, block binder) {
   return b;
 }
 
-block gen_op_call(opcode op, block arglist) {
-  assert(op == CALL_1_1);
-  assert(opcode_describe(op)->flags & OP_HAS_VARIABLE_LENGTH_ARGLIST);
-  inst* i = inst_new(op);
-  i->arglist = arglist;
-  return block_join(inst_block(i), inst_block(inst_new(CALLSEQ_END)));
-}
-
 static void inst_join(inst* a, inst* b) {
   assert(a && b);
   assert(!a->next);
@@ -289,6 +281,17 @@ block gen_function(const char* name, block body) {
   return b;
 }
 
+block gen_lambda(block body) {
+  return gen_function("@lambda", body);
+}
+
+block gen_call(const char* name, block args) {
+  inst* i = inst_new(CALL_1_1);
+  i->arglist = BLOCK(gen_op_block_unbound(CLOSURE_REF, name), args);
+  return BLOCK(inst_block(i), inst_block(inst_new(CALLSEQ_END)));
+}
+
+
 
 block gen_subexp(block a) {
   return BLOCK(gen_op_simple(DUP), a, gen_op_simple(SWAP));
@@ -436,7 +439,7 @@ static int count_cfunctions(block b) {
 
 // Expands call instructions into a calling sequence
 // Checking for argument count compatibility happens later
-static block expand_call_arglist(struct bytecode* bc, block b) {
+static block expand_call_arglist(block b) {
   block ret = gen_noop();
   for (inst* curr; (curr = block_take(&b));) {
     if (opcode_describe(curr->op)->flags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
@@ -448,7 +451,7 @@ static block expand_call_arglist(struct bytecode* bc, block b) {
       curr->arglist = gen_noop();
       assert(arglist.first && "zeroth argument (function to call) must be present");
       inst* function = arglist.first->bound_by;
-      assert(function);
+      assert(function); // FIXME better errors
 
       switch (function->op) {
       default: assert(0 && "Unknown parameter type"); break;
@@ -479,25 +482,30 @@ static block expand_call_arglist(struct bytecode* bc, block b) {
         break;
       }
 
-      case CLOSURE_CREATE_C:
+      case CLOSURE_CREATE_C: {
         // Arguments to C functions not yet supported
-        assert(block_is_single(arglist));
-        assert(arglist.first->op == CLOSURE_REF);
+        inst* cfunction_ref = block_take(&arglist);
+        block prelude = gen_noop();
+        int nargs = 0;
+        for (inst* i; (i = block_take(&arglist)); ) {
+          assert(i->op == CLOSURE_CREATE); // FIXME
+          block body = i->subfn;
+          i->subfn = gen_noop();
+          inst_free(i);
+          prelude = BLOCK(prelude, gen_subexp(expand_call_arglist(body)));
+          nargs++;
+        }
+        assert(curr->op == CALL_1_1);
         curr->imm.intval = 1;
-        ret = BLOCK(ret, inst_block(curr), arglist, inst_block(seq_end));
+        ret = BLOCK(ret, prelude, inst_block(curr), inst_block(cfunction_ref), inst_block(seq_end));
         break;
       }
+      }
     } else {
       ret = BLOCK(ret, inst_block(curr));
     }
   }
-  if (bc->parent) {
-    // functions should end in a return
-    return BLOCK(ret, gen_op_simple(RET));
-  } else {
-    // the toplevel should YIELD;BACKTRACK; when it finds an answer
-    return BLOCK(ret, gen_op_simple(YIELD), gen_op_simple(BACKTRACK));
-  }
+  return ret;
 }
 
 static int compile(struct locfile* locations, struct bytecode* bc, block b) {
@@ -506,7 +514,14 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
   int var_frame_idx = 0;
   bc->nsubfunctions = 0;
   bc->nclosures = 0;
-  b = expand_call_arglist(bc, b);
+  b = expand_call_arglist(b);
+  if (bc->parent) {
+    // functions should end in a return
+    b = BLOCK(b, gen_op_simple(RET));
+  } else {
+    // the toplevel should YIELD;BACKTRACK; when it finds an answer
+    b = BLOCK(b, gen_op_simple(YIELD), gen_op_simple(BACKTRACK));
+  }
   for (inst* curr = b.first; curr; curr = curr->next) {
     if (!curr->next) assert(curr == b.last);
     pos += opcode_length(curr->op);
@@ -550,6 +565,7 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
       subfn->globals = bc->globals;
       subfn->parent = bc;
       errors += compile(locations, subfn, curr->subfn);
+      curr->subfn = gen_noop();
     }
   } else {
     bc->subfunctions = 0;
@@ -571,7 +587,7 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
     if (opflags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
       assert(curr->op == CALL_1_1);
       int nargs = curr->imm.intval;
-      assert(nargs > 0);
+      assert(nargs > 0 && nargs < 100); //FIXME
       code[pos++] = (uint16_t)nargs;
 
       int desired_params = 0;
@@ -630,6 +646,7 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
   }
   bc->constants = constant_pool;
   bc->nlocals = maxvar + 2; // FIXME: frames of size zero?
+  block_free(b);
   return errors;
 }
 
diff --git a/compile.h b/compile.h
index d9ed654e..c8a326da 100644
--- a/compile.h
+++ b/compile.h
@@ -23,10 +23,11 @@ block gen_op_target(opcode op, block target);
 block gen_op_var_unbound(opcode op, const char* name);
 block gen_op_var_bound(opcode op, block binder);
 block gen_op_block_unbound(opcode op, const char* name);
-block gen_op_call(opcode op, block arglist);
 block gen_op_symbol(opcode op, const char* name);
 
 block gen_function(const char* name, block body);
+block gen_lambda(block body);
+block gen_call(const char* name, block body);
 block gen_subexp(block a);
 block gen_both(block a, block b);
 block gen_collect(block expr);
diff --git a/execute.c b/execute.c
index 605db552..e1e9b511 100644
--- a/execute.c
+++ b/execute.c
@@ -514,7 +514,6 @@ struct bytecode* jq_compile(const char* str) {
   if (nerrors == 0) {
     program = builtins_bind(program);
     nerrors = block_compile(program, &locations, &bc);
-    block_free(program);
   }
   if (nerrors) {
     fprintf(stderr, "%d compile %s\n", nerrors, nerrors > 1 ? "errors" : "error");
diff --git a/parser.y b/parser.y
index e8cbf6d8..92d6f7cd 100644
--- a/parser.y
+++ b/parser.y
@@ -152,12 +152,11 @@ static block gen_binop(block a, block b, int op) {
   }
   assert(funcname);
 
-  return BLOCK(gen_subexp(a), gen_subexp(b), 
-               gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, funcname)));
+  return gen_call(funcname, BLOCK(gen_lambda(a), gen_lambda(b)));
 }
 
 static block gen_format(block a) {
-  return BLOCK(a, gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, "tostring")));
+  return BLOCK(a, gen_call("tostring", gen_noop()));
 }
  
 static block gen_update(block a, block op, int optype) {
@@ -386,14 +385,11 @@ String {
   jv_free($2);
 } | 
 IDENT {
-  $$ = gen_location(@$, gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, jv_string_value($1))));
+  $$ = gen_location(@$, gen_call(jv_string_value($1), gen_noop()));
   jv_free($1);
 } |
 IDENT '(' Exp ')' {
-  $$ = gen_op_call(CALL_1_1, 
-                   block_join(gen_op_block_unbound(CLOSURE_REF, jv_string_value($1)),
-                              block_bind(gen_function("@lambda", $3),
-                                         gen_noop(), OP_IS_CALL_PSEUDO)));
+  $$ = gen_call(jv_string_value($1), gen_lambda($3));
   $$ = gen_location(@1, $$);
   jv_free($1);
 } |

From 4c658475681fdd2a12c9239976776684ff3d6375 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 26 Nov 2012 01:40:35 +0000
Subject: [PATCH 146/284] Raise a proper error from the lexer on unmatched
 },),]

---
 lexer.l | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/lexer.l b/lexer.l
index e0bb2b7b..b09ccce4 100644
--- a/lexer.l
+++ b/lexer.l
@@ -126,6 +126,10 @@ static int try_exit(int c, int state, yyscan_t yyscanner) {
     match = ')'; 
     ret = QQSTRING_INTERP_END;
     break;
+
+  default:
+    // may not be the best error to give
+    return INVALID_CHARACTER;
   }
   assert(match);
   if (match == c) {

From 334a79b7040df4b5942da9688fbee0e5d3af9fd7 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 26 Nov 2012 18:53:47 +0000
Subject: [PATCH 147/284] Define bytecoded builtins more concisely.

---
 builtin.c | 50 +++++++++++++++++---------------------------------
 1 file changed, 17 insertions(+), 33 deletions(-)

diff --git a/builtin.c b/builtin.c
index e1144e3d..657a7a1f 100644
--- a/builtin.c
+++ b/builtin.c
@@ -251,27 +251,6 @@ static void f_type(jv input[], jv output[]) {
   jv_free(input[0]);
 }
 
-static block j_empty() {
-  return gen_function("empty", gen_op_simple(BACKTRACK));
-}
-
-static block j_false() {
-  return gen_function("false", gen_op_const(LOADK, jv_false()));
-}
-
-static block j_true() {
-  return gen_function("true", gen_op_const(LOADK, jv_true()));
-}
-
-static block j_null() {
-  return gen_function("null", gen_op_const(LOADK, jv_null()));
-}
-
-static block j_not() {
-  return gen_function("not", gen_condbranch(gen_op_const(LOADK, jv_false()),
-                                            gen_op_const(LOADK, jv_true())));
-}
-
 static struct cfunction function_list[] = {
   {f_plus, "_plus", CALL_BUILTIN_3_1},
   {f_minus, "_minus", CALL_BUILTIN_3_1},
@@ -294,13 +273,22 @@ static struct cfunction function_list[] = {
 static struct symbol_table cbuiltins = {function_list, sizeof(function_list)/sizeof(function_list[0])};
 
 typedef block (*bytecoded_builtin)();
-static bytecoded_builtin bytecoded_builtins[] = {
-  j_empty,
-  j_false,
-  j_true,
-  j_null,
-  j_not,
-};
+struct bytecoded_builtin { const char* name; block code; };
+static block bind_bytecoded_builtins(block b) {
+  struct bytecoded_builtin builtin_defs[] = {
+    {"empty", gen_op_simple(BACKTRACK)},
+    {"false", gen_op_const(LOADK, jv_false())},
+    {"true", gen_op_const(LOADK, jv_true())},
+    {"null", gen_op_const(LOADK, jv_null())},
+    {"not", gen_condbranch(gen_op_const(LOADK, jv_false()),
+                           gen_op_const(LOADK, jv_true()))}
+  };
+  block builtins = gen_noop();
+  for (unsigned i=0; i<sizeof(builtin_defs)/sizeof(builtin_defs[0]); i++) {
+    builtins = BLOCK(builtins, gen_function(builtin_defs[i].name, builtin_defs[i].code));
+  }
+  return block_bind(builtins, b, OP_IS_CALL_PSEUDO);
+}
 
 static const char* jq_builtins[] = {
   "def map(f): [.[] | f];",
@@ -318,10 +306,6 @@ block builtins_bind(block b) {
     b = block_bind(funcs, b, OP_IS_CALL_PSEUDO);
     locfile_free(&src);
   }
-  block builtins = gen_noop();
-  for (unsigned i=0; i<sizeof(bytecoded_builtins)/sizeof(bytecoded_builtins[0]); i++) {
-    block_append(&builtins, bytecoded_builtins[i]());
-  }
-  b = block_bind(builtins, b, OP_IS_CALL_PSEUDO);
+  b = bind_bytecoded_builtins(b);
   return gen_cbinding(&cbuiltins, b);
 }

From d56370f734a2195fb473b8809f40358b024bb073 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 26 Nov 2012 22:22:45 +0000
Subject: [PATCH 148/284] Move some higher-level JSON manipulation functions
 into jv_aux.{c,h}

---
 Makefile  |  2 +-
 execute.c |  1 +
 jv.h      | 61 ------------------------------------------------------
 jv_aux.c  | 62 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 jv_aux.h  | 11 ++++++++++
 5 files changed, 75 insertions(+), 62 deletions(-)
 create mode 100644 jv_aux.c
 create mode 100644 jv_aux.h

diff --git a/Makefile b/Makefile
index 9c5e1635..0c2d3177 100644
--- a/Makefile
+++ b/Makefile
@@ -21,7 +21,7 @@ version.gen.h: VERSION
 	sed 's/.*/#define JQ_VERSION "&"/' $^ > $@
 main.c: version.gen.h
 
-JQ_SRC=parser.gen.c lexer.gen.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c
+JQ_SRC=parser.gen.c lexer.gen.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c jv_aux.c
 
 
 jq_test: $(JQ_SRC) jq_test.c
diff --git a/execute.c b/execute.c
index e1e9b511..fa6b1b79 100644
--- a/execute.c
+++ b/execute.c
@@ -14,6 +14,7 @@
 
 #include "locfile.h"
 #include "jv.h"
+#include "jv_aux.h"
 #include "parser.h"
 #include "builtin.h"
 
diff --git a/jv.h b/jv.h
index e67d614a..c81b2e24 100644
--- a/jv.h
+++ b/jv.h
@@ -112,67 +112,6 @@ jv jv_parse(const char* string);
 jv jv_parse_sized(const char* string, int length);
 
 
-static jv jv_lookup(jv t, jv k) {
-  jv v;
-  if (jv_get_kind(t) == JV_KIND_OBJECT && jv_get_kind(k) == JV_KIND_STRING) {
-    v = jv_object_get(t, k);
-    if (!jv_is_valid(v)) {
-      jv_free(v);
-      v = jv_null();
-    }
-  } else if (jv_get_kind(t) == JV_KIND_ARRAY && jv_get_kind(k) == JV_KIND_NUMBER) {
-    // FIXME: don't do lookup for noninteger index
-    v = jv_array_get(t, (int)jv_number_value(k));
-    if (!jv_is_valid(v)) {
-      jv_free(v);
-      v = jv_null();
-    }
-  } else if (jv_get_kind(t) == JV_KIND_NULL && 
-             (jv_get_kind(k) == JV_KIND_STRING || jv_get_kind(k) == JV_KIND_NUMBER)) {
-    jv_free(t);
-    jv_free(k);
-    v = jv_null();
-  } else {
-    v = jv_invalid_with_msg(jv_string_fmt("Cannot index %s with %s",
-                                          jv_kind_name(jv_get_kind(t)),
-                                          jv_kind_name(jv_get_kind(k))));
-    jv_free(t);
-    jv_free(k);
-  }
-  return v;
-}
-
-static jv jv_modify(jv t, jv k, jv v) {
-  int isnull = jv_get_kind(t) == JV_KIND_NULL;
-  if (jv_get_kind(k) == JV_KIND_STRING && 
-      (jv_get_kind(t) == JV_KIND_OBJECT || isnull)) {
-    if (isnull) t = jv_object();
-    t = jv_object_set(t, k, v);
-  } else if (jv_get_kind(k) == JV_KIND_NUMBER &&
-             (jv_get_kind(t) == JV_KIND_ARRAY || isnull)) {
-    if (isnull) t = jv_array();
-    t = jv_array_set(t, (int)jv_number_value(k), v);
-  } else {
-    jv err = jv_invalid_with_msg(jv_string_fmt("Cannot update field at %s index of %s",
-                                               jv_kind_name(jv_get_kind(t)),
-                                               jv_kind_name(jv_get_kind(v))));
-    jv_free(t);
-    jv_free(k);
-    jv_free(v);
-    t = err;
-  }
-  return t;
-}
-
-static jv jv_insert(jv root, jv value, jv* path, int pathlen) {
-  if (pathlen == 0) {
-    jv_free(root);
-    return value;
-  }
-  return jv_modify(root, jv_copy(*path), 
-                   jv_insert(jv_lookup(jv_copy(root), jv_copy(*path)), value, path+1, pathlen-1));
-}
-
 
 
 
diff --git a/jv_aux.c b/jv_aux.c
new file mode 100644
index 00000000..483a75ef
--- /dev/null
+++ b/jv_aux.c
@@ -0,0 +1,62 @@
+#include "jv_aux.h"
+
+jv jv_lookup(jv t, jv k) {
+  jv v;
+  if (jv_get_kind(t) == JV_KIND_OBJECT && jv_get_kind(k) == JV_KIND_STRING) {
+    v = jv_object_get(t, k);
+    if (!jv_is_valid(v)) {
+      jv_free(v);
+      v = jv_null();
+    }
+  } else if (jv_get_kind(t) == JV_KIND_ARRAY && jv_get_kind(k) == JV_KIND_NUMBER) {
+    // FIXME: don't do lookup for noninteger index
+    v = jv_array_get(t, (int)jv_number_value(k));
+    if (!jv_is_valid(v)) {
+      jv_free(v);
+      v = jv_null();
+    }
+  } else if (jv_get_kind(t) == JV_KIND_NULL && 
+             (jv_get_kind(k) == JV_KIND_STRING || jv_get_kind(k) == JV_KIND_NUMBER)) {
+    jv_free(t);
+    jv_free(k);
+    v = jv_null();
+  } else {
+    v = jv_invalid_with_msg(jv_string_fmt("Cannot index %s with %s",
+                                          jv_kind_name(jv_get_kind(t)),
+                                          jv_kind_name(jv_get_kind(k))));
+    jv_free(t);
+    jv_free(k);
+  }
+  return v;
+}
+
+jv jv_modify(jv t, jv k, jv v) {
+  int isnull = jv_get_kind(t) == JV_KIND_NULL;
+  if (jv_get_kind(k) == JV_KIND_STRING && 
+      (jv_get_kind(t) == JV_KIND_OBJECT || isnull)) {
+    if (isnull) t = jv_object();
+    t = jv_object_set(t, k, v);
+  } else if (jv_get_kind(k) == JV_KIND_NUMBER &&
+             (jv_get_kind(t) == JV_KIND_ARRAY || isnull)) {
+    if (isnull) t = jv_array();
+    t = jv_array_set(t, (int)jv_number_value(k), v);
+  } else {
+    jv err = jv_invalid_with_msg(jv_string_fmt("Cannot update field at %s index of %s",
+                                               jv_kind_name(jv_get_kind(t)),
+                                               jv_kind_name(jv_get_kind(v))));
+    jv_free(t);
+    jv_free(k);
+    jv_free(v);
+    t = err;
+  }
+  return t;
+}
+
+jv jv_insert(jv root, jv value, jv* path, int pathlen) {
+  if (pathlen == 0) {
+    jv_free(root);
+    return value;
+  }
+  return jv_modify(root, jv_copy(*path), 
+                   jv_insert(jv_lookup(jv_copy(root), jv_copy(*path)), value, path+1, pathlen-1));
+}
diff --git a/jv_aux.h b/jv_aux.h
new file mode 100644
index 00000000..9b91b664
--- /dev/null
+++ b/jv_aux.h
@@ -0,0 +1,11 @@
+#ifndef JV_AUX_H
+#define JV_AUX_H
+
+#include "jv.h"
+
+jv jv_lookup(jv t, jv k);
+jv jv_modify(jv t, jv k, jv v);
+jv jv_insert(jv root, jv value, jv* path, int pathlen);
+
+
+#endif

From 006357f954c72bf4212bbc16e869efbfe9d06eda Mon Sep 17 00:00:00 2001
From: Lee Thompson <thompson@dtosolutions.com>
Date: Tue, 27 Nov 2012 16:02:59 -0600
Subject: [PATCH 149/284] initial attempt at autoconf implementation, removed
 all generated code from git

---
 AUTHORS              |    6 +
 Makefile             |   66 -
 Makefile.am          |   69 +
 NEWS                 |    5 +
 README               |    5 +
 VERSION              |    2 +-
 configure.ac         |   66 +
 jv_utf8_tables.gen.h |   35 -
 lexer.gen.c          | 2324 ----------------------------------
 lexer.gen.h          |  362 ------
 main.c               |    6 +-
 parser.gen.c         | 2878 ------------------------------------------
 parser.gen.h         |  132 --
 setup.sh             |   14 +
 14 files changed, 169 insertions(+), 5801 deletions(-)
 create mode 100644 AUTHORS
 delete mode 100644 Makefile
 create mode 100644 Makefile.am
 create mode 100644 NEWS
 create mode 100644 README
 create mode 100644 configure.ac
 delete mode 100644 jv_utf8_tables.gen.h
 delete mode 100644 lexer.gen.c
 delete mode 100644 lexer.gen.h
 delete mode 100644 parser.gen.c
 delete mode 100644 parser.gen.h
 create mode 100755 setup.sh

diff --git a/AUTHORS b/AUTHORS
new file mode 100644
index 00000000..6d78ef76
--- /dev/null
+++ b/AUTHORS
@@ -0,0 +1,6 @@
+Created By:
+Stephen Dolan <mu@netsoc.tcd.ie>
+
+Contributions by
+Anthony Shortland <anthony@dtosolutions.com> - rpmbuild target
+Lee Thompson <thompson@dtosolutions.com> - autoconf stuff
diff --git a/Makefile b/Makefile
deleted file mode 100644
index 59111fa1..00000000
--- a/Makefile
+++ /dev/null
@@ -1,66 +0,0 @@
-CC=gcc -Wextra -Wall -Wno-missing-field-initializers -Wno-unused-parameter -std=gnu99 -ggdb -Wno-unused-function
-prefix=/usr/local
-
-.PHONY: all clean releasedep tarball install uninstall test releasetag
-all: jq
-
-
-lexer.gen.c: lexer.l
-	flex -o lexer.gen.c --header-file=lexer.gen.h lexer.l
-lexer.gen.h: lexer.gen.c
-
-parser.gen.c: parser.y lexer.gen.h
-	bison -W -d parser.y -v --report-file=parser.gen.info -o $@
-parser.gen.h: parser.gen.c
-
-jv_utf8_tables.gen.h: gen_utf8_tables.py
-	python $^ > $@
-jv_unicode.c: jv_utf8_tables.gen.h
-
-version.gen.h: VERSION
-	sed 's/.*/#define JQ_VERSION "&"/' $^ > $@
-main.c: version.gen.h
-
-JQ_SRC=parser.gen.c lexer.gen.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c
-
-
-jq_test: $(JQ_SRC) jq_test.c
-	$(CC) -DJQ_DEBUG=1 -o $@ $^
-
-jq: $(JQ_SRC) main.c
-	$(CC) -O -DJQ_DEBUG=0 -o $@ $^
-
-test: jq_test
-	valgrind --error-exitcode=1 -q --leak-check=full ./jq_test >/dev/null
-
-
-releasedep: lexer.gen.c parser.gen.c jv_utf8_tables.gen.h
-
-releasetag:
-	git tag -s "jq-$$(cat VERSION)" -m "jq release $$(cat VERSION)"
-
-docs/content/2.download/source/jq.tgz: jq
-	mkdir -p `dirname $@`
-	tar -czvf $@ `git ls-files; ls *.gen.*`
-
-tarball: docs/content/2.download/source/jq.tgz
-
-install: jq
-	install -d -m 0755 $(prefix)/bin
-	install -m 0755 jq $(prefix)/bin
-
-uninstall:
-	test -d $(prefix)/bin && \
-	cd $(prefix)/bin && \
-	rm -f jq
-
-RELEASE ?= 1
-
-rpmbuild: jq
-	@echo "Packaging jq as an RPM ..."
-	mkdir -p rpm/SOURCES rpm/BUILD rpm/BUILDROOT rpm/RPMS
-	rm -rf jq-$$(cat VERSION)
-	mkdir -p jq-$$(cat VERSION)/bin
-	cp jq jq-$$(cat VERSION)/bin
-	tar -zcf rpm/SOURCES/jq-$$(cat VERSION).tgz jq-$$(cat VERSION)/bin/jq
-	rpmbuild --target $$(uname -m) --buildroot ${PWD}/rpm/BUILDROOT/jq-$$(cat VERSION)-${RELEASE}.noarch --define "_topdir ${PWD}/rpm" --define "version $$(cat VERSION)" --define "release ${RELEASE}" -bb --clean rpm/SPECS/jq.spec
diff --git a/Makefile.am b/Makefile.am
new file mode 100644
index 00000000..62d035d8
--- /dev/null
+++ b/Makefile.am
@@ -0,0 +1,69 @@
+# Converted to automake by thompson@dtosolutions.com 26NOV12
+
+# setup is only used by distribution developers, not package developers.
+# Still, as a matter of allowing patching, its not a bad idea to distribute 
+# the developer setup script in the tarball.
+EXTRA_DIST = setup.sh config.h.in ChangeLog
+
+# README.md is expected in Github projects, good stuff in it, so we'll 
+# distribute it and install it with the package in the doc directory.
+docdir = ${datadir}/doc/${PACKAGE}
+dist_doc_DATA = README.md INSTALL COPYING AUTHORS README NEWS
+
+JQ_SRC = opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c
+# If we distribute the generated files in the source release, packagers won't have to have
+# python, bison, and flex
+DIST_JQ_SRC = parser.gen.c lexer.gen.c jv_utf8_tables.gen.h parser.gen.h lexer.gen.h
+
+bin_PROGRAMS = jq jq_test
+if DEVCFLAGS_ENABLED
+DEVCFLAGS = -Wextra -Wall -Wno-missing-field-initializers -Wno-unused -parameter -std=gnu99 -ggdb -Wno-unused-function
+AM_CPPFLAGS = $(DEVCFLAGS)
+endif
+
+jq_SOURCES = $(JQ_SRC) main.c
+dist_jq_SOURCES = $(DIST_JQ_SRC)
+jq_CPPFLAGS = -O $(DEVCFLAGS) -DJQ_DEBUG=0
+
+
+TESTS = jq_test
+jq_test_SOURCES = $(JQ_SRC) jq_test.c
+dist_jq_test_SOURCES = $(DIST_JQ_SRC)
+jq_test_CPPFLAGS = $(DEVCFLAGS) -DJQ_DEBUG=1
+LOG_COMPILER = valgrind
+AM_LOG_FLAGS = --error-exitcode=1 -q --leak-check=full
+
+lexer.gen.c: lexer.l
+	flex -o lexer.gen.c --header-file=lexer.gen.h lexer.l
+lexer.gen.h: lexer.gen.c
+
+# if this fails on OSX, install bison from macports or homebrew.  OSX comes
+# with bison 2.3 which is too old
+parser.gen.c: parser.y lexer.gen.h
+	bison --warnings=all -d parser.y -v --report-file=parser.gen.info -o $@
+parser.gen.h: parser.gen.c
+
+jv_utf8_tables.gen.h: gen_utf8_tables.py
+	python $^ > $@
+jv_unicode.c: jv_utf8_tables.gen.h
+
+ChangeLog:
+	git log --name-status > $@
+
+main.c: config.h
+
+releasedep: lexer.gen.c parser.gen.c jv_utf8_tables.gen.h
+
+releasetag:
+	git tag -s "jq-$$(cat VERSION)" -m "jq release $$(cat VERSION)"
+
+# can probably delete and have RPM created off autoconf generated tarball releases
+RELEASE ?= 1
+rpmbuild: jq
+	@echo "Packaging jq as an RPM ..."
+	mkdir -p rpm/SOURCES rpm/BUILD rpm/BUILDROOT rpm/RPMS
+	rm -rf jq-$$(cat VERSION)
+	mkdir -p jq-$$(cat VERSION)/bin
+	cp jq jq-$$(cat VERSION)/bin
+	tar -zcf rpm/SOURCES/jq-$$(cat VERSION).tgz jq-$$(cat VERSION)/bin/jq
+	rpmbuild --target $$(uname -m) --buildroot ${PWD}/rpm/BUILDROOT/jq-$$(cat VERSION)-${RELEASE}.noarch --define "_topdir ${PWD}/rpm" --define "version $$(cat VERSION)" --define "release ${RELEASE}" -bb --clean rpm/SPECS/jq.spec
diff --git a/NEWS b/NEWS
new file mode 100644
index 00000000..16a32b3c
--- /dev/null
+++ b/NEWS
@@ -0,0 +1,5 @@
+
+   NEWS for jq 
+
+
+
diff --git a/README b/README
new file mode 100644
index 00000000..c6933dae
--- /dev/null
+++ b/README
@@ -0,0 +1,5 @@
+Since this is a github project and an autoconf project, the
+README file is not used, README.md is the file to READ!
+
+When you checkout the file, run "setup.sh" which gets autoconf initialized.
+Then follow the instructions in INSTALL.  Real standard stuff...
diff --git a/VERSION b/VERSION
index 9459d4ba..5625e59d 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-1.1
+1.2
diff --git a/configure.ac b/configure.ac
new file mode 100644
index 00000000..09997385
--- /dev/null
+++ b/configure.ac
@@ -0,0 +1,66 @@
+AC_INIT([jq], m4_esyscmd([tr -d '\n' <VERSION]), [mu@netsoc.tcd.ie],
+             [jq], [http://stedolan.github.com/jq/])
+
+dnl Created autoconf implementation thompson@dtosolutions, 26NOV12
+AC_PREREQ([2.61])
+AC_CONFIG_AUX_DIR([config])
+AM_INIT_AUTOMAKE([parallel-tests])
+AC_PROG_CC
+AC_PROG_CC_STDC
+AC_PROG_CPP_WERROR
+
+AM_PROG_CC_C_O
+
+dnl   CFLAGS is concidered a packagers variable, not a developer variable
+dnl   in Auto-tools.  For developer ease of use, CFLAGS are set how the
+dnl   developers like them by default but the packager can disable if so
+dnl   desired.  This is useful if something other than gcc is needed or
+dnl   for distros that need to heavily tweek the compiler (gentoo, ARM cpu
+dnl   linux's, etc)
+AC_ARG_ENABLE([devcflags],
+              [AC_HELP_STRING([--enable-devcflags=@<:@yes/no@:>@],
+                              [Enable the same CFLAGS used by jq developers @<:@default=yes@:>@])],
+              [enable_devcflags=$enableval],
+              [enable_devcflags=yes])
+AC_MSG_RESULT($enable_devcflags)
+dnl AM_CONDITIONAL(DEVCFLAGS, test x$enable_devcflags = xyes)
+if test "$enable_devcflags" = "yes"; then
+  AM_CONDITIONAL(DEVCFLAGS_ENABLED, true)
+fi
+
+dnl Check for sed
+AC_CHECK_PROGS(regex_cmd, sed)
+if test x$regex_cmd = "x" ; then
+    AC_MSG_NOTICE([sed is required to patch jq.])
+fi
+
+dnl Check for flex
+AC_CHECK_PROGS(flex_cmd, flex)
+if test x$flex_cmd = "x" ; then
+    AC_MSG_NOTICE([flex is required to patch jq.])
+fi
+
+dnl Check for bison
+AC_CHECK_PROGS(bison_cmd, bison)
+if test x$bison_cmd = "x" ; then
+    AC_MSG_NOTICE([bison is required to patch jq.])
+fi
+
+ AC_CONFIG_HEADERS(config.h)
+
+dnl Check for python
+AC_CHECK_PROGS(python_cmd, python)
+if test x$python_cmd = "x" ; then
+    AC_MSG_NOTICE([python is required to patch jq.])
+fi
+
+dnl Check for valgrind
+AC_CHECK_PROGS(valgrind_cmd, valgrind)
+if test x$valgrind_cmd = "x" ; then
+    AC_MSG_NOTICE([valgrind is required to test jq.])
+fi
+
+dnl AC_CONFIG_MACRO_DIR([m4])
+AM_INIT_AUTOMAKE([-Wall dist-bzip2 dist-zip])
+AC_CONFIG_FILES([Makefile])
+AC_OUTPUT
diff --git a/jv_utf8_tables.gen.h b/jv_utf8_tables.gen.h
deleted file mode 100644
index 24d9a63a..00000000
--- a/jv_utf8_tables.gen.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#define UTF8_CONTINUATION_BYTE ((unsigned char)255)
-static const unsigned char utf8_coding_length[] =
- {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-  0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-  0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
-  0x04, 0x04, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-static const unsigned char utf8_coding_bits[] =
- {0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
-  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
-  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
-  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
-  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
-  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
-  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
-  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
-  0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
-  0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
-  0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
-  0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
-  0x00, 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
-  0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
-  0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-  0x07, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
diff --git a/lexer.gen.c b/lexer.gen.c
deleted file mode 100644
index c1458c69..00000000
--- a/lexer.gen.c
+++ /dev/null
@@ -1,2324 +0,0 @@
-#line 2 "lexer.gen.c"
-
-#line 4 "lexer.gen.c"
-
-#define  YY_INT_ALIGNED short int
-
-/* A lexical scanner generated by flex */
-
-#define FLEX_SCANNER
-#define YY_FLEX_MAJOR_VERSION 2
-#define YY_FLEX_MINOR_VERSION 5
-#define YY_FLEX_SUBMINOR_VERSION 35
-#if YY_FLEX_SUBMINOR_VERSION > 0
-#define FLEX_BETA
-#endif
-
-/* First, we deal with  platform-specific or compiler-specific issues. */
-
-/* begin standard C headers. */
-#include <stdio.h>
-#include <string.h>
-#include <errno.h>
-#include <stdlib.h>
-
-/* end standard C headers. */
-
-/* flex integer type definitions */
-
-#ifndef FLEXINT_H
-#define FLEXINT_H
-
-/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
-
-#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-
-/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
- * if you want the limit (max/min) macros for int types. 
- */
-#ifndef __STDC_LIMIT_MACROS
-#define __STDC_LIMIT_MACROS 1
-#endif
-
-#include <inttypes.h>
-typedef int8_t flex_int8_t;
-typedef uint8_t flex_uint8_t;
-typedef int16_t flex_int16_t;
-typedef uint16_t flex_uint16_t;
-typedef int32_t flex_int32_t;
-typedef uint32_t flex_uint32_t;
-#else
-typedef signed char flex_int8_t;
-typedef short int flex_int16_t;
-typedef int flex_int32_t;
-typedef unsigned char flex_uint8_t; 
-typedef unsigned short int flex_uint16_t;
-typedef unsigned int flex_uint32_t;
-
-/* Limits of integral types. */
-#ifndef INT8_MIN
-#define INT8_MIN               (-128)
-#endif
-#ifndef INT16_MIN
-#define INT16_MIN              (-32767-1)
-#endif
-#ifndef INT32_MIN
-#define INT32_MIN              (-2147483647-1)
-#endif
-#ifndef INT8_MAX
-#define INT8_MAX               (127)
-#endif
-#ifndef INT16_MAX
-#define INT16_MAX              (32767)
-#endif
-#ifndef INT32_MAX
-#define INT32_MAX              (2147483647)
-#endif
-#ifndef UINT8_MAX
-#define UINT8_MAX              (255U)
-#endif
-#ifndef UINT16_MAX
-#define UINT16_MAX             (65535U)
-#endif
-#ifndef UINT32_MAX
-#define UINT32_MAX             (4294967295U)
-#endif
-
-#endif /* ! C99 */
-
-#endif /* ! FLEXINT_H */
-
-#ifdef __cplusplus
-
-/* The "const" storage-class-modifier is valid. */
-#define YY_USE_CONST
-
-#else	/* ! __cplusplus */
-
-/* C99 requires __STDC__ to be defined as 1. */
-#if defined (__STDC__)
-
-#define YY_USE_CONST
-
-#endif	/* defined (__STDC__) */
-#endif	/* ! __cplusplus */
-
-#ifdef YY_USE_CONST
-#define yyconst const
-#else
-#define yyconst
-#endif
-
-/* Returned upon end-of-file. */
-#define YY_NULL 0
-
-/* Promotes a possibly negative, possibly signed char to an unsigned
- * integer for use as an array index.  If the signed char is negative,
- * we want to instead treat it as an 8-bit unsigned char, hence the
- * double cast.
- */
-#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
-
-/* An opaque pointer. */
-#ifndef YY_TYPEDEF_YY_SCANNER_T
-#define YY_TYPEDEF_YY_SCANNER_T
-typedef void* yyscan_t;
-#endif
-
-/* For convenience, these vars (plus the bison vars far below)
-   are macros in the reentrant scanner. */
-#define yyin yyg->yyin_r
-#define yyout yyg->yyout_r
-#define yyextra yyg->yyextra_r
-#define yyleng yyg->yyleng_r
-#define yytext yyg->yytext_r
-#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
-#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
-#define yy_flex_debug yyg->yy_flex_debug_r
-
-/* Enter a start condition.  This macro really ought to take a parameter,
- * but we do it the disgusting crufty way forced on us by the ()-less
- * definition of BEGIN.
- */
-#define BEGIN yyg->yy_start = 1 + 2 *
-
-/* Translate the current start state into a value that can be later handed
- * to BEGIN to return to the state.  The YYSTATE alias is for lex
- * compatibility.
- */
-#define YY_START ((yyg->yy_start - 1) / 2)
-#define YYSTATE YY_START
-
-/* Action number for EOF rule of a given start state. */
-#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
-
-/* Special action meaning "start processing a new file". */
-#define YY_NEW_FILE jq_yyrestart(yyin ,yyscanner )
-
-#define YY_END_OF_BUFFER_CHAR 0
-
-/* Size of default input buffer. */
-#ifndef YY_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k.
- * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
- * Ditto for the __ia64__ case accordingly.
- */
-#define YY_BUF_SIZE 32768
-#else
-#define YY_BUF_SIZE 16384
-#endif /* __ia64__ */
-#endif
-
-/* The state buf must be large enough to hold one state per character in the main buffer.
- */
-#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
-
-#ifndef YY_TYPEDEF_YY_BUFFER_STATE
-#define YY_TYPEDEF_YY_BUFFER_STATE
-typedef struct yy_buffer_state *YY_BUFFER_STATE;
-#endif
-
-#define EOB_ACT_CONTINUE_SCAN 0
-#define EOB_ACT_END_OF_FILE 1
-#define EOB_ACT_LAST_MATCH 2
-
-    #define YY_LESS_LINENO(n)
-    
-/* Return all but the first "n" matched characters back to the input stream. */
-#define yyless(n) \
-	do \
-		{ \
-		/* Undo effects of setting up yytext. */ \
-        int yyless_macro_arg = (n); \
-        YY_LESS_LINENO(yyless_macro_arg);\
-		*yy_cp = yyg->yy_hold_char; \
-		YY_RESTORE_YY_MORE_OFFSET \
-		yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
-		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
-		} \
-	while ( 0 )
-
-#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
-
-#ifndef YY_TYPEDEF_YY_SIZE_T
-#define YY_TYPEDEF_YY_SIZE_T
-typedef size_t yy_size_t;
-#endif
-
-#ifndef YY_STRUCT_YY_BUFFER_STATE
-#define YY_STRUCT_YY_BUFFER_STATE
-struct yy_buffer_state
-	{
-	FILE *yy_input_file;
-
-	char *yy_ch_buf;		/* input buffer */
-	char *yy_buf_pos;		/* current position in input buffer */
-
-	/* Size of input buffer in bytes, not including room for EOB
-	 * characters.
-	 */
-	yy_size_t yy_buf_size;
-
-	/* Number of characters read into yy_ch_buf, not including EOB
-	 * characters.
-	 */
-	int yy_n_chars;
-
-	/* Whether we "own" the buffer - i.e., we know we created it,
-	 * and can realloc() it to grow it, and should free() it to
-	 * delete it.
-	 */
-	int yy_is_our_buffer;
-
-	/* Whether this is an "interactive" input source; if so, and
-	 * if we're using stdio for input, then we want to use getc()
-	 * instead of fread(), to make sure we stop fetching input after
-	 * each newline.
-	 */
-	int yy_is_interactive;
-
-	/* Whether we're considered to be at the beginning of a line.
-	 * If so, '^' rules will be active on the next match, otherwise
-	 * not.
-	 */
-	int yy_at_bol;
-
-    int yy_bs_lineno; /**< The line count. */
-    int yy_bs_column; /**< The column count. */
-    
-	/* Whether to try to fill the input buffer when we reach the
-	 * end of it.
-	 */
-	int yy_fill_buffer;
-
-	int yy_buffer_status;
-
-#define YY_BUFFER_NEW 0
-#define YY_BUFFER_NORMAL 1
-	/* When an EOF's been seen but there's still some text to process
-	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
-	 * shouldn't try reading from the input source any more.  We might
-	 * still have a bunch of tokens to match, though, because of
-	 * possible backing-up.
-	 *
-	 * When we actually see the EOF, we change the status to "new"
-	 * (via jq_yyrestart()), so that the user can continue scanning by
-	 * just pointing yyin at a new input file.
-	 */
-#define YY_BUFFER_EOF_PENDING 2
-
-	};
-#endif /* !YY_STRUCT_YY_BUFFER_STATE */
-
-/* We provide macros for accessing buffer states in case in the
- * future we want to put the buffer states in a more general
- * "scanner state".
- *
- * Returns the top of the stack, or NULL.
- */
-#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
-                          ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
-                          : NULL)
-
-/* Same as previous macro, but useful when we know that the buffer stack is not
- * NULL or when we need an lvalue. For internal use only.
- */
-#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
-
-void jq_yyrestart (FILE *input_file ,yyscan_t yyscanner );
-void jq_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
-YY_BUFFER_STATE jq_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
-void jq_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
-void jq_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
-void jq_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
-void jq_yypop_buffer_state (yyscan_t yyscanner );
-
-static void jq_yyensure_buffer_stack (yyscan_t yyscanner );
-static void jq_yy_load_buffer_state (yyscan_t yyscanner );
-static void jq_yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
-
-#define YY_FLUSH_BUFFER jq_yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
-
-YY_BUFFER_STATE jq_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
-YY_BUFFER_STATE jq_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
-YY_BUFFER_STATE jq_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
-
-void *jq_yyalloc (yy_size_t ,yyscan_t yyscanner );
-void *jq_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
-void jq_yyfree (void * ,yyscan_t yyscanner );
-
-#define yy_new_buffer jq_yy_create_buffer
-
-#define yy_set_interactive(is_interactive) \
-	{ \
-	if ( ! YY_CURRENT_BUFFER ){ \
-        jq_yyensure_buffer_stack (yyscanner); \
-		YY_CURRENT_BUFFER_LVALUE =    \
-            jq_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
-	} \
-	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
-	}
-
-#define yy_set_bol(at_bol) \
-	{ \
-	if ( ! YY_CURRENT_BUFFER ){\
-        jq_yyensure_buffer_stack (yyscanner); \
-		YY_CURRENT_BUFFER_LVALUE =    \
-            jq_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
-	} \
-	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
-	}
-
-#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
-
-/* Begin user sect3 */
-
-#define jq_yywrap(n) 1
-#define YY_SKIP_YYWRAP
-
-typedef unsigned char YY_CHAR;
-
-typedef int yy_state_type;
-
-#define yytext_ptr yytext_r
-
-static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
-static yy_state_type yy_try_NUL_trans (yy_state_type current_state  ,yyscan_t yyscanner);
-static int yy_get_next_buffer (yyscan_t yyscanner );
-static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
-
-/* Done after the current pattern has been matched and before the
- * corresponding action - sets up yytext.
- */
-#define YY_DO_BEFORE_ACTION \
-	yyg->yytext_ptr = yy_bp; \
-	yyleng = (size_t) (yy_cp - yy_bp); \
-	yyg->yy_hold_char = *yy_cp; \
-	*yy_cp = '\0'; \
-	yyg->yy_c_buf_p = yy_cp;
-
-#define YY_NUM_RULES 36
-#define YY_END_OF_BUFFER 37
-/* This struct is not used in this scanner,
-   but its presence is necessary. */
-struct yy_trans_info
-	{
-	flex_int32_t yy_verify;
-	flex_int32_t yy_nxt;
-	};
-static yyconst flex_int16_t yy_accept[96] =
-    {   0,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,   37,   35,   34,   34,   35,   27,    1,   23,
-       24,   25,   23,   23,   23,   23,   23,   26,   23,   23,
-       23,   33,   33,   33,   33,   33,   33,   33,   33,   23,
-       31,   31,   29,   32,   34,    2,    1,   17,   15,   26,
-       16,    0,   13,   18,   20,    3,   21,   33,   33,    4,
-       33,   33,   33,   33,    6,   11,   33,   14,   31,   30,
-       28,   30,    0,   26,   19,   10,   33,    5,   33,   33,
-       12,   33,    0,   30,   33,    9,    8,    7,   30,   33,
-       30,   33,   33,   22,    0
-
-    } ;
-
-static yyconst flex_int32_t yy_ec[256] =
-    {   0,
-        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
-        1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    2,    5,    6,    7,    8,    1,    1,    1,    9,
-       10,   11,   12,   13,   14,   15,   16,   17,   17,   17,
-       17,   17,   17,   17,   17,   17,   17,   18,   19,   20,
-       21,   22,    1,    1,   23,   23,   23,   23,   24,   23,
-       23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
-       23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
-       25,   26,   27,    1,   28,    1,   29,   23,   30,   31,
-
-       32,   33,   23,   34,   35,   23,   23,   36,   23,   37,
-       38,   23,   23,   39,   40,   41,   42,   23,   23,   23,
-       23,   23,   43,   44,   45,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1
-    } ;
-
-static yyconst flex_int32_t yy_meta[46] =
-    {   0,
-        1,    1,    2,    2,    1,    3,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    4,    1,    1,    1,
-        1,    1,    4,    4,    1,    5,    1,    6,    4,    4,
-        4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
-        4,    4,    1,    1,    1
-    } ;
-
-static yyconst flex_int16_t yy_base[105] =
-    {   0,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-       43,   44,  152,  153,   49,   51,  130,  153,    0,  153,
-      153,  153,  129,  128,   40,   41,   43,   51,  127,  126,
-      125,    0,   23,  107,  112,   35,  110,   88,   91,  100,
-        0,    0,  153,   39,   74,  153,    0,  153,  153,   63,
-      153,   72,   94,  153,  153,  153,  153,    0,   75,    0,
-       68,   71,   27,   72,    0,    0,   70,  153,    0,   75,
-      153,   74,   82,   81,  153,    0,   56,    0,   63,   62,
-        0,   56,   65,   66,   62,    0,    0,    0,   64,   53,
-       59,   45,   39,    0,  153,  107,  113,  116,  122,  128,
-
-      131,  133,  135,  137
-    } ;
-
-static yyconst flex_int16_t yy_def[105] =
-    {   0,
-       95,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-       96,   96,   95,   95,   95,   95,   95,   95,   97,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   98,   98,   98,   98,   98,   98,   98,   98,   95,
-       99,   99,   95,  100,   95,   95,   97,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   98,   98,   98,
-       98,   98,   98,   98,   98,   98,   98,   95,   99,   95,
-       95,  101,   95,   95,   95,   98,   98,   98,   98,   98,
-       98,   98,  100,  102,   98,   98,   98,   98,  103,   98,
-      104,   98,   98,   98,    0,   95,   95,   95,   95,   95,
-
-       95,   95,   95,   95
-    } ;
-
-static yyconst flex_int16_t yy_nxt[199] =
-    {   0,
-       14,   15,   16,   14,   17,   18,   19,   20,   21,   22,
-       23,   24,   20,   25,   26,   27,   28,   20,   20,   29,
-       30,   31,   32,   32,   21,   14,   22,   32,   33,   34,
-       35,   36,   32,   32,   37,   32,   32,   38,   32,   32,
-       39,   32,   21,   40,   22,   42,   42,   71,   43,   43,
-       45,   45,   45,   45,   50,   50,   50,   50,   53,   59,
-       51,   79,   60,   54,   52,   50,   80,   50,   44,   44,
-       63,   64,   52,   95,   52,   45,   45,   50,   94,   50,
-       72,   93,   52,   73,   83,   73,   52,   92,   74,   83,
-       90,   83,   88,   87,   52,   86,   85,   74,   74,   83,
-
-       83,   82,   81,   78,   77,   76,   72,   41,   41,   41,
-       41,   41,   41,   47,   75,   47,   47,   47,   47,   58,
-       68,   58,   69,   69,   67,   69,   66,   69,   70,   70,
-       70,   70,   70,   70,   84,   84,   89,   89,   91,   91,
-       70,   70,   65,   62,   61,   57,   56,   55,   49,   48,
-       46,   95,   13,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95
-
-    } ;
-
-static yyconst flex_int16_t yy_chk[199] =
-    {   0,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,   11,   12,   44,   11,   12,
-       15,   15,   16,   16,   25,   26,   25,   26,   27,   33,
-       25,   63,   33,   27,   26,   28,   63,   28,   11,   12,
-       36,   36,   26,   83,   28,   45,   45,   50,   93,   50,
-       44,   92,   28,   52,   91,   52,   50,   90,   52,   89,
-       85,   84,   82,   80,   50,   79,   77,   74,   73,   72,
-
-       70,   67,   64,   62,   61,   59,   83,   96,   96,   96,
-       96,   96,   96,   97,   53,   97,   97,   97,   97,   98,
-       40,   98,   99,   99,   39,   99,   38,   99,  100,  100,
-      100,  100,  100,  100,  101,  101,  102,  102,  103,  103,
-      104,  104,   37,   35,   34,   31,   30,   29,   24,   23,
-       17,   13,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95
-
-    } ;
-
-/* The intent behind this definition is that it'll catch
- * any uses of REJECT which flex missed.
- */
-#define REJECT reject_used_but_not_detected
-#define yymore() yymore_used_but_not_detected
-#define YY_MORE_ADJ 0
-#define YY_RESTORE_YY_MORE_OFFSET
-#line 1 "lexer.l"
-#line 2 "lexer.l"
-#include "compile.h"
-
-struct lexer_param;
-
-#include "parser.gen.h"  /* Generated by bison. */
-
-#define YY_USER_ACTION                           \
-  do {                                           \
-    yylloc->start = jq_yyget_extra(yyscanner);      \
-    yylloc->end = yylloc->start + yyleng;        \
-    jq_yyset_extra(yylloc->end,yyscanner);         \
-  } while (0);
-
-
-
-
-
-
-#line 23 "lexer.l"
-  static int enter(int opening, int state, yyscan_t yyscanner);
-  static int try_exit(int closing, int state, yyscan_t yyscanner);
-#define YY_NO_INPUT 1
-#line 542 "lexer.gen.c"
-
-#define INITIAL 0
-#define IN_PAREN 1
-#define IN_BRACKET 2
-#define IN_BRACE 3
-#define IN_QQINTERP 4
-#define IN_QQSTRING 5
-
-#ifndef YY_NO_UNISTD_H
-/* Special case for "unistd.h", since it is non-ANSI. We include it way
- * down here because we want the user's section 1 to have been scanned first.
- * The user has a chance to override it with an option.
- */
-#include <unistd.h>
-#endif
-
-#define YY_EXTRA_TYPE int
-
-/* Holds the entire state of the reentrant scanner. */
-struct yyguts_t
-    {
-
-    /* User-defined. Not touched by flex. */
-    YY_EXTRA_TYPE yyextra_r;
-
-    /* The rest are the same as the globals declared in the non-reentrant scanner. */
-    FILE *yyin_r, *yyout_r;
-    size_t yy_buffer_stack_top; /**< index of top of stack. */
-    size_t yy_buffer_stack_max; /**< capacity of stack. */
-    YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
-    char yy_hold_char;
-    int yy_n_chars;
-    int yyleng_r;
-    char *yy_c_buf_p;
-    int yy_init;
-    int yy_start;
-    int yy_did_buffer_switch_on_eof;
-    int yy_start_stack_ptr;
-    int yy_start_stack_depth;
-    int *yy_start_stack;
-    yy_state_type yy_last_accepting_state;
-    char* yy_last_accepting_cpos;
-
-    int yylineno_r;
-    int yy_flex_debug_r;
-
-    char *yytext_r;
-    int yy_more_flag;
-    int yy_more_len;
-
-    YYSTYPE * yylval_r;
-
-    YYLTYPE * yylloc_r;
-
-    }; /* end struct yyguts_t */
-
-static int yy_init_globals (yyscan_t yyscanner );
-
-    /* This must go here because YYSTYPE and YYLTYPE are included
-     * from bison output in section 1.*/
-    #    define yylval yyg->yylval_r
-    
-    #    define yylloc yyg->yylloc_r
-    
-int jq_yylex_init (yyscan_t* scanner);
-
-int jq_yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
-
-/* Accessor methods to globals.
-   These are made visible to non-reentrant scanners for convenience. */
-
-int jq_yylex_destroy (yyscan_t yyscanner );
-
-int jq_yyget_debug (yyscan_t yyscanner );
-
-void jq_yyset_debug (int debug_flag ,yyscan_t yyscanner );
-
-YY_EXTRA_TYPE jq_yyget_extra (yyscan_t yyscanner );
-
-void jq_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
-
-FILE *jq_yyget_in (yyscan_t yyscanner );
-
-void jq_yyset_in  (FILE * in_str ,yyscan_t yyscanner );
-
-FILE *jq_yyget_out (yyscan_t yyscanner );
-
-void jq_yyset_out  (FILE * out_str ,yyscan_t yyscanner );
-
-int jq_yyget_leng (yyscan_t yyscanner );
-
-char *jq_yyget_text (yyscan_t yyscanner );
-
-int jq_yyget_lineno (yyscan_t yyscanner );
-
-void jq_yyset_lineno (int line_number ,yyscan_t yyscanner );
-
-YYSTYPE * jq_yyget_lval (yyscan_t yyscanner );
-
-void jq_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
-
-       YYLTYPE *jq_yyget_lloc (yyscan_t yyscanner );
-    
-        void jq_yyset_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner );
-    
-/* Macros after this point can all be overridden by user definitions in
- * section 1.
- */
-
-#ifndef YY_SKIP_YYWRAP
-#ifdef __cplusplus
-extern "C" int jq_yywrap (yyscan_t yyscanner );
-#else
-extern int jq_yywrap (yyscan_t yyscanner );
-#endif
-#endif
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
-#endif
-
-#ifndef YY_NO_INPUT
-
-#ifdef __cplusplus
-static int yyinput (yyscan_t yyscanner );
-#else
-static int input (yyscan_t yyscanner );
-#endif
-
-#endif
-
-    static void yy_push_state (int new_state ,yyscan_t yyscanner);
-    
-    static void yy_pop_state (yyscan_t yyscanner );
-    
-    static int yy_top_state (yyscan_t yyscanner );
-    
-/* Amount of stuff to slurp up with each read. */
-#ifndef YY_READ_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k */
-#define YY_READ_BUF_SIZE 16384
-#else
-#define YY_READ_BUF_SIZE 8192
-#endif /* __ia64__ */
-#endif
-
-/* Copy whatever the last rule matched to the standard output. */
-#ifndef ECHO
-/* This used to be an fputs(), but since the string might contain NUL's,
- * we now use fwrite().
- */
-#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
-#endif
-
-/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
- * is returned in "result".
- */
-#ifndef YY_INPUT
-#define YY_INPUT(buf,result,max_size) \
-	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
-		{ \
-		int c = '*'; \
-		size_t n; \
-		for ( n = 0; n < max_size && \
-			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
-			buf[n] = (char) c; \
-		if ( c == '\n' ) \
-			buf[n++] = (char) c; \
-		if ( c == EOF && ferror( yyin ) ) \
-			YY_FATAL_ERROR( "input in flex scanner failed" ); \
-		result = n; \
-		} \
-	else \
-		{ \
-		errno=0; \
-		while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
-			{ \
-			if( errno != EINTR) \
-				{ \
-				YY_FATAL_ERROR( "input in flex scanner failed" ); \
-				break; \
-				} \
-			errno=0; \
-			clearerr(yyin); \
-			} \
-		}\
-\
-
-#endif
-
-/* No semi-colon after return; correct usage is to write "yyterminate();" -
- * we don't want an extra ';' after the "return" because that will cause
- * some compilers to complain about unreachable statements.
- */
-#ifndef yyterminate
-#define yyterminate() return YY_NULL
-#endif
-
-/* Number of entries by which start-condition stack grows. */
-#ifndef YY_START_STACK_INCR
-#define YY_START_STACK_INCR 25
-#endif
-
-/* Report a fatal error. */
-#ifndef YY_FATAL_ERROR
-#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
-#endif
-
-/* end tables serialization structures and prototypes */
-
-/* Default declaration of generated scanner - a define so the user can
- * easily add parameters.
- */
-#ifndef YY_DECL
-#define YY_DECL_IS_OURS 1
-
-extern int jq_yylex \
-               (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner);
-
-#define YY_DECL int jq_yylex \
-               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
-#endif /* !YY_DECL */
-
-/* Code executed at the beginning of each rule, after yytext and yyleng
- * have been set up.
- */
-#ifndef YY_USER_ACTION
-#define YY_USER_ACTION
-#endif
-
-/* Code executed at the end of each rule. */
-#ifndef YY_BREAK
-#define YY_BREAK break;
-#endif
-
-#define YY_RULE_SETUP \
-	YY_USER_ACTION
-
-/** The main scanner function which does all the work.
- */
-YY_DECL
-{
-	register yy_state_type yy_current_state;
-	register char *yy_cp, *yy_bp;
-	register int yy_act;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-#line 35 "lexer.l"
-
-
-#line 798 "lexer.gen.c"
-
-    yylval = yylval_param;
-
-    yylloc = yylloc_param;
-
-	if ( !yyg->yy_init )
-		{
-		yyg->yy_init = 1;
-
-#ifdef YY_USER_INIT
-		YY_USER_INIT;
-#endif
-
-		if ( ! yyg->yy_start )
-			yyg->yy_start = 1;	/* first start state */
-
-		if ( ! yyin )
-			yyin = stdin;
-
-		if ( ! yyout )
-			yyout = stdout;
-
-		if ( ! YY_CURRENT_BUFFER ) {
-			jq_yyensure_buffer_stack (yyscanner);
-			YY_CURRENT_BUFFER_LVALUE =
-				jq_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
-		}
-
-		jq_yy_load_buffer_state(yyscanner );
-		}
-
-	while ( 1 )		/* loops until end-of-file is reached */
-		{
-		yy_cp = yyg->yy_c_buf_p;
-
-		/* Support of yytext. */
-		*yy_cp = yyg->yy_hold_char;
-
-		/* yy_bp points to the position in yy_ch_buf of the start of
-		 * the current run.
-		 */
-		yy_bp = yy_cp;
-
-		yy_current_state = yyg->yy_start;
-yy_match:
-		do
-			{
-			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
-			if ( yy_accept[yy_current_state] )
-				{
-				yyg->yy_last_accepting_state = yy_current_state;
-				yyg->yy_last_accepting_cpos = yy_cp;
-				}
-			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-				{
-				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 96 )
-					yy_c = yy_meta[(unsigned int) yy_c];
-				}
-			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-			++yy_cp;
-			}
-		while ( yy_base[yy_current_state] != 153 );
-
-yy_find_action:
-		yy_act = yy_accept[yy_current_state];
-		if ( yy_act == 0 )
-			{ /* have to back up */
-			yy_cp = yyg->yy_last_accepting_cpos;
-			yy_current_state = yyg->yy_last_accepting_state;
-			yy_act = yy_accept[yy_current_state];
-			}
-
-		YY_DO_BEFORE_ACTION;
-
-do_action:	/* This label is used only to access EOF actions. */
-
-		switch ( yy_act )
-	{ /* beginning of action switch */
-			case 0: /* must back up */
-			/* undo the effects of YY_DO_BEFORE_ACTION */
-			*yy_cp = yyg->yy_hold_char;
-			yy_cp = yyg->yy_last_accepting_cpos;
-			yy_current_state = yyg->yy_last_accepting_state;
-			goto yy_find_action;
-
-case 1:
-YY_RULE_SETUP
-#line 37 "lexer.l"
-{ /* comments */ }
-	YY_BREAK
-case 2:
-YY_RULE_SETUP
-#line 39 "lexer.l"
-{ return NEQ; }
-	YY_BREAK
-case 3:
-YY_RULE_SETUP
-#line 40 "lexer.l"
-{ return EQ; }
-	YY_BREAK
-case 4:
-YY_RULE_SETUP
-#line 41 "lexer.l"
-{ return AS; }
-	YY_BREAK
-case 5:
-YY_RULE_SETUP
-#line 42 "lexer.l"
-{ return DEF; }
-	YY_BREAK
-case 6:
-YY_RULE_SETUP
-#line 43 "lexer.l"
-{ return IF; }
-	YY_BREAK
-case 7:
-YY_RULE_SETUP
-#line 44 "lexer.l"
-{ return THEN; }
-	YY_BREAK
-case 8:
-YY_RULE_SETUP
-#line 45 "lexer.l"
-{ return ELSE; }
-	YY_BREAK
-case 9:
-YY_RULE_SETUP
-#line 46 "lexer.l"
-{ return ELSE_IF; }
-	YY_BREAK
-case 10:
-YY_RULE_SETUP
-#line 47 "lexer.l"
-{ return AND; }
-	YY_BREAK
-case 11:
-YY_RULE_SETUP
-#line 48 "lexer.l"
-{ return OR; }
-	YY_BREAK
-case 12:
-YY_RULE_SETUP
-#line 49 "lexer.l"
-{ return END; }
-	YY_BREAK
-case 13:
-YY_RULE_SETUP
-#line 50 "lexer.l"
-{ return DEFINEDOR; }
-	YY_BREAK
-case 14:
-YY_RULE_SETUP
-#line 51 "lexer.l"
-{ return SETPIPE; }
-	YY_BREAK
-case 15:
-YY_RULE_SETUP
-#line 52 "lexer.l"
-{ return SETPLUS; }
-	YY_BREAK
-case 16:
-YY_RULE_SETUP
-#line 53 "lexer.l"
-{ return SETMINUS; }
-	YY_BREAK
-case 17:
-YY_RULE_SETUP
-#line 54 "lexer.l"
-{ return SETMULT; }
-	YY_BREAK
-case 18:
-YY_RULE_SETUP
-#line 55 "lexer.l"
-{ return SETDIV; }
-	YY_BREAK
-case 19:
-YY_RULE_SETUP
-#line 56 "lexer.l"
-{ return SETDEFINEDOR; }
-	YY_BREAK
-case 20:
-YY_RULE_SETUP
-#line 57 "lexer.l"
-{ return LESSEQ; }
-	YY_BREAK
-case 21:
-YY_RULE_SETUP
-#line 58 "lexer.l"
-{ return GREATEREQ; }
-	YY_BREAK
-case 22:
-YY_RULE_SETUP
-#line 59 "lexer.l"
-{ return CONTAINS; }
-	YY_BREAK
-case 23:
-YY_RULE_SETUP
-#line 60 "lexer.l"
-{ return yytext[0];}
-	YY_BREAK
-case 24:
-YY_RULE_SETUP
-#line 62 "lexer.l"
-{
-  return enter(yytext[0], YY_START, yyscanner);
-}
-	YY_BREAK
-case 25:
-YY_RULE_SETUP
-#line 66 "lexer.l"
-{
-  return try_exit(yytext[0], YY_START, yyscanner);
-}
-	YY_BREAK
-case 26:
-YY_RULE_SETUP
-#line 71 "lexer.l"
-{ 
-   yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; 
-}
-	YY_BREAK
-case 27:
-YY_RULE_SETUP
-#line 75 "lexer.l"
-{
-  yy_push_state(IN_QQSTRING, yyscanner);
-  return QQSTRING_START;
-}
-	YY_BREAK
-
-case 28:
-YY_RULE_SETUP
-#line 81 "lexer.l"
-{
-    return enter(QQSTRING_INTERP_START, YY_START, yyscanner);
-  }
-	YY_BREAK
-case 29:
-YY_RULE_SETUP
-#line 84 "lexer.l"
-{
-    yy_pop_state(yyscanner);
-    return QQSTRING_END;
-  }
-	YY_BREAK
-case 30:
-/* rule 30 can match eol */
-YY_RULE_SETUP
-#line 88 "lexer.l"
-{
-    /* pass escapes to the json parser */
-    jv escapes = jv_string_fmt("\"%.*s\"", yyleng, yytext);
-    yylval->literal = jv_parse_sized(jv_string_value(escapes), jv_string_length(jv_copy(escapes)));
-    jv_free(escapes);
-    return QQSTRING_TEXT;
-  }
-	YY_BREAK
-case 31:
-/* rule 31 can match eol */
-YY_RULE_SETUP
-#line 95 "lexer.l"
-{
-    yylval->literal = jv_string_sized(yytext, yyleng);
-    return QQSTRING_TEXT;
-  }
-	YY_BREAK
-case 32:
-YY_RULE_SETUP
-#line 99 "lexer.l"
-{
-    return INVALID_CHARACTER;
-  }
-	YY_BREAK
-
-case 33:
-YY_RULE_SETUP
-#line 105 "lexer.l"
-{ yylval->literal = jv_string(yytext); return IDENT;}
-	YY_BREAK
-case 34:
-/* rule 34 can match eol */
-YY_RULE_SETUP
-#line 107 "lexer.l"
-{}
-	YY_BREAK
-case 35:
-YY_RULE_SETUP
-#line 109 "lexer.l"
-{ return INVALID_CHARACTER; }
-	YY_BREAK
-case 36:
-YY_RULE_SETUP
-#line 111 "lexer.l"
-YY_FATAL_ERROR( "flex scanner jammed" );
-	YY_BREAK
-#line 1095 "lexer.gen.c"
-case YY_STATE_EOF(INITIAL):
-case YY_STATE_EOF(IN_PAREN):
-case YY_STATE_EOF(IN_BRACKET):
-case YY_STATE_EOF(IN_BRACE):
-case YY_STATE_EOF(IN_QQINTERP):
-case YY_STATE_EOF(IN_QQSTRING):
-	yyterminate();
-
-	case YY_END_OF_BUFFER:
-		{
-		/* Amount of text matched not including the EOB char. */
-		int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
-
-		/* Undo the effects of YY_DO_BEFORE_ACTION. */
-		*yy_cp = yyg->yy_hold_char;
-		YY_RESTORE_YY_MORE_OFFSET
-
-		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
-			{
-			/* We're scanning a new file or input source.  It's
-			 * possible that this happened because the user
-			 * just pointed yyin at a new source and called
-			 * jq_yylex().  If so, then we have to assure
-			 * consistency between YY_CURRENT_BUFFER and our
-			 * globals.  Here is the right place to do so, because
-			 * this is the first action (other than possibly a
-			 * back-up) that will match for the new input source.
-			 */
-			yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
-			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
-			}
-
-		/* Note that here we test for yy_c_buf_p "<=" to the position
-		 * of the first EOB in the buffer, since yy_c_buf_p will
-		 * already have been incremented past the NUL character
-		 * (since all states make transitions on EOB to the
-		 * end-of-buffer state).  Contrast this with the test
-		 * in input().
-		 */
-		if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
-			{ /* This was really a NUL. */
-			yy_state_type yy_next_state;
-
-			yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
-
-			yy_current_state = yy_get_previous_state( yyscanner );
-
-			/* Okay, we're now positioned to make the NUL
-			 * transition.  We couldn't have
-			 * yy_get_previous_state() go ahead and do it
-			 * for us because it doesn't know how to deal
-			 * with the possibility of jamming (and we don't
-			 * want to build jamming into it because then it
-			 * will run more slowly).
-			 */
-
-			yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
-
-			yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
-
-			if ( yy_next_state )
-				{
-				/* Consume the NUL. */
-				yy_cp = ++yyg->yy_c_buf_p;
-				yy_current_state = yy_next_state;
-				goto yy_match;
-				}
-
-			else
-				{
-				yy_cp = yyg->yy_c_buf_p;
-				goto yy_find_action;
-				}
-			}
-
-		else switch ( yy_get_next_buffer( yyscanner ) )
-			{
-			case EOB_ACT_END_OF_FILE:
-				{
-				yyg->yy_did_buffer_switch_on_eof = 0;
-
-				if ( jq_yywrap(yyscanner ) )
-					{
-					/* Note: because we've taken care in
-					 * yy_get_next_buffer() to have set up
-					 * yytext, we can now set up
-					 * yy_c_buf_p so that if some total
-					 * hoser (like flex itself) wants to
-					 * call the scanner after we return the
-					 * YY_NULL, it'll still work - another
-					 * YY_NULL will get returned.
-					 */
-					yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
-
-					yy_act = YY_STATE_EOF(YY_START);
-					goto do_action;
-					}
-
-				else
-					{
-					if ( ! yyg->yy_did_buffer_switch_on_eof )
-						YY_NEW_FILE;
-					}
-				break;
-				}
-
-			case EOB_ACT_CONTINUE_SCAN:
-				yyg->yy_c_buf_p =
-					yyg->yytext_ptr + yy_amount_of_matched_text;
-
-				yy_current_state = yy_get_previous_state( yyscanner );
-
-				yy_cp = yyg->yy_c_buf_p;
-				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
-				goto yy_match;
-
-			case EOB_ACT_LAST_MATCH:
-				yyg->yy_c_buf_p =
-				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
-
-				yy_current_state = yy_get_previous_state( yyscanner );
-
-				yy_cp = yyg->yy_c_buf_p;
-				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
-				goto yy_find_action;
-			}
-		break;
-		}
-
-	default:
-		YY_FATAL_ERROR(
-			"fatal flex scanner internal error--no action found" );
-	} /* end of action switch */
-		} /* end of scanning one token */
-} /* end of jq_yylex */
-
-/* yy_get_next_buffer - try to read in a new buffer
- *
- * Returns a code representing an action:
- *	EOB_ACT_LAST_MATCH -
- *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
- *	EOB_ACT_END_OF_FILE - end of file
- */
-static int yy_get_next_buffer (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
-	register char *source = yyg->yytext_ptr;
-	register int number_to_move, i;
-	int ret_val;
-
-	if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
-		YY_FATAL_ERROR(
-		"fatal flex scanner internal error--end of buffer missed" );
-
-	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
-		{ /* Don't try to fill the buffer, so this is an EOF. */
-		if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
-			{
-			/* We matched a single character, the EOB, so
-			 * treat this as a final EOF.
-			 */
-			return EOB_ACT_END_OF_FILE;
-			}
-
-		else
-			{
-			/* We matched some text prior to the EOB, first
-			 * process it.
-			 */
-			return EOB_ACT_LAST_MATCH;
-			}
-		}
-
-	/* Try to read more data. */
-
-	/* First move last chars to start of buffer. */
-	number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
-
-	for ( i = 0; i < number_to_move; ++i )
-		*(dest++) = *(source++);
-
-	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
-		/* don't do the read, it's not guaranteed to return an EOF,
-		 * just force an EOF
-		 */
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
-
-	else
-		{
-			int num_to_read =
-			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
-
-		while ( num_to_read <= 0 )
-			{ /* Not enough room in the buffer - grow it. */
-
-			/* just a shorter name for the current buffer */
-			YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
-
-			int yy_c_buf_p_offset =
-				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);
-
-			if ( b->yy_is_our_buffer )
-				{
-				int new_size = b->yy_buf_size * 2;
-
-				if ( new_size <= 0 )
-					b->yy_buf_size += b->yy_buf_size / 8;
-				else
-					b->yy_buf_size *= 2;
-
-				b->yy_ch_buf = (char *)
-					/* Include room in for 2 EOB chars. */
-					jq_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
-				}
-			else
-				/* Can't grow it, we don't own it. */
-				b->yy_ch_buf = 0;
-
-			if ( ! b->yy_ch_buf )
-				YY_FATAL_ERROR(
-				"fatal error - scanner input buffer overflow" );
-
-			yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
-
-			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
-						number_to_move - 1;
-
-			}
-
-		if ( num_to_read > YY_READ_BUF_SIZE )
-			num_to_read = YY_READ_BUF_SIZE;
-
-		/* Read in more data. */
-		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
-			yyg->yy_n_chars, (size_t) num_to_read );
-
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
-		}
-
-	if ( yyg->yy_n_chars == 0 )
-		{
-		if ( number_to_move == YY_MORE_ADJ )
-			{
-			ret_val = EOB_ACT_END_OF_FILE;
-			jq_yyrestart(yyin  ,yyscanner);
-			}
-
-		else
-			{
-			ret_val = EOB_ACT_LAST_MATCH;
-			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
-				YY_BUFFER_EOF_PENDING;
-			}
-		}
-
-	else
-		ret_val = EOB_ACT_CONTINUE_SCAN;
-
-	if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
-		/* Extend the array by 50%, plus the number we really need. */
-		yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
-		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) jq_yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
-		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
-			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
-	}
-
-	yyg->yy_n_chars += number_to_move;
-	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
-	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
-
-	yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
-
-	return ret_val;
-}
-
-/* yy_get_previous_state - get the state just before the EOB char was reached */
-
-    static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
-{
-	register yy_state_type yy_current_state;
-	register char *yy_cp;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	yy_current_state = yyg->yy_start;
-
-	for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
-		{
-		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
-		if ( yy_accept[yy_current_state] )
-			{
-			yyg->yy_last_accepting_state = yy_current_state;
-			yyg->yy_last_accepting_cpos = yy_cp;
-			}
-		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-			{
-			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 96 )
-				yy_c = yy_meta[(unsigned int) yy_c];
-			}
-		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-		}
-
-	return yy_current_state;
-}
-
-/* yy_try_NUL_trans - try to make a transition on the NUL character
- *
- * synopsis
- *	next_state = yy_try_NUL_trans( current_state );
- */
-    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
-{
-	register int yy_is_jam;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
-	register char *yy_cp = yyg->yy_c_buf_p;
-
-	register YY_CHAR yy_c = 1;
-	if ( yy_accept[yy_current_state] )
-		{
-		yyg->yy_last_accepting_state = yy_current_state;
-		yyg->yy_last_accepting_cpos = yy_cp;
-		}
-	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-		{
-		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 96 )
-			yy_c = yy_meta[(unsigned int) yy_c];
-		}
-	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-	yy_is_jam = (yy_current_state == 95);
-
-	return yy_is_jam ? 0 : yy_current_state;
-}
-
-#ifndef YY_NO_INPUT
-#ifdef __cplusplus
-    static int yyinput (yyscan_t yyscanner)
-#else
-    static int input  (yyscan_t yyscanner)
-#endif
-
-{
-	int c;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	*yyg->yy_c_buf_p = yyg->yy_hold_char;
-
-	if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
-		{
-		/* yy_c_buf_p now points to the character we want to return.
-		 * If this occurs *before* the EOB characters, then it's a
-		 * valid NUL; if not, then we've hit the end of the buffer.
-		 */
-		if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
-			/* This was really a NUL. */
-			*yyg->yy_c_buf_p = '\0';
-
-		else
-			{ /* need more input */
-			int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
-			++yyg->yy_c_buf_p;
-
-			switch ( yy_get_next_buffer( yyscanner ) )
-				{
-				case EOB_ACT_LAST_MATCH:
-					/* This happens because yy_g_n_b()
-					 * sees that we've accumulated a
-					 * token and flags that we need to
-					 * try matching the token before
-					 * proceeding.  But for input(),
-					 * there's no matching to consider.
-					 * So convert the EOB_ACT_LAST_MATCH
-					 * to EOB_ACT_END_OF_FILE.
-					 */
-
-					/* Reset buffer status. */
-					jq_yyrestart(yyin ,yyscanner);
-
-					/*FALLTHROUGH*/
-
-				case EOB_ACT_END_OF_FILE:
-					{
-					if ( jq_yywrap(yyscanner ) )
-						return EOF;
-
-					if ( ! yyg->yy_did_buffer_switch_on_eof )
-						YY_NEW_FILE;
-#ifdef __cplusplus
-					return yyinput(yyscanner);
-#else
-					return input(yyscanner);
-#endif
-					}
-
-				case EOB_ACT_CONTINUE_SCAN:
-					yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
-					break;
-				}
-			}
-		}
-
-	c = *(unsigned char *) yyg->yy_c_buf_p;	/* cast for 8-bit char's */
-	*yyg->yy_c_buf_p = '\0';	/* preserve yytext */
-	yyg->yy_hold_char = *++yyg->yy_c_buf_p;
-
-	return c;
-}
-#endif	/* ifndef YY_NO_INPUT */
-
-/** Immediately switch to a different input stream.
- * @param input_file A readable stream.
- * @param yyscanner The scanner object.
- * @note This function does not reset the start condition to @c INITIAL .
- */
-    void jq_yyrestart  (FILE * input_file , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	if ( ! YY_CURRENT_BUFFER ){
-        jq_yyensure_buffer_stack (yyscanner);
-		YY_CURRENT_BUFFER_LVALUE =
-            jq_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
-	}
-
-	jq_yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
-	jq_yy_load_buffer_state(yyscanner );
-}
-
-/** Switch to a different input buffer.
- * @param new_buffer The new input buffer.
- * @param yyscanner The scanner object.
- */
-    void jq_yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	/* TODO. We should be able to replace this entire function body
-	 * with
-	 *		jq_yypop_buffer_state();
-	 *		jq_yypush_buffer_state(new_buffer);
-     */
-	jq_yyensure_buffer_stack (yyscanner);
-	if ( YY_CURRENT_BUFFER == new_buffer )
-		return;
-
-	if ( YY_CURRENT_BUFFER )
-		{
-		/* Flush out information for old buffer. */
-		*yyg->yy_c_buf_p = yyg->yy_hold_char;
-		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
-		}
-
-	YY_CURRENT_BUFFER_LVALUE = new_buffer;
-	jq_yy_load_buffer_state(yyscanner );
-
-	/* We don't actually know whether we did this switch during
-	 * EOF (jq_yywrap()) processing, but the only time this flag
-	 * is looked at is after jq_yywrap() is called, so it's safe
-	 * to go ahead and always set it.
-	 */
-	yyg->yy_did_buffer_switch_on_eof = 1;
-}
-
-static void jq_yy_load_buffer_state  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-	yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
-	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
-	yyg->yy_hold_char = *yyg->yy_c_buf_p;
-}
-
-/** Allocate and initialize an input buffer state.
- * @param file A readable stream.
- * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
- * @param yyscanner The scanner object.
- * @return the allocated buffer state.
- */
-    YY_BUFFER_STATE jq_yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
-{
-	YY_BUFFER_STATE b;
-    
-	b = (YY_BUFFER_STATE) jq_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
-	if ( ! b )
-		YY_FATAL_ERROR( "out of dynamic memory in jq_yy_create_buffer()" );
-
-	b->yy_buf_size = size;
-
-	/* yy_ch_buf has to be 2 characters longer than the size given because
-	 * we need to put in 2 end-of-buffer characters.
-	 */
-	b->yy_ch_buf = (char *) jq_yyalloc(b->yy_buf_size + 2 ,yyscanner );
-	if ( ! b->yy_ch_buf )
-		YY_FATAL_ERROR( "out of dynamic memory in jq_yy_create_buffer()" );
-
-	b->yy_is_our_buffer = 1;
-
-	jq_yy_init_buffer(b,file ,yyscanner);
-
-	return b;
-}
-
-/** Destroy the buffer.
- * @param b a buffer created with jq_yy_create_buffer()
- * @param yyscanner The scanner object.
- */
-    void jq_yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	if ( ! b )
-		return;
-
-	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
-		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
-
-	if ( b->yy_is_our_buffer )
-		jq_yyfree((void *) b->yy_ch_buf ,yyscanner );
-
-	jq_yyfree((void *) b ,yyscanner );
-}
-
-#ifndef __cplusplus
-extern int isatty (int );
-#endif /* __cplusplus */
-    
-/* Initializes or reinitializes a buffer.
- * This function is sometimes called more than once on the same buffer,
- * such as during a jq_yyrestart() or at EOF.
- */
-    static void jq_yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
-
-{
-	int oerrno = errno;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	jq_yy_flush_buffer(b ,yyscanner);
-
-	b->yy_input_file = file;
-	b->yy_fill_buffer = 1;
-
-    /* If b is the current buffer, then jq_yy_init_buffer was _probably_
-     * called from jq_yyrestart() or through yy_get_next_buffer.
-     * In that case, we don't want to reset the lineno or column.
-     */
-    if (b != YY_CURRENT_BUFFER){
-        b->yy_bs_lineno = 1;
-        b->yy_bs_column = 0;
-    }
-
-        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
-    
-	errno = oerrno;
-}
-
-/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
- * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
- * @param yyscanner The scanner object.
- */
-    void jq_yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	if ( ! b )
-		return;
-
-	b->yy_n_chars = 0;
-
-	/* We always need two end-of-buffer characters.  The first causes
-	 * a transition to the end-of-buffer state.  The second causes
-	 * a jam in that state.
-	 */
-	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
-	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
-
-	b->yy_buf_pos = &b->yy_ch_buf[0];
-
-	b->yy_at_bol = 1;
-	b->yy_buffer_status = YY_BUFFER_NEW;
-
-	if ( b == YY_CURRENT_BUFFER )
-		jq_yy_load_buffer_state(yyscanner );
-}
-
-/** Pushes the new state onto the stack. The new state becomes
- *  the current state. This function will allocate the stack
- *  if necessary.
- *  @param new_buffer The new state.
- *  @param yyscanner The scanner object.
- */
-void jq_yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	if (new_buffer == NULL)
-		return;
-
-	jq_yyensure_buffer_stack(yyscanner);
-
-	/* This block is copied from jq_yy_switch_to_buffer. */
-	if ( YY_CURRENT_BUFFER )
-		{
-		/* Flush out information for old buffer. */
-		*yyg->yy_c_buf_p = yyg->yy_hold_char;
-		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
-		}
-
-	/* Only push if top exists. Otherwise, replace top. */
-	if (YY_CURRENT_BUFFER)
-		yyg->yy_buffer_stack_top++;
-	YY_CURRENT_BUFFER_LVALUE = new_buffer;
-
-	/* copied from jq_yy_switch_to_buffer. */
-	jq_yy_load_buffer_state(yyscanner );
-	yyg->yy_did_buffer_switch_on_eof = 1;
-}
-
-/** Removes and deletes the top of the stack, if present.
- *  The next element becomes the new top.
- *  @param yyscanner The scanner object.
- */
-void jq_yypop_buffer_state (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	if (!YY_CURRENT_BUFFER)
-		return;
-
-	jq_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
-	YY_CURRENT_BUFFER_LVALUE = NULL;
-	if (yyg->yy_buffer_stack_top > 0)
-		--yyg->yy_buffer_stack_top;
-
-	if (YY_CURRENT_BUFFER) {
-		jq_yy_load_buffer_state(yyscanner );
-		yyg->yy_did_buffer_switch_on_eof = 1;
-	}
-}
-
-/* Allocates the stack if it does not exist.
- *  Guarantees space for at least one push.
- */
-static void jq_yyensure_buffer_stack (yyscan_t yyscanner)
-{
-	int num_to_alloc;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	if (!yyg->yy_buffer_stack) {
-
-		/* First allocation is just for 2 elements, since we don't know if this
-		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
-		 * immediate realloc on the next call.
-         */
-		num_to_alloc = 1;
-		yyg->yy_buffer_stack = (struct yy_buffer_state**)jq_yyalloc
-								(num_to_alloc * sizeof(struct yy_buffer_state*)
-								, yyscanner);
-		if ( ! yyg->yy_buffer_stack )
-			YY_FATAL_ERROR( "out of dynamic memory in jq_yyensure_buffer_stack()" );
-								  
-		memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
-				
-		yyg->yy_buffer_stack_max = num_to_alloc;
-		yyg->yy_buffer_stack_top = 0;
-		return;
-	}
-
-	if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
-
-		/* Increase the buffer to prepare for a possible push. */
-		int grow_size = 8 /* arbitrary grow size */;
-
-		num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
-		yyg->yy_buffer_stack = (struct yy_buffer_state**)jq_yyrealloc
-								(yyg->yy_buffer_stack,
-								num_to_alloc * sizeof(struct yy_buffer_state*)
-								, yyscanner);
-		if ( ! yyg->yy_buffer_stack )
-			YY_FATAL_ERROR( "out of dynamic memory in jq_yyensure_buffer_stack()" );
-
-		/* zero only the new slots.*/
-		memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
-		yyg->yy_buffer_stack_max = num_to_alloc;
-	}
-}
-
-/** Setup the input buffer state to scan directly from a user-specified character buffer.
- * @param base the character buffer
- * @param size the size in bytes of the character buffer
- * @param yyscanner The scanner object.
- * @return the newly allocated buffer state object. 
- */
-YY_BUFFER_STATE jq_yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
-{
-	YY_BUFFER_STATE b;
-    
-	if ( size < 2 ||
-	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
-	     base[size-1] != YY_END_OF_BUFFER_CHAR )
-		/* They forgot to leave room for the EOB's. */
-		return 0;
-
-	b = (YY_BUFFER_STATE) jq_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
-	if ( ! b )
-		YY_FATAL_ERROR( "out of dynamic memory in jq_yy_scan_buffer()" );
-
-	b->yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */
-	b->yy_buf_pos = b->yy_ch_buf = base;
-	b->yy_is_our_buffer = 0;
-	b->yy_input_file = 0;
-	b->yy_n_chars = b->yy_buf_size;
-	b->yy_is_interactive = 0;
-	b->yy_at_bol = 1;
-	b->yy_fill_buffer = 0;
-	b->yy_buffer_status = YY_BUFFER_NEW;
-
-	jq_yy_switch_to_buffer(b ,yyscanner );
-
-	return b;
-}
-
-/** Setup the input buffer state to scan a string. The next call to jq_yylex() will
- * scan from a @e copy of @a str.
- * @param yystr a NUL-terminated string to scan
- * @param yyscanner The scanner object.
- * @return the newly allocated buffer state object.
- * @note If you want to scan bytes that may contain NUL values, then use
- *       jq_yy_scan_bytes() instead.
- */
-YY_BUFFER_STATE jq_yy_scan_string (yyconst char * yystr , yyscan_t yyscanner)
-{
-    
-	return jq_yy_scan_bytes(yystr,strlen(yystr) ,yyscanner);
-}
-
-/** Setup the input buffer state to scan the given bytes. The next call to jq_yylex() will
- * scan from a @e copy of @a bytes.
- * @param yybytes the byte buffer to scan
- * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
- * @param yyscanner The scanner object.
- * @return the newly allocated buffer state object.
- */
-YY_BUFFER_STATE jq_yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
-{
-	YY_BUFFER_STATE b;
-	char *buf;
-	yy_size_t n;
-	int i;
-    
-	/* Get memory for full buffer, including space for trailing EOB's. */
-	n = _yybytes_len + 2;
-	buf = (char *) jq_yyalloc(n ,yyscanner );
-	if ( ! buf )
-		YY_FATAL_ERROR( "out of dynamic memory in jq_yy_scan_bytes()" );
-
-	for ( i = 0; i < _yybytes_len; ++i )
-		buf[i] = yybytes[i];
-
-	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
-
-	b = jq_yy_scan_buffer(buf,n ,yyscanner);
-	if ( ! b )
-		YY_FATAL_ERROR( "bad buffer in jq_yy_scan_bytes()" );
-
-	/* It's okay to grow etc. this buffer, and we should throw it
-	 * away when we're done.
-	 */
-	b->yy_is_our_buffer = 1;
-
-	return b;
-}
-
-    static void yy_push_state (int  new_state , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	if ( yyg->yy_start_stack_ptr >= yyg->yy_start_stack_depth )
-		{
-		yy_size_t new_size;
-
-		yyg->yy_start_stack_depth += YY_START_STACK_INCR;
-		new_size = yyg->yy_start_stack_depth * sizeof( int );
-
-		if ( ! yyg->yy_start_stack )
-			yyg->yy_start_stack = (int *) jq_yyalloc(new_size ,yyscanner );
-
-		else
-			yyg->yy_start_stack = (int *) jq_yyrealloc((void *) yyg->yy_start_stack,new_size ,yyscanner );
-
-		if ( ! yyg->yy_start_stack )
-			YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
-		}
-
-	yyg->yy_start_stack[yyg->yy_start_stack_ptr++] = YY_START;
-
-	BEGIN(new_state);
-}
-
-    static void yy_pop_state  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	if ( --yyg->yy_start_stack_ptr < 0 )
-		YY_FATAL_ERROR( "start-condition stack underflow" );
-
-	BEGIN(yyg->yy_start_stack[yyg->yy_start_stack_ptr]);
-}
-
-    static int yy_top_state  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	return yyg->yy_start_stack[yyg->yy_start_stack_ptr - 1];
-}
-
-#ifndef YY_EXIT_FAILURE
-#define YY_EXIT_FAILURE 2
-#endif
-
-static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
-{
-    	(void) fprintf( stderr, "%s\n", msg );
-	exit( YY_EXIT_FAILURE );
-}
-
-/* Redefine yyless() so it works in section 3 code. */
-
-#undef yyless
-#define yyless(n) \
-	do \
-		{ \
-		/* Undo effects of setting up yytext. */ \
-        int yyless_macro_arg = (n); \
-        YY_LESS_LINENO(yyless_macro_arg);\
-		yytext[yyleng] = yyg->yy_hold_char; \
-		yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
-		yyg->yy_hold_char = *yyg->yy_c_buf_p; \
-		*yyg->yy_c_buf_p = '\0'; \
-		yyleng = yyless_macro_arg; \
-		} \
-	while ( 0 )
-
-/* Accessor  methods (get/set functions) to struct members. */
-
-/** Get the user-defined data for this scanner.
- * @param yyscanner The scanner object.
- */
-YY_EXTRA_TYPE jq_yyget_extra  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yyextra;
-}
-
-/** Get the current line number.
- * @param yyscanner The scanner object.
- */
-int jq_yyget_lineno  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    
-        if (! YY_CURRENT_BUFFER)
-            return 0;
-    
-    return yylineno;
-}
-
-/** Get the current column number.
- * @param yyscanner The scanner object.
- */
-int jq_yyget_column  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    
-        if (! YY_CURRENT_BUFFER)
-            return 0;
-    
-    return yycolumn;
-}
-
-/** Get the input stream.
- * @param yyscanner The scanner object.
- */
-FILE *jq_yyget_in  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yyin;
-}
-
-/** Get the output stream.
- * @param yyscanner The scanner object.
- */
-FILE *jq_yyget_out  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yyout;
-}
-
-/** Get the length of the current token.
- * @param yyscanner The scanner object.
- */
-int jq_yyget_leng  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yyleng;
-}
-
-/** Get the current token.
- * @param yyscanner The scanner object.
- */
-
-char *jq_yyget_text  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yytext;
-}
-
-/** Set the user-defined data. This data is never touched by the scanner.
- * @param user_defined The data to be associated with this scanner.
- * @param yyscanner The scanner object.
- */
-void jq_yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yyextra = user_defined ;
-}
-
-/** Set the current line number.
- * @param line_number
- * @param yyscanner The scanner object.
- */
-void jq_yyset_lineno (int  line_number , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-        /* lineno is only valid if an input buffer exists. */
-        if (! YY_CURRENT_BUFFER )
-           yy_fatal_error( "jq_yyset_lineno called with no buffer" , yyscanner); 
-    
-    yylineno = line_number;
-}
-
-/** Set the current column.
- * @param line_number
- * @param yyscanner The scanner object.
- */
-void jq_yyset_column (int  column_no , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-        /* column is only valid if an input buffer exists. */
-        if (! YY_CURRENT_BUFFER )
-           yy_fatal_error( "jq_yyset_column called with no buffer" , yyscanner); 
-    
-    yycolumn = column_no;
-}
-
-/** Set the input stream. This does not discard the current
- * input buffer.
- * @param in_str A readable stream.
- * @param yyscanner The scanner object.
- * @see jq_yy_switch_to_buffer
- */
-void jq_yyset_in (FILE *  in_str , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yyin = in_str ;
-}
-
-void jq_yyset_out (FILE *  out_str , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yyout = out_str ;
-}
-
-int jq_yyget_debug  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yy_flex_debug;
-}
-
-void jq_yyset_debug (int  bdebug , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yy_flex_debug = bdebug ;
-}
-
-/* Accessor methods for yylval and yylloc */
-
-YYSTYPE * jq_yyget_lval  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yylval;
-}
-
-void jq_yyset_lval (YYSTYPE *  yylval_param , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yylval = yylval_param;
-}
-
-YYLTYPE *jq_yyget_lloc  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yylloc;
-}
-    
-void jq_yyset_lloc (YYLTYPE *  yylloc_param , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yylloc = yylloc_param;
-}
-    
-/* User-visible API */
-
-/* jq_yylex_init is special because it creates the scanner itself, so it is
- * the ONLY reentrant function that doesn't take the scanner as the last argument.
- * That's why we explicitly handle the declaration, instead of using our macros.
- */
-
-int jq_yylex_init(yyscan_t* ptr_yy_globals)
-
-{
-    if (ptr_yy_globals == NULL){
-        errno = EINVAL;
-        return 1;
-    }
-
-    *ptr_yy_globals = (yyscan_t) jq_yyalloc ( sizeof( struct yyguts_t ), NULL );
-
-    if (*ptr_yy_globals == NULL){
-        errno = ENOMEM;
-        return 1;
-    }
-
-    /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
-    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
-
-    return yy_init_globals ( *ptr_yy_globals );
-}
-
-/* jq_yylex_init_extra has the same functionality as jq_yylex_init, but follows the
- * convention of taking the scanner as the last argument. Note however, that
- * this is a *pointer* to a scanner, as it will be allocated by this call (and
- * is the reason, too, why this function also must handle its own declaration).
- * The user defined value in the first argument will be available to jq_yyalloc in
- * the yyextra field.
- */
-
-int jq_yylex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
-
-{
-    struct yyguts_t dummy_yyguts;
-
-    jq_yyset_extra (yy_user_defined, &dummy_yyguts);
-
-    if (ptr_yy_globals == NULL){
-        errno = EINVAL;
-        return 1;
-    }
-	
-    *ptr_yy_globals = (yyscan_t) jq_yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
-	
-    if (*ptr_yy_globals == NULL){
-        errno = ENOMEM;
-        return 1;
-    }
-    
-    /* By setting to 0xAA, we expose bugs in
-    yy_init_globals. Leave at 0x00 for releases. */
-    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
-    
-    jq_yyset_extra (yy_user_defined, *ptr_yy_globals);
-    
-    return yy_init_globals ( *ptr_yy_globals );
-}
-
-static int yy_init_globals (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    /* Initialization is the same as for the non-reentrant scanner.
-     * This function is called from jq_yylex_destroy(), so don't allocate here.
-     */
-
-    yyg->yy_buffer_stack = 0;
-    yyg->yy_buffer_stack_top = 0;
-    yyg->yy_buffer_stack_max = 0;
-    yyg->yy_c_buf_p = (char *) 0;
-    yyg->yy_init = 0;
-    yyg->yy_start = 0;
-
-    yyg->yy_start_stack_ptr = 0;
-    yyg->yy_start_stack_depth = 0;
-    yyg->yy_start_stack =  NULL;
-
-/* Defined in main.c */
-#ifdef YY_STDINIT
-    yyin = stdin;
-    yyout = stdout;
-#else
-    yyin = (FILE *) 0;
-    yyout = (FILE *) 0;
-#endif
-
-    /* For future reference: Set errno on error, since we are called by
-     * jq_yylex_init()
-     */
-    return 0;
-}
-
-/* jq_yylex_destroy is for both reentrant and non-reentrant scanners. */
-int jq_yylex_destroy  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-    /* Pop the buffer stack, destroying each element. */
-	while(YY_CURRENT_BUFFER){
-		jq_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
-		YY_CURRENT_BUFFER_LVALUE = NULL;
-		jq_yypop_buffer_state(yyscanner);
-	}
-
-	/* Destroy the stack itself. */
-	jq_yyfree(yyg->yy_buffer_stack ,yyscanner);
-	yyg->yy_buffer_stack = NULL;
-
-    /* Destroy the start condition stack. */
-        jq_yyfree(yyg->yy_start_stack ,yyscanner );
-        yyg->yy_start_stack = NULL;
-
-    /* Reset the globals. This is important in a non-reentrant scanner so the next time
-     * jq_yylex() is called, initialization will occur. */
-    yy_init_globals( yyscanner);
-
-    /* Destroy the main struct (reentrant only). */
-    jq_yyfree ( yyscanner , yyscanner );
-    yyscanner = NULL;
-    return 0;
-}
-
-/*
- * Internal utility routines.
- */
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
-{
-	register int i;
-	for ( i = 0; i < n; ++i )
-		s1[i] = s2[i];
-}
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
-{
-	register int n;
-	for ( n = 0; s[n]; ++n )
-		;
-
-	return n;
-}
-#endif
-
-void *jq_yyalloc (yy_size_t  size , yyscan_t yyscanner)
-{
-	return (void *) malloc( size );
-}
-
-void *jq_yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
-{
-	/* The cast to (char *) in the following accommodates both
-	 * implementations that use char* generic pointers, and those
-	 * that use void* generic pointers.  It works with the latter
-	 * because both ANSI C and C++ allow castless assignment from
-	 * any pointer type to void*, and deal with argument conversions
-	 * as though doing an assignment.
-	 */
-	return (void *) realloc( (char *) ptr, size );
-}
-
-void jq_yyfree (void * ptr , yyscan_t yyscanner)
-{
-	free( (char *) ptr );	/* see jq_yyrealloc() for (char *) cast */
-}
-
-#define YYTABLES_NAME "yytables"
-
-#line 111 "lexer.l"
-
-
-/* perhaps these should be calls... */
-/*
-"true" { return TRUE; }
-"false" { return FALSE; }
-"null" { return NULL; }
-*/
-static int try_exit(int c, int state, yyscan_t yyscanner) {
-  char match = 0;
-  int ret;
-  switch (state) {
-  case IN_PAREN: match = ret = ')'; break;
-  case IN_BRACKET: match = ret = ']'; break;
-  case IN_BRACE: match = ret = '}'; break;
-
-  case IN_QQINTERP:
-    match = ')'; 
-    ret = QQSTRING_INTERP_END;
-    break;
-  }
-  assert(match);
-  if (match == c) {
-    yy_pop_state(yyscanner);
-    return ret;
-  } else {
-    // FIXME: should we pop? Give a better error at least
-    return INVALID_CHARACTER;
-  }
-}
-
-static int enter(int c, int currstate, yyscan_t yyscanner) {
-  int state = 0;
-  switch (c) {
-  case '(': state = IN_PAREN; break;
-  case '[': state = IN_BRACKET; break;
-  case '{': state = IN_BRACE; break;
-  case QQSTRING_INTERP_START: state = IN_QQINTERP; break;
-  }
-  assert(state);
-  yy_push_state(state, yyscanner);
-  return c;
-}
-
diff --git a/lexer.gen.h b/lexer.gen.h
deleted file mode 100644
index 9249586d..00000000
--- a/lexer.gen.h
+++ /dev/null
@@ -1,362 +0,0 @@
-#ifndef jq_yyHEADER_H
-#define jq_yyHEADER_H 1
-#define jq_yyIN_HEADER 1
-
-#line 6 "lexer.gen.h"
-
-#line 8 "lexer.gen.h"
-
-#define  YY_INT_ALIGNED short int
-
-/* A lexical scanner generated by flex */
-
-#define FLEX_SCANNER
-#define YY_FLEX_MAJOR_VERSION 2
-#define YY_FLEX_MINOR_VERSION 5
-#define YY_FLEX_SUBMINOR_VERSION 35
-#if YY_FLEX_SUBMINOR_VERSION > 0
-#define FLEX_BETA
-#endif
-
-/* First, we deal with  platform-specific or compiler-specific issues. */
-
-/* begin standard C headers. */
-#include <stdio.h>
-#include <string.h>
-#include <errno.h>
-#include <stdlib.h>
-
-/* end standard C headers. */
-
-/* flex integer type definitions */
-
-#ifndef FLEXINT_H
-#define FLEXINT_H
-
-/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
-
-#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-
-/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
- * if you want the limit (max/min) macros for int types. 
- */
-#ifndef __STDC_LIMIT_MACROS
-#define __STDC_LIMIT_MACROS 1
-#endif
-
-#include <inttypes.h>
-typedef int8_t flex_int8_t;
-typedef uint8_t flex_uint8_t;
-typedef int16_t flex_int16_t;
-typedef uint16_t flex_uint16_t;
-typedef int32_t flex_int32_t;
-typedef uint32_t flex_uint32_t;
-#else
-typedef signed char flex_int8_t;
-typedef short int flex_int16_t;
-typedef int flex_int32_t;
-typedef unsigned char flex_uint8_t; 
-typedef unsigned short int flex_uint16_t;
-typedef unsigned int flex_uint32_t;
-
-/* Limits of integral types. */
-#ifndef INT8_MIN
-#define INT8_MIN               (-128)
-#endif
-#ifndef INT16_MIN
-#define INT16_MIN              (-32767-1)
-#endif
-#ifndef INT32_MIN
-#define INT32_MIN              (-2147483647-1)
-#endif
-#ifndef INT8_MAX
-#define INT8_MAX               (127)
-#endif
-#ifndef INT16_MAX
-#define INT16_MAX              (32767)
-#endif
-#ifndef INT32_MAX
-#define INT32_MAX              (2147483647)
-#endif
-#ifndef UINT8_MAX
-#define UINT8_MAX              (255U)
-#endif
-#ifndef UINT16_MAX
-#define UINT16_MAX             (65535U)
-#endif
-#ifndef UINT32_MAX
-#define UINT32_MAX             (4294967295U)
-#endif
-
-#endif /* ! C99 */
-
-#endif /* ! FLEXINT_H */
-
-#ifdef __cplusplus
-
-/* The "const" storage-class-modifier is valid. */
-#define YY_USE_CONST
-
-#else	/* ! __cplusplus */
-
-/* C99 requires __STDC__ to be defined as 1. */
-#if defined (__STDC__)
-
-#define YY_USE_CONST
-
-#endif	/* defined (__STDC__) */
-#endif	/* ! __cplusplus */
-
-#ifdef YY_USE_CONST
-#define yyconst const
-#else
-#define yyconst
-#endif
-
-/* An opaque pointer. */
-#ifndef YY_TYPEDEF_YY_SCANNER_T
-#define YY_TYPEDEF_YY_SCANNER_T
-typedef void* yyscan_t;
-#endif
-
-/* For convenience, these vars (plus the bison vars far below)
-   are macros in the reentrant scanner. */
-#define yyin yyg->yyin_r
-#define yyout yyg->yyout_r
-#define yyextra yyg->yyextra_r
-#define yyleng yyg->yyleng_r
-#define yytext yyg->yytext_r
-#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
-#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
-#define yy_flex_debug yyg->yy_flex_debug_r
-
-/* Size of default input buffer. */
-#ifndef YY_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k.
- * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
- * Ditto for the __ia64__ case accordingly.
- */
-#define YY_BUF_SIZE 32768
-#else
-#define YY_BUF_SIZE 16384
-#endif /* __ia64__ */
-#endif
-
-#ifndef YY_TYPEDEF_YY_BUFFER_STATE
-#define YY_TYPEDEF_YY_BUFFER_STATE
-typedef struct yy_buffer_state *YY_BUFFER_STATE;
-#endif
-
-#ifndef YY_TYPEDEF_YY_SIZE_T
-#define YY_TYPEDEF_YY_SIZE_T
-typedef size_t yy_size_t;
-#endif
-
-#ifndef YY_STRUCT_YY_BUFFER_STATE
-#define YY_STRUCT_YY_BUFFER_STATE
-struct yy_buffer_state
-	{
-	FILE *yy_input_file;
-
-	char *yy_ch_buf;		/* input buffer */
-	char *yy_buf_pos;		/* current position in input buffer */
-
-	/* Size of input buffer in bytes, not including room for EOB
-	 * characters.
-	 */
-	yy_size_t yy_buf_size;
-
-	/* Number of characters read into yy_ch_buf, not including EOB
-	 * characters.
-	 */
-	int yy_n_chars;
-
-	/* Whether we "own" the buffer - i.e., we know we created it,
-	 * and can realloc() it to grow it, and should free() it to
-	 * delete it.
-	 */
-	int yy_is_our_buffer;
-
-	/* Whether this is an "interactive" input source; if so, and
-	 * if we're using stdio for input, then we want to use getc()
-	 * instead of fread(), to make sure we stop fetching input after
-	 * each newline.
-	 */
-	int yy_is_interactive;
-
-	/* Whether we're considered to be at the beginning of a line.
-	 * If so, '^' rules will be active on the next match, otherwise
-	 * not.
-	 */
-	int yy_at_bol;
-
-    int yy_bs_lineno; /**< The line count. */
-    int yy_bs_column; /**< The column count. */
-    
-	/* Whether to try to fill the input buffer when we reach the
-	 * end of it.
-	 */
-	int yy_fill_buffer;
-
-	int yy_buffer_status;
-
-	};
-#endif /* !YY_STRUCT_YY_BUFFER_STATE */
-
-void jq_yyrestart (FILE *input_file ,yyscan_t yyscanner );
-void jq_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
-YY_BUFFER_STATE jq_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
-void jq_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
-void jq_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
-void jq_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
-void jq_yypop_buffer_state (yyscan_t yyscanner );
-
-YY_BUFFER_STATE jq_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
-YY_BUFFER_STATE jq_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
-YY_BUFFER_STATE jq_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
-
-void *jq_yyalloc (yy_size_t ,yyscan_t yyscanner );
-void *jq_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
-void jq_yyfree (void * ,yyscan_t yyscanner );
-
-/* Begin user sect3 */
-
-#define jq_yywrap(n) 1
-#define YY_SKIP_YYWRAP
-
-#define yytext_ptr yytext_r
-
-#ifdef YY_HEADER_EXPORT_START_CONDITIONS
-#define INITIAL 0
-#define IN_PAREN 1
-#define IN_BRACKET 2
-#define IN_BRACE 3
-#define IN_QQINTERP 4
-#define IN_QQSTRING 5
-
-#endif
-
-#ifndef YY_NO_UNISTD_H
-/* Special case for "unistd.h", since it is non-ANSI. We include it way
- * down here because we want the user's section 1 to have been scanned first.
- * The user has a chance to override it with an option.
- */
-#include <unistd.h>
-#endif
-
-#define YY_EXTRA_TYPE int
-
-int jq_yylex_init (yyscan_t* scanner);
-
-int jq_yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
-
-/* Accessor methods to globals.
-   These are made visible to non-reentrant scanners for convenience. */
-
-int jq_yylex_destroy (yyscan_t yyscanner );
-
-int jq_yyget_debug (yyscan_t yyscanner );
-
-void jq_yyset_debug (int debug_flag ,yyscan_t yyscanner );
-
-YY_EXTRA_TYPE jq_yyget_extra (yyscan_t yyscanner );
-
-void jq_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
-
-FILE *jq_yyget_in (yyscan_t yyscanner );
-
-void jq_yyset_in  (FILE * in_str ,yyscan_t yyscanner );
-
-FILE *jq_yyget_out (yyscan_t yyscanner );
-
-void jq_yyset_out  (FILE * out_str ,yyscan_t yyscanner );
-
-int jq_yyget_leng (yyscan_t yyscanner );
-
-char *jq_yyget_text (yyscan_t yyscanner );
-
-int jq_yyget_lineno (yyscan_t yyscanner );
-
-void jq_yyset_lineno (int line_number ,yyscan_t yyscanner );
-
-YYSTYPE * jq_yyget_lval (yyscan_t yyscanner );
-
-void jq_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
-
-       YYLTYPE *jq_yyget_lloc (yyscan_t yyscanner );
-    
-        void jq_yyset_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner );
-    
-/* Macros after this point can all be overridden by user definitions in
- * section 1.
- */
-
-#ifndef YY_SKIP_YYWRAP
-#ifdef __cplusplus
-extern "C" int jq_yywrap (yyscan_t yyscanner );
-#else
-extern int jq_yywrap (yyscan_t yyscanner );
-#endif
-#endif
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
-#endif
-
-#ifndef YY_NO_INPUT
-
-#endif
-
-/* Amount of stuff to slurp up with each read. */
-#ifndef YY_READ_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k */
-#define YY_READ_BUF_SIZE 16384
-#else
-#define YY_READ_BUF_SIZE 8192
-#endif /* __ia64__ */
-#endif
-
-/* Number of entries by which start-condition stack grows. */
-#ifndef YY_START_STACK_INCR
-#define YY_START_STACK_INCR 25
-#endif
-
-/* Default declaration of generated scanner - a define so the user can
- * easily add parameters.
- */
-#ifndef YY_DECL
-#define YY_DECL_IS_OURS 1
-
-extern int jq_yylex \
-               (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner);
-
-#define YY_DECL int jq_yylex \
-               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
-#endif /* !YY_DECL */
-
-/* yy_get_previous_state - get the state just before the EOB char was reached */
-
-#undef YY_NEW_FILE
-#undef YY_FLUSH_BUFFER
-#undef yy_set_bol
-#undef yy_new_buffer
-#undef yy_set_interactive
-#undef YY_DO_BEFORE_ACTION
-
-#ifdef YY_DECL_IS_OURS
-#undef YY_DECL_IS_OURS
-#undef YY_DECL
-#endif
-
-#line 111 "lexer.l"
-
-
-#line 361 "lexer.gen.h"
-#undef jq_yyIN_HEADER
-#endif /* jq_yyHEADER_H */
diff --git a/main.c b/main.c
index 74ca0e6e..06a7e91e 100644
--- a/main.c
+++ b/main.c
@@ -9,12 +9,12 @@
 #include "locfile.h"
 #include "parser.h"
 #include "execute.h"
-#include "version.gen.h"
+#include "config.h"  /* Autoconf generated header file */
 
 static const char* progname;
 
 static void usage() {
-  fprintf(stderr, "\njq - commandline JSON processor [version %s]\n", JQ_VERSION);
+  fprintf(stderr, "\njq - commandline JSON processor [version %s]\n", PACKAGE_VERSION);
   fprintf(stderr, "Usage: %s [options] <jq filter>\n\n", progname);
   fprintf(stderr, "For a description of the command line options and\n");
   fprintf(stderr, "how to write jq filters (and why you might want to)\n");
@@ -122,7 +122,7 @@ int main(int argc, char* argv[]) {
     } else if (isoption(argv[i], 'h', "help")) {
       usage();
     } else if (isoption(argv[i], 'V', "version")) {
-      fprintf(stderr, "jq version %s\n", JQ_VERSION);
+      fprintf(stderr, "jq version %s\n", PACKAGE_VERSION);
       return 0;
     } else {
       fprintf(stderr, "%s: Unknown option %s\n", progname, argv[i]);
diff --git a/parser.gen.c b/parser.gen.c
deleted file mode 100644
index 896eb2a3..00000000
--- a/parser.gen.c
+++ /dev/null
@@ -1,2878 +0,0 @@
-/* A Bison parser, made by GNU Bison 2.5.  */
-
-/* Bison implementation for Yacc-like parsers in C
-   
-      Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
-   
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-   
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-   
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
-
-/* As a special exception, you may create a larger work that contains
-   part or all of the Bison parser skeleton and distribute that work
-   under terms of your choice, so long as that work isn't itself a
-   parser generator using the skeleton or a modified version thereof
-   as a parser skeleton.  Alternatively, if you modify or redistribute
-   the parser skeleton itself, you may (at your option) remove this
-   special exception, which will cause the skeleton and the resulting
-   Bison output files to be licensed under the GNU General Public
-   License without this special exception.
-   
-   This special exception was added by the Free Software Foundation in
-   version 2.2 of Bison.  */
-
-/* C LALR(1) parser skeleton written by Richard Stallman, by
-   simplifying the original so-called "semantic" parser.  */
-
-/* All symbols defined below should begin with yy or YY, to avoid
-   infringing on user name space.  This should be done even for local
-   variables, as they might otherwise be expanded by user macros.
-   There are some unavoidable exceptions within include files to
-   define necessary library symbols; they are noted "INFRINGES ON
-   USER NAME SPACE" below.  */
-
-/* Identify Bison output.  */
-#define YYBISON 1
-
-/* Bison version.  */
-#define YYBISON_VERSION "2.5"
-
-/* Skeleton name.  */
-#define YYSKELETON_NAME "yacc.c"
-
-/* Pure parsers.  */
-#define YYPURE 1
-
-/* Push parsers.  */
-#define YYPUSH 0
-
-/* Pull parsers.  */
-#define YYPULL 1
-
-/* Using locations.  */
-#define YYLSP_NEEDED 1
-
-
-
-/* Copy the first part of user declarations.  */
-
-/* Line 268 of yacc.c  */
-#line 1 "parser.y"
-
-#include <stdio.h>
-#include <string.h>
-#include "compile.h"
-
-struct lexer_param;
-
-
-
-/* Line 268 of yacc.c  */
-#line 81 "parser.gen.c"
-
-/* Enabling traces.  */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-
-/* Enabling verbose error messages.  */
-#ifdef YYERROR_VERBOSE
-# undef YYERROR_VERBOSE
-# define YYERROR_VERBOSE 1
-#else
-# define YYERROR_VERBOSE 1
-#endif
-
-/* Enabling the token table.  */
-#ifndef YYTOKEN_TABLE
-# define YYTOKEN_TABLE 0
-#endif
-
-/* "%code requires" blocks.  */
-
-/* Line 288 of yacc.c  */
-#line 9 "parser.y"
-
-#include "locfile.h"
-#define YYLTYPE location
-#define YYLLOC_DEFAULT(Loc, Rhs, N)             \
-  do {                                          \
-    if (N) {                                    \
-      (Loc).start = YYRHSLOC(Rhs, 1).start;     \
-      (Loc).end = YYRHSLOC(Rhs, N).end;         \
-    } else {                                    \
-      (Loc).start = YYRHSLOC(Rhs, 0).end;       \
-      (Loc).end = YYRHSLOC(Rhs, 0).end;         \
-    }                                           \
-  } while (0)
- 
-
-
-/* Line 288 of yacc.c  */
-#line 122 "parser.gen.c"
-
-/* Tokens.  */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
-   /* Put the tokens into the symbol table, so that GDB and other debuggers
-      know about them.  */
-   enum yytokentype {
-     INVALID_CHARACTER = 258,
-     IDENT = 259,
-     LITERAL = 260,
-     EQ = 261,
-     NEQ = 262,
-     DEFINEDOR = 263,
-     AS = 264,
-     DEF = 265,
-     IF = 266,
-     THEN = 267,
-     ELSE = 268,
-     ELSE_IF = 269,
-     END = 270,
-     AND = 271,
-     OR = 272,
-     SETPIPE = 273,
-     SETPLUS = 274,
-     SETMINUS = 275,
-     SETMULT = 276,
-     SETDIV = 277,
-     SETDEFINEDOR = 278,
-     LESSEQ = 279,
-     GREATEREQ = 280,
-     CONTAINS = 281,
-     QQSTRING_START = 282,
-     QQSTRING_TEXT = 283,
-     QQSTRING_INTERP_START = 284,
-     QQSTRING_INTERP_END = 285,
-     QQSTRING_END = 286
-   };
-#endif
-
-
-
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE
-{
-
-/* Line 293 of yacc.c  */
-#line 27 "parser.y"
-
-  jv literal;
-  block blk;
-
-
-
-/* Line 293 of yacc.c  */
-#line 177 "parser.gen.c"
-} YYSTYPE;
-# define YYSTYPE_IS_TRIVIAL 1
-# define yystype YYSTYPE /* obsolescent; will be withdrawn */
-# define YYSTYPE_IS_DECLARED 1
-#endif
-
-#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
-typedef struct YYLTYPE
-{
-  int first_line;
-  int first_column;
-  int last_line;
-  int last_column;
-} YYLTYPE;
-# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
-# define YYLTYPE_IS_DECLARED 1
-# define YYLTYPE_IS_TRIVIAL 1
-#endif
-
-
-/* Copy the second part of user declarations.  */
-
-/* Line 343 of yacc.c  */
-#line 90 "parser.y"
-
-#include "lexer.gen.h"
-struct lexer_param {
-  yyscan_t lexer;
-};
-#define FAIL(loc, msg)                                             \
-  do {                                                             \
-    location l = loc;                                              \
-    yyerror(&l, answer, errors, locations, lexer_param_ptr, msg);  \
-    /*YYERROR*/;                                                   \
-  } while (0)
-
-void yyerror(YYLTYPE* loc, block* answer, int* errors, 
-             struct locfile* locations, struct lexer_param* lexer_param_ptr, const char *s){
-  (*errors)++;
-  locfile_locate(locations, *loc, "error: %s", s);
-}
-
-int yylex(YYSTYPE* yylval, YYLTYPE* yylloc, block* answer, int* errors, 
-          struct locfile* locations, struct lexer_param* lexer_param_ptr) {
-  yyscan_t lexer = lexer_param_ptr->lexer;
-  while (1) {
-    int tok = jq_yylex(yylval, yylloc, lexer);
-    if (tok == INVALID_CHARACTER) {
-      FAIL(*yylloc, "Invalid character");
-    } else {
-      if ((tok == LITERAL || tok == QQSTRING_TEXT) && !jv_is_valid(yylval->literal)) {
-        jv msg = jv_invalid_get_msg(jv_copy(yylval->literal));
-        if (jv_get_kind(msg) == JV_KIND_STRING) {
-          FAIL(*yylloc, jv_string_value(msg));
-        } else {
-          FAIL(*yylloc, "Invalid literal");
-        }
-        jv_free(msg);
-        jv_free(yylval->literal);
-        yylval->literal = jv_null();
-      }
-      return tok;
-    }
-  }
-}
-
-static block gen_dictpair(block k, block v) {
-  block b = gen_subexp(k);
-  block_append(&b, gen_subexp(v));
-  block_append(&b, gen_op_simple(INSERT));
-  return b;
-}
-
-static block gen_index(block obj, block key) {
-  return block_join(obj, block_join(gen_subexp(key), gen_op_simple(INDEX)));
-}
-
-static block gen_binop(block a, block b, int op) {
-  const char* funcname = 0;
-  switch (op) {
-  case '+': funcname = "_plus"; break;
-  case '-': funcname = "_minus"; break;
-  case '*': funcname = "_multiply"; break;
-  case '/': funcname = "_divide"; break;
-  case EQ: funcname = "_equal"; break;
-  case NEQ: funcname = "_notequal"; break;
-  case '<': funcname = "_less"; break;
-  case '>': funcname = "_greater"; break;
-  case LESSEQ: funcname = "_lesseq"; break;
-  case GREATEREQ: funcname = "_greatereq"; break;
-  case CONTAINS: funcname = "_contains"; break;
-  }
-  assert(funcname);
-
-  block c = gen_noop();
-  block_append(&c, gen_subexp(a));
-  block_append(&c, gen_subexp(b));
-  block_append(&c, gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, funcname)));
-  return c;
-}
-
-static block gen_format(block a) {
-  return block_join(a, gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, "tostring")));
-}
- 
-static block gen_update(block a, block op, int optype) {
-  block assign = a;
-  block_append(&assign, gen_op_simple(DUP));
-  if (optype) {
-    op = gen_binop(gen_noop(), op, optype);
-  }
-  block_append(&assign, op);
-  return gen_assign(assign);
-}
-
-
-
-/* Line 343 of yacc.c  */
-#line 296 "parser.gen.c"
-
-#ifdef short
-# undef short
-#endif
-
-#ifdef YYTYPE_UINT8
-typedef YYTYPE_UINT8 yytype_uint8;
-#else
-typedef unsigned char yytype_uint8;
-#endif
-
-#ifdef YYTYPE_INT8
-typedef YYTYPE_INT8 yytype_int8;
-#elif (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-typedef signed char yytype_int8;
-#else
-typedef short int yytype_int8;
-#endif
-
-#ifdef YYTYPE_UINT16
-typedef YYTYPE_UINT16 yytype_uint16;
-#else
-typedef unsigned short int yytype_uint16;
-#endif
-
-#ifdef YYTYPE_INT16
-typedef YYTYPE_INT16 yytype_int16;
-#else
-typedef short int yytype_int16;
-#endif
-
-#ifndef YYSIZE_T
-# ifdef __SIZE_TYPE__
-#  define YYSIZE_T __SIZE_TYPE__
-# elif defined size_t
-#  define YYSIZE_T size_t
-# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-#  define YYSIZE_T size_t
-# else
-#  define YYSIZE_T unsigned int
-# endif
-#endif
-
-#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
-
-#ifndef YY_
-# if defined YYENABLE_NLS && YYENABLE_NLS
-#  if ENABLE_NLS
-#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
-#   define YY_(msgid) dgettext ("bison-runtime", msgid)
-#  endif
-# endif
-# ifndef YY_
-#  define YY_(msgid) msgid
-# endif
-#endif
-
-/* Suppress unused-variable warnings by "using" E.  */
-#if ! defined lint || defined __GNUC__
-# define YYUSE(e) ((void) (e))
-#else
-# define YYUSE(e) /* empty */
-#endif
-
-/* Identity function, used to suppress warnings about constant conditions.  */
-#ifndef lint
-# define YYID(n) (n)
-#else
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static int
-YYID (int yyi)
-#else
-static int
-YYID (yyi)
-    int yyi;
-#endif
-{
-  return yyi;
-}
-#endif
-
-#if ! defined yyoverflow || YYERROR_VERBOSE
-
-/* The parser invokes alloca or malloc; define the necessary symbols.  */
-
-# ifdef YYSTACK_USE_ALLOCA
-#  if YYSTACK_USE_ALLOCA
-#   ifdef __GNUC__
-#    define YYSTACK_ALLOC __builtin_alloca
-#   elif defined __BUILTIN_VA_ARG_INCR
-#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
-#   elif defined _AIX
-#    define YYSTACK_ALLOC __alloca
-#   elif defined _MSC_VER
-#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
-#    define alloca _alloca
-#   else
-#    define YYSTACK_ALLOC alloca
-#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-#     ifndef EXIT_SUCCESS
-#      define EXIT_SUCCESS 0
-#     endif
-#    endif
-#   endif
-#  endif
-# endif
-
-# ifdef YYSTACK_ALLOC
-   /* Pacify GCC's `empty if-body' warning.  */
-#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
-#  ifndef YYSTACK_ALLOC_MAXIMUM
-    /* The OS might guarantee only one guard page at the bottom of the stack,
-       and a page size can be as small as 4096 bytes.  So we cannot safely
-       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
-       to allow for a few compiler-allocated temporary stack slots.  */
-#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
-#  endif
-# else
-#  define YYSTACK_ALLOC YYMALLOC
-#  define YYSTACK_FREE YYFREE
-#  ifndef YYSTACK_ALLOC_MAXIMUM
-#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
-#  endif
-#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
-       && ! ((defined YYMALLOC || defined malloc) \
-	     && (defined YYFREE || defined free)))
-#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-#   ifndef EXIT_SUCCESS
-#    define EXIT_SUCCESS 0
-#   endif
-#  endif
-#  ifndef YYMALLOC
-#   define YYMALLOC malloc
-#   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
-#   endif
-#  endif
-#  ifndef YYFREE
-#   define YYFREE free
-#   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-void free (void *); /* INFRINGES ON USER NAME SPACE */
-#   endif
-#  endif
-# endif
-#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
-
-
-#if (! defined yyoverflow \
-     && (! defined __cplusplus \
-	 || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
-	     && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
-
-/* A type that is properly aligned for any stack member.  */
-union yyalloc
-{
-  yytype_int16 yyss_alloc;
-  YYSTYPE yyvs_alloc;
-  YYLTYPE yyls_alloc;
-};
-
-/* The size of the maximum gap between one aligned stack and the next.  */
-# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
-
-/* The size of an array large to enough to hold all stacks, each with
-   N elements.  */
-# define YYSTACK_BYTES(N) \
-     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
-      + 2 * YYSTACK_GAP_MAXIMUM)
-
-# define YYCOPY_NEEDED 1
-
-/* Relocate STACK from its old location to the new one.  The
-   local variables YYSIZE and YYSTACKSIZE give the old and new number of
-   elements in the stack, and YYPTR gives the new location of the
-   stack.  Advance YYPTR to a properly aligned location for the next
-   stack.  */
-# define YYSTACK_RELOCATE(Stack_alloc, Stack)				\
-    do									\
-      {									\
-	YYSIZE_T yynewbytes;						\
-	YYCOPY (&yyptr->Stack_alloc, Stack, yysize);			\
-	Stack = &yyptr->Stack_alloc;					\
-	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
-	yyptr += yynewbytes / sizeof (*yyptr);				\
-      }									\
-    while (YYID (0))
-
-#endif
-
-#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
-/* Copy COUNT objects from FROM to TO.  The source and destination do
-   not overlap.  */
-# ifndef YYCOPY
-#  if defined __GNUC__ && 1 < __GNUC__
-#   define YYCOPY(To, From, Count) \
-      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
-#  else
-#   define YYCOPY(To, From, Count)		\
-      do					\
-	{					\
-	  YYSIZE_T yyi;				\
-	  for (yyi = 0; yyi < (Count); yyi++)	\
-	    (To)[yyi] = (From)[yyi];		\
-	}					\
-      while (YYID (0))
-#  endif
-# endif
-#endif /* !YYCOPY_NEEDED */
-
-/* YYFINAL -- State number of the termination state.  */
-#define YYFINAL  35
-/* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   854
-
-/* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  51
-/* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  12
-/* YYNRULES -- Number of rules.  */
-#define YYNRULES  70
-/* YYNRULES -- Number of states.  */
-#define YYNSTATES  151
-
-/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
-#define YYUNDEFTOK  2
-#define YYMAXUTOK   286
-
-#define YYTRANSLATE(YYX)						\
-  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
-
-/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
-static const yytype_uint8 yytranslate[] =
-{
-       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,    42,     2,     2,     2,
-      44,    45,    40,    38,    34,    39,    46,    41,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,    43,    32,
-      36,    35,    37,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,    47,     2,    48,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,    49,    33,    50,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31
-};
-
-#if YYDEBUG
-/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
-   YYRHS.  */
-static const yytype_uint16 yyprhs[] =
-{
-       0,     0,     3,     5,     7,     8,    11,    14,    21,    27,
-      31,    35,    39,    43,    47,    51,    55,    59,    63,    67,
-      71,    75,    79,    83,    87,    91,    95,    99,   103,   107,
-     111,   115,   119,   123,   125,   129,   135,   144,   145,   148,
-     153,   159,   163,   167,   169,   171,   175,   178,   183,   187,
-     189,   191,   195,   199,   202,   206,   209,   211,   216,   220,
-     224,   229,   233,   234,   236,   240,   244,   248,   252,   254,
-     260
-};
-
-/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
-static const yytype_int8 yyrhs[] =
-{
-      52,     0,    -1,    54,    -1,    53,    -1,    -1,    56,    53,
-      -1,    56,    54,    -1,    60,     9,    42,     4,    33,    54,
-      -1,    11,    54,    12,    54,    58,    -1,    11,    54,     1,
-      -1,    54,    35,    54,    -1,    54,    17,    54,    -1,    54,
-      16,    54,    -1,    54,     8,    54,    -1,    54,    23,    54,
-      -1,    54,    18,    54,    -1,    54,    33,    54,    -1,    54,
-      34,    54,    -1,    54,    38,    54,    -1,    54,    19,    54,
-      -1,    54,    39,    54,    -1,    54,    20,    54,    -1,    54,
-      40,    54,    -1,    54,    21,    54,    -1,    54,    41,    54,
-      -1,    54,    22,    54,    -1,    54,     6,    54,    -1,    54,
-       7,    54,    -1,    54,    36,    54,    -1,    54,    37,    54,
-      -1,    54,    24,    54,    -1,    54,    25,    54,    -1,    54,
-      26,    54,    -1,    60,    -1,    27,    57,    31,    -1,    10,
-       4,    43,    54,    32,    -1,    10,     4,    44,     4,    45,
-      43,    54,    32,    -1,    -1,    57,    28,    -1,    57,    29,
-      54,    30,    -1,    14,    54,    12,    54,    58,    -1,    13,
-      54,    15,    -1,    59,    33,    59,    -1,    60,    -1,    46,
-      -1,    60,    46,     4,    -1,    46,     4,    -1,    60,    47,
-      54,    48,    -1,    60,    47,    48,    -1,     5,    -1,    55,
-      -1,    44,    54,    45,    -1,    47,    54,    48,    -1,    47,
-      48,    -1,    49,    61,    50,    -1,    42,     4,    -1,     4,
-      -1,     4,    44,    54,    45,    -1,    44,     1,    45,    -1,
-      47,     1,    48,    -1,    60,    47,     1,    48,    -1,    49,
-       1,    50,    -1,    -1,    62,    -1,    62,    34,    61,    -1,
-       1,    34,    61,    -1,     4,    43,    59,    -1,    55,    43,
-      59,    -1,     4,    -1,    44,    54,    45,    43,    59,    -1,
-      44,     1,    45,    43,    59,    -1
-};
-
-/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
-static const yytype_uint16 yyrline[] =
-{
-       0,   185,   185,   188,   193,   196,   201,   205,   212,   215,
-     220,   229,   233,   237,   241,   245,   249,   253,   257,   261,
-     265,   269,   273,   277,   281,   285,   289,   293,   297,   301,
-     305,   309,   313,   317,   322,   327,   333,   341,   344,   347,
-     353,   356,   361,   365,   371,   374,   377,   381,   384,   387,
-     390,   393,   396,   399,   402,   407,   411,   415,   425,   426,
-     427,   428,   431,   434,   435,   436,   439,   442,   445,   449,
-     452
-};
-#endif
-
-#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
-/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
-   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
-static const char *const yytname[] =
-{
-  "$end", "error", "$undefined", "INVALID_CHARACTER", "IDENT", "LITERAL",
-  "\"==\"", "\"!=\"", "\"//\"", "\"as\"", "\"def\"", "\"if\"", "\"then\"",
-  "\"else\"", "\"elif\"", "\"end\"", "\"and\"", "\"or\"", "\"|=\"",
-  "\"+=\"", "\"-=\"", "\"*=\"", "\"/=\"", "\"//=\"", "\"<=\"", "\">=\"",
-  "\"contains\"", "QQSTRING_START", "QQSTRING_TEXT",
-  "QQSTRING_INTERP_START", "QQSTRING_INTERP_END", "QQSTRING_END", "';'",
-  "'|'", "','", "'='", "'<'", "'>'", "'+'", "'-'", "'*'", "'/'", "'$'",
-  "':'", "'('", "')'", "'.'", "'['", "']'", "'{'", "'}'", "$accept",
-  "TopLevel", "FuncDefs", "Exp", "String", "FuncDef", "QQString",
-  "ElseBody", "ExpD", "Term", "MkDict", "MkDictPair", 0
-};
-#endif
-
-# ifdef YYPRINT
-/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
-   token YYLEX-NUM.  */
-static const yytype_uint16 yytoknum[] =
-{
-       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,    59,   124,    44,    61,    60,    62,    43,    45,
-      42,    47,    36,    58,    40,    41,    46,    91,    93,   123,
-     125
-};
-# endif
-
-/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
-static const yytype_uint8 yyr1[] =
-{
-       0,    51,    52,    52,    53,    53,    54,    54,    54,    54,
-      54,    54,    54,    54,    54,    54,    54,    54,    54,    54,
-      54,    54,    54,    54,    54,    54,    54,    54,    54,    54,
-      54,    54,    54,    54,    55,    56,    56,    57,    57,    57,
-      58,    58,    59,    59,    60,    60,    60,    60,    60,    60,
-      60,    60,    60,    60,    60,    60,    60,    60,    60,    60,
-      60,    60,    61,    61,    61,    61,    62,    62,    62,    62,
-      62
-};
-
-/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
-static const yytype_uint8 yyr2[] =
-{
-       0,     2,     1,     1,     0,     2,     2,     6,     5,     3,
-       3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-       3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-       3,     3,     3,     1,     3,     5,     8,     0,     2,     4,
-       5,     3,     3,     1,     1,     3,     2,     4,     3,     1,
-       1,     3,     3,     2,     3,     2,     1,     4,     3,     3,
-       4,     3,     0,     1,     3,     3,     3,     3,     1,     5,
-       5
-};
-
-/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
-   Performed when YYTABLE doesn't specify something else to do.  Zero
-   means the default is an error.  */
-static const yytype_uint8 yydefact[] =
-{
-       4,    56,    49,     0,     0,    37,     0,     0,    44,     0,
-       0,     0,     3,     2,    50,     4,    33,     0,     0,     0,
-       0,     0,    55,     0,     0,    46,     0,    53,     0,     0,
-      68,     0,     0,     0,    63,     1,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
-       6,     0,     0,     0,     0,     0,     0,     9,     0,    38,
-       0,    34,    58,    51,    59,    52,     0,    61,     0,     0,
-       0,     0,    54,     0,    26,    27,    13,    12,    11,    15,
-      19,    21,    23,    25,    14,    30,    31,    32,    16,    17,
-      10,    28,    29,    18,    20,    22,    24,     0,    45,     0,
-      48,     0,    57,     0,     0,     0,     0,     0,    65,    66,
-      43,     0,     0,    67,    64,     0,    60,    47,    35,     0,
-       0,     0,     8,    39,     0,     0,     0,     0,     0,     0,
-       0,    42,    70,    69,     7,     0,    41,     0,    36,     0,
-      40
-};
-
-/* YYDEFGOTO[NTERM-NUM].  */
-static const yytype_int16 yydefgoto[] =
-{
-      -1,    11,    12,    60,    14,    20,    21,   132,   119,    16,
-      33,    34
-};
-
-/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
-   STATE-NUM.  */
-#define YYPACT_NINF -76
-static const yytype_int16 yypact[] =
-{
-     179,   -42,   -76,    10,   179,   -76,    16,   131,    18,    79,
-      65,    28,   -76,   662,   -76,   179,    53,   179,   -28,   302,
-     179,   -18,   -76,   -15,   338,   -76,   -19,   -76,   223,   -29,
-     -11,   155,   -10,    14,     1,   -76,   179,   179,   179,   179,
-     179,   179,   179,   179,   179,   179,   179,   179,   179,   179,
-     179,   179,   179,   179,   179,   179,   179,   179,   179,   -76,
-     662,    -8,    72,   106,   374,   179,    73,   -76,   179,   -76,
-     179,   -76,   -76,   -76,   -76,   -76,    74,   -76,   165,    34,
-     410,   165,   -76,    74,   807,   807,   734,   813,   786,   760,
-     760,   760,   760,   760,   760,   807,   807,   807,   698,   734,
-     760,   807,   807,   -16,   -16,   -76,   -76,    77,   -76,    37,
-     -76,   259,   -76,   482,    41,   446,   518,    48,   -76,    54,
-     -20,    45,    50,    54,   -76,    58,   -76,   -76,   -76,    51,
-     179,   179,   -76,   -76,   165,   165,   165,   179,   179,   554,
-     590,   -76,    54,    54,   698,   626,   -76,   179,   -76,   446,
-     -76
-};
-
-/* YYPGOTO[NTERM-NUM].  */
-static const yytype_int8 yypgoto[] =
-{
-     -76,   -76,    80,     0,    -9,     8,   -76,   -53,   -63,   -75,
-     -64,   -76
-};
-
-/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
-   positive, shift that token.  If negative, reduce the rule which
-   number is the opposite.  If YYTABLE_NINF, syntax error.  */
-#define YYTABLE_NINF -63
-static const yytype_int16 yytable[] =
-{
-      13,    32,    17,   120,    19,    76,   120,    24,    15,    28,
-      69,    70,   118,    71,    18,    65,    66,    64,   123,   124,
-      22,    77,    25,    15,    57,    58,    62,    63,    35,    74,
-      72,    80,    78,    81,   107,    83,    84,    85,    86,    87,
-      88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
-      98,    99,   100,   101,   102,   103,   104,   105,   106,   120,
-     120,   120,    61,   111,    82,   113,    29,    32,   115,    30,
-     116,   141,   142,   143,    32,   117,   108,   114,    30,   121,
-      26,   125,    76,     1,     2,   126,   129,   134,   135,     3,
-       4,   137,     5,   136,   138,    59,   150,     0,     0,    62,
-      63,     5,     0,     0,     0,     0,     5,   109,     0,    31,
-       1,     2,     0,     0,     0,   -62,     3,     4,    31,     0,
-       0,     6,     0,     7,   -62,     8,     9,    27,    10,     0,
-     139,   140,    23,     5,     0,     1,     2,   144,   145,     0,
-       0,     3,     4,     0,     0,     0,     0,   149,     6,     0,
-       7,     0,     8,     9,   110,    10,    79,     0,     5,     1,
-       2,     0,     0,     0,     0,     3,     4,     0,     0,     1,
-       2,     0,     0,     6,     0,     7,     0,     8,     9,     0,
-      10,     0,     5,     1,     2,     0,     0,     0,     0,     3,
-       4,     0,     5,     0,     0,     0,     0,     6,     0,     7,
-       0,     8,     9,     0,    10,     0,     5,     6,     0,     7,
-       0,     8,     9,     0,    10,     0,     0,     0,     0,     0,
-       0,     6,     0,     7,     0,     8,     9,     0,    10,    36,
-      37,    38,     0,     0,     0,     0,     0,     0,     0,    39,
-      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
-       0,     0,     0,     0,     0,     0,    50,    51,    52,    53,
-      54,    55,    56,    57,    58,    36,    37,    38,     0,     0,
-       0,    75,     0,     0,     0,    39,    40,    41,    42,    43,
-      44,    45,    46,    47,    48,    49,     0,     0,     0,     0,
-       0,     0,    50,    51,    52,    53,    54,    55,    56,    57,
-      58,     0,     0,    67,     0,     0,     0,   127,    36,    37,
-      38,     0,     0,     0,    68,     0,     0,     0,    39,    40,
-      41,    42,    43,    44,    45,    46,    47,    48,    49,     0,
-       0,     0,     0,     0,     0,    50,    51,    52,    53,    54,
-      55,    56,    57,    58,    36,    37,    38,     0,     0,     0,
-       0,     0,     0,     0,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    49,     0,     0,     0,     0,     0,
-       0,    50,    51,    52,    53,    54,    55,    56,    57,    58,
-      36,    37,    38,    73,     0,     0,     0,     0,     0,     0,
-      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
-      49,     0,     0,     0,     0,     0,     0,    50,    51,    52,
-      53,    54,    55,    56,    57,    58,    36,    37,    38,   112,
-       0,     0,     0,     0,     0,     0,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,    49,     0,     0,     0,
-       0,     0,     0,    50,    51,    52,    53,    54,    55,    56,
-      57,    58,    36,    37,    38,   122,     0,     0,     0,   130,
-     131,     0,    39,    40,    41,    42,    43,    44,    45,    46,
-      47,    48,    49,     0,     0,     0,     0,     0,     0,    50,
-      51,    52,    53,    54,    55,    56,    57,    58,    36,    37,
-      38,     0,     0,     0,     0,     0,     0,     0,    39,    40,
-      41,    42,    43,    44,    45,    46,    47,    48,    49,     0,
-       0,     0,     0,     0,   128,    50,    51,    52,    53,    54,
-      55,    56,    57,    58,    36,    37,    38,     0,     0,     0,
-       0,     0,     0,     0,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    49,     0,     0,     0,   133,     0,
-       0,    50,    51,    52,    53,    54,    55,    56,    57,    58,
-      36,    37,    38,     0,     0,     0,     0,     0,     0,   146,
-      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
-      49,     0,     0,     0,     0,     0,     0,    50,    51,    52,
-      53,    54,    55,    56,    57,    58,    36,    37,    38,     0,
-       0,     0,   147,     0,     0,     0,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,    49,     0,     0,     0,
-       0,     0,     0,    50,    51,    52,    53,    54,    55,    56,
-      57,    58,    36,    37,    38,     0,     0,     0,     0,     0,
-       0,     0,    39,    40,    41,    42,    43,    44,    45,    46,
-      47,    48,    49,     0,     0,     0,     0,     0,   148,    50,
-      51,    52,    53,    54,    55,    56,    57,    58,    36,    37,
-      38,     0,     0,     0,     0,     0,     0,     0,    39,    40,
-      41,    42,    43,    44,    45,    46,    47,    48,    49,     0,
-       0,     0,     0,     0,     0,    50,    51,    52,    53,    54,
-      55,    56,    57,    58,    36,    37,    38,     0,     0,     0,
-       0,     0,     0,     0,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    49,     0,     0,     0,     0,     0,
-       0,     0,    51,    52,    53,    54,    55,    56,    57,    58,
-      36,    37,    38,     0,     0,     0,     0,     0,     0,     0,
-      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
-      49,     0,     0,     0,     0,     0,    36,    37,     0,    52,
-      53,    54,    55,    56,    57,    58,    39,    40,   -63,   -63,
-     -63,   -63,   -63,   -63,    47,    48,    49,     0,     0,     0,
-       0,     0,    36,    37,     0,   -63,    53,    54,    55,    56,
-      57,    58,    39,     0,     0,     0,     0,     0,     0,     0,
-      47,    48,    49,   -63,   -63,     0,     0,     0,     0,    36,
-      37,     0,    53,    54,    55,    56,    57,    58,     0,     0,
-       0,   -63,   -63,   -63,     0,     0,     0,    47,    48,    49,
-       0,     0,     0,   -63,   -63,    55,    56,    57,    58,    53,
-      54,    55,    56,    57,    58
-};
-
-#define yypact_value_is_default(yystate) \
-  ((yystate) == (-76))
-
-#define yytable_value_is_error(yytable_value) \
-  ((yytable_value) == (-63))
-
-static const yytype_int16 yycheck[] =
-{
-       0,    10,    44,    78,     4,    34,    81,     7,     0,     9,
-      28,    29,    76,    31,     4,    43,    44,    17,    81,    83,
-       4,    50,     4,    15,    40,    41,    46,    47,     0,    48,
-      45,    31,    43,    43,    42,    34,    36,    37,    38,    39,
-      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    57,    58,   134,
-     135,   136,     9,    63,    50,    65,     1,    76,    68,     4,
-      70,   134,   135,   136,    83,     1,     4,     4,     4,    45,
-       1,     4,    34,     4,     5,    48,    45,    33,    43,    10,
-      11,    33,    27,    43,    43,    15,   149,    -1,    -1,    46,
-      47,    27,    -1,    -1,    -1,    -1,    27,     1,    -1,    44,
-       4,     5,    -1,    -1,    -1,    50,    10,    11,    44,    -1,
-      -1,    42,    -1,    44,    50,    46,    47,    48,    49,    -1,
-     130,   131,     1,    27,    -1,     4,     5,   137,   138,    -1,
-      -1,    10,    11,    -1,    -1,    -1,    -1,   147,    42,    -1,
-      44,    -1,    46,    47,    48,    49,     1,    -1,    27,     4,
-       5,    -1,    -1,    -1,    -1,    10,    11,    -1,    -1,     4,
-       5,    -1,    -1,    42,    -1,    44,    -1,    46,    47,    -1,
-      49,    -1,    27,     4,     5,    -1,    -1,    -1,    -1,    10,
-      11,    -1,    27,    -1,    -1,    -1,    -1,    42,    -1,    44,
-      -1,    46,    47,    -1,    49,    -1,    27,    42,    -1,    44,
-      -1,    46,    47,    -1,    49,    -1,    -1,    -1,    -1,    -1,
-      -1,    42,    -1,    44,    -1,    46,    47,    -1,    49,     6,
-       7,     8,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      -1,    -1,    -1,    -1,    -1,    -1,    33,    34,    35,    36,
-      37,    38,    39,    40,    41,     6,     7,     8,    -1,    -1,
-      -1,    48,    -1,    -1,    -1,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    -1,    -1,    -1,    -1,
-      -1,    -1,    33,    34,    35,    36,    37,    38,    39,    40,
-      41,    -1,    -1,     1,    -1,    -1,    -1,    48,     6,     7,
-       8,    -1,    -1,    -1,    12,    -1,    -1,    -1,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
-      -1,    -1,    -1,    -1,    -1,    33,    34,    35,    36,    37,
-      38,    39,    40,    41,     6,     7,     8,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    -1,    -1,    -1,    -1,    -1,
-      -1,    33,    34,    35,    36,    37,    38,    39,    40,    41,
-       6,     7,     8,    45,    -1,    -1,    -1,    -1,    -1,    -1,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    -1,    -1,    -1,    -1,    -1,    -1,    33,    34,    35,
-      36,    37,    38,    39,    40,    41,     6,     7,     8,    45,
-      -1,    -1,    -1,    -1,    -1,    -1,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    26,    -1,    -1,    -1,
-      -1,    -1,    -1,    33,    34,    35,    36,    37,    38,    39,
-      40,    41,     6,     7,     8,    45,    -1,    -1,    -1,    13,
-      14,    -1,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    -1,    -1,    -1,    -1,    -1,    -1,    33,
-      34,    35,    36,    37,    38,    39,    40,    41,     6,     7,
-       8,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
-      -1,    -1,    -1,    -1,    32,    33,    34,    35,    36,    37,
-      38,    39,    40,    41,     6,     7,     8,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    -1,    -1,    -1,    30,    -1,
-      -1,    33,    34,    35,    36,    37,    38,    39,    40,    41,
-       6,     7,     8,    -1,    -1,    -1,    -1,    -1,    -1,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    -1,    -1,    -1,    -1,    -1,    -1,    33,    34,    35,
-      36,    37,    38,    39,    40,    41,     6,     7,     8,    -1,
-      -1,    -1,    12,    -1,    -1,    -1,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    26,    -1,    -1,    -1,
-      -1,    -1,    -1,    33,    34,    35,    36,    37,    38,    39,
-      40,    41,     6,     7,     8,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    -1,    -1,    -1,    -1,    -1,    32,    33,
-      34,    35,    36,    37,    38,    39,    40,    41,     6,     7,
-       8,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
-      -1,    -1,    -1,    -1,    -1,    33,    34,    35,    36,    37,
-      38,    39,    40,    41,     6,     7,     8,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    34,    35,    36,    37,    38,    39,    40,    41,
-       6,     7,     8,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    -1,    -1,    -1,    -1,    -1,     6,     7,    -1,    35,
-      36,    37,    38,    39,    40,    41,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    26,    -1,    -1,    -1,
-      -1,    -1,     6,     7,    -1,    35,    36,    37,    38,    39,
-      40,    41,    16,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      24,    25,    26,     6,     7,    -1,    -1,    -1,    -1,     6,
-       7,    -1,    36,    37,    38,    39,    40,    41,    -1,    -1,
-      -1,    24,    25,    26,    -1,    -1,    -1,    24,    25,    26,
-      -1,    -1,    -1,    36,    37,    38,    39,    40,    41,    36,
-      37,    38,    39,    40,    41
-};
-
-/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
-   symbol of state STATE-NUM.  */
-static const yytype_uint8 yystos[] =
-{
-       0,     4,     5,    10,    11,    27,    42,    44,    46,    47,
-      49,    52,    53,    54,    55,    56,    60,    44,     4,    54,
-      56,    57,     4,     1,    54,     4,     1,    48,    54,     1,
-       4,    44,    55,    61,    62,     0,     6,     7,     8,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      33,    34,    35,    36,    37,    38,    39,    40,    41,    53,
-      54,     9,    46,    47,    54,    43,    44,     1,    12,    28,
-      29,    31,    45,    45,    48,    48,    34,    50,    43,     1,
-      54,    43,    50,    34,    54,    54,    54,    54,    54,    54,
-      54,    54,    54,    54,    54,    54,    54,    54,    54,    54,
-      54,    54,    54,    54,    54,    54,    54,    42,     4,     1,
-      48,    54,    45,    54,     4,    54,    54,     1,    61,    59,
-      60,    45,    45,    59,    61,     4,    48,    48,    32,    45,
-      13,    14,    58,    30,    33,    43,    43,    33,    43,    54,
-      54,    59,    59,    59,    54,    54,    15,    12,    32,    54,
-      58
-};
-
-#define yyerrok		(yyerrstatus = 0)
-#define yyclearin	(yychar = YYEMPTY)
-#define YYEMPTY		(-2)
-#define YYEOF		0
-
-#define YYACCEPT	goto yyacceptlab
-#define YYABORT		goto yyabortlab
-#define YYERROR		goto yyerrorlab
-
-
-/* Like YYERROR except do call yyerror.  This remains here temporarily
-   to ease the transition to the new meaning of YYERROR, for GCC.
-   Once GCC version 2 has supplanted version 1, this can go.  However,
-   YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
-   in Bison 2.4.2's NEWS entry, where a plan to phase it out is
-   discussed.  */
-
-#define YYFAIL		goto yyerrlab
-#if defined YYFAIL
-  /* This is here to suppress warnings from the GCC cpp's
-     -Wunused-macros.  Normally we don't worry about that warning, but
-     some users do, and we want to make it easy for users to remove
-     YYFAIL uses, which will produce warnings from Bison 2.5.  */
-#endif
-
-#define YYRECOVERING()  (!!yyerrstatus)
-
-#define YYBACKUP(Token, Value)					\
-do								\
-  if (yychar == YYEMPTY && yylen == 1)				\
-    {								\
-      yychar = (Token);						\
-      yylval = (Value);						\
-      YYPOPSTACK (1);						\
-      goto yybackup;						\
-    }								\
-  else								\
-    {								\
-      yyerror (&yylloc, answer, errors, locations, lexer_param_ptr, YY_("syntax error: cannot back up")); \
-      YYERROR;							\
-    }								\
-while (YYID (0))
-
-
-#define YYTERROR	1
-#define YYERRCODE	256
-
-
-/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
-   If N is 0, then set CURRENT to the empty location which ends
-   the previous symbol: RHS[0] (always defined).  */
-
-#define YYRHSLOC(Rhs, K) ((Rhs)[K])
-#ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N)				\
-    do									\
-      if (YYID (N))                                                    \
-	{								\
-	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
-	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
-	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
-	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
-	}								\
-      else								\
-	{								\
-	  (Current).first_line   = (Current).last_line   =		\
-	    YYRHSLOC (Rhs, 0).last_line;				\
-	  (Current).first_column = (Current).last_column =		\
-	    YYRHSLOC (Rhs, 0).last_column;				\
-	}								\
-    while (YYID (0))
-#endif
-
-
-/* YY_LOCATION_PRINT -- Print the location on the stream.
-   This macro was not mandated originally: define only if we know
-   we won't break user code: when these are the locations we know.  */
-
-#ifndef YY_LOCATION_PRINT
-# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
-#  define YY_LOCATION_PRINT(File, Loc)			\
-     fprintf (File, "%d.%d-%d.%d",			\
-	      (Loc).first_line, (Loc).first_column,	\
-	      (Loc).last_line,  (Loc).last_column)
-# else
-#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
-# endif
-#endif
-
-
-/* YYLEX -- calling `yylex' with the right arguments.  */
-
-#ifdef YYLEX_PARAM
-# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
-#else
-# define YYLEX yylex (&yylval, &yylloc, answer, errors, locations, lexer_param_ptr)
-#endif
-
-/* Enable debugging if requested.  */
-#if YYDEBUG
-
-# ifndef YYFPRINTF
-#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
-#  define YYFPRINTF fprintf
-# endif
-
-# define YYDPRINTF(Args)			\
-do {						\
-  if (yydebug)					\
-    YYFPRINTF Args;				\
-} while (YYID (0))
-
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location)			  \
-do {									  \
-  if (yydebug)								  \
-    {									  \
-      YYFPRINTF (stderr, "%s ", Title);					  \
-      yy_symbol_print (stderr,						  \
-		  Type, Value, Location, answer, errors, locations, lexer_param_ptr); \
-      YYFPRINTF (stderr, "\n");						  \
-    }									  \
-} while (YYID (0))
-
-
-/*--------------------------------.
-| Print this symbol on YYOUTPUT.  |
-`--------------------------------*/
-
-/*ARGSUSED*/
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr)
-#else
-static void
-yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors, locations, lexer_param_ptr)
-    FILE *yyoutput;
-    int yytype;
-    YYSTYPE const * const yyvaluep;
-    YYLTYPE const * const yylocationp;
-    block* answer;
-    int* errors;
-    struct locfile* locations;
-    struct lexer_param* lexer_param_ptr;
-#endif
-{
-  if (!yyvaluep)
-    return;
-  YYUSE (yylocationp);
-  YYUSE (answer);
-  YYUSE (errors);
-  YYUSE (locations);
-  YYUSE (lexer_param_ptr);
-# ifdef YYPRINT
-  if (yytype < YYNTOKENS)
-    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
-# else
-  YYUSE (yyoutput);
-# endif
-  switch (yytype)
-    {
-      default:
-	break;
-    }
-}
-
-
-/*--------------------------------.
-| Print this symbol on YYOUTPUT.  |
-`--------------------------------*/
-
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr)
-#else
-static void
-yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors, locations, lexer_param_ptr)
-    FILE *yyoutput;
-    int yytype;
-    YYSTYPE const * const yyvaluep;
-    YYLTYPE const * const yylocationp;
-    block* answer;
-    int* errors;
-    struct locfile* locations;
-    struct lexer_param* lexer_param_ptr;
-#endif
-{
-  if (yytype < YYNTOKENS)
-    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
-  else
-    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
-
-  YY_LOCATION_PRINT (yyoutput, *yylocationp);
-  YYFPRINTF (yyoutput, ": ");
-  yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors, locations, lexer_param_ptr);
-  YYFPRINTF (yyoutput, ")");
-}
-
-/*------------------------------------------------------------------.
-| yy_stack_print -- Print the state stack from its BOTTOM up to its |
-| TOP (included).                                                   |
-`------------------------------------------------------------------*/
-
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
-#else
-static void
-yy_stack_print (yybottom, yytop)
-    yytype_int16 *yybottom;
-    yytype_int16 *yytop;
-#endif
-{
-  YYFPRINTF (stderr, "Stack now");
-  for (; yybottom <= yytop; yybottom++)
-    {
-      int yybot = *yybottom;
-      YYFPRINTF (stderr, " %d", yybot);
-    }
-  YYFPRINTF (stderr, "\n");
-}
-
-# define YY_STACK_PRINT(Bottom, Top)				\
-do {								\
-  if (yydebug)							\
-    yy_stack_print ((Bottom), (Top));				\
-} while (YYID (0))
-
-
-/*------------------------------------------------.
-| Report that the YYRULE is going to be reduced.  |
-`------------------------------------------------*/
-
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr)
-#else
-static void
-yy_reduce_print (yyvsp, yylsp, yyrule, answer, errors, locations, lexer_param_ptr)
-    YYSTYPE *yyvsp;
-    YYLTYPE *yylsp;
-    int yyrule;
-    block* answer;
-    int* errors;
-    struct locfile* locations;
-    struct lexer_param* lexer_param_ptr;
-#endif
-{
-  int yynrhs = yyr2[yyrule];
-  int yyi;
-  unsigned long int yylno = yyrline[yyrule];
-  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
-	     yyrule - 1, yylno);
-  /* The symbols being reduced.  */
-  for (yyi = 0; yyi < yynrhs; yyi++)
-    {
-      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
-      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
-		       &(yyvsp[(yyi + 1) - (yynrhs)])
-		       , &(yylsp[(yyi + 1) - (yynrhs)])		       , answer, errors, locations, lexer_param_ptr);
-      YYFPRINTF (stderr, "\n");
-    }
-}
-
-# define YY_REDUCE_PRINT(Rule)		\
-do {					\
-  if (yydebug)				\
-    yy_reduce_print (yyvsp, yylsp, Rule, answer, errors, locations, lexer_param_ptr); \
-} while (YYID (0))
-
-/* Nonzero means print parse trace.  It is left uninitialized so that
-   multiple parsers can coexist.  */
-int yydebug;
-#else /* !YYDEBUG */
-# define YYDPRINTF(Args)
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
-# define YY_STACK_PRINT(Bottom, Top)
-# define YY_REDUCE_PRINT(Rule)
-#endif /* !YYDEBUG */
-
-
-/* YYINITDEPTH -- initial size of the parser's stacks.  */
-#ifndef	YYINITDEPTH
-# define YYINITDEPTH 200
-#endif
-
-/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
-   if the built-in stack extension method is used).
-
-   Do not make this value too large; the results are undefined if
-   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
-   evaluated with infinite-precision integer arithmetic.  */
-
-#ifndef YYMAXDEPTH
-# define YYMAXDEPTH 10000
-#endif
-
-
-#if YYERROR_VERBOSE
-
-# ifndef yystrlen
-#  if defined __GLIBC__ && defined _STRING_H
-#   define yystrlen strlen
-#  else
-/* Return the length of YYSTR.  */
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static YYSIZE_T
-yystrlen (const char *yystr)
-#else
-static YYSIZE_T
-yystrlen (yystr)
-    const char *yystr;
-#endif
-{
-  YYSIZE_T yylen;
-  for (yylen = 0; yystr[yylen]; yylen++)
-    continue;
-  return yylen;
-}
-#  endif
-# endif
-
-# ifndef yystpcpy
-#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
-#   define yystpcpy stpcpy
-#  else
-/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
-   YYDEST.  */
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static char *
-yystpcpy (char *yydest, const char *yysrc)
-#else
-static char *
-yystpcpy (yydest, yysrc)
-    char *yydest;
-    const char *yysrc;
-#endif
-{
-  char *yyd = yydest;
-  const char *yys = yysrc;
-
-  while ((*yyd++ = *yys++) != '\0')
-    continue;
-
-  return yyd - 1;
-}
-#  endif
-# endif
-
-# ifndef yytnamerr
-/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
-   quotes and backslashes, so that it's suitable for yyerror.  The
-   heuristic is that double-quoting is unnecessary unless the string
-   contains an apostrophe, a comma, or backslash (other than
-   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
-   null, do not copy; instead, return the length of what the result
-   would have been.  */
-static YYSIZE_T
-yytnamerr (char *yyres, const char *yystr)
-{
-  if (*yystr == '"')
-    {
-      YYSIZE_T yyn = 0;
-      char const *yyp = yystr;
-
-      for (;;)
-	switch (*++yyp)
-	  {
-	  case '\'':
-	  case ',':
-	    goto do_not_strip_quotes;
-
-	  case '\\':
-	    if (*++yyp != '\\')
-	      goto do_not_strip_quotes;
-	    /* Fall through.  */
-	  default:
-	    if (yyres)
-	      yyres[yyn] = *yyp;
-	    yyn++;
-	    break;
-
-	  case '"':
-	    if (yyres)
-	      yyres[yyn] = '\0';
-	    return yyn;
-	  }
-    do_not_strip_quotes: ;
-    }
-
-  if (! yyres)
-    return yystrlen (yystr);
-
-  return yystpcpy (yyres, yystr) - yyres;
-}
-# endif
-
-/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
-   about the unexpected token YYTOKEN for the state stack whose top is
-   YYSSP.
-
-   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
-   not large enough to hold the message.  In that case, also set
-   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
-   required number of bytes is too large to store.  */
-static int
-yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
-                yytype_int16 *yyssp, int yytoken)
-{
-  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
-  YYSIZE_T yysize = yysize0;
-  YYSIZE_T yysize1;
-  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
-  /* Internationalized format string. */
-  const char *yyformat = 0;
-  /* Arguments of yyformat. */
-  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
-  /* Number of reported tokens (one for the "unexpected", one per
-     "expected"). */
-  int yycount = 0;
-
-  /* There are many possibilities here to consider:
-     - Assume YYFAIL is not used.  It's too flawed to consider.  See
-       <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
-       for details.  YYERROR is fine as it does not invoke this
-       function.
-     - If this state is a consistent state with a default action, then
-       the only way this function was invoked is if the default action
-       is an error action.  In that case, don't check for expected
-       tokens because there are none.
-     - The only way there can be no lookahead present (in yychar) is if
-       this state is a consistent state with a default action.  Thus,
-       detecting the absence of a lookahead is sufficient to determine
-       that there is no unexpected or expected token to report.  In that
-       case, just report a simple "syntax error".
-     - Don't assume there isn't a lookahead just because this state is a
-       consistent state with a default action.  There might have been a
-       previous inconsistent state, consistent state with a non-default
-       action, or user semantic action that manipulated yychar.
-     - Of course, the expected token list depends on states to have
-       correct lookahead information, and it depends on the parser not
-       to perform extra reductions after fetching a lookahead from the
-       scanner and before detecting a syntax error.  Thus, state merging
-       (from LALR or IELR) and default reductions corrupt the expected
-       token list.  However, the list is correct for canonical LR with
-       one exception: it will still contain any token that will not be
-       accepted due to an error action in a later state.
-  */
-  if (yytoken != YYEMPTY)
-    {
-      int yyn = yypact[*yyssp];
-      yyarg[yycount++] = yytname[yytoken];
-      if (!yypact_value_is_default (yyn))
-        {
-          /* Start YYX at -YYN if negative to avoid negative indexes in
-             YYCHECK.  In other words, skip the first -YYN actions for
-             this state because they are default actions.  */
-          int yyxbegin = yyn < 0 ? -yyn : 0;
-          /* Stay within bounds of both yycheck and yytname.  */
-          int yychecklim = YYLAST - yyn + 1;
-          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
-          int yyx;
-
-          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
-            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
-                && !yytable_value_is_error (yytable[yyx + yyn]))
-              {
-                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
-                  {
-                    yycount = 1;
-                    yysize = yysize0;
-                    break;
-                  }
-                yyarg[yycount++] = yytname[yyx];
-                yysize1 = yysize + yytnamerr (0, yytname[yyx]);
-                if (! (yysize <= yysize1
-                       && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
-                  return 2;
-                yysize = yysize1;
-              }
-        }
-    }
-
-  switch (yycount)
-    {
-# define YYCASE_(N, S)                      \
-      case N:                               \
-        yyformat = S;                       \
-      break
-      YYCASE_(0, YY_("syntax error"));
-      YYCASE_(1, YY_("syntax error, unexpected %s"));
-      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
-      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
-      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
-      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
-# undef YYCASE_
-    }
-
-  yysize1 = yysize + yystrlen (yyformat);
-  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
-    return 2;
-  yysize = yysize1;
-
-  if (*yymsg_alloc < yysize)
-    {
-      *yymsg_alloc = 2 * yysize;
-      if (! (yysize <= *yymsg_alloc
-             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
-        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
-      return 1;
-    }
-
-  /* Avoid sprintf, as that infringes on the user's name space.
-     Don't have undefined behavior even if the translation
-     produced a string with the wrong number of "%s"s.  */
-  {
-    char *yyp = *yymsg;
-    int yyi = 0;
-    while ((*yyp = *yyformat) != '\0')
-      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
-        {
-          yyp += yytnamerr (yyp, yyarg[yyi++]);
-          yyformat += 2;
-        }
-      else
-        {
-          yyp++;
-          yyformat++;
-        }
-  }
-  return 0;
-}
-#endif /* YYERROR_VERBOSE */
-
-/*-----------------------------------------------.
-| Release the memory associated to this symbol.  |
-`-----------------------------------------------*/
-
-/*ARGSUSED*/
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr)
-#else
-static void
-yydestruct (yymsg, yytype, yyvaluep, yylocationp, answer, errors, locations, lexer_param_ptr)
-    const char *yymsg;
-    int yytype;
-    YYSTYPE *yyvaluep;
-    YYLTYPE *yylocationp;
-    block* answer;
-    int* errors;
-    struct locfile* locations;
-    struct lexer_param* lexer_param_ptr;
-#endif
-{
-  YYUSE (yyvaluep);
-  YYUSE (yylocationp);
-  YYUSE (answer);
-  YYUSE (errors);
-  YYUSE (locations);
-  YYUSE (lexer_param_ptr);
-
-  if (!yymsg)
-    yymsg = "Deleting";
-  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
-
-  switch (yytype)
-    {
-      case 4: /* "IDENT" */
-
-/* Line 1391 of yacc.c  */
-#line 32 "parser.y"
-	{ jv_free((yyvaluep->literal)); };
-
-/* Line 1391 of yacc.c  */
-#line 1541 "parser.gen.c"
-	break;
-      case 5: /* "LITERAL" */
-
-/* Line 1391 of yacc.c  */
-#line 32 "parser.y"
-	{ jv_free((yyvaluep->literal)); };
-
-/* Line 1391 of yacc.c  */
-#line 1550 "parser.gen.c"
-	break;
-      case 28: /* "QQSTRING_TEXT" */
-
-/* Line 1391 of yacc.c  */
-#line 32 "parser.y"
-	{ jv_free((yyvaluep->literal)); };
-
-/* Line 1391 of yacc.c  */
-#line 1559 "parser.gen.c"
-	break;
-      case 53: /* "FuncDefs" */
-
-/* Line 1391 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1568 "parser.gen.c"
-	break;
-      case 54: /* "Exp" */
-
-/* Line 1391 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1577 "parser.gen.c"
-	break;
-      case 55: /* "String" */
-
-/* Line 1391 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1586 "parser.gen.c"
-	break;
-      case 56: /* "FuncDef" */
-
-/* Line 1391 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1595 "parser.gen.c"
-	break;
-      case 57: /* "QQString" */
-
-/* Line 1391 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1604 "parser.gen.c"
-	break;
-      case 58: /* "ElseBody" */
-
-/* Line 1391 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1613 "parser.gen.c"
-	break;
-      case 59: /* "ExpD" */
-
-/* Line 1391 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1622 "parser.gen.c"
-	break;
-      case 60: /* "Term" */
-
-/* Line 1391 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1631 "parser.gen.c"
-	break;
-      case 61: /* "MkDict" */
-
-/* Line 1391 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1640 "parser.gen.c"
-	break;
-      case 62: /* "MkDictPair" */
-
-/* Line 1391 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1649 "parser.gen.c"
-	break;
-
-      default:
-	break;
-    }
-}
-
-
-/* Prevent warnings from -Wmissing-prototypes.  */
-#ifdef YYPARSE_PARAM
-#if defined __STDC__ || defined __cplusplus
-int yyparse (void *YYPARSE_PARAM);
-#else
-int yyparse ();
-#endif
-#else /* ! YYPARSE_PARAM */
-#if defined __STDC__ || defined __cplusplus
-int yyparse (block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr);
-#else
-int yyparse ();
-#endif
-#endif /* ! YYPARSE_PARAM */
-
-
-/*----------.
-| yyparse.  |
-`----------*/
-
-#ifdef YYPARSE_PARAM
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-int
-yyparse (void *YYPARSE_PARAM)
-#else
-int
-yyparse (YYPARSE_PARAM)
-    void *YYPARSE_PARAM;
-#endif
-#else /* ! YYPARSE_PARAM */
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-int
-yyparse (block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr)
-#else
-int
-yyparse (answer, errors, locations, lexer_param_ptr)
-    block* answer;
-    int* errors;
-    struct locfile* locations;
-    struct lexer_param* lexer_param_ptr;
-#endif
-#endif
-{
-/* The lookahead symbol.  */
-int yychar;
-
-/* The semantic value of the lookahead symbol.  */
-YYSTYPE yylval;
-
-/* Location data for the lookahead symbol.  */
-YYLTYPE yylloc;
-
-    /* Number of syntax errors so far.  */
-    int yynerrs;
-
-    int yystate;
-    /* Number of tokens to shift before error messages enabled.  */
-    int yyerrstatus;
-
-    /* The stacks and their tools:
-       `yyss': related to states.
-       `yyvs': related to semantic values.
-       `yyls': related to locations.
-
-       Refer to the stacks thru separate pointers, to allow yyoverflow
-       to reallocate them elsewhere.  */
-
-    /* The state stack.  */
-    yytype_int16 yyssa[YYINITDEPTH];
-    yytype_int16 *yyss;
-    yytype_int16 *yyssp;
-
-    /* The semantic value stack.  */
-    YYSTYPE yyvsa[YYINITDEPTH];
-    YYSTYPE *yyvs;
-    YYSTYPE *yyvsp;
-
-    /* The location stack.  */
-    YYLTYPE yylsa[YYINITDEPTH];
-    YYLTYPE *yyls;
-    YYLTYPE *yylsp;
-
-    /* The locations where the error started and ended.  */
-    YYLTYPE yyerror_range[3];
-
-    YYSIZE_T yystacksize;
-
-  int yyn;
-  int yyresult;
-  /* Lookahead token as an internal (translated) token number.  */
-  int yytoken;
-  /* The variables used to return semantic value and location from the
-     action routines.  */
-  YYSTYPE yyval;
-  YYLTYPE yyloc;
-
-#if YYERROR_VERBOSE
-  /* Buffer for error messages, and its allocated size.  */
-  char yymsgbuf[128];
-  char *yymsg = yymsgbuf;
-  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
-#endif
-
-#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
-
-  /* The number of symbols on the RHS of the reduced rule.
-     Keep to zero when no symbol should be popped.  */
-  int yylen = 0;
-
-  yytoken = 0;
-  yyss = yyssa;
-  yyvs = yyvsa;
-  yyls = yylsa;
-  yystacksize = YYINITDEPTH;
-
-  YYDPRINTF ((stderr, "Starting parse\n"));
-
-  yystate = 0;
-  yyerrstatus = 0;
-  yynerrs = 0;
-  yychar = YYEMPTY; /* Cause a token to be read.  */
-
-  /* Initialize stack pointers.
-     Waste one element of value and location stack
-     so that they stay on the same level as the state stack.
-     The wasted elements are never initialized.  */
-  yyssp = yyss;
-  yyvsp = yyvs;
-  yylsp = yyls;
-
-#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
-  /* Initialize the default location before parsing starts.  */
-  yylloc.first_line   = yylloc.last_line   = 1;
-  yylloc.first_column = yylloc.last_column = 1;
-#endif
-
-  goto yysetstate;
-
-/*------------------------------------------------------------.
-| yynewstate -- Push a new state, which is found in yystate.  |
-`------------------------------------------------------------*/
- yynewstate:
-  /* In all cases, when you get here, the value and location stacks
-     have just been pushed.  So pushing a state here evens the stacks.  */
-  yyssp++;
-
- yysetstate:
-  *yyssp = yystate;
-
-  if (yyss + yystacksize - 1 <= yyssp)
-    {
-      /* Get the current used size of the three stacks, in elements.  */
-      YYSIZE_T yysize = yyssp - yyss + 1;
-
-#ifdef yyoverflow
-      {
-	/* Give user a chance to reallocate the stack.  Use copies of
-	   these so that the &'s don't force the real ones into
-	   memory.  */
-	YYSTYPE *yyvs1 = yyvs;
-	yytype_int16 *yyss1 = yyss;
-	YYLTYPE *yyls1 = yyls;
-
-	/* Each stack pointer address is followed by the size of the
-	   data in use in that stack, in bytes.  This used to be a
-	   conditional around just the two extra args, but that might
-	   be undefined if yyoverflow is a macro.  */
-	yyoverflow (YY_("memory exhausted"),
-		    &yyss1, yysize * sizeof (*yyssp),
-		    &yyvs1, yysize * sizeof (*yyvsp),
-		    &yyls1, yysize * sizeof (*yylsp),
-		    &yystacksize);
-
-	yyls = yyls1;
-	yyss = yyss1;
-	yyvs = yyvs1;
-      }
-#else /* no yyoverflow */
-# ifndef YYSTACK_RELOCATE
-      goto yyexhaustedlab;
-# else
-      /* Extend the stack our own way.  */
-      if (YYMAXDEPTH <= yystacksize)
-	goto yyexhaustedlab;
-      yystacksize *= 2;
-      if (YYMAXDEPTH < yystacksize)
-	yystacksize = YYMAXDEPTH;
-
-      {
-	yytype_int16 *yyss1 = yyss;
-	union yyalloc *yyptr =
-	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
-	if (! yyptr)
-	  goto yyexhaustedlab;
-	YYSTACK_RELOCATE (yyss_alloc, yyss);
-	YYSTACK_RELOCATE (yyvs_alloc, yyvs);
-	YYSTACK_RELOCATE (yyls_alloc, yyls);
-#  undef YYSTACK_RELOCATE
-	if (yyss1 != yyssa)
-	  YYSTACK_FREE (yyss1);
-      }
-# endif
-#endif /* no yyoverflow */
-
-      yyssp = yyss + yysize - 1;
-      yyvsp = yyvs + yysize - 1;
-      yylsp = yyls + yysize - 1;
-
-      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
-		  (unsigned long int) yystacksize));
-
-      if (yyss + yystacksize - 1 <= yyssp)
-	YYABORT;
-    }
-
-  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
-
-  if (yystate == YYFINAL)
-    YYACCEPT;
-
-  goto yybackup;
-
-/*-----------.
-| yybackup.  |
-`-----------*/
-yybackup:
-
-  /* Do appropriate processing given the current state.  Read a
-     lookahead token if we need one and don't already have one.  */
-
-  /* First try to decide what to do without reference to lookahead token.  */
-  yyn = yypact[yystate];
-  if (yypact_value_is_default (yyn))
-    goto yydefault;
-
-  /* Not known => get a lookahead token if don't already have one.  */
-
-  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
-  if (yychar == YYEMPTY)
-    {
-      YYDPRINTF ((stderr, "Reading a token: "));
-      yychar = YYLEX;
-    }
-
-  if (yychar <= YYEOF)
-    {
-      yychar = yytoken = YYEOF;
-      YYDPRINTF ((stderr, "Now at end of input.\n"));
-    }
-  else
-    {
-      yytoken = YYTRANSLATE (yychar);
-      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
-    }
-
-  /* If the proper action on seeing token YYTOKEN is to reduce or to
-     detect an error, take that action.  */
-  yyn += yytoken;
-  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
-    goto yydefault;
-  yyn = yytable[yyn];
-  if (yyn <= 0)
-    {
-      if (yytable_value_is_error (yyn))
-        goto yyerrlab;
-      yyn = -yyn;
-      goto yyreduce;
-    }
-
-  /* Count tokens shifted since error; after three, turn off error
-     status.  */
-  if (yyerrstatus)
-    yyerrstatus--;
-
-  /* Shift the lookahead token.  */
-  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
-
-  /* Discard the shifted token.  */
-  yychar = YYEMPTY;
-
-  yystate = yyn;
-  *++yyvsp = yylval;
-  *++yylsp = yylloc;
-  goto yynewstate;
-
-
-/*-----------------------------------------------------------.
-| yydefault -- do the default action for the current state.  |
-`-----------------------------------------------------------*/
-yydefault:
-  yyn = yydefact[yystate];
-  if (yyn == 0)
-    goto yyerrlab;
-  goto yyreduce;
-
-
-/*-----------------------------.
-| yyreduce -- Do a reduction.  |
-`-----------------------------*/
-yyreduce:
-  /* yyn is the number of a rule to reduce with.  */
-  yylen = yyr2[yyn];
-
-  /* If YYLEN is nonzero, implement the default value of the action:
-     `$$ = $1'.
-
-     Otherwise, the following line sets YYVAL to garbage.
-     This behavior is undocumented and Bison
-     users should not rely upon it.  Assigning to YYVAL
-     unconditionally makes the parser a bit smaller, and it avoids a
-     GCC warning that YYVAL may be used uninitialized.  */
-  yyval = yyvsp[1-yylen];
-
-  /* Default location.  */
-  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
-  YY_REDUCE_PRINT (yyn);
-  switch (yyn)
-    {
-        case 2:
-
-/* Line 1806 of yacc.c  */
-#line 185 "parser.y"
-    {
-  *answer = (yyvsp[(1) - (1)].blk);
-}
-    break;
-
-  case 3:
-
-/* Line 1806 of yacc.c  */
-#line 188 "parser.y"
-    {
-  *answer = (yyvsp[(1) - (1)].blk);
-}
-    break;
-
-  case 4:
-
-/* Line 1806 of yacc.c  */
-#line 193 "parser.y"
-    {
-  (yyval.blk) = gen_noop();
-}
-    break;
-
-  case 5:
-
-/* Line 1806 of yacc.c  */
-#line 196 "parser.y"
-    {
-  (yyval.blk) = block_join((yyvsp[(1) - (2)].blk), (yyvsp[(2) - (2)].blk));
-}
-    break;
-
-  case 6:
-
-/* Line 1806 of yacc.c  */
-#line 201 "parser.y"
-    {
-  (yyval.blk) = block_bind((yyvsp[(1) - (2)].blk), (yyvsp[(2) - (2)].blk), OP_IS_CALL_PSEUDO);
-}
-    break;
-
-  case 7:
-
-/* Line 1806 of yacc.c  */
-#line 205 "parser.y"
-    {
-  (yyval.blk) = gen_op_simple(DUP);
-  block_append(&(yyval.blk), (yyvsp[(1) - (6)].blk));
-  block_append(&(yyval.blk), block_bind(gen_op_var_unbound(STOREV, jv_string_value((yyvsp[(4) - (6)].literal))), (yyvsp[(6) - (6)].blk), OP_HAS_VARIABLE));
-  jv_free((yyvsp[(4) - (6)].literal));
-}
-    break;
-
-  case 8:
-
-/* Line 1806 of yacc.c  */
-#line 212 "parser.y"
-    {
-  (yyval.blk) = gen_cond((yyvsp[(2) - (5)].blk), (yyvsp[(4) - (5)].blk), (yyvsp[(5) - (5)].blk));
-}
-    break;
-
-  case 9:
-
-/* Line 1806 of yacc.c  */
-#line 215 "parser.y"
-    {
-  FAIL((yyloc), "Possibly unterminated 'if' statment");
-  (yyval.blk) = (yyvsp[(2) - (3)].blk);
-}
-    break;
-
-  case 10:
-
-/* Line 1806 of yacc.c  */
-#line 220 "parser.y"
-    {
-  block assign = gen_op_simple(DUP);
-  block_append(&assign, (yyvsp[(3) - (3)].blk));
-  block_append(&assign, gen_op_simple(SWAP));
-  block_append(&assign, (yyvsp[(1) - (3)].blk));
-  block_append(&assign, gen_op_simple(SWAP));
-  (yyval.blk) = gen_assign(assign);
-}
-    break;
-
-  case 11:
-
-/* Line 1806 of yacc.c  */
-#line 229 "parser.y"
-    {
-  (yyval.blk) = gen_or((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
-}
-    break;
-
-  case 12:
-
-/* Line 1806 of yacc.c  */
-#line 233 "parser.y"
-    {
-  (yyval.blk) = gen_and((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
-}
-    break;
-
-  case 13:
-
-/* Line 1806 of yacc.c  */
-#line 237 "parser.y"
-    {
-  (yyval.blk) = gen_definedor((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
-}
-    break;
-
-  case 14:
-
-/* Line 1806 of yacc.c  */
-#line 241 "parser.y"
-    {
-  (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), gen_definedor(gen_noop(), (yyvsp[(3) - (3)].blk)), 0);
-}
-    break;
-
-  case 15:
-
-/* Line 1806 of yacc.c  */
-#line 245 "parser.y"
-    {
-  (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), 0);
-}
-    break;
-
-  case 16:
-
-/* Line 1806 of yacc.c  */
-#line 249 "parser.y"
-    { 
-  (yyval.blk) = block_join((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk)); 
-}
-    break;
-
-  case 17:
-
-/* Line 1806 of yacc.c  */
-#line 253 "parser.y"
-    { 
-  (yyval.blk) = gen_both((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk)); 
-}
-    break;
-
-  case 18:
-
-/* Line 1806 of yacc.c  */
-#line 257 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '+');
-}
-    break;
-
-  case 19:
-
-/* Line 1806 of yacc.c  */
-#line 261 "parser.y"
-    {
-  (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '+');
-}
-    break;
-
-  case 20:
-
-/* Line 1806 of yacc.c  */
-#line 265 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '-');
-}
-    break;
-
-  case 21:
-
-/* Line 1806 of yacc.c  */
-#line 269 "parser.y"
-    {
-  (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '-');
-}
-    break;
-
-  case 22:
-
-/* Line 1806 of yacc.c  */
-#line 273 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '*');
-}
-    break;
-
-  case 23:
-
-/* Line 1806 of yacc.c  */
-#line 277 "parser.y"
-    {
-  (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '*');
-}
-    break;
-
-  case 24:
-
-/* Line 1806 of yacc.c  */
-#line 281 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '/');
-}
-    break;
-
-  case 25:
-
-/* Line 1806 of yacc.c  */
-#line 285 "parser.y"
-    {
-  (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '/');
-}
-    break;
-
-  case 26:
-
-/* Line 1806 of yacc.c  */
-#line 289 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), EQ);
-}
-    break;
-
-  case 27:
-
-/* Line 1806 of yacc.c  */
-#line 293 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), NEQ);
-}
-    break;
-
-  case 28:
-
-/* Line 1806 of yacc.c  */
-#line 297 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '<');
-}
-    break;
-
-  case 29:
-
-/* Line 1806 of yacc.c  */
-#line 301 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '>');
-}
-    break;
-
-  case 30:
-
-/* Line 1806 of yacc.c  */
-#line 305 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), LESSEQ);
-}
-    break;
-
-  case 31:
-
-/* Line 1806 of yacc.c  */
-#line 309 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), GREATEREQ);
-}
-    break;
-
-  case 32:
-
-/* Line 1806 of yacc.c  */
-#line 313 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), CONTAINS);
-}
-    break;
-
-  case 33:
-
-/* Line 1806 of yacc.c  */
-#line 317 "parser.y"
-    { 
-  (yyval.blk) = (yyvsp[(1) - (1)].blk); 
-}
-    break;
-
-  case 34:
-
-/* Line 1806 of yacc.c  */
-#line 322 "parser.y"
-    {
-  (yyval.blk) = (yyvsp[(2) - (3)].blk);
-}
-    break;
-
-  case 35:
-
-/* Line 1806 of yacc.c  */
-#line 327 "parser.y"
-    {
-  block body = block_join((yyvsp[(4) - (5)].blk), gen_op_simple(RET));
-  (yyval.blk) = gen_op_block_defn_rec(CLOSURE_CREATE, jv_string_value((yyvsp[(2) - (5)].literal)), body);
-  jv_free((yyvsp[(2) - (5)].literal));
-}
-    break;
-
-  case 36:
-
-/* Line 1806 of yacc.c  */
-#line 333 "parser.y"
-    {
-  block body = block_bind(gen_op_block_unbound(CLOSURE_PARAM, jv_string_value((yyvsp[(4) - (8)].literal))), block_join((yyvsp[(7) - (8)].blk), gen_op_simple(RET)), OP_IS_CALL_PSEUDO);
-  (yyval.blk) = gen_op_block_defn_rec(CLOSURE_CREATE, jv_string_value((yyvsp[(2) - (8)].literal)), body);
-  jv_free((yyvsp[(2) - (8)].literal));
-  jv_free((yyvsp[(4) - (8)].literal));
-}
-    break;
-
-  case 37:
-
-/* Line 1806 of yacc.c  */
-#line 341 "parser.y"
-    {
-  (yyval.blk) = gen_op_const(LOADK, jv_string(""));
-}
-    break;
-
-  case 38:
-
-/* Line 1806 of yacc.c  */
-#line 344 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (2)].blk), gen_op_const(LOADK, (yyvsp[(2) - (2)].literal)), '+');
-}
-    break;
-
-  case 39:
-
-/* Line 1806 of yacc.c  */
-#line 347 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (4)].blk), gen_format((yyvsp[(3) - (4)].blk)), '+');
-}
-    break;
-
-  case 40:
-
-/* Line 1806 of yacc.c  */
-#line 353 "parser.y"
-    {
-  (yyval.blk) = gen_cond((yyvsp[(2) - (5)].blk), (yyvsp[(4) - (5)].blk), (yyvsp[(5) - (5)].blk));
-}
-    break;
-
-  case 41:
-
-/* Line 1806 of yacc.c  */
-#line 356 "parser.y"
-    {
-  (yyval.blk) = (yyvsp[(2) - (3)].blk);
-}
-    break;
-
-  case 42:
-
-/* Line 1806 of yacc.c  */
-#line 361 "parser.y"
-    { 
-  (yyval.blk) = block_join((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
-}
-    break;
-
-  case 43:
-
-/* Line 1806 of yacc.c  */
-#line 365 "parser.y"
-    {
-  (yyval.blk) = (yyvsp[(1) - (1)].blk);
-}
-    break;
-
-  case 44:
-
-/* Line 1806 of yacc.c  */
-#line 371 "parser.y"
-    {
-  (yyval.blk) = gen_noop(); 
-}
-    break;
-
-  case 45:
-
-/* Line 1806 of yacc.c  */
-#line 374 "parser.y"
-    {
-  (yyval.blk) = gen_index((yyvsp[(1) - (3)].blk), gen_op_const(LOADK, (yyvsp[(3) - (3)].literal))); 
-}
-    break;
-
-  case 46:
-
-/* Line 1806 of yacc.c  */
-#line 377 "parser.y"
-    { 
-  (yyval.blk) = gen_index(gen_noop(), gen_op_const(LOADK, (yyvsp[(2) - (2)].literal))); 
-}
-    break;
-
-  case 47:
-
-/* Line 1806 of yacc.c  */
-#line 381 "parser.y"
-    {
-  (yyval.blk) = gen_index((yyvsp[(1) - (4)].blk), (yyvsp[(3) - (4)].blk)); 
-}
-    break;
-
-  case 48:
-
-/* Line 1806 of yacc.c  */
-#line 384 "parser.y"
-    {
-  (yyval.blk) = block_join((yyvsp[(1) - (3)].blk), gen_op_simple(EACH)); 
-}
-    break;
-
-  case 49:
-
-/* Line 1806 of yacc.c  */
-#line 387 "parser.y"
-    {
-  (yyval.blk) = gen_op_const(LOADK, (yyvsp[(1) - (1)].literal)); 
-}
-    break;
-
-  case 50:
-
-/* Line 1806 of yacc.c  */
-#line 390 "parser.y"
-    {
-  (yyval.blk) = (yyvsp[(1) - (1)].blk);
-}
-    break;
-
-  case 51:
-
-/* Line 1806 of yacc.c  */
-#line 393 "parser.y"
-    { 
-  (yyval.blk) = (yyvsp[(2) - (3)].blk); 
-}
-    break;
-
-  case 52:
-
-/* Line 1806 of yacc.c  */
-#line 396 "parser.y"
-    { 
-  (yyval.blk) = gen_collect((yyvsp[(2) - (3)].blk)); 
-}
-    break;
-
-  case 53:
-
-/* Line 1806 of yacc.c  */
-#line 399 "parser.y"
-    { 
-  (yyval.blk) = gen_op_const(LOADK, jv_array()); 
-}
-    break;
-
-  case 54:
-
-/* Line 1806 of yacc.c  */
-#line 402 "parser.y"
-    { 
-  (yyval.blk) = gen_subexp(gen_op_const(LOADK, jv_object()));
-  block_append(&(yyval.blk), (yyvsp[(2) - (3)].blk));
-  block_append(&(yyval.blk), gen_op_simple(POP));
-}
-    break;
-
-  case 55:
-
-/* Line 1806 of yacc.c  */
-#line 407 "parser.y"
-    {
-  (yyval.blk) = gen_location((yyloc), gen_op_var_unbound(LOADV, jv_string_value((yyvsp[(2) - (2)].literal))));
-  jv_free((yyvsp[(2) - (2)].literal));
-}
-    break;
-
-  case 56:
-
-/* Line 1806 of yacc.c  */
-#line 411 "parser.y"
-    {
-  (yyval.blk) = gen_location((yyloc), gen_op_call(CALL_1_1, gen_op_block_unbound(CLOSURE_REF, jv_string_value((yyvsp[(1) - (1)].literal)))));
-  jv_free((yyvsp[(1) - (1)].literal));
-}
-    break;
-
-  case 57:
-
-/* Line 1806 of yacc.c  */
-#line 415 "parser.y"
-    {
-  (yyval.blk) = gen_op_call(CALL_1_1, 
-                   block_join(gen_op_block_unbound(CLOSURE_REF, jv_string_value((yyvsp[(1) - (4)].literal))),
-                              block_bind(gen_op_block_defn(CLOSURE_CREATE,
-                                                "lambda",
-                                                           block_join((yyvsp[(3) - (4)].blk), gen_op_simple(RET))),
-                                         gen_noop(), OP_IS_CALL_PSEUDO)));
-  (yyval.blk) = gen_location((yylsp[(1) - (4)]), (yyval.blk));
-  jv_free((yyvsp[(1) - (4)].literal));
-}
-    break;
-
-  case 58:
-
-/* Line 1806 of yacc.c  */
-#line 425 "parser.y"
-    { (yyval.blk) = gen_noop(); }
-    break;
-
-  case 59:
-
-/* Line 1806 of yacc.c  */
-#line 426 "parser.y"
-    { (yyval.blk) = gen_noop(); }
-    break;
-
-  case 60:
-
-/* Line 1806 of yacc.c  */
-#line 427 "parser.y"
-    { (yyval.blk) = (yyvsp[(1) - (4)].blk); }
-    break;
-
-  case 61:
-
-/* Line 1806 of yacc.c  */
-#line 428 "parser.y"
-    { (yyval.blk) = gen_noop(); }
-    break;
-
-  case 62:
-
-/* Line 1806 of yacc.c  */
-#line 431 "parser.y"
-    { 
-  (yyval.blk)=gen_noop(); 
-}
-    break;
-
-  case 63:
-
-/* Line 1806 of yacc.c  */
-#line 434 "parser.y"
-    { (yyval.blk) = (yyvsp[(1) - (1)].blk); }
-    break;
-
-  case 64:
-
-/* Line 1806 of yacc.c  */
-#line 435 "parser.y"
-    { (yyval.blk)=block_join((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk)); }
-    break;
-
-  case 65:
-
-/* Line 1806 of yacc.c  */
-#line 436 "parser.y"
-    { (yyval.blk) = (yyvsp[(3) - (3)].blk); }
-    break;
-
-  case 66:
-
-/* Line 1806 of yacc.c  */
-#line 439 "parser.y"
-    { 
-  (yyval.blk) = gen_dictpair(gen_op_const(LOADK, (yyvsp[(1) - (3)].literal)), (yyvsp[(3) - (3)].blk));
- }
-    break;
-
-  case 67:
-
-/* Line 1806 of yacc.c  */
-#line 442 "parser.y"
-    {
-  (yyval.blk) = gen_dictpair((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
-  }
-    break;
-
-  case 68:
-
-/* Line 1806 of yacc.c  */
-#line 445 "parser.y"
-    {
-  (yyval.blk) = gen_dictpair(gen_op_const(LOADK, jv_copy((yyvsp[(1) - (1)].literal))),
-                    gen_index(gen_noop(), gen_op_const(LOADK, (yyvsp[(1) - (1)].literal))));
-  }
-    break;
-
-  case 69:
-
-/* Line 1806 of yacc.c  */
-#line 449 "parser.y"
-    {
-  (yyval.blk) = gen_dictpair((yyvsp[(2) - (5)].blk), (yyvsp[(5) - (5)].blk));
-  }
-    break;
-
-  case 70:
-
-/* Line 1806 of yacc.c  */
-#line 452 "parser.y"
-    { (yyval.blk) = (yyvsp[(5) - (5)].blk); }
-    break;
-
-
-
-/* Line 1806 of yacc.c  */
-#line 2612 "parser.gen.c"
-      default: break;
-    }
-  /* User semantic actions sometimes alter yychar, and that requires
-     that yytoken be updated with the new translation.  We take the
-     approach of translating immediately before every use of yytoken.
-     One alternative is translating here after every semantic action,
-     but that translation would be missed if the semantic action invokes
-     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
-     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
-     incorrect destructor might then be invoked immediately.  In the
-     case of YYERROR or YYBACKUP, subsequent parser actions might lead
-     to an incorrect destructor call or verbose syntax error message
-     before the lookahead is translated.  */
-  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
-
-  YYPOPSTACK (yylen);
-  yylen = 0;
-  YY_STACK_PRINT (yyss, yyssp);
-
-  *++yyvsp = yyval;
-  *++yylsp = yyloc;
-
-  /* Now `shift' the result of the reduction.  Determine what state
-     that goes to, based on the state we popped back to and the rule
-     number reduced by.  */
-
-  yyn = yyr1[yyn];
-
-  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
-  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
-    yystate = yytable[yystate];
-  else
-    yystate = yydefgoto[yyn - YYNTOKENS];
-
-  goto yynewstate;
-
-
-/*------------------------------------.
-| yyerrlab -- here on detecting error |
-`------------------------------------*/
-yyerrlab:
-  /* Make sure we have latest lookahead translation.  See comments at
-     user semantic actions for why this is necessary.  */
-  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
-
-  /* If not already recovering from an error, report this error.  */
-  if (!yyerrstatus)
-    {
-      ++yynerrs;
-#if ! YYERROR_VERBOSE
-      yyerror (&yylloc, answer, errors, locations, lexer_param_ptr, YY_("syntax error"));
-#else
-# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
-                                        yyssp, yytoken)
-      {
-        char const *yymsgp = YY_("syntax error");
-        int yysyntax_error_status;
-        yysyntax_error_status = YYSYNTAX_ERROR;
-        if (yysyntax_error_status == 0)
-          yymsgp = yymsg;
-        else if (yysyntax_error_status == 1)
-          {
-            if (yymsg != yymsgbuf)
-              YYSTACK_FREE (yymsg);
-            yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
-            if (!yymsg)
-              {
-                yymsg = yymsgbuf;
-                yymsg_alloc = sizeof yymsgbuf;
-                yysyntax_error_status = 2;
-              }
-            else
-              {
-                yysyntax_error_status = YYSYNTAX_ERROR;
-                yymsgp = yymsg;
-              }
-          }
-        yyerror (&yylloc, answer, errors, locations, lexer_param_ptr, yymsgp);
-        if (yysyntax_error_status == 2)
-          goto yyexhaustedlab;
-      }
-# undef YYSYNTAX_ERROR
-#endif
-    }
-
-  yyerror_range[1] = yylloc;
-
-  if (yyerrstatus == 3)
-    {
-      /* If just tried and failed to reuse lookahead token after an
-	 error, discard it.  */
-
-      if (yychar <= YYEOF)
-	{
-	  /* Return failure if at end of input.  */
-	  if (yychar == YYEOF)
-	    YYABORT;
-	}
-      else
-	{
-	  yydestruct ("Error: discarding",
-		      yytoken, &yylval, &yylloc, answer, errors, locations, lexer_param_ptr);
-	  yychar = YYEMPTY;
-	}
-    }
-
-  /* Else will try to reuse lookahead token after shifting the error
-     token.  */
-  goto yyerrlab1;
-
-
-/*---------------------------------------------------.
-| yyerrorlab -- error raised explicitly by YYERROR.  |
-`---------------------------------------------------*/
-yyerrorlab:
-
-  /* Pacify compilers like GCC when the user code never invokes
-     YYERROR and the label yyerrorlab therefore never appears in user
-     code.  */
-  if (/*CONSTCOND*/ 0)
-     goto yyerrorlab;
-
-  yyerror_range[1] = yylsp[1-yylen];
-  /* Do not reclaim the symbols of the rule which action triggered
-     this YYERROR.  */
-  YYPOPSTACK (yylen);
-  yylen = 0;
-  YY_STACK_PRINT (yyss, yyssp);
-  yystate = *yyssp;
-  goto yyerrlab1;
-
-
-/*-------------------------------------------------------------.
-| yyerrlab1 -- common code for both syntax error and YYERROR.  |
-`-------------------------------------------------------------*/
-yyerrlab1:
-  yyerrstatus = 3;	/* Each real token shifted decrements this.  */
-
-  for (;;)
-    {
-      yyn = yypact[yystate];
-      if (!yypact_value_is_default (yyn))
-	{
-	  yyn += YYTERROR;
-	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
-	    {
-	      yyn = yytable[yyn];
-	      if (0 < yyn)
-		break;
-	    }
-	}
-
-      /* Pop the current state because it cannot handle the error token.  */
-      if (yyssp == yyss)
-	YYABORT;
-
-      yyerror_range[1] = *yylsp;
-      yydestruct ("Error: popping",
-		  yystos[yystate], yyvsp, yylsp, answer, errors, locations, lexer_param_ptr);
-      YYPOPSTACK (1);
-      yystate = *yyssp;
-      YY_STACK_PRINT (yyss, yyssp);
-    }
-
-  *++yyvsp = yylval;
-
-  yyerror_range[2] = yylloc;
-  /* Using YYLLOC is tempting, but would change the location of
-     the lookahead.  YYLOC is available though.  */
-  YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
-  *++yylsp = yyloc;
-
-  /* Shift the error token.  */
-  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
-
-  yystate = yyn;
-  goto yynewstate;
-
-
-/*-------------------------------------.
-| yyacceptlab -- YYACCEPT comes here.  |
-`-------------------------------------*/
-yyacceptlab:
-  yyresult = 0;
-  goto yyreturn;
-
-/*-----------------------------------.
-| yyabortlab -- YYABORT comes here.  |
-`-----------------------------------*/
-yyabortlab:
-  yyresult = 1;
-  goto yyreturn;
-
-#if !defined(yyoverflow) || YYERROR_VERBOSE
-/*-------------------------------------------------.
-| yyexhaustedlab -- memory exhaustion comes here.  |
-`-------------------------------------------------*/
-yyexhaustedlab:
-  yyerror (&yylloc, answer, errors, locations, lexer_param_ptr, YY_("memory exhausted"));
-  yyresult = 2;
-  /* Fall through.  */
-#endif
-
-yyreturn:
-  if (yychar != YYEMPTY)
-    {
-      /* Make sure we have latest lookahead translation.  See comments at
-         user semantic actions for why this is necessary.  */
-      yytoken = YYTRANSLATE (yychar);
-      yydestruct ("Cleanup: discarding lookahead",
-                  yytoken, &yylval, &yylloc, answer, errors, locations, lexer_param_ptr);
-    }
-  /* Do not reclaim the symbols of the rule which action triggered
-     this YYABORT or YYACCEPT.  */
-  YYPOPSTACK (yylen);
-  YY_STACK_PRINT (yyss, yyssp);
-  while (yyssp != yyss)
-    {
-      yydestruct ("Cleanup: popping",
-		  yystos[*yyssp], yyvsp, yylsp, answer, errors, locations, lexer_param_ptr);
-      YYPOPSTACK (1);
-    }
-#ifndef yyoverflow
-  if (yyss != yyssa)
-    YYSTACK_FREE (yyss);
-#endif
-#if YYERROR_VERBOSE
-  if (yymsg != yymsgbuf)
-    YYSTACK_FREE (yymsg);
-#endif
-  /* Make sure YYID is used.  */
-  return YYID (yyresult);
-}
-
-
-
-/* Line 2067 of yacc.c  */
-#line 453 "parser.y"
-
-
-int jq_parse(struct locfile* locations, block* answer) {
-  struct lexer_param scanner;
-  YY_BUFFER_STATE buf;
-  jq_yylex_init_extra(0, &scanner.lexer);
-  buf = jq_yy_scan_bytes(locations->data, locations->length, scanner.lexer);
-  int errors = 0;
-  *answer = gen_noop();
-  yyparse(answer, &errors, locations, &scanner);
-  jq_yy_delete_buffer(buf, scanner.lexer);
-  jq_yylex_destroy(scanner.lexer);
-  if (errors > 0) {
-    block_free(*answer);
-    *answer = gen_noop();
-  }
-  return errors;
-}
-
-int jq_parse_library(struct locfile* locations, block* answer) {
-  int errs = jq_parse(locations, answer);
-  if (errs) return errs;
-  if (!block_has_only_binders(*answer, OP_IS_CALL_PSEUDO)) {
-    locfile_locate(locations, UNKNOWN_LOCATION, "error: library should only have function definitions, not a main expression");
-    return 1;
-  }
-  return 0;
-}
-
diff --git a/parser.gen.h b/parser.gen.h
deleted file mode 100644
index bf9f9f8c..00000000
--- a/parser.gen.h
+++ /dev/null
@@ -1,132 +0,0 @@
-/* A Bison parser, made by GNU Bison 2.5.  */
-
-/* Bison interface for Yacc-like parsers in C
-   
-      Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
-   
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-   
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-   
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
-
-/* As a special exception, you may create a larger work that contains
-   part or all of the Bison parser skeleton and distribute that work
-   under terms of your choice, so long as that work isn't itself a
-   parser generator using the skeleton or a modified version thereof
-   as a parser skeleton.  Alternatively, if you modify or redistribute
-   the parser skeleton itself, you may (at your option) remove this
-   special exception, which will cause the skeleton and the resulting
-   Bison output files to be licensed under the GNU General Public
-   License without this special exception.
-   
-   This special exception was added by the Free Software Foundation in
-   version 2.2 of Bison.  */
-
-/* "%code requires" blocks.  */
-
-/* Line 2068 of yacc.c  */
-#line 9 "parser.y"
-
-#include "locfile.h"
-#define YYLTYPE location
-#define YYLLOC_DEFAULT(Loc, Rhs, N)             \
-  do {                                          \
-    if (N) {                                    \
-      (Loc).start = YYRHSLOC(Rhs, 1).start;     \
-      (Loc).end = YYRHSLOC(Rhs, N).end;         \
-    } else {                                    \
-      (Loc).start = YYRHSLOC(Rhs, 0).end;       \
-      (Loc).end = YYRHSLOC(Rhs, 0).end;         \
-    }                                           \
-  } while (0)
- 
-
-
-/* Line 2068 of yacc.c  */
-#line 55 "parser.gen.h"
-
-/* Tokens.  */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
-   /* Put the tokens into the symbol table, so that GDB and other debuggers
-      know about them.  */
-   enum yytokentype {
-     INVALID_CHARACTER = 258,
-     IDENT = 259,
-     LITERAL = 260,
-     EQ = 261,
-     NEQ = 262,
-     DEFINEDOR = 263,
-     AS = 264,
-     DEF = 265,
-     IF = 266,
-     THEN = 267,
-     ELSE = 268,
-     ELSE_IF = 269,
-     END = 270,
-     AND = 271,
-     OR = 272,
-     SETPIPE = 273,
-     SETPLUS = 274,
-     SETMINUS = 275,
-     SETMULT = 276,
-     SETDIV = 277,
-     SETDEFINEDOR = 278,
-     LESSEQ = 279,
-     GREATEREQ = 280,
-     CONTAINS = 281,
-     QQSTRING_START = 282,
-     QQSTRING_TEXT = 283,
-     QQSTRING_INTERP_START = 284,
-     QQSTRING_INTERP_END = 285,
-     QQSTRING_END = 286
-   };
-#endif
-
-
-
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE
-{
-
-/* Line 2068 of yacc.c  */
-#line 27 "parser.y"
-
-  jv literal;
-  block blk;
-
-
-
-/* Line 2068 of yacc.c  */
-#line 110 "parser.gen.h"
-} YYSTYPE;
-# define YYSTYPE_IS_TRIVIAL 1
-# define yystype YYSTYPE /* obsolescent; will be withdrawn */
-# define YYSTYPE_IS_DECLARED 1
-#endif
-
-
-
-#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
-typedef struct YYLTYPE
-{
-  int first_line;
-  int first_column;
-  int last_line;
-  int last_column;
-} YYLTYPE;
-# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
-# define YYLTYPE_IS_DECLARED 1
-# define YYLTYPE_IS_TRIVIAL 1
-#endif
-
-
-
diff --git a/setup.sh b/setup.sh
new file mode 100755
index 00000000..58297f67
--- /dev/null
+++ b/setup.sh
@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+
+# RUN ME after pulling the code from git!
+if [ "clean" == "$1" ]; then
+  make distclean
+  rm -rf tmp autom4te.cache config
+  rm -f INSTALL Makefile.in aclocal.m4 configure config.h.in *.gen.c *.gen.h ChangeLog
+else
+  autoreconf --install
+  ./configure --prefix=/opt/junk
+  mkdir tmp
+  make DESTDIR=./tmp install
+  make distcheck
+fi

From ddeec45b2ea79fc23277e9ff8d0e70c929ba61a8 Mon Sep 17 00:00:00 2001
From: Lee Thompson <thompson@dtosolutions.com>
Date: Wed, 28 Nov 2012 01:08:23 -0600
Subject: [PATCH 150/284] revert back to make invoking flex, fix a few bugs

---
 .gitignore              |    5 +-
 Makefile.am             |   45 +-
 builtin.c               |    2 +-
 configure.ac            |   11 +-
 execute.c               |    2 +-
 parser.h => jq_parser.h |    4 +-
 lexer.l                 |    2 +-
 parser.gen.info         | 3565 ---------------------------------------
 parser.y                |    2 +-
 setup.sh                |   14 +-
 10 files changed, 55 insertions(+), 3597 deletions(-)
 rename parser.h => jq_parser.h (75%)
 delete mode 100644 parser.gen.info

diff --git a/.gitignore b/.gitignore
index e43b388c..56c1a5ca 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,13 +1,10 @@
 *.o
 *~
 
-# Autogenerated
-*.gen.*
-
 # Test binaries
 jv_test
 jv_parse
 parsertest*~
 
 # Something delightfully recursive happens otherwise
-docs/content/2.download/source/*
\ No newline at end of file
+docs/content/2.download/source/*
diff --git a/Makefile.am b/Makefile.am
index 62d035d8..18acb864 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -3,26 +3,30 @@
 # setup is only used by distribution developers, not package developers.
 # Still, as a matter of allowing patching, its not a bad idea to distribute 
 # the developer setup script in the tarball.
-EXTRA_DIST = setup.sh config.h.in ChangeLog
+EXTRA_DIST = setup.sh config.h.in ChangeLog VERSION lexer.l lexer.h gen_utf8_tables.py
 
 # README.md is expected in Github projects, good stuff in it, so we'll 
 # distribute it and install it with the package in the doc directory.
 docdir = ${datadir}/doc/${PACKAGE}
 dist_doc_DATA = README.md INSTALL COPYING AUTHORS README NEWS
 
-JQ_SRC = opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c
-# If we distribute the generated files in the source release, packagers won't have to have
-# python, bison, and flex
-DIST_JQ_SRC = parser.gen.c lexer.gen.c jv_utf8_tables.gen.h parser.gen.h lexer.gen.h
+JQ_INCS = jq_parser.h builtin.h bytecode.h compile.h execute.h forkable_stack.h frame_layout.h jv.h jv_dtoa.h jv_parse.h jv_unicode.h locfile.h opcode.h opcode_list.h parser.y jv_utf8_tables.gen.h
+
+JQ_SRC = opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c lexer.c $(JQ_INCS)
 
-bin_PROGRAMS = jq jq_test
 if DEVCFLAGS_ENABLED
-DEVCFLAGS = -Wextra -Wall -Wno-missing-field-initializers -Wno-unused -parameter -std=gnu99 -ggdb -Wno-unused-function
+DEVCFLAGS = -Wextra -Wall -Wno-missing-field-initializers -Wno-unused-parameter -std=gnu99 -ggdb -Wno-unused-function
 AM_CPPFLAGS = $(DEVCFLAGS)
 endif
 
+# Tell YACC (bison) autoconf macros that you want a header file created.
+# If the --warnings=all fails, you probably have an old version of bison
+# OSX ships an old bison, so update with homebrew or macports
+AM_YFLAGS = --warnings=all -d
+
+bin_PROGRAMS = jq jq_test
+BUILT_SOURCES = jv_utf8_tables.gen.h lexer.h lexer.c
 jq_SOURCES = $(JQ_SRC) main.c
-dist_jq_SOURCES = $(DIST_JQ_SRC)
 jq_CPPFLAGS = -O $(DEVCFLAGS) -DJQ_DEBUG=0
 
 
@@ -33,18 +37,22 @@ jq_test_CPPFLAGS = $(DEVCFLAGS) -DJQ_DEBUG=1
 LOG_COMPILER = valgrind
 AM_LOG_FLAGS = --error-exitcode=1 -q --leak-check=full
 
-lexer.gen.c: lexer.l
-	flex -o lexer.gen.c --header-file=lexer.gen.h lexer.l
-lexer.gen.h: lexer.gen.c
+# nasty circular dependency on header files between the generated C files
+parser.o: lexer.c
 
-# if this fails on OSX, install bison from macports or homebrew.  OSX comes
-# with bison 2.3 which is too old
-parser.gen.c: parser.y lexer.gen.h
-	bison --warnings=all -d parser.y -v --report-file=parser.gen.info -o $@
-parser.gen.h: parser.gen.c
+lexer.o: parcer.c
+
+lexer.c: parser.h
+
+# While there is some autoconf macro support for lex/flex, it doesn't support
+# header file creation so we'll use good old make
+lexer.c: lexer.l
+	flex -o lexer.c --header-file=lexer.h lexer.l
+lexer.h: lexer.c
 
 jv_utf8_tables.gen.h: gen_utf8_tables.py
 	python $^ > $@
+
 jv_unicode.c: jv_utf8_tables.gen.h
 
 ChangeLog:
@@ -52,8 +60,6 @@ ChangeLog:
 
 main.c: config.h
 
-releasedep: lexer.gen.c parser.gen.c jv_utf8_tables.gen.h
-
 releasetag:
 	git tag -s "jq-$$(cat VERSION)" -m "jq release $$(cat VERSION)"
 
@@ -67,3 +73,6 @@ rpmbuild: jq
 	cp jq jq-$$(cat VERSION)/bin
 	tar -zcf rpm/SOURCES/jq-$$(cat VERSION).tgz jq-$$(cat VERSION)/bin/jq
 	rpmbuild --target $$(uname -m) --buildroot ${PWD}/rpm/BUILDROOT/jq-$$(cat VERSION)-${RELEASE}.noarch --define "_topdir ${PWD}/rpm" --define "version $$(cat VERSION)" --define "release ${RELEASE}" -bb --clean rpm/SPECS/jq.spec
+
+dist-clean-local:
+	rm -f $(BUILT_SOURCES)
diff --git a/builtin.c b/builtin.c
index fb6f072c..bbda554d 100644
--- a/builtin.c
+++ b/builtin.c
@@ -1,7 +1,7 @@
 #include <string.h>
 #include "builtin.h"
 #include "compile.h"
-#include "parser.h"
+#include "jq_parser.h"
 #include "locfile.h"
 
 enum {
diff --git a/configure.ac b/configure.ac
index 09997385..52037ca8 100644
--- a/configure.ac
+++ b/configure.ac
@@ -8,9 +8,13 @@ AM_INIT_AUTOMAKE([parallel-tests])
 AC_PROG_CC
 AC_PROG_CC_STDC
 AC_PROG_CPP_WERROR
+AC_PROG_YACC
 
 AM_PROG_CC_C_O
 
+dnl couldn't use AM_PROG_LEX as it doesn't support header files like the
+dnl AC_PROG_YACC macros...
+
 dnl   CFLAGS is concidered a packagers variable, not a developer variable
 dnl   in Auto-tools.  For developer ease of use, CFLAGS are set how the
 dnl   developers like them by default but the packager can disable if so
@@ -28,6 +32,10 @@ if test "$enable_devcflags" = "yes"; then
   AM_CONDITIONAL(DEVCFLAGS_ENABLED, true)
 fi
 
+dnl
+dnl these program checks should probably be deleted
+dnl
+
 dnl Check for sed
 AC_CHECK_PROGS(regex_cmd, sed)
 if test x$regex_cmd = "x" ; then
@@ -46,8 +54,6 @@ if test x$bison_cmd = "x" ; then
     AC_MSG_NOTICE([bison is required to patch jq.])
 fi
 
- AC_CONFIG_HEADERS(config.h)
-
 dnl Check for python
 AC_CHECK_PROGS(python_cmd, python)
 if test x$python_cmd = "x" ; then
@@ -61,6 +67,7 @@ if test x$valgrind_cmd = "x" ; then
 fi
 
 dnl AC_CONFIG_MACRO_DIR([m4])
+AC_CONFIG_HEADERS(config.h)
 AM_INIT_AUTOMAKE([-Wall dist-bzip2 dist-zip])
 AC_CONFIG_FILES([Makefile])
 AC_OUTPUT
diff --git a/execute.c b/execute.c
index 93aefc0e..a596e28b 100644
--- a/execute.c
+++ b/execute.c
@@ -14,7 +14,7 @@
 
 #include "locfile.h"
 #include "jv.h"
-#include "parser.h"
+#include "jq_parser.h"
 #include "builtin.h"
 
 typedef struct {
diff --git a/parser.h b/jq_parser.h
similarity index 75%
rename from parser.h
rename to jq_parser.h
index 25eff019..8dc37163 100644
--- a/parser.h
+++ b/jq_parser.h
@@ -1,5 +1,5 @@
-#ifndef PARSER_H
-#define PARSER_H
+#ifndef JQ_PARSER_H
+#define JQ_PARSER_H
 
 int jq_parse(struct locfile* source, block* answer);
 int jq_parse_library(struct locfile* locations, block* answer);
diff --git a/lexer.l b/lexer.l
index 368d4989..ec01d25e 100644
--- a/lexer.l
+++ b/lexer.l
@@ -3,7 +3,7 @@
 
 struct lexer_param;
 
-#include "parser.gen.h"  /* Generated by bison. */
+#include "parser.h"  /* Generated by bison. */
 
 #define YY_USER_ACTION                           \
   do {                                           \
diff --git a/parser.gen.info b/parser.gen.info
deleted file mode 100644
index 8f1f5656..00000000
--- a/parser.gen.info
+++ /dev/null
@@ -1,3565 +0,0 @@
-Terminals unused in grammar
-
-   INVALID_CHARACTER
-
-
-Grammar
-
-    0 $accept: TopLevel $end
-
-    1 TopLevel: Exp
-    2         | FuncDefs
-
-    3 FuncDefs: /* empty */
-    4         | FuncDef FuncDefs
-
-    5 Exp: FuncDef Exp
-    6    | Term "as" '$' IDENT '|' Exp
-    7    | "if" Exp "then" Exp ElseBody
-    8    | "if" Exp error
-    9    | Exp '=' Exp
-   10    | Exp "or" Exp
-   11    | Exp "and" Exp
-   12    | Exp "//" Exp
-   13    | Exp "//=" Exp
-   14    | Exp "|=" Exp
-   15    | Exp '|' Exp
-   16    | Exp ',' Exp
-   17    | Exp '+' Exp
-   18    | Exp "+=" Exp
-   19    | Exp '-' Exp
-   20    | Exp "-=" Exp
-   21    | Exp '*' Exp
-   22    | Exp "*=" Exp
-   23    | Exp '/' Exp
-   24    | Exp "/=" Exp
-   25    | Exp "==" Exp
-   26    | Exp "!=" Exp
-   27    | Exp '<' Exp
-   28    | Exp '>' Exp
-   29    | Exp "<=" Exp
-   30    | Exp ">=" Exp
-   31    | Exp "contains" Exp
-   32    | Term
-
-   33 String: QQSTRING_START QQString QQSTRING_END
-
-   34 FuncDef: "def" IDENT ':' Exp ';'
-   35        | "def" IDENT '(' IDENT ')' ':' Exp ';'
-
-   36 QQString: /* empty */
-   37         | QQString QQSTRING_TEXT
-   38         | QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END
-
-   39 ElseBody: "elif" Exp "then" Exp ElseBody
-   40         | "else" Exp "end"
-
-   41 ExpD: ExpD '|' ExpD
-   42     | Term
-
-   43 Term: '.'
-   44     | Term '.' IDENT
-   45     | '.' IDENT
-   46     | Term '[' Exp ']'
-   47     | Term '[' ']'
-   48     | LITERAL
-   49     | String
-   50     | '(' Exp ')'
-   51     | '[' Exp ']'
-   52     | '[' ']'
-   53     | '{' MkDict '}'
-   54     | '$' IDENT
-   55     | IDENT
-   56     | IDENT '(' Exp ')'
-   57     | '(' error ')'
-   58     | '[' error ']'
-   59     | Term '[' error ']'
-   60     | '{' error '}'
-
-   61 MkDict: /* empty */
-   62       | MkDictPair
-   63       | MkDictPair ',' MkDict
-   64       | error ',' MkDict
-
-   65 MkDictPair: IDENT ':' ExpD
-   66           | String ':' ExpD
-   67           | IDENT
-   68           | '(' Exp ')' ':' ExpD
-   69           | '(' error ')' ':' ExpD
-
-
-Terminals, with rules where they appear
-
-$end (0) 0
-'$' (36) 6 54
-'(' (40) 35 50 56 57 68 69
-')' (41) 35 50 56 57 68 69
-'*' (42) 21
-'+' (43) 17
-',' (44) 16 63 64
-'-' (45) 19
-'.' (46) 43 44 45
-'/' (47) 23
-':' (58) 34 35 65 66 68 69
-';' (59) 34 35
-'<' (60) 27
-'=' (61) 9
-'>' (62) 28
-'[' (91) 46 47 51 52 58 59
-']' (93) 46 47 51 52 58 59
-'{' (123) 53 60
-'|' (124) 6 15 41
-'}' (125) 53 60
-error (256) 8 57 58 59 60 64 69
-INVALID_CHARACTER (258)
-IDENT (259) 6 34 35 44 45 54 55 56 65 67
-LITERAL (260) 48
-"==" (261) 25
-"!=" (262) 26
-"//" (263) 12
-"as" (264) 6
-"def" (265) 34 35
-"if" (266) 7 8
-"then" (267) 7 39
-"else" (268) 40
-"elif" (269) 39
-"end" (270) 40
-"and" (271) 11
-"or" (272) 10
-"|=" (273) 14
-"+=" (274) 18
-"-=" (275) 20
-"*=" (276) 22
-"/=" (277) 24
-"//=" (278) 13
-"<=" (279) 29
-">=" (280) 30
-"contains" (281) 31
-QQSTRING_START (282) 33
-QQSTRING_TEXT (283) 37
-QQSTRING_INTERP_START (284) 38
-QQSTRING_INTERP_END (285) 38
-QQSTRING_END (286) 33
-
-
-Nonterminals, with rules where they appear
-
-$accept (51)
-    on left: 0
-TopLevel (52)
-    on left: 1 2, on right: 0
-FuncDefs (53)
-    on left: 3 4, on right: 2 4
-Exp (54)
-    on left: 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
-    25 26 27 28 29 30 31 32, on right: 1 5 6 7 8 9 10 11 12 13 14 15
-    16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 34 35 38 39 40
-    46 50 51 56 68
-String (55)
-    on left: 33, on right: 49 66
-FuncDef (56)
-    on left: 34 35, on right: 4 5
-QQString (57)
-    on left: 36 37 38, on right: 33 37 38
-ElseBody (58)
-    on left: 39 40, on right: 7 39
-ExpD (59)
-    on left: 41 42, on right: 41 65 66 68 69
-Term (60)
-    on left: 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60,
-    on right: 6 32 42 44 46 47 59
-MkDict (61)
-    on left: 61 62 63 64, on right: 53 63 64
-MkDictPair (62)
-    on left: 65 66 67 68 69, on right: 62 63
-
-
-state 0
-
-    0 $accept: . TopLevel $end
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    $default  reduce using rule 3 (FuncDefs)
-
-    TopLevel  go to state 11
-    FuncDefs  go to state 12
-    Exp       go to state 13
-    String    go to state 14
-    FuncDef   go to state 15
-    Term      go to state 16
-
-
-state 1
-
-   55 Term: IDENT .
-   56     | IDENT . '(' Exp ')'
-
-    '('  shift, and go to state 17
-
-    $default  reduce using rule 55 (Term)
-
-
-state 2
-
-   48 Term: LITERAL .
-
-    $default  reduce using rule 48 (Term)
-
-
-state 3
-
-   34 FuncDef: "def" . IDENT ':' Exp ';'
-   35        | "def" . IDENT '(' IDENT ')' ':' Exp ';'
-
-    IDENT  shift, and go to state 18
-
-
-state 4
-
-    7 Exp: "if" . Exp "then" Exp ElseBody
-    8    | "if" . Exp error
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 19
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 5
-
-   33 String: QQSTRING_START . QQString QQSTRING_END
-
-    $default  reduce using rule 36 (QQString)
-
-    QQString  go to state 21
-
-
-state 6
-
-   54 Term: '$' . IDENT
-
-    IDENT  shift, and go to state 22
-
-
-state 7
-
-   50 Term: '(' . Exp ')'
-   57     | '(' . error ')'
-
-    error           shift, and go to state 23
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 24
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 8
-
-   43 Term: '.' .
-   45     | '.' . IDENT
-
-    IDENT  shift, and go to state 25
-
-    $default  reduce using rule 43 (Term)
-
-
-state 9
-
-   51 Term: '[' . Exp ']'
-   52     | '[' . ']'
-   58     | '[' . error ']'
-
-    error           shift, and go to state 26
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    ']'             shift, and go to state 27
-    '{'             shift, and go to state 10
-
-    Exp      go to state 28
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 10
-
-   53 Term: '{' . MkDict '}'
-   60     | '{' . error '}'
-
-    error           shift, and go to state 29
-    IDENT           shift, and go to state 30
-    QQSTRING_START  shift, and go to state 5
-    '('             shift, and go to state 31
-
-    '}'  reduce using rule 61 (MkDict)
-
-    String      go to state 32
-    MkDict      go to state 33
-    MkDictPair  go to state 34
-
-
-state 11
-
-    0 $accept: TopLevel . $end
-
-    $end  shift, and go to state 35
-
-
-state 12
-
-    2 TopLevel: FuncDefs .
-
-    $default  reduce using rule 2 (TopLevel)
-
-
-state 13
-
-    1 TopLevel: Exp .
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    $default  reduce using rule 1 (TopLevel)
-
-
-state 14
-
-   49 Term: String .
-
-    $default  reduce using rule 49 (Term)
-
-
-state 15
-
-    4 FuncDefs: FuncDef . FuncDefs
-    5 Exp: FuncDef . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    $default  reduce using rule 3 (FuncDefs)
-
-    FuncDefs  go to state 59
-    Exp       go to state 60
-    String    go to state 14
-    FuncDef   go to state 15
-    Term      go to state 16
-
-
-state 16
-
-    6 Exp: Term . "as" '$' IDENT '|' Exp
-   32    | Term .
-   44 Term: Term . '.' IDENT
-   46     | Term . '[' Exp ']'
-   47     | Term . '[' ']'
-   59     | Term . '[' error ']'
-
-    "as"  shift, and go to state 61
-    '.'   shift, and go to state 62
-    '['   shift, and go to state 63
-
-    $default  reduce using rule 32 (Exp)
-
-
-state 17
-
-   56 Term: IDENT '(' . Exp ')'
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 64
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 18
-
-   34 FuncDef: "def" IDENT . ':' Exp ';'
-   35        | "def" IDENT . '(' IDENT ')' ':' Exp ';'
-
-    ':'  shift, and go to state 65
-    '('  shift, and go to state 66
-
-
-state 19
-
-    7 Exp: "if" Exp . "then" Exp ElseBody
-    8    | "if" Exp . error
-    9    | Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    error       shift, and go to state 67
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "then"      shift, and go to state 68
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-
-state 20
-
-    5 Exp: FuncDef . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 60
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 21
-
-   33 String: QQSTRING_START QQString . QQSTRING_END
-   37 QQString: QQString . QQSTRING_TEXT
-   38         | QQString . QQSTRING_INTERP_START Exp QQSTRING_INTERP_END
-
-    QQSTRING_TEXT          shift, and go to state 69
-    QQSTRING_INTERP_START  shift, and go to state 70
-    QQSTRING_END           shift, and go to state 71
-
-
-state 22
-
-   54 Term: '$' IDENT .
-
-    $default  reduce using rule 54 (Term)
-
-
-state 23
-
-   57 Term: '(' error . ')'
-
-    ')'  shift, and go to state 72
-
-
-state 24
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   50 Term: '(' Exp . ')'
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-    ')'         shift, and go to state 73
-
-
-state 25
-
-   45 Term: '.' IDENT .
-
-    $default  reduce using rule 45 (Term)
-
-
-state 26
-
-   58 Term: '[' error . ']'
-
-    ']'  shift, and go to state 74
-
-
-state 27
-
-   52 Term: '[' ']' .
-
-    $default  reduce using rule 52 (Term)
-
-
-state 28
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   51 Term: '[' Exp . ']'
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-    ']'         shift, and go to state 75
-
-
-state 29
-
-   60 Term: '{' error . '}'
-   64 MkDict: error . ',' MkDict
-
-    ','  shift, and go to state 76
-    '}'  shift, and go to state 77
-
-
-state 30
-
-   65 MkDictPair: IDENT . ':' ExpD
-   67           | IDENT .
-
-    ':'  shift, and go to state 78
-
-    $default  reduce using rule 67 (MkDictPair)
-
-
-state 31
-
-   68 MkDictPair: '(' . Exp ')' ':' ExpD
-   69           | '(' . error ')' ':' ExpD
-
-    error           shift, and go to state 79
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 80
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 32
-
-   66 MkDictPair: String . ':' ExpD
-
-    ':'  shift, and go to state 81
-
-
-state 33
-
-   53 Term: '{' MkDict . '}'
-
-    '}'  shift, and go to state 82
-
-
-state 34
-
-   62 MkDict: MkDictPair .
-   63       | MkDictPair . ',' MkDict
-
-    ','  shift, and go to state 83
-
-    $default  reduce using rule 62 (MkDict)
-
-
-state 35
-
-    0 $accept: TopLevel $end .
-
-    $default  accept
-
-
-state 36
-
-   25 Exp: Exp "==" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 84
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 37
-
-   26 Exp: Exp "!=" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 85
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 38
-
-   12 Exp: Exp "//" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 86
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 39
-
-   11 Exp: Exp "and" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 87
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 40
-
-   10 Exp: Exp "or" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 88
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 41
-
-   14 Exp: Exp "|=" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 89
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 42
-
-   18 Exp: Exp "+=" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 90
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 43
-
-   20 Exp: Exp "-=" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 91
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 44
-
-   22 Exp: Exp "*=" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 92
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 45
-
-   24 Exp: Exp "/=" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 93
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 46
-
-   13 Exp: Exp "//=" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 94
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 47
-
-   29 Exp: Exp "<=" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 95
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 48
-
-   30 Exp: Exp ">=" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 96
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 49
-
-   31 Exp: Exp "contains" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 97
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 50
-
-   15 Exp: Exp '|' . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 98
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 51
-
-   16 Exp: Exp ',' . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 99
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 52
-
-    9 Exp: Exp '=' . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 100
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 53
-
-   27 Exp: Exp '<' . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 101
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 54
-
-   28 Exp: Exp '>' . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 102
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 55
-
-   17 Exp: Exp '+' . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 103
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 56
-
-   19 Exp: Exp '-' . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 104
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 57
-
-   21 Exp: Exp '*' . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 105
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 58
-
-   23 Exp: Exp '/' . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 106
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 59
-
-    4 FuncDefs: FuncDef FuncDefs .
-
-    $default  reduce using rule 4 (FuncDefs)
-
-
-state 60
-
-    5 Exp: FuncDef Exp .
-    9    | Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    $default  reduce using rule 5 (Exp)
-
-
-state 61
-
-    6 Exp: Term "as" . '$' IDENT '|' Exp
-
-    '$'  shift, and go to state 107
-
-
-state 62
-
-   44 Term: Term '.' . IDENT
-
-    IDENT  shift, and go to state 108
-
-
-state 63
-
-   46 Term: Term '[' . Exp ']'
-   47     | Term '[' . ']'
-   59     | Term '[' . error ']'
-
-    error           shift, and go to state 109
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    ']'             shift, and go to state 110
-    '{'             shift, and go to state 10
-
-    Exp      go to state 111
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 64
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   56 Term: IDENT '(' Exp . ')'
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-    ')'         shift, and go to state 112
-
-
-state 65
-
-   34 FuncDef: "def" IDENT ':' . Exp ';'
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 113
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 66
-
-   35 FuncDef: "def" IDENT '(' . IDENT ')' ':' Exp ';'
-
-    IDENT  shift, and go to state 114
-
-
-state 67
-
-    8 Exp: "if" Exp error .
-
-    $default  reduce using rule 8 (Exp)
-
-
-state 68
-
-    7 Exp: "if" Exp "then" . Exp ElseBody
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 115
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 69
-
-   37 QQString: QQString QQSTRING_TEXT .
-
-    $default  reduce using rule 37 (QQString)
-
-
-state 70
-
-   38 QQString: QQString QQSTRING_INTERP_START . Exp QQSTRING_INTERP_END
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 116
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 71
-
-   33 String: QQSTRING_START QQString QQSTRING_END .
-
-    $default  reduce using rule 33 (String)
-
-
-state 72
-
-   57 Term: '(' error ')' .
-
-    $default  reduce using rule 57 (Term)
-
-
-state 73
-
-   50 Term: '(' Exp ')' .
-
-    $default  reduce using rule 50 (Term)
-
-
-state 74
-
-   58 Term: '[' error ']' .
-
-    $default  reduce using rule 58 (Term)
-
-
-state 75
-
-   51 Term: '[' Exp ']' .
-
-    $default  reduce using rule 51 (Term)
-
-
-state 76
-
-   64 MkDict: error ',' . MkDict
-
-    error           shift, and go to state 117
-    IDENT           shift, and go to state 30
-    QQSTRING_START  shift, and go to state 5
-    '('             shift, and go to state 31
-
-    '}'  reduce using rule 61 (MkDict)
-
-    String      go to state 32
-    MkDict      go to state 118
-    MkDictPair  go to state 34
-
-
-state 77
-
-   60 Term: '{' error '}' .
-
-    $default  reduce using rule 60 (Term)
-
-
-state 78
-
-   65 MkDictPair: IDENT ':' . ExpD
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    String  go to state 14
-    ExpD    go to state 119
-    Term    go to state 120
-
-
-state 79
-
-   69 MkDictPair: '(' error . ')' ':' ExpD
-
-    ')'  shift, and go to state 121
-
-
-state 80
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   68 MkDictPair: '(' Exp . ')' ':' ExpD
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-    ')'         shift, and go to state 122
-
-
-state 81
-
-   66 MkDictPair: String ':' . ExpD
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    String  go to state 14
-    ExpD    go to state 123
-    Term    go to state 120
-
-
-state 82
-
-   53 Term: '{' MkDict '}' .
-
-    $default  reduce using rule 53 (Term)
-
-
-state 83
-
-   63 MkDict: MkDictPair ',' . MkDict
-
-    error           shift, and go to state 117
-    IDENT           shift, and go to state 30
-    QQSTRING_START  shift, and go to state 5
-    '('             shift, and go to state 31
-
-    '}'  reduce using rule 61 (MkDict)
-
-    String      go to state 32
-    MkDict      go to state 124
-    MkDictPair  go to state 34
-
-
-state 84
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   25    | Exp "==" Exp .
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    '+'  shift, and go to state 55
-    '-'  shift, and go to state 56
-    '*'  shift, and go to state 57
-    '/'  shift, and go to state 58
-
-    "=="        error (nonassociative)
-    "!="        error (nonassociative)
-    "<="        error (nonassociative)
-    ">="        error (nonassociative)
-    "contains"  error (nonassociative)
-    '<'         error (nonassociative)
-    '>'         error (nonassociative)
-
-    $default  reduce using rule 25 (Exp)
-
-
-state 85
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   26    | Exp "!=" Exp .
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    '+'  shift, and go to state 55
-    '-'  shift, and go to state 56
-    '*'  shift, and go to state 57
-    '/'  shift, and go to state 58
-
-    "=="        error (nonassociative)
-    "!="        error (nonassociative)
-    "<="        error (nonassociative)
-    ">="        error (nonassociative)
-    "contains"  error (nonassociative)
-    '<'         error (nonassociative)
-    '>'         error (nonassociative)
-
-    $default  reduce using rule 26 (Exp)
-
-
-state 86
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   12    | Exp "//" Exp .
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    $default  reduce using rule 12 (Exp)
-
-
-state 87
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   11    | Exp "and" Exp .
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    $default  reduce using rule 11 (Exp)
-
-
-state 88
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   10    | Exp "or" Exp .
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "and"       shift, and go to state 39
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    $default  reduce using rule 10 (Exp)
-
-
-state 89
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   14    | Exp "|=" Exp .
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    "|="   error (nonassociative)
-    "+="   error (nonassociative)
-    "-="   error (nonassociative)
-    "*="   error (nonassociative)
-    "/="   error (nonassociative)
-    "//="  error (nonassociative)
-    '='    error (nonassociative)
-
-    $default  reduce using rule 14 (Exp)
-
-
-state 90
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   18    | Exp "+=" Exp .
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    "|="   error (nonassociative)
-    "+="   error (nonassociative)
-    "-="   error (nonassociative)
-    "*="   error (nonassociative)
-    "/="   error (nonassociative)
-    "//="  error (nonassociative)
-    '='    error (nonassociative)
-
-    $default  reduce using rule 18 (Exp)
-
-
-state 91
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   20    | Exp "-=" Exp .
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    "|="   error (nonassociative)
-    "+="   error (nonassociative)
-    "-="   error (nonassociative)
-    "*="   error (nonassociative)
-    "/="   error (nonassociative)
-    "//="  error (nonassociative)
-    '='    error (nonassociative)
-
-    $default  reduce using rule 20 (Exp)
-
-
-state 92
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   22    | Exp "*=" Exp .
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    "|="   error (nonassociative)
-    "+="   error (nonassociative)
-    "-="   error (nonassociative)
-    "*="   error (nonassociative)
-    "/="   error (nonassociative)
-    "//="  error (nonassociative)
-    '='    error (nonassociative)
-
-    $default  reduce using rule 22 (Exp)
-
-
-state 93
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   24    | Exp "/=" Exp .
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    "|="   error (nonassociative)
-    "+="   error (nonassociative)
-    "-="   error (nonassociative)
-    "*="   error (nonassociative)
-    "/="   error (nonassociative)
-    "//="  error (nonassociative)
-    '='    error (nonassociative)
-
-    $default  reduce using rule 24 (Exp)
-
-
-state 94
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   13    | Exp "//=" Exp .
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    "|="   error (nonassociative)
-    "+="   error (nonassociative)
-    "-="   error (nonassociative)
-    "*="   error (nonassociative)
-    "/="   error (nonassociative)
-    "//="  error (nonassociative)
-    '='    error (nonassociative)
-
-    $default  reduce using rule 13 (Exp)
-
-
-state 95
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   29    | Exp "<=" Exp .
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    '+'  shift, and go to state 55
-    '-'  shift, and go to state 56
-    '*'  shift, and go to state 57
-    '/'  shift, and go to state 58
-
-    "=="        error (nonassociative)
-    "!="        error (nonassociative)
-    "<="        error (nonassociative)
-    ">="        error (nonassociative)
-    "contains"  error (nonassociative)
-    '<'         error (nonassociative)
-    '>'         error (nonassociative)
-
-    $default  reduce using rule 29 (Exp)
-
-
-state 96
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   30    | Exp ">=" Exp .
-   31    | Exp . "contains" Exp
-
-    '+'  shift, and go to state 55
-    '-'  shift, and go to state 56
-    '*'  shift, and go to state 57
-    '/'  shift, and go to state 58
-
-    "=="        error (nonassociative)
-    "!="        error (nonassociative)
-    "<="        error (nonassociative)
-    ">="        error (nonassociative)
-    "contains"  error (nonassociative)
-    '<'         error (nonassociative)
-    '>'         error (nonassociative)
-
-    $default  reduce using rule 30 (Exp)
-
-
-state 97
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   31    | Exp "contains" Exp .
-
-    '+'  shift, and go to state 55
-    '-'  shift, and go to state 56
-    '*'  shift, and go to state 57
-    '/'  shift, and go to state 58
-
-    "=="        error (nonassociative)
-    "!="        error (nonassociative)
-    "<="        error (nonassociative)
-    ">="        error (nonassociative)
-    "contains"  error (nonassociative)
-    '<'         error (nonassociative)
-    '>'         error (nonassociative)
-
-    $default  reduce using rule 31 (Exp)
-
-
-state 98
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   15    | Exp '|' Exp .
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    $default  reduce using rule 15 (Exp)
-
-
-state 99
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   16    | Exp ',' Exp .
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    $default  reduce using rule 16 (Exp)
-
-
-state 100
-
-    9 Exp: Exp . '=' Exp
-    9    | Exp '=' Exp .
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    "|="   error (nonassociative)
-    "+="   error (nonassociative)
-    "-="   error (nonassociative)
-    "*="   error (nonassociative)
-    "/="   error (nonassociative)
-    "//="  error (nonassociative)
-    '='    error (nonassociative)
-
-    $default  reduce using rule 9 (Exp)
-
-
-state 101
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   27    | Exp '<' Exp .
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    '+'  shift, and go to state 55
-    '-'  shift, and go to state 56
-    '*'  shift, and go to state 57
-    '/'  shift, and go to state 58
-
-    "=="        error (nonassociative)
-    "!="        error (nonassociative)
-    "<="        error (nonassociative)
-    ">="        error (nonassociative)
-    "contains"  error (nonassociative)
-    '<'         error (nonassociative)
-    '>'         error (nonassociative)
-
-    $default  reduce using rule 27 (Exp)
-
-
-state 102
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   28    | Exp '>' Exp .
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    '+'  shift, and go to state 55
-    '-'  shift, and go to state 56
-    '*'  shift, and go to state 57
-    '/'  shift, and go to state 58
-
-    "=="        error (nonassociative)
-    "!="        error (nonassociative)
-    "<="        error (nonassociative)
-    ">="        error (nonassociative)
-    "contains"  error (nonassociative)
-    '<'         error (nonassociative)
-    '>'         error (nonassociative)
-
-    $default  reduce using rule 28 (Exp)
-
-
-state 103
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   17    | Exp '+' Exp .
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    '*'  shift, and go to state 57
-    '/'  shift, and go to state 58
-
-    $default  reduce using rule 17 (Exp)
-
-
-state 104
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   19    | Exp '-' Exp .
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    '*'  shift, and go to state 57
-    '/'  shift, and go to state 58
-
-    $default  reduce using rule 19 (Exp)
-
-
-state 105
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   21    | Exp '*' Exp .
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    $default  reduce using rule 21 (Exp)
-
-
-state 106
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   23    | Exp '/' Exp .
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    $default  reduce using rule 23 (Exp)
-
-
-state 107
-
-    6 Exp: Term "as" '$' . IDENT '|' Exp
-
-    IDENT  shift, and go to state 125
-
-
-state 108
-
-   44 Term: Term '.' IDENT .
-
-    $default  reduce using rule 44 (Term)
-
-
-state 109
-
-   59 Term: Term '[' error . ']'
-
-    ']'  shift, and go to state 126
-
-
-state 110
-
-   47 Term: Term '[' ']' .
-
-    $default  reduce using rule 47 (Term)
-
-
-state 111
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   46 Term: Term '[' Exp . ']'
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-    ']'         shift, and go to state 127
-
-
-state 112
-
-   56 Term: IDENT '(' Exp ')' .
-
-    $default  reduce using rule 56 (Term)
-
-
-state 113
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   34 FuncDef: "def" IDENT ':' Exp . ';'
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    ';'         shift, and go to state 128
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-
-state 114
-
-   35 FuncDef: "def" IDENT '(' IDENT . ')' ':' Exp ';'
-
-    ')'  shift, and go to state 129
-
-
-state 115
-
-    7 Exp: "if" Exp "then" Exp . ElseBody
-    9    | Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "else"      shift, and go to state 130
-    "elif"      shift, and go to state 131
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    ElseBody  go to state 132
-
-
-state 116
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   38 QQString: QQString QQSTRING_INTERP_START Exp . QQSTRING_INTERP_END
-
-    "=="                 shift, and go to state 36
-    "!="                 shift, and go to state 37
-    "//"                 shift, and go to state 38
-    "and"                shift, and go to state 39
-    "or"                 shift, and go to state 40
-    "|="                 shift, and go to state 41
-    "+="                 shift, and go to state 42
-    "-="                 shift, and go to state 43
-    "*="                 shift, and go to state 44
-    "/="                 shift, and go to state 45
-    "//="                shift, and go to state 46
-    "<="                 shift, and go to state 47
-    ">="                 shift, and go to state 48
-    "contains"           shift, and go to state 49
-    QQSTRING_INTERP_END  shift, and go to state 133
-    '|'                  shift, and go to state 50
-    ','                  shift, and go to state 51
-    '='                  shift, and go to state 52
-    '<'                  shift, and go to state 53
-    '>'                  shift, and go to state 54
-    '+'                  shift, and go to state 55
-    '-'                  shift, and go to state 56
-    '*'                  shift, and go to state 57
-    '/'                  shift, and go to state 58
-
-
-state 117
-
-   64 MkDict: error . ',' MkDict
-
-    ','  shift, and go to state 76
-
-
-state 118
-
-   64 MkDict: error ',' MkDict .
-
-    $default  reduce using rule 64 (MkDict)
-
-
-state 119
-
-   41 ExpD: ExpD . '|' ExpD
-   65 MkDictPair: IDENT ':' ExpD .
-
-    '|'  shift, and go to state 134
-
-    $default  reduce using rule 65 (MkDictPair)
-
-
-state 120
-
-   42 ExpD: Term .
-   44 Term: Term . '.' IDENT
-   46     | Term . '[' Exp ']'
-   47     | Term . '[' ']'
-   59     | Term . '[' error ']'
-
-    '.'  shift, and go to state 62
-    '['  shift, and go to state 63
-
-    $default  reduce using rule 42 (ExpD)
-
-
-state 121
-
-   69 MkDictPair: '(' error ')' . ':' ExpD
-
-    ':'  shift, and go to state 135
-
-
-state 122
-
-   68 MkDictPair: '(' Exp ')' . ':' ExpD
-
-    ':'  shift, and go to state 136
-
-
-state 123
-
-   41 ExpD: ExpD . '|' ExpD
-   66 MkDictPair: String ':' ExpD .
-
-    '|'  shift, and go to state 134
-
-    $default  reduce using rule 66 (MkDictPair)
-
-
-state 124
-
-   63 MkDict: MkDictPair ',' MkDict .
-
-    $default  reduce using rule 63 (MkDict)
-
-
-state 125
-
-    6 Exp: Term "as" '$' IDENT . '|' Exp
-
-    '|'  shift, and go to state 137
-
-
-state 126
-
-   59 Term: Term '[' error ']' .
-
-    $default  reduce using rule 59 (Term)
-
-
-state 127
-
-   46 Term: Term '[' Exp ']' .
-
-    $default  reduce using rule 46 (Term)
-
-
-state 128
-
-   34 FuncDef: "def" IDENT ':' Exp ';' .
-
-    $default  reduce using rule 34 (FuncDef)
-
-
-state 129
-
-   35 FuncDef: "def" IDENT '(' IDENT ')' . ':' Exp ';'
-
-    ':'  shift, and go to state 138
-
-
-state 130
-
-   40 ElseBody: "else" . Exp "end"
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 139
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 131
-
-   39 ElseBody: "elif" . Exp "then" Exp ElseBody
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 140
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 132
-
-    7 Exp: "if" Exp "then" Exp ElseBody .
-
-    $default  reduce using rule 7 (Exp)
-
-
-state 133
-
-   38 QQString: QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END .
-
-    $default  reduce using rule 38 (QQString)
-
-
-state 134
-
-   41 ExpD: ExpD '|' . ExpD
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    String  go to state 14
-    ExpD    go to state 141
-    Term    go to state 120
-
-
-state 135
-
-   69 MkDictPair: '(' error ')' ':' . ExpD
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    String  go to state 14
-    ExpD    go to state 142
-    Term    go to state 120
-
-
-state 136
-
-   68 MkDictPair: '(' Exp ')' ':' . ExpD
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    String  go to state 14
-    ExpD    go to state 143
-    Term    go to state 120
-
-
-state 137
-
-    6 Exp: Term "as" '$' IDENT '|' . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 144
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 138
-
-   35 FuncDef: "def" IDENT '(' IDENT ')' ':' . Exp ';'
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 145
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 139
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   40 ElseBody: "else" Exp . "end"
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "end"       shift, and go to state 146
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-
-state 140
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   39 ElseBody: "elif" Exp . "then" Exp ElseBody
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "then"      shift, and go to state 147
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-
-state 141
-
-   41 ExpD: ExpD . '|' ExpD
-   41     | ExpD '|' ExpD .
-
-    $default  reduce using rule 41 (ExpD)
-
-
-state 142
-
-   41 ExpD: ExpD . '|' ExpD
-   69 MkDictPair: '(' error ')' ':' ExpD .
-
-    '|'  shift, and go to state 134
-
-    $default  reduce using rule 69 (MkDictPair)
-
-
-state 143
-
-   41 ExpD: ExpD . '|' ExpD
-   68 MkDictPair: '(' Exp ')' ':' ExpD .
-
-    '|'  shift, and go to state 134
-
-    $default  reduce using rule 68 (MkDictPair)
-
-
-state 144
-
-    6 Exp: Term "as" '$' IDENT '|' Exp .
-    9    | Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    $default  reduce using rule 6 (Exp)
-
-
-state 145
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   35 FuncDef: "def" IDENT '(' IDENT ')' ':' Exp . ';'
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    ';'         shift, and go to state 148
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-
-state 146
-
-   40 ElseBody: "else" Exp "end" .
-
-    $default  reduce using rule 40 (ElseBody)
-
-
-state 147
-
-   39 ElseBody: "elif" Exp "then" . Exp ElseBody
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 149
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 148
-
-   35 FuncDef: "def" IDENT '(' IDENT ')' ':' Exp ';' .
-
-    $default  reduce using rule 35 (FuncDef)
-
-
-state 149
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   39 ElseBody: "elif" Exp "then" Exp . ElseBody
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "else"      shift, and go to state 130
-    "elif"      shift, and go to state 131
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    ElseBody  go to state 150
-
-
-state 150
-
-   39 ElseBody: "elif" Exp "then" Exp ElseBody .
-
-    $default  reduce using rule 39 (ElseBody)
diff --git a/parser.y b/parser.y
index 8a2495b5..515f5a40 100644
--- a/parser.y
+++ b/parser.y
@@ -88,7 +88,7 @@ struct lexer_param;
 
 %type <blk> Exp Term MkDict MkDictPair ExpD ElseBody QQString FuncDef FuncDefs String
 %{
-#include "lexer.gen.h"
+#include "lexer.h"
 struct lexer_param {
   yyscan_t lexer;
 };
diff --git a/setup.sh b/setup.sh
index 58297f67..bb3c26ce 100755
--- a/setup.sh
+++ b/setup.sh
@@ -2,9 +2,19 @@
 
 # RUN ME after pulling the code from git!
 if [ "clean" == "$1" ]; then
-  make distclean
+  make distclean || echo "continuing..."
   rm -rf tmp autom4te.cache config
-  rm -f INSTALL Makefile.in aclocal.m4 configure config.h.in *.gen.c *.gen.h ChangeLog
+  rm -f INSTALL Makefile.in aclocal.m4 configure config.h.in ChangeLog
+  rm -f jv_utf8_tables.gen.h lexer.c lexer.h parser.c parser.h
+elif [ "superclean" == "$1" ]; then
+  ver=$(tr -d '\n' <VERSION)
+  if [ "x${ver}" != "x" ]; then
+    if [ -d jq-${ver} ]; then
+      chmod -R u+w jq-${ver}
+      rm -rf jq-${ver}
+    fi
+    rm -f jq-${ver}.*
+  fi
 else
   autoreconf --install
   ./configure --prefix=/opt/junk

From 9e743d517a047566996181549f05383948c0d0c0 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Fri, 30 Nov 2012 20:27:16 +0000
Subject: [PATCH 151/284] Sort function and more general comparison operators.

---
 builtin.c |  66 ++++++-------------
 jv_aux.c  | 190 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 jv_aux.h  |   6 ++
 testdata  |   4 ++
 4 files changed, 219 insertions(+), 47 deletions(-)

diff --git a/builtin.c b/builtin.c
index 756b069d..eea85ed6 100644
--- a/builtin.c
+++ b/builtin.c
@@ -3,6 +3,7 @@
 #include "compile.h"
 #include "parser.h"
 #include "locfile.h"
+#include "jv_aux.h"
 
 enum {
   CMP_OP_LESS,
@@ -127,22 +128,11 @@ static void f_notequal(jv input[], jv output[]) {
 
 static void order_cmp(jv input[], jv output[], int op) {
   jv_free(input[0]);
-  jv a = input[2];
-  jv b = input[1];
-  if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
-    double da = jv_number_value(a);
-    double db = jv_number_value(b);
-    output[0] = jv_bool((op == CMP_OP_LESS && da < db) ||
-                        (op == CMP_OP_LESSEQ && da <= db) ||
-                        (op == CMP_OP_GREATEREQ && da >= db) ||
-                        (op == CMP_OP_GREATER && da > db));
-  } else {
-    output[0] = jv_invalid_with_msg(jv_string_fmt("Attempted to compare order of %s wrt %s",
-                                                  jv_kind_name(jv_get_kind(a)),
-                                                  jv_kind_name(jv_get_kind(b))));
-    jv_free(a);
-    jv_free(b);
-  }
+  int r = jv_cmp(input[2], input[1]);
+  output[0] = jv_bool((op == CMP_OP_LESS && r < 0) ||
+                      (op == CMP_OP_LESSEQ && r <= 0) ||
+                      (op == CMP_OP_GREATEREQ && r >= 0) ||
+                      (op == CMP_OP_GREATER && r > 0));
 }
 
 static void f_less(jv input[], jv output[]) {
@@ -222,38 +212,9 @@ static void f_tostring(jv input[], jv output[]) {
   }
 }
 
-static int string_cmp(const void* pa, const void* pb){
-  const jv* a = pa;
-  const jv* b = pb;
-  int lena = jv_string_length(jv_copy(*a));
-  int lenb = jv_string_length(jv_copy(*b));
-  int minlen = lena < lenb ? lena : lenb;
-  int r = memcmp(jv_string_value(*a), jv_string_value(*b), minlen);
-  if (r == 0) r = lena - lenb;
-  return r;
-}
-
 static void f_keys(jv input[], jv output[]) {
-  if (jv_get_kind(input[0]) == JV_KIND_OBJECT) {
-    int nkeys = jv_object_length(jv_copy(input[0]));
-    jv* keys = malloc(sizeof(jv) * nkeys);
-    int kidx = 0;
-    jv_object_foreach(i, input[0]) {
-      keys[kidx++] = jv_object_iter_key(input[0], i);
-    }
-    qsort(keys, nkeys, sizeof(jv), string_cmp);
-    output[0] = jv_array_sized(nkeys);
-    for (int i = 0; i<nkeys; i++) {
-      output[0] = jv_array_append(output[0], keys[i]);
-    }
-    free(keys);
-    jv_free(input[0]);
-  } else if (jv_get_kind(input[0]) == JV_KIND_ARRAY) {
-    int n = jv_array_length(input[0]);
-    output[0] = jv_array();
-    for (int i=0; i<n; i++){
-      output[0] = jv_array_set(output[0], i, jv_number(i));
-    }
+  if (jv_get_kind(input[0]) == JV_KIND_OBJECT || jv_get_kind(input[0]) == JV_KIND_ARRAY) {
+    output[0] = jv_keys(input[0]);
   } else {
     output[0] = jv_invalid_with_msg(jv_string_fmt("'keys' only supports object, not %s",
                                                   jv_kind_name(jv_get_kind(input[0]))));
@@ -261,6 +222,16 @@ static void f_keys(jv input[], jv output[]) {
   }
 }
 
+static void f_sort(jv input[], jv output[]){
+  if (jv_get_kind(input[0]) == JV_KIND_ARRAY) {
+    output[0] = jv_sort(input[0], jv_copy(input[0]));
+  } else {
+    output[0] = jv_invalid_with_msg(jv_string_fmt("only arrays may be sorted, not %s",
+                                                  jv_kind_name(jv_get_kind(input[0]))));
+    jv_free(input[0]);
+  }
+}
+
 static void f_type(jv input[], jv output[]) {
   output[0] = jv_string(jv_kind_name(jv_get_kind(input[0])));
   jv_free(input[0]);
@@ -284,6 +255,7 @@ static struct cfunction function_list[] = {
   {f_length, "length", CALL_BUILTIN_1_1},
   {f_type, "type", CALL_BUILTIN_1_1},
   {f_add, "add", CALL_BUILTIN_1_1},
+  {f_sort, "sort", CALL_BUILTIN_1_1},
 };
 
 static struct symbol_table cbuiltins = {function_list, sizeof(function_list)/sizeof(function_list[0])};
diff --git a/jv_aux.c b/jv_aux.c
index 483a75ef..15bc3de7 100644
--- a/jv_aux.c
+++ b/jv_aux.c
@@ -1,4 +1,6 @@
 #include "jv_aux.h"
+#include <string.h>
+#include <stdlib.h>
 
 jv jv_lookup(jv t, jv k) {
   jv v;
@@ -60,3 +62,191 @@ jv jv_insert(jv root, jv value, jv* path, int pathlen) {
   return jv_modify(root, jv_copy(*path), 
                    jv_insert(jv_lookup(jv_copy(root), jv_copy(*path)), value, path+1, pathlen-1));
 }
+
+
+static int string_cmp(const void* pa, const void* pb){
+  const jv* a = pa;
+  const jv* b = pb;
+  int lena = jv_string_length(jv_copy(*a));
+  int lenb = jv_string_length(jv_copy(*b));
+  int minlen = lena < lenb ? lena : lenb;
+  int r = memcmp(jv_string_value(*a), jv_string_value(*b), minlen);
+  if (r == 0) r = lena - lenb;
+  return r;
+}
+
+jv jv_keys(jv x) {
+  if (jv_get_kind(x) == JV_KIND_OBJECT) {
+    int nkeys = jv_object_length(jv_copy(x));
+    jv* keys = malloc(sizeof(jv) * nkeys);
+    int kidx = 0;
+    jv_object_foreach(i, x) {
+      keys[kidx++] = jv_object_iter_key(x, i);
+    }
+    qsort(keys, nkeys, sizeof(jv), string_cmp);
+    jv answer = jv_array_sized(nkeys);
+    for (int i = 0; i<nkeys; i++) {
+      answer = jv_array_append(answer, keys[i]);
+    }
+    free(keys);
+    jv_free(x);
+    return answer;
+  } else if (jv_get_kind(x) == JV_KIND_ARRAY) {
+    int n = jv_array_length(x);
+    jv answer = jv_array();
+    for (int i=0; i<n; i++){
+      answer = jv_array_set(answer, i, jv_number(i));
+    }
+    return answer;
+  } else {
+    assert(0 && "jv_keys passed something neither object nor array");
+    return jv_invalid();
+  }
+}
+
+int jv_cmp(jv a, jv b) {
+  if (jv_get_kind(a) != jv_get_kind(b)) {
+    int r = (int)jv_get_kind(a) - (int)jv_get_kind(b);
+    jv_free(a);
+    jv_free(b);
+    return r;
+  }
+  int r = 0;
+  switch (jv_get_kind(a)) {
+  default:
+    assert(0 && "invalid kind passed to jv_cmp");
+  case JV_KIND_NULL:
+  case JV_KIND_FALSE:
+  case JV_KIND_TRUE:
+    // there's only one of each of these values
+    r = 0;
+    break;
+
+  case JV_KIND_NUMBER: {
+    double da = jv_number_value(a), db = jv_number_value(b);
+    
+    // handle NaN as though it were null
+    if (da != da) r = jv_cmp(jv_null(), jv_number(db));
+    else if (db != db) r = jv_cmp(jv_number(da), jv_null());
+    else if (da < db) r = -1;
+    else if (da == db) r = 0;
+    else r = 1;
+    break;
+  }
+
+  case JV_KIND_STRING: {
+    r = string_cmp(&a, &b);
+    break;
+  }
+
+  case JV_KIND_ARRAY: {
+    // Lexical ordering of arrays
+    int i = 0;
+    while (r == 0) {
+      int a_done = i >= jv_array_length(jv_copy(a));
+      int b_done = i >= jv_array_length(jv_copy(b));
+      if (a_done || b_done) {
+        r = b_done - a_done; //suddenly, logic
+        break;
+      }
+      jv xa = jv_array_get(jv_copy(a), i);
+      jv xb = jv_array_get(jv_copy(b), i);
+      r = jv_cmp(xa, xb);
+      i++;
+    }
+    break;
+  }
+
+  case JV_KIND_OBJECT: {
+    jv keys_a = jv_keys(jv_copy(a));
+    jv keys_b = jv_keys(jv_copy(b));
+    r = jv_cmp(jv_copy(keys_a), keys_b);
+    if (r == 0) {
+      for (int i=0; i<jv_array_length(jv_copy(keys_a)); i++) {
+        jv key = jv_array_get(jv_copy(keys_a), i);
+        jv xa = jv_object_get(jv_copy(a), jv_copy(key));
+        jv xb = jv_object_get(jv_copy(b), key);
+        r = jv_cmp(xa, xb);
+        if (r) break;
+      }
+    }
+    jv_free(keys_a);
+    break;
+  }
+  }
+
+  jv_free(a);
+  jv_free(b);
+  return r;
+}
+
+
+struct sort_entry {
+  jv object;
+  jv key;
+};
+
+static int sort_cmp(const void* pa, const void* pb) {
+  const struct sort_entry* a = pa;
+  const struct sort_entry* b = pb;
+  int r = jv_cmp(jv_copy(a->key), jv_copy(b->key));
+  // comparing by address if r == 0 makes the sort stable
+  return r ? r : (int)(a - b);
+}
+
+static struct sort_entry* sort_items(jv objects, jv keys) {
+  assert(jv_get_kind(objects) == JV_KIND_ARRAY);
+  assert(jv_get_kind(keys) == JV_KIND_ARRAY);
+  assert(jv_array_length(jv_copy(objects)) == jv_array_length(jv_copy(keys)));
+  int n = jv_array_length(jv_copy(objects));
+  struct sort_entry* entries = malloc(sizeof(struct sort_entry) * n);
+  for (int i=0; i<n; i++) {
+    entries[i].object = jv_array_get(jv_copy(objects), i);
+    entries[i].key = jv_array_get(jv_copy(keys), i);
+  }
+  jv_free(objects);
+  jv_free(keys);
+  qsort(entries, n, sizeof(struct sort_entry), sort_cmp);
+  return entries;
+}
+
+jv jv_sort(jv objects, jv keys) {
+  assert(jv_get_kind(objects) == JV_KIND_ARRAY);
+  assert(jv_get_kind(keys) == JV_KIND_ARRAY);
+  assert(jv_array_length(jv_copy(objects)) == jv_array_length(jv_copy(keys)));
+  int n = jv_array_length(jv_copy(objects));
+  struct sort_entry* entries = sort_items(objects, keys);
+  jv ret = jv_array();
+  for (int i=0; i<n; i++) {
+    jv_free(entries[i].key);
+    ret = jv_array_set(ret, i, entries[i].object);
+  }
+  free(entries);
+  return ret;
+}
+
+jv jv_group(jv objects, jv keys) {
+  assert(jv_get_kind(objects) == JV_KIND_ARRAY);
+  assert(jv_get_kind(keys) == JV_KIND_ARRAY);
+  assert(jv_array_length(jv_copy(objects)) == jv_array_length(jv_copy(keys)));
+  int n = jv_array_length(jv_copy(objects));
+  struct sort_entry* entries = sort_items(objects, keys);
+  jv ret = jv_array();
+  jv curr_key = entries[0].key;
+  jv group = jv_array_append(jv_array(), entries[0].object);
+  for (int i = 1; i < n; i++) {
+    if (jv_equal(jv_copy(curr_key), jv_copy(entries[i].key))) {
+      jv_free(entries[i].key);
+    } else {
+      jv_free(curr_key);
+      curr_key = entries[i].key;
+      ret = jv_array_append(ret, group);
+      group = jv_array();
+    }
+    group = jv_array_append(group, entries[i].object);
+  }
+  jv_free(curr_key);
+  ret = jv_array_append(ret, group);
+  free(entries);
+  return ret;
+}
diff --git a/jv_aux.h b/jv_aux.h
index 9b91b664..36b0e5e4 100644
--- a/jv_aux.h
+++ b/jv_aux.h
@@ -7,5 +7,11 @@ jv jv_lookup(jv t, jv k);
 jv jv_modify(jv t, jv k, jv v);
 jv jv_insert(jv root, jv value, jv* path, int pathlen);
 
+jv jv_keys(jv /*object or array*/);
+int jv_cmp(jv, jv);
+
+jv jv_group(jv objects, jv keys);
+jv jv_sort(jv objects, jv keys);
+
 
 #endif
diff --git a/testdata b/testdata
index de224b96..1bab84f2 100644
--- a/testdata
+++ b/testdata
@@ -425,3 +425,7 @@ true
 {foo: {baz: 12, blap: {bar: 13}}, bar: 14} contains {bar: 14, foo: {blap: {bar: 14}}}
 {}
 false
+
+sort
+[42,[2,5,3,11],10,{"a":42,"b":2},{"a":42},true,2,[2,6],"hello",null,[2,5,6],{"a":[],"b":1},"abc","ab",[3,10],{},false,"abcd",null]
+[null,null,false,true,2,10,42,"ab","abc","abcd","hello",[2,5,3,11],[2,5,6],[2,6],[3,10],{},{"a":42},{"a":42,"b":2},{"a":[],"b":1}]

From 251f221b85216ca50329c4ef1788fc617863ce06 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sat, 1 Dec 2012 19:41:36 +0000
Subject: [PATCH 152/284] Refactor of function call codegen. Separate codegen
 for C and jq calls.

---
 compile.c     | 84 ++++++++++++++++++++++++---------------------------
 execute.c     |  6 ++--
 opcode.c      |  2 +-
 opcode_list.h |  2 +-
 4 files changed, 44 insertions(+), 50 deletions(-)

diff --git a/compile.c b/compile.c
index 46e5dd88..c85ef938 100644
--- a/compile.c
+++ b/compile.c
@@ -56,12 +56,8 @@ static inst* inst_new(opcode op) {
 
 static void inst_free(struct inst* i) {
   free(i->symbol);
-  if (opcode_describe(i->op)->flags & OP_HAS_BLOCK) {
-    block_free(i->subfn);
-  }
-  if (opcode_describe(i->op)->flags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
-    block_free(i->arglist);
-  }
+  block_free(i->subfn);
+  block_free(i->arglist);
   if (opcode_describe(i->op)->flags & OP_HAS_CONSTANT) {
     jv_free(i->imm.constant);
   }
@@ -486,7 +482,7 @@ static block expand_call_arglist(block b) {
         // Arguments to C functions not yet supported
         inst* cfunction_ref = block_take(&arglist);
         block prelude = gen_noop();
-        int nargs = 0;
+        int nargs = 2;
         for (inst* i; (i = block_take(&arglist)); ) {
           assert(i->op == CLOSURE_CREATE); // FIXME
           block body = i->subfn;
@@ -496,8 +492,11 @@ static block expand_call_arglist(block b) {
           nargs++;
         }
         assert(curr->op == CALL_1_1);
-        curr->imm.intval = 1;
-        ret = BLOCK(ret, prelude, inst_block(curr), inst_block(cfunction_ref), inst_block(seq_end));
+        curr->op = CALL_BUILTIN_1_1;
+        curr->imm.intval = nargs;
+        assert(!curr->arglist.first);
+        curr->arglist = inst_block(cfunction_ref);
+        ret = BLOCK(ret, prelude, inst_block(curr), inst_block(seq_end));
         break;
       }
       }
@@ -584,38 +583,46 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
     code[pos++] = curr->op;
     int opflags = op->flags;
     assert(!(op->flags & OP_IS_CALL_PSEUDO));
-    if (opflags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
+    if (curr->op == CALL_BUILTIN_1_1) {
+      int nargs = curr->imm.intval;
+      code[pos++] = (uint16_t)nargs;
+      assert(block_is_single(curr->arglist));
+      inst* cfunc = curr->arglist.first;
+      assert(cfunc && cfunc->bound_by->op == CLOSURE_CREATE_C);
+      assert(opcode_length(*opcode_rewrite) == 
+             opcode_length(bc->globals->cfunctions[cfunc->bound_by->imm.intval].callop));
+      *opcode_rewrite = bc->globals->cfunctions[cfunc->bound_by->imm.intval].callop;
+      code[pos++] = cfunc->bound_by->imm.intval;
+      // FIXME arg errors
+      assert(nargs > 0);
+    } else if (opflags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
       assert(curr->op == CALL_1_1);
       int nargs = curr->imm.intval;
       assert(nargs > 0 && nargs < 100); //FIXME
       code[pos++] = (uint16_t)nargs;
-
-      int desired_params = 0;
-      for (int i=0; i<nargs; i++) {
+      curr = curr->next;
+      assert(curr && opcode_describe(curr->op)->flags & OP_IS_CALL_PSEUDO);
+      assert(curr->bound_by->op == CLOSURE_CREATE ||
+             curr->bound_by->op == CLOSURE_PARAM);
+      code[pos++] = nesting_level(bc, curr->bound_by);
+      if (curr->bound_by->op == CLOSURE_CREATE) {
+        code[pos++] = curr->bound_by->imm.intval | ARG_NEWCLOSURE;
+        inst* i = curr->bound_by;
+        // FIXME arg errors
+        assert(nargs - 1 == i->compiled->subfunctions[i->imm.intval]->nclosures);
+      } else {
+        code[pos++] = curr->bound_by->imm.intval;
+        // FIXME arg errors
+        assert(nargs == 1);
+      }
+      for (int i=1; i<nargs; i++) {
         curr = curr->next;
         assert(curr && opcode_describe(curr->op)->flags & OP_IS_CALL_PSEUDO);
+        assert(curr->op == CLOSURE_REF);
         code[pos++] = nesting_level(bc, curr->bound_by);
-        switch (curr->bound_by->op) {
-        default: assert(0 && "Unknown type of argument");
-        case CLOSURE_CREATE:
-          code[pos++] = curr->bound_by->imm.intval | ARG_NEWCLOSURE;
-          if (i == 0) {
-            inst* i = curr->bound_by;
-            desired_params = i->compiled->subfunctions[i->imm.intval]->nclosures;
-          }
-          break;
-        case CLOSURE_PARAM:
-          code[pos++] = curr->bound_by->imm.intval;
-          if (i == 0) desired_params = 0;
-          break;
-        case CLOSURE_CREATE_C:
-          code[pos++] = curr->bound_by->imm.intval;
-          *opcode_rewrite = bc->globals->cfunctions[curr->bound_by->imm.intval].callop;
-          if (i == 0) desired_params = 0;
-          break;
-        }
+        assert(curr->bound_by->op == CLOSURE_CREATE);
+        code[pos++] = curr->bound_by->imm.intval | ARG_NEWCLOSURE;
       }
-      assert(nargs - 1 == desired_params);
     } else if (opflags & OP_HAS_CONSTANT) {
       code[pos++] = jv_array_length(jv_copy(constant_pool));
       constant_pool = jv_array_append(constant_pool, jv_copy(curr->imm.constant));
@@ -629,17 +636,6 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
       assert(curr->imm.target->bytecode_pos > pos); // only forward branches
       code[pos] = curr->imm.target->bytecode_pos - (pos + 1);
       pos++;
-    } else if (opflags & OP_HAS_CFUNC) {
-      assert(curr->symbol);
-      int found = 0;
-      for (int i=0; i<bc->globals->ncfunctions; i++) {
-        if (!strcmp(curr->symbol, bc->globals->cfunctions[i].name)) {
-          code[pos++] = i;
-          found = 1;
-          break;
-        }
-      }
-      assert(found);
     } else if (op->length > 1) {
       assert(0 && "codegen not implemented for this operation");
     }
diff --git a/execute.c b/execute.c
index fa6b1b79..74221a55 100644
--- a/execute.c
+++ b/execute.c
@@ -411,9 +411,8 @@ jv jq_next() {
     }
       
     case CALL_BUILTIN_1_1: {
-      assert(*pc == 1); // no closure args allowed
+      assert(*pc == 2);
       pc++; // skip nclosures
-      pc++; // skip level
       stackval top = stack_pop();
       cfunc_input[0] = top.value;
       struct cfunction* func = &frame_current_bytecode(&frame_stk)->globals->cfunctions[*pc++];
@@ -429,9 +428,8 @@ jv jq_next() {
     }
 
     case CALL_BUILTIN_3_1: {
-      assert(*pc == 1); // no closure args allowed
+      assert(*pc == 4); // no closure args allowed
       pc++; // skip nclosures
-      pc++; // skip level
       stackval top = stack_pop();
       jv a = stack_pop().value;
       jv b = stack_pop().value;
diff --git a/opcode.c b/opcode.c
index 6e85e709..c4c6356d 100644
--- a/opcode.c
+++ b/opcode.c
@@ -5,7 +5,7 @@
 #define CONSTANT OP_HAS_CONSTANT, 2
 #define VARIABLE (OP_HAS_VARIABLE | OP_HAS_BINDING), 3
 #define BRANCH OP_HAS_BRANCH, 2
-#define CFUNC (OP_HAS_SYMBOL | OP_HAS_CFUNC | OP_HAS_VARIABLE_LENGTH_ARGLIST), 2
+#define CFUNC (OP_HAS_SYMBOL | OP_HAS_CFUNC), 3
 #define UFUNC (OP_HAS_UFUNC | OP_HAS_VARIABLE_LENGTH_ARGLIST), 2
 #define CALLSEQ_END_IMM (OP_IS_CALL_PSEUDO), 0
 #define CLOSURE_PARAM_IMM (OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 0
diff --git a/opcode_list.h b/opcode_list.h
index 00817a13..34a68e1c 100644
--- a/opcode_list.h
+++ b/opcode_list.h
@@ -18,7 +18,7 @@ OP(INSERT, NONE,    4, 2)
 OP(ASSIGN, VARIABLE, 3, 0)
 
 OP(CALL_BUILTIN_1_1, CFUNC, 1, 1)
-OP(CALL_BUILTIN_2_1, CFUNC, 2, 1)
+OP(WTFBROKEN, CFUNC, 2, 1)
 OP(CALL_BUILTIN_3_1, CFUNC, 3, 1)
 
 OP(CALL_1_1, UFUNC, 1, 1)

From 125e2785025ed1a4363800d712bdf4e782a94cd4 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 2 Dec 2012 20:45:55 +0000
Subject: [PATCH 153/284] Clean up calls to C functions, unify opcodes

---
 builtin.c     | 36 ++++++++++++++++++------------------
 bytecode.c    |  4 ++--
 bytecode.h    |  2 +-
 compile.c     | 32 +++++++++++++++-----------------
 execute.c     | 42 +++++++++++++-----------------------------
 opcode_list.h |  6 ++----
 6 files changed, 51 insertions(+), 71 deletions(-)

diff --git a/builtin.c b/builtin.c
index eea85ed6..ae4df33b 100644
--- a/builtin.c
+++ b/builtin.c
@@ -238,24 +238,24 @@ static void f_type(jv input[], jv output[]) {
 }
 
 static struct cfunction function_list[] = {
-  {f_plus, "_plus", CALL_BUILTIN_3_1},
-  {f_minus, "_minus", CALL_BUILTIN_3_1},
-  {f_multiply, "_multiply", CALL_BUILTIN_3_1},
-  {f_divide, "_divide", CALL_BUILTIN_3_1},
-  {f_tonumber, "tonumber", CALL_BUILTIN_1_1},
-  {f_tostring, "tostring", CALL_BUILTIN_1_1},
-  {f_keys, "keys", CALL_BUILTIN_1_1},
-  {f_equal, "_equal", CALL_BUILTIN_3_1},
-  {f_notequal, "_notequal", CALL_BUILTIN_3_1},
-  {f_less, "_less", CALL_BUILTIN_3_1},
-  {f_greater, "_greater", CALL_BUILTIN_3_1},
-  {f_lesseq, "_lesseq", CALL_BUILTIN_3_1},
-  {f_greatereq, "_greatereq", CALL_BUILTIN_3_1},
-  {f_contains, "_contains", CALL_BUILTIN_3_1},
-  {f_length, "length", CALL_BUILTIN_1_1},
-  {f_type, "type", CALL_BUILTIN_1_1},
-  {f_add, "add", CALL_BUILTIN_1_1},
-  {f_sort, "sort", CALL_BUILTIN_1_1},
+  {f_plus, "_plus", 3},
+  {f_minus, "_minus", 3},
+  {f_multiply, "_multiply", 3},
+  {f_divide, "_divide", 3},
+  {f_tonumber, "tonumber", 1},
+  {f_tostring, "tostring", 1},
+  {f_keys, "keys", 1},
+  {f_equal, "_equal", 3},
+  {f_notequal, "_notequal", 3},
+  {f_less, "_less", 3},
+  {f_greater, "_greater", 3},
+  {f_lesseq, "_lesseq", 3},
+  {f_greatereq, "_greatereq", 3},
+  {f_contains, "_contains", 3},
+  {f_length, "length", 1},
+  {f_type, "type", 1},
+  {f_add, "add", 1},
+  {f_sort, "sort", 1},
 };
 
 static struct symbol_table cbuiltins = {function_list, sizeof(function_list)/sizeof(function_list[0])};
diff --git a/bytecode.c b/bytecode.c
index bafd0474..a18f0d90 100644
--- a/bytecode.c
+++ b/bytecode.c
@@ -7,7 +7,7 @@
 
 static int bytecode_operation_length(uint16_t* codeptr) {
   if (opcode_describe(*codeptr)->flags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
-    return 2 + codeptr[1] * 2;
+    return 4 + codeptr[1] * 2;
   } else {
     return opcode_length(*codeptr);
   }
@@ -42,7 +42,7 @@ void dump_operation(struct bytecode* bc, uint16_t* codeptr) {
   if (op->length > 1) {
     uint16_t imm = bc->code[pc++];
     if (op->flags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
-      for (int i=0; i<imm; i++) {
+      for (int i=0; i<imm+1; i++) {
         uint16_t level = bc->code[pc++];
         uint16_t idx = bc->code[pc++];
         if (idx & ARG_NEWCLOSURE) {
diff --git a/bytecode.h b/bytecode.h
index 5ffe80a6..011745c0 100644
--- a/bytecode.h
+++ b/bytecode.h
@@ -10,7 +10,7 @@ typedef void (*cfunction_ptr)(jv input[], jv output[]);
 struct cfunction {
   cfunction_ptr fptr;
   const char* name;
-  opcode callop;
+  int nargs;
 };
 
 #define MAX_CFUNCTION_ARGS 10
diff --git a/compile.c b/compile.c
index c85ef938..d31e0c34 100644
--- a/compile.c
+++ b/compile.c
@@ -282,7 +282,7 @@ block gen_lambda(block body) {
 }
 
 block gen_call(const char* name, block args) {
-  inst* i = inst_new(CALL_1_1);
+  inst* i = inst_new(CALL_JQ);
   i->arglist = BLOCK(gen_op_block_unbound(CLOSURE_REF, name), args);
   return BLOCK(inst_block(i), inst_block(inst_new(CALLSEQ_END)));
 }
@@ -439,7 +439,7 @@ static block expand_call_arglist(block b) {
   block ret = gen_noop();
   for (inst* curr; (curr = block_take(&b));) {
     if (opcode_describe(curr->op)->flags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
-      assert(curr->op == CALL_1_1);
+      assert(curr->op == CALL_JQ);
       inst* seq_end = block_take(&b);
       assert(seq_end && seq_end->op == CALLSEQ_END);
       // We expand the argument list as a series of instructions
@@ -473,7 +473,8 @@ static block expand_call_arglist(block b) {
         }
 
         assert(!arglist.first);
-        curr->imm.intval = nargs;
+        assert(nargs > 0);
+        curr->imm.intval = nargs - 1;
         ret = BLOCK(ret, prelude, inst_block(curr), callargs, inst_block(seq_end));
         break;
       }
@@ -482,7 +483,7 @@ static block expand_call_arglist(block b) {
         // Arguments to C functions not yet supported
         inst* cfunction_ref = block_take(&arglist);
         block prelude = gen_noop();
-        int nargs = 2;
+        int nargs = 1;
         for (inst* i; (i = block_take(&arglist)); ) {
           assert(i->op == CLOSURE_CREATE); // FIXME
           block body = i->subfn;
@@ -491,8 +492,8 @@ static block expand_call_arglist(block b) {
           prelude = BLOCK(prelude, gen_subexp(expand_call_arglist(body)));
           nargs++;
         }
-        assert(curr->op == CALL_1_1);
-        curr->op = CALL_BUILTIN_1_1;
+        assert(curr->op == CALL_JQ);
+        curr->op = CALL_BUILTIN;
         curr->imm.intval = nargs;
         assert(!curr->arglist.first);
         curr->arglist = inst_block(cfunction_ref);
@@ -579,26 +580,23 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
     const struct opcode_description* op = opcode_describe(curr->op);
     if (op->length == 0)
       continue;
-    uint16_t* opcode_rewrite = &code[pos];
     code[pos++] = curr->op;
     int opflags = op->flags;
     assert(!(op->flags & OP_IS_CALL_PSEUDO));
-    if (curr->op == CALL_BUILTIN_1_1) {
+    if (curr->op == CALL_BUILTIN) {
       int nargs = curr->imm.intval;
       code[pos++] = (uint16_t)nargs;
       assert(block_is_single(curr->arglist));
       inst* cfunc = curr->arglist.first;
       assert(cfunc && cfunc->bound_by->op == CLOSURE_CREATE_C);
-      assert(opcode_length(*opcode_rewrite) == 
-             opcode_length(bc->globals->cfunctions[cfunc->bound_by->imm.intval].callop));
-      *opcode_rewrite = bc->globals->cfunctions[cfunc->bound_by->imm.intval].callop;
+      //*opcode_rewrite = bc->globals->cfunctions[cfunc->bound_by->imm.intval].callop;
       code[pos++] = cfunc->bound_by->imm.intval;
       // FIXME arg errors
-      assert(nargs > 0);
+      assert(nargs == bc->globals->cfunctions[cfunc->bound_by->imm.intval].nargs);
     } else if (opflags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
-      assert(curr->op == CALL_1_1);
+      assert(curr->op == CALL_JQ);
       int nargs = curr->imm.intval;
-      assert(nargs > 0 && nargs < 100); //FIXME
+      assert(nargs >= 0 && nargs < 100); //FIXME
       code[pos++] = (uint16_t)nargs;
       curr = curr->next;
       assert(curr && opcode_describe(curr->op)->flags & OP_IS_CALL_PSEUDO);
@@ -609,13 +607,13 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
         code[pos++] = curr->bound_by->imm.intval | ARG_NEWCLOSURE;
         inst* i = curr->bound_by;
         // FIXME arg errors
-        assert(nargs - 1 == i->compiled->subfunctions[i->imm.intval]->nclosures);
+        assert(nargs == i->compiled->subfunctions[i->imm.intval]->nclosures);
       } else {
         code[pos++] = curr->bound_by->imm.intval;
         // FIXME arg errors
-        assert(nargs == 1);
+        assert(nargs == 0);
       }
-      for (int i=1; i<nargs; i++) {
+      for (int i=0; i<nargs; i++) {
         curr = curr->next;
         assert(curr && opcode_describe(curr->op)->flags & OP_IS_CALL_PSEUDO);
         assert(curr->op == CLOSURE_REF);
diff --git a/execute.c b/execute.c
index 74221a55..8aeee779 100644
--- a/execute.c
+++ b/execute.c
@@ -167,7 +167,9 @@ jv jq_next() {
     printf("\t");
     const struct opcode_description* opdesc = opcode_describe(opcode);
     data_stk_elem* param;
-    for (int i=0; i<opdesc->stack_in; i++) {
+    int stack_in = opdesc->stack_in;
+    if (stack_in == -1) stack_in = pc[1];
+    for (int i=0; i<stack_in; i++) {
       if (i == 0) {
         param = forkable_stack_peek(&data_stk);
       } else {
@@ -410,11 +412,13 @@ jv jq_next() {
       return value;
     }
       
-    case CALL_BUILTIN_1_1: {
-      assert(*pc == 2);
-      pc++; // skip nclosures
+    case CALL_BUILTIN: {
+      int nargs = *pc++;
       stackval top = stack_pop();
       cfunc_input[0] = top.value;
+      for (int i = 1; i < nargs; i++) {
+        cfunc_input[i] = stack_pop().value;
+      }
       struct cfunction* func = &frame_current_bytecode(&frame_stk)->globals->cfunctions[*pc++];
       func->fptr(cfunc_input, cfunc_output);
       top.value = cfunc_output[0];
@@ -427,36 +431,16 @@ jv jq_next() {
       break;
     }
 
-    case CALL_BUILTIN_3_1: {
-      assert(*pc == 4); // no closure args allowed
-      pc++; // skip nclosures
-      stackval top = stack_pop();
-      jv a = stack_pop().value;
-      jv b = stack_pop().value;
-      cfunc_input[0] = top.value;
-      cfunc_input[1] = a;
-      cfunc_input[2] = b;
-      struct cfunction* func = &frame_current_bytecode(&frame_stk)->globals->cfunctions[*pc++];
-      func->fptr(cfunc_input, cfunc_output);
-      top.value = cfunc_output[0];
-      if (jv_is_valid(top.value)) {
-        stack_push(top);
-      } else {
-        print_error(top.value);
-        goto do_backtrack;
-      }
-      break;
-    }
-
-    case CALL_1_1: {
+    case CALL_JQ: {
       uint16_t nclosures = *pc++;
+      uint16_t* retaddr = pc + 2 + nclosures*2;
       frame_ptr new_frame = frame_push(&frame_stk, 
                                        make_closure(&frame_stk, frame_current(&frame_stk), pc),
-                                       pc + nclosures * 2);
+                                       retaddr);
       pc += 2;
       frame_ptr old_frame = forkable_stack_peek_next(&frame_stk, new_frame);
-      assert(nclosures - 1 == frame_self(new_frame)->bc->nclosures);
-      for (int i=0; i<nclosures-1; i++) {
+      assert(nclosures == frame_self(new_frame)->bc->nclosures);
+      for (int i=0; i<nclosures; i++) {
         *frame_closure_arg(new_frame, i) = make_closure(&frame_stk, old_frame, pc);
         pc += 2;
       }
diff --git a/opcode_list.h b/opcode_list.h
index 34a68e1c..27211a2d 100644
--- a/opcode_list.h
+++ b/opcode_list.h
@@ -17,11 +17,9 @@ OP(INSERT, NONE,    4, 2)
 
 OP(ASSIGN, VARIABLE, 3, 0)
 
-OP(CALL_BUILTIN_1_1, CFUNC, 1, 1)
-OP(WTFBROKEN, CFUNC, 2, 1)
-OP(CALL_BUILTIN_3_1, CFUNC, 3, 1)
+OP(CALL_BUILTIN, CFUNC, -1, 1)
 
-OP(CALL_1_1, UFUNC, 1, 1)
+OP(CALL_JQ, UFUNC, 1, 1)
 OP(RET, NONE, 1, 1)
 
 OP(CALLSEQ_END, CALLSEQ_END_IMM, 0, 0)

From b6f2fbbe62be72e7eb52fda9f5ca5a8838869ae4 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 2 Dec 2012 21:25:54 +0000
Subject: [PATCH 154/284] Move all the includes one place to the left

---
 builtin.c  |  1 +
 builtin.h  | 11 ++++++++++-
 bytecode.h |  9 +--------
 compile.c  |  1 +
 compile.h  |  5 ++++-
 execute.c  |  1 -
 6 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/builtin.c b/builtin.c
index ae4df33b..4fca4a63 100644
--- a/builtin.c
+++ b/builtin.c
@@ -1,5 +1,6 @@
 #include <string.h>
 #include "builtin.h"
+#include "bytecode.h"
 #include "compile.h"
 #include "parser.h"
 #include "locfile.h"
diff --git a/builtin.h b/builtin.h
index fe2ac6ac..b6c26cda 100644
--- a/builtin.h
+++ b/builtin.h
@@ -1,9 +1,18 @@
 #ifndef BUILTIN_H
 #define BUILTIN_H
 
-#include "bytecode.h"
 #include "compile.h"
 
 block builtins_bind(block);
 
+
+typedef void (*cfunction_ptr)(jv input[], jv output[]);
+
+struct cfunction {
+  cfunction_ptr fptr;
+  const char* name;
+  int nargs;
+};
+
+
 #endif
diff --git a/bytecode.h b/bytecode.h
index 011745c0..e84f1387 100644
--- a/bytecode.h
+++ b/bytecode.h
@@ -4,14 +4,7 @@
 
 #include "jv.h"
 #include "opcode.h"
-
-typedef void (*cfunction_ptr)(jv input[], jv output[]);
-
-struct cfunction {
-  cfunction_ptr fptr;
-  const char* name;
-  int nargs;
-};
+#include "builtin.h"
 
 #define MAX_CFUNCTION_ARGS 10
 struct symbol_table {
diff --git a/compile.c b/compile.c
index d31e0c34..b7c202ac 100644
--- a/compile.c
+++ b/compile.c
@@ -3,6 +3,7 @@
 #include <stdlib.h>
 #include "opcode.h"
 #include "compile.h"
+#include "bytecode.h"
 #include "locfile.h"
 
 struct inst {
diff --git a/compile.h b/compile.h
index c8a326da..9a885159 100644
--- a/compile.h
+++ b/compile.h
@@ -1,10 +1,13 @@
 #ifndef COMPILE_H
 #define COMPILE_H
 #include <stdint.h>
-#include "bytecode.h"
+#include "jv.h"
 #include "opcode.h"
 #include "locfile.h"
 
+struct bytecode;
+struct symbol_table;
+
 struct inst;
 typedef struct inst inst;
 
diff --git a/execute.c b/execute.c
index 8aeee779..8c56b67c 100644
--- a/execute.c
+++ b/execute.c
@@ -7,7 +7,6 @@
 
 #include "opcode.h"
 #include "bytecode.h"
-#include "compile.h"
 
 #include "forkable_stack.h"
 #include "frame_layout.h"

From ea9db414edd078d8cb5e95a7694df7ae81d6daac Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 2 Dec 2012 22:12:08 +0000
Subject: [PATCH 155/284] Clean up implementation of builtin functions.

---
 builtin.c | 322 ++++++++++++++++++++++++++----------------------------
 builtin.h |   5 +-
 compile.c |   3 +-
 execute.c |   4 +-
 4 files changed, 163 insertions(+), 171 deletions(-)

diff --git a/builtin.c b/builtin.c
index 4fca4a63..f432bea5 100644
--- a/builtin.c
+++ b/builtin.c
@@ -6,41 +6,62 @@
 #include "locfile.h"
 #include "jv_aux.h"
 
-enum {
-  CMP_OP_LESS,
-  CMP_OP_GREATER,
-  CMP_OP_LESSEQ,
-  CMP_OP_GREATEREQ
-} _cmp_op;
 
-static void f_plus(jv input[], jv output[]) {
-  jv_free(input[0]);
-  jv a = input[2];
-  jv b = input[1];
-  if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
-    output[0] = jv_number(jv_number_value(a) + 
-                          jv_number_value(b));
-  } else if (jv_get_kind(a) == JV_KIND_STRING && jv_get_kind(b) == JV_KIND_STRING) {
-    output[0] = jv_string_concat(a, b);
-  } else if (jv_get_kind(a) == JV_KIND_ARRAY && jv_get_kind(b) == JV_KIND_ARRAY) {
-    output[0] = jv_array_concat(a, b);
-  } else if (jv_get_kind(a) == JV_KIND_OBJECT && jv_get_kind(b) == JV_KIND_OBJECT) {
-    output[0] = jv_object_merge(a, b);
-  } else {
-    output[0] = jv_invalid_with_msg(jv_string_fmt("Attempted to add %s and %s",
-                                                  jv_kind_name(jv_get_kind(a)),
-                                                  jv_kind_name(jv_get_kind(b))));
-    jv_free(a);
-    jv_free(b);
+typedef jv (*func_1)(jv);
+typedef jv (*func_2)(jv,jv);
+typedef jv (*func_3)(jv,jv,jv);
+typedef jv (*func_4)(jv,jv,jv,jv);
+typedef jv (*func_5)(jv,jv,jv,jv,jv);
+jv cfunction_invoke(struct cfunction* function, jv input[]) {
+  switch (function->nargs) {
+  case 1: return ((func_1)function->fptr)(input[0]);
+  case 2: return ((func_2)function->fptr)(input[0], input[1]);
+  case 3: return ((func_3)function->fptr)(input[0], input[1], input[2]);
+  case 4: return ((func_4)function->fptr)(input[0], input[1], input[2], input[3]);
+  case 5: return ((func_5)function->fptr)(input[0], input[1], input[2], input[3], input[4]);
+  default: return jv_invalid_with_msg(jv_string("Function takes too many arguments"));
   }
 }
 
-static void f_minus(jv input[], jv output[]) {
-  jv_free(input[0]);
-  jv a = input[2];
-  jv b = input[1];
+static jv type_error(jv bad, const char* msg) {
+  jv err = jv_invalid_with_msg(jv_string_fmt("%s %s",
+                                             jv_kind_name(jv_get_kind(bad)),
+                                             msg));
+  jv_free(bad);
+  return err;
+}
+
+static jv type_error2(jv bad1, jv bad2, const char* msg) {
+  jv err = jv_invalid_with_msg(jv_string_fmt("%s and %s %s",
+                                             jv_kind_name(jv_get_kind(bad1)),
+                                             jv_kind_name(jv_get_kind(bad2)),
+                                             msg));
+  jv_free(bad1);
+  jv_free(bad2);
+  return err;
+}
+
+
+static jv f_plus(jv input, jv a, jv b) {
+  jv_free(input);
   if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
-    output[0] = jv_number(jv_number_value(a) - jv_number_value(b));
+    return jv_number(jv_number_value(a) + 
+                     jv_number_value(b));
+  } else if (jv_get_kind(a) == JV_KIND_STRING && jv_get_kind(b) == JV_KIND_STRING) {
+    return jv_string_concat(a, b);
+  } else if (jv_get_kind(a) == JV_KIND_ARRAY && jv_get_kind(b) == JV_KIND_ARRAY) {
+    return jv_array_concat(a, b);
+  } else if (jv_get_kind(a) == JV_KIND_OBJECT && jv_get_kind(b) == JV_KIND_OBJECT) {
+    return jv_object_merge(a, b);
+  } else {
+    return type_error2(a, b, "cannot be added");
+  }
+}
+
+static jv f_minus(jv input, jv a, jv b) {
+  jv_free(input);
+  if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
+    return jv_number(jv_number_value(a) - jv_number_value(b));
   } else if (jv_get_kind(a) == JV_KIND_ARRAY && jv_get_kind(b) == JV_KIND_ARRAY) {
     jv out = jv_array();
     for (int i=0; i<jv_array_length(jv_copy(a)); i++) {
@@ -58,205 +79,174 @@ static void f_minus(jv input[], jv output[]) {
     }
     jv_free(a);
     jv_free(b);
-    output[0] = out;
+    return out;
   } else {
-    output[0] = jv_invalid_with_msg(jv_string_fmt("Attempted to subtract %s and %s",
-                                                  jv_kind_name(jv_get_kind(a)),
-                                                  jv_kind_name(jv_get_kind(b))));
-    jv_free(a);
-    jv_free(b);
+    return type_error2(a, b, "cannot be subtracted");
   }
 }
 
-static void f_multiply(jv input[], jv output[]) {
-  jv_free(input[0]);
-  jv a = input[2];
-  jv b = input[1];
+static jv f_multiply(jv input, jv a, jv b) {
+  jv_free(input);
   if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
-    output[0] = jv_number(jv_number_value(a) * jv_number_value(b));
+    return jv_number(jv_number_value(a) * jv_number_value(b));
   } else {
-    output[0] = jv_invalid_with_msg(jv_string_fmt("Attempted to multiply %s and %s",
-                                                  jv_kind_name(jv_get_kind(a)),
-                                                  jv_kind_name(jv_get_kind(b))));
-    jv_free(a);
-    jv_free(b);
+    return type_error2(a, b, "cannot be multiplied");
   }  
 }
 
-static void f_divide(jv input[], jv output[]) {
-  jv_free(input[0]);
-  jv a = input[2];
-  jv b = input[1];
+static jv f_divide(jv input, jv a, jv b) {
+  jv_free(input);
   if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
-    output[0] = jv_number(jv_number_value(a) / jv_number_value(b));
+    return jv_number(jv_number_value(a) / jv_number_value(b));
   } else {
-    output[0] = jv_invalid_with_msg(jv_string_fmt("Attempted to divide %s by %s",
-                                                  jv_kind_name(jv_get_kind(a)),
-                                                  jv_kind_name(jv_get_kind(b))));
-    jv_free(a);
-    jv_free(b);
+    return type_error2(a, b, "cannot be divided");
   }  
 }
 
-static void f_add(jv input[], jv output[]) {
-  jv array = input[0];
+static jv f_add(jv array) {
   if (jv_get_kind(array) != JV_KIND_ARRAY) {
-    output[0] = jv_invalid_with_msg(jv_string_fmt("Cannot add elements of an %s",
-                                                  jv_kind_name(jv_get_kind(array))));
+    return type_error(array, "cannot have its elements added");
   } else if (jv_array_length(jv_copy(array)) == 0) {
-    output[0] = jv_null();
+    jv_free(array);
+    return jv_null();
   } else {
     jv sum = jv_array_get(jv_copy(array), 0);
     for (int i = 1; i < jv_array_length(jv_copy(array)); i++) {
-      jv x = jv_array_get(jv_copy(array), i);
-      jv add_args[] = {jv_null(), x, sum};
-      f_plus(add_args, &sum);
+      sum = f_plus(jv_null(), sum, jv_array_get(jv_copy(array), i));
     }
-    output[0] = sum;
+    jv_free(array);
+    return sum;
   }
-  jv_free(array);
 }
 
-static void f_equal(jv input[], jv output[]) {
-  jv_free(input[0]);
-  output[0] = jv_bool(jv_equal(input[2], input[1]));
+static jv f_equal(jv input, jv a, jv b) {
+  jv_free(input);
+  return jv_bool(jv_equal(a, b));
 }
 
-static void f_notequal(jv input[], jv output[]) {
-  jv_free(input[0]);
-  output[0] = jv_bool(jv_equal(input[2], input[1]) == 0);
+static jv f_notequal(jv input, jv a, jv b) {
+  jv_free(input);
+  return jv_bool(!jv_equal(a, b));
 }
 
-static void order_cmp(jv input[], jv output[], int op) {
-  jv_free(input[0]);
-  int r = jv_cmp(input[2], input[1]);
-  output[0] = jv_bool((op == CMP_OP_LESS && r < 0) ||
-                      (op == CMP_OP_LESSEQ && r <= 0) ||
-                      (op == CMP_OP_GREATEREQ && r >= 0) ||
-                      (op == CMP_OP_GREATER && r > 0));
+enum cmp_op {
+  CMP_OP_LESS,
+  CMP_OP_GREATER,
+  CMP_OP_LESSEQ,
+  CMP_OP_GREATEREQ
+};
+
+static jv order_cmp(jv input, jv a, jv b, enum cmp_op op) {
+  jv_free(input);
+  int r = jv_cmp(a, b);
+  return jv_bool((op == CMP_OP_LESS && r < 0) ||
+                 (op == CMP_OP_LESSEQ && r <= 0) ||
+                 (op == CMP_OP_GREATEREQ && r >= 0) ||
+                 (op == CMP_OP_GREATER && r > 0));
 }
 
-static void f_less(jv input[], jv output[]) {
-  order_cmp(input, output, CMP_OP_LESS);
+static jv f_less(jv input, jv a, jv b) {
+  return order_cmp(input, a, b, CMP_OP_LESS);
 }
 
-static void f_greater(jv input[], jv output[]) {
-  order_cmp(input, output, CMP_OP_GREATER);
+static jv f_greater(jv input, jv a, jv b) {
+  return order_cmp(input, a, b, CMP_OP_GREATER);
 }
 
-static void f_lesseq(jv input[], jv output[]) {
-  order_cmp(input, output, CMP_OP_LESSEQ);
+static jv f_lesseq(jv input, jv a, jv b) {
+  return order_cmp(input, a, b, CMP_OP_LESSEQ);
 }
 
-static void f_greatereq(jv input[], jv output[]) {
-  order_cmp(input, output, CMP_OP_GREATEREQ);
+static jv f_greatereq(jv input, jv a, jv b) {
+  return order_cmp(input, a, b, CMP_OP_GREATEREQ);
 }
 
-static void f_contains(jv input[], jv output[]) {
-  jv_free(input[0]);
-  jv a = input[2];
-  jv b = input[1];
+static jv f_contains(jv input, jv a, jv b) {
+  jv_free(input);
   jv_kind akind = jv_get_kind(a);
 
   if (akind == jv_get_kind(b)) {
-    output[0] = jv_bool(jv_contains(a, b));
-  } else {  
-    output[0] = jv_invalid_with_msg(jv_string_fmt("Can only check containment of values of the same type."));
-    jv_free(a);
-    jv_free(b);
+    return jv_bool(jv_contains(a, b));
+  } else {
+    return type_error2(a, b, "cannot have their containment checked");
   }
 }
 
-static void f_tonumber(jv input[], jv output[]) {
-  if (jv_get_kind(input[0]) == JV_KIND_NUMBER) {
-    output[0] = input[0];
-  } else if (jv_get_kind(input[0]) == JV_KIND_STRING) {
-    jv parsed = jv_parse(jv_string_value(input[0]));
-    if (!jv_is_valid(parsed)) {
-      jv_free(input[0]);
-      output[0] = parsed;
-    } else if (jv_get_kind(parsed) != JV_KIND_NUMBER) {
-      output[0] = jv_invalid_with_msg(jv_string_fmt("'%s' is not a number",
-                                                    jv_string_value(input[0])));
-      jv_free(input[0]);
-    } else {
-      jv_free(input[0]);
-      output[0] = parsed;
+static jv f_tonumber(jv input) {
+  if (jv_get_kind(input) == JV_KIND_NUMBER) {
+    return input;
+  }
+  if (jv_get_kind(input) == JV_KIND_STRING) {
+    jv parsed = jv_parse(jv_string_value(input));
+    if (!jv_is_valid(parsed) || jv_get_kind(parsed) == JV_KIND_NUMBER) {
+      jv_free(input);
+      return parsed;
     }
+  }
+  return type_error(input, "cannot be parsed as a number");
+}
+
+static jv f_length(jv input) {
+  if (jv_get_kind(input) == JV_KIND_ARRAY) {
+    return jv_number(jv_array_length(input));
+  } else if (jv_get_kind(input) == JV_KIND_OBJECT) {
+    return jv_number(jv_object_length(input));
+  } else if (jv_get_kind(input) == JV_KIND_STRING) {
+    return jv_number(jv_string_length(input));
   } else {
-    output[0] = jv_invalid_with_msg(jv_string_fmt("Cannot parse %s as a number",
-                                                  jv_kind_name(jv_get_kind(input[0]))));
-    jv_free(input[0]);
-    return;
+    return type_error(input, "has no length");
   }
 }
 
-static void f_length(jv input[], jv output[]) {
-  if (jv_get_kind(input[0]) == JV_KIND_ARRAY) {
-    output[0] = jv_number(jv_array_length(input[0]));
-  } else if (jv_get_kind(input[0]) == JV_KIND_OBJECT) {
-    output[0] = jv_number(jv_object_length(input[0]));
-  } else if (jv_get_kind(input[0]) == JV_KIND_STRING) {
-    output[0] = jv_number(jv_string_length(input[0]));
+static jv f_tostring(jv input) {
+  if (jv_get_kind(input) == JV_KIND_STRING) {
+    return input;
   } else {
-    output[0] = jv_invalid_with_msg(jv_string_fmt("Cannot get the length of %s",
-                                                  jv_kind_name(jv_get_kind(input[0]))));
-    jv_free(input[0]);
+    return jv_dump_string(input, 0);
   }
 }
 
-static void f_tostring(jv input[], jv output[]) {
-  if (jv_get_kind(input[0]) == JV_KIND_STRING) {
-    output[0] = input[0];
+static jv f_keys(jv input) {
+  if (jv_get_kind(input) == JV_KIND_OBJECT || jv_get_kind(input) == JV_KIND_ARRAY) {
+    return jv_keys(input);
   } else {
-    output[0] = jv_dump_string(input[0], 0);
+    return type_error(input, "has no keys");
   }
 }
 
-static void f_keys(jv input[], jv output[]) {
-  if (jv_get_kind(input[0]) == JV_KIND_OBJECT || jv_get_kind(input[0]) == JV_KIND_ARRAY) {
-    output[0] = jv_keys(input[0]);
+static jv f_sort(jv input){
+  if (jv_get_kind(input) == JV_KIND_ARRAY) {
+    return jv_sort(input, jv_copy(input));
   } else {
-    output[0] = jv_invalid_with_msg(jv_string_fmt("'keys' only supports object, not %s",
-                                                  jv_kind_name(jv_get_kind(input[0]))));
-    jv_free(input[0]);
+    return type_error(input, "cannot be sorted, as it is not an array");
   }
 }
 
-static void f_sort(jv input[], jv output[]){
-  if (jv_get_kind(input[0]) == JV_KIND_ARRAY) {
-    output[0] = jv_sort(input[0], jv_copy(input[0]));
-  } else {
-    output[0] = jv_invalid_with_msg(jv_string_fmt("only arrays may be sorted, not %s",
-                                                  jv_kind_name(jv_get_kind(input[0]))));
-    jv_free(input[0]);
-  }
-}
-
-static void f_type(jv input[], jv output[]) {
-  output[0] = jv_string(jv_kind_name(jv_get_kind(input[0])));
-  jv_free(input[0]);
+static jv f_type(jv input) {
+  jv out = jv_string(jv_kind_name(jv_get_kind(input)));
+  jv_free(input);
+  return out;
 }
 
 static struct cfunction function_list[] = {
-  {f_plus, "_plus", 3},
-  {f_minus, "_minus", 3},
-  {f_multiply, "_multiply", 3},
-  {f_divide, "_divide", 3},
-  {f_tonumber, "tonumber", 1},
-  {f_tostring, "tostring", 1},
-  {f_keys, "keys", 1},
-  {f_equal, "_equal", 3},
-  {f_notequal, "_notequal", 3},
-  {f_less, "_less", 3},
-  {f_greater, "_greater", 3},
-  {f_lesseq, "_lesseq", 3},
-  {f_greatereq, "_greatereq", 3},
-  {f_contains, "_contains", 3},
-  {f_length, "length", 1},
-  {f_type, "type", 1},
-  {f_add, "add", 1},
-  {f_sort, "sort", 1},
+  {(cfunction_ptr)f_plus, "_plus", 3},
+  {(cfunction_ptr)f_minus, "_minus", 3},
+  {(cfunction_ptr)f_multiply, "_multiply", 3},
+  {(cfunction_ptr)f_divide, "_divide", 3},
+  {(cfunction_ptr)f_tonumber, "tonumber", 1},
+  {(cfunction_ptr)f_tostring, "tostring", 1},
+  {(cfunction_ptr)f_keys, "keys", 1},
+  {(cfunction_ptr)f_equal, "_equal", 3},
+  {(cfunction_ptr)f_notequal, "_notequal", 3},
+  {(cfunction_ptr)f_less, "_less", 3},
+  {(cfunction_ptr)f_greater, "_greater", 3},
+  {(cfunction_ptr)f_lesseq, "_lesseq", 3},
+  {(cfunction_ptr)f_greatereq, "_greatereq", 3},
+  {(cfunction_ptr)f_contains, "_contains", 3},
+  {(cfunction_ptr)f_length, "length", 1},
+  {(cfunction_ptr)f_type, "type", 1},
+  {(cfunction_ptr)f_add, "add", 1},
+  {(cfunction_ptr)f_sort, "sort", 1},
 };
 
 static struct symbol_table cbuiltins = {function_list, sizeof(function_list)/sizeof(function_list[0])};
diff --git a/builtin.h b/builtin.h
index b6c26cda..538a1391 100644
--- a/builtin.h
+++ b/builtin.h
@@ -6,7 +6,7 @@
 block builtins_bind(block);
 
 
-typedef void (*cfunction_ptr)(jv input[], jv output[]);
+typedef void (*cfunction_ptr)(void);
 
 struct cfunction {
   cfunction_ptr fptr;
@@ -15,4 +15,7 @@ struct cfunction {
 };
 
 
+jv cfunction_invoke(struct cfunction* function, jv input[]);
+
+
 #endif
diff --git a/compile.c b/compile.c
index b7c202ac..acc89749 100644
--- a/compile.c
+++ b/compile.c
@@ -490,7 +490,8 @@ static block expand_call_arglist(block b) {
           block body = i->subfn;
           i->subfn = gen_noop();
           inst_free(i);
-          prelude = BLOCK(prelude, gen_subexp(expand_call_arglist(body)));
+          // arguments should be pushed in reverse order, prepend them to prelude
+          prelude = BLOCK(gen_subexp(expand_call_arglist(body)), prelude);
           nargs++;
         }
         assert(curr->op == CALL_JQ);
diff --git a/execute.c b/execute.c
index 8c56b67c..8fadc7e7 100644
--- a/execute.c
+++ b/execute.c
@@ -149,7 +149,6 @@ void print_error(jv value) {
 
 jv jq_next() {
   jv cfunc_input[MAX_CFUNCTION_ARGS];
-  jv cfunc_output[MAX_CFUNCTION_ARGS];
 
   assert(!forkable_stack_empty(&frame_stk));
   uint16_t* pc = *frame_current_retaddr(&frame_stk);
@@ -419,8 +418,7 @@ jv jq_next() {
         cfunc_input[i] = stack_pop().value;
       }
       struct cfunction* func = &frame_current_bytecode(&frame_stk)->globals->cfunctions[*pc++];
-      func->fptr(cfunc_input, cfunc_output);
-      top.value = cfunc_output[0];
+      top.value = cfunction_invoke(func, cfunc_input);
       if (jv_is_valid(top.value)) {
         stack_push(top);
       } else {

From 63d10433c9e92028d5b6acda47119bde998eae1f Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 2 Dec 2012 22:22:08 +0000
Subject: [PATCH 156/284] Fix a horrible scoping/associativity bug.

`1 as $x | . | $x` didn't compile, as it was parsed as

    (1 as $x | .) | $x

where `$x` is undefined, rather than as

    1 as $x | (. | $x)
---
 parser.y | 2 +-
 testdata | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/parser.y b/parser.y
index 59d535e6..9c234506 100644
--- a/parser.y
+++ b/parser.y
@@ -75,7 +75,7 @@ struct lexer_param;
 
  /* revolting hack */
 %left ';'
-%left '|'
+%right '|'
 %left ','
 %right "//"
 %nonassoc '=' SETPIPE SETPLUS SETMINUS SETMULT SETDIV SETDEFINEDOR
diff --git a/testdata b/testdata
index 1bab84f2..e6fcaaf7 100644
--- a/testdata
+++ b/testdata
@@ -146,6 +146,10 @@ null
 [6]
 [7]
 
+42 as $x | . | . | . + 432 | $x + 1
+34324
+43
+
 1 as $x | [$x,$x,$x as $x | $x]
 null
 [1,1,1]

From ed7f95a492b647c7da3fc4bc2c9194b4bbbf7622 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 2 Dec 2012 22:24:02 +0000
Subject: [PATCH 157/284] Demote "contains" to a built-in function rather than
 an operator.

---
 builtin.c                        |  5 ++-
 docs/content/3.manual/manual.yml | 56 +++++++++++++++++---------------
 lexer.l                          |  1 -
 parser.y                         |  8 +----
 testdata                         | 20 ++++++------
 5 files changed, 42 insertions(+), 48 deletions(-)

diff --git a/builtin.c b/builtin.c
index f432bea5..ab13a2bb 100644
--- a/builtin.c
+++ b/builtin.c
@@ -161,8 +161,7 @@ static jv f_greatereq(jv input, jv a, jv b) {
   return order_cmp(input, a, b, CMP_OP_GREATEREQ);
 }
 
-static jv f_contains(jv input, jv a, jv b) {
-  jv_free(input);
+static jv f_contains(jv a, jv b) {
   jv_kind akind = jv_get_kind(a);
 
   if (akind == jv_get_kind(b)) {
@@ -242,7 +241,7 @@ static struct cfunction function_list[] = {
   {(cfunction_ptr)f_greater, "_greater", 3},
   {(cfunction_ptr)f_lesseq, "_lesseq", 3},
   {(cfunction_ptr)f_greatereq, "_greatereq", 3},
-  {(cfunction_ptr)f_contains, "_contains", 3},
+  {(cfunction_ptr)f_contains, "contains", 2},
   {(cfunction_ptr)f_length, "length", 1},
   {(cfunction_ptr)f_type, "type", 1},
   {(cfunction_ptr)f_add, "add", 1},
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 437afdff..60679ba2 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -487,6 +487,35 @@ sections:
             input: '[1, "1", [1]]'
             output: ['"1"', '"1"', '"[1]"']
 
+      - title: `contains`
+        body: |
+
+          The filter `contains(b)` will produce true if b is
+          completely contained within the input. A string B is
+          contained in a string A if B is a substring of A. An array B
+          is contained in an array A is all elements in B are
+          contained in any element in A. An object B is contained in
+          object A if all of the values in B are contained in the
+          value in A with the same key. All other types are assumed to
+          be contained in each other if they are equal.
+
+        examples:
+          - program: 'contains("bar")'
+            input: '"foobar"'
+            output: ['true']
+          - program: 'contains(["baz", "bar"])'
+            input: '["foobar", "foobaz", "blarp"]'
+            output: ['true']
+          - program: 'contains(["bazzzzz", "bar"])'
+            input: '["foobar", "foobaz", "blarp"]'
+            output: ['false']
+          - program: 'contains({foo: 12, bar: [{barp: 12}]})'
+            input: '{foo: 12, bar:[1,2,{barp:12, blip:13}]}'
+            output: ['true']
+          - program: 'contains({foo: 12, bar: [{barp: 15}]})'
+            input: '{foo: 12, bar:[1,2,{barp:12, blip:13}]}'
+            output: ['false']
+
       - title: "String interpolation - `\(foo)`"
         body: |
 
@@ -522,33 +551,6 @@ sections:
           - program: '.[] == 1'
             input: '[1, 1.0, "1", "banana"]'
             output: ['[true, true, false, false]']
-      - title: `contains`
-        body: |
-
-          The expression 'a contains b' will produce true if b is completely
-          contained within a. A string B is contained in a string A if B is a
-          substring of A. An array B is contained in an array A is all elements
-          in B are contained in any element in A. An object B is contained in
-          object A if all of the values in B are contained in the value in A with
-          the same key. All other types are assumed to be contained in each other
-          if they are equal.
-
-        examples:
-          - program: '. == contains "bar"'
-            input: '"foobar"'
-            output: ['true']
-          - program: '. contains ["baz", "bar"]'
-            input: '["foobar", "foobaz", "blarp"]'
-            output: ['true']
-          - program: '. contains ["bazzzzz", "bar"]'
-            input: '["foobar", "foobaz", "blarp"]'
-            output: ['false']
-          - program: '. contains {foo: 12, bar: [{barp: 12}]}'
-            input: '{foo: 12, bar:[1,2,{barp:12, blip:13}]}'
-            output: ['true']
-          - program: '. contains {foo: 12, bar: [{barp: 15}]}'
-            input: '{foo: 12, bar:[1,2,{barp:12, blip:13}]}'
-            output: ['false']
       - title: if-then-else
         body: |
 
diff --git a/lexer.l b/lexer.l
index 4f283011..b09ccce4 100644
--- a/lexer.l
+++ b/lexer.l
@@ -56,7 +56,6 @@ struct lexer_param;
 "//=" { return SETDEFINEDOR; }
 "<=" { return LESSEQ; }
 ">=" { return GREATEREQ; }
-"contains" { return CONTAINS; }
 "."|"="|";"|","|":"|"|"|"+"|"-"|"*"|"/"|"\$"|"<"|">" { return yytext[0];}
 
 "["|"{"|"(" {
diff --git a/parser.y b/parser.y
index 9c234506..bdee008b 100644
--- a/parser.y
+++ b/parser.y
@@ -65,7 +65,6 @@ struct lexer_param;
 %token SETDEFINEDOR "//="
 %token LESSEQ "<="
 %token GREATEREQ ">="
-%token CONTAINS "contains"
 
 %token QQSTRING_START
 %token <literal> QQSTRING_TEXT
@@ -81,7 +80,7 @@ struct lexer_param;
 %nonassoc '=' SETPIPE SETPLUS SETMINUS SETMULT SETDIV SETDEFINEDOR
 %left OR
 %left AND
-%nonassoc NEQ EQ '<' '>' LESSEQ GREATEREQ CONTAINS
+%nonassoc NEQ EQ '<' '>' LESSEQ GREATEREQ
 %left '+' '-'
 %left '*' '/'
 
@@ -150,7 +149,6 @@ static block gen_binop(block a, block b, int op) {
   case '>': funcname = "_greater"; break;
   case LESSEQ: funcname = "_lesseq"; break;
   case GREATEREQ: funcname = "_greatereq"; break;
-  case CONTAINS: funcname = "_contains"; break;
   }
   assert(funcname);
 
@@ -295,10 +293,6 @@ Exp ">=" Exp {
   $$ = gen_binop($1, $3, GREATEREQ);
 } |
 
-Exp "contains" Exp {
-  $$ = gen_binop($1, $3, CONTAINS);
-} |
-
 Term { 
   $$ = $1; 
 }
diff --git a/testdata b/testdata
index e6fcaaf7..30df927b 100644
--- a/testdata
+++ b/testdata
@@ -406,27 +406,27 @@ def inc(x): x |= .+1; inc(.[].a)
 [true,false]
 
 # containment operator
-["foo" contains "foo", "foobar" contains "foo", "foo" contains "foobar"]
+[("foo" | contains("foo")), ("foobar" | contains("foo")), ("foo" | contains("foobar"))]
 {}
 [true, true, false]
 
-[[] contains [], [1,2,3] contains [1,2], [1,2,3] contains [3,1], [1,2,3] contains [4], [1,2,3] contains [1,4]]
-{}
+map(.[1] as $needle | .[0] | contains($needle))
+[[[],[]], [[1,2,3], [1,2]], [[1,2,3], [3,1]], [[1,2,3], [4]], [[1,2,3], [1,4]]]
 [true, true, true, false, false]
 
-[["foobar", "foobaz"] contains ["baz", "bar"], ["foobar", "foobaz"] contains ["foo"], ["foobar", "foobaz"] contains ["blap"]]
+map(.[1] as $needle | .[0] | contains($needle))
+[[["foobar", "foobaz"], ["baz", "bar"]], [["foobar", "foobaz"], ["foo"]], [["foobar", "foobaz"], ["blap"]]]
+[true, true, false]
+
+[({foo: 12, bar:13} | contains({foo: 12})), ({foo: 12} | contains({})), ({foo: 12, bar:13} | contains({baz:14}))]
 {}
 [true, true, false]
 
-[{foo: 12, bar:13} contains {foo: 12}, {foo: 12} contains {}, {foo: 12, bar:13} contains {baz:14}]
-{}
-[true, true, false]
-
-{foo: {baz: 12, blap: {bar: 13}}, bar: 14} contains {bar: 14, foo: {blap: {}}}
+{foo: {baz: 12, blap: {bar: 13}}, bar: 14} | contains({bar: 14, foo: {blap: {}}})
 {}
 true
 
-{foo: {baz: 12, blap: {bar: 13}}, bar: 14} contains {bar: 14, foo: {blap: {bar: 14}}}
+{foo: {baz: 12, blap: {bar: 13}}, bar: 14} | contains({bar: 14, foo: {blap: {bar: 14}}})
 {}
 false
 

From 11965aaa2e9cf2b09c431e682cdc459b99de60fb Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 2 Dec 2012 23:22:15 +0000
Subject: [PATCH 158/284] sort_by and group_by functions, tests and docs.

---
 builtin.c                        | 24 ++++++++++++
 docs/content/3.manual/manual.yml | 64 ++++++++++++++++++++++++++++++++
 testdata                         |  8 ++++
 3 files changed, 96 insertions(+)

diff --git a/builtin.c b/builtin.c
index ab13a2bb..43cfe267 100644
--- a/builtin.c
+++ b/builtin.c
@@ -221,6 +221,26 @@ static jv f_sort(jv input){
   }
 }
 
+static jv f_sort_by_impl(jv input, jv keys) {
+  if (jv_get_kind(input) == JV_KIND_ARRAY && 
+      jv_get_kind(keys) == JV_KIND_ARRAY &&
+      jv_array_length(jv_copy(input)) == jv_array_length(jv_copy(keys))) {
+    return jv_sort(input, keys);
+  } else {
+    return type_error2(input, keys, "cannot be sorted, as they are not both arrays");
+  }
+}
+
+static jv f_group_by_impl(jv input, jv keys) {
+  if (jv_get_kind(input) == JV_KIND_ARRAY && 
+      jv_get_kind(keys) == JV_KIND_ARRAY &&
+      jv_array_length(jv_copy(input)) == jv_array_length(jv_copy(keys))) {
+    return jv_group(input, keys);
+  } else {
+    return type_error2(input, keys, "cannot be sorted, as they are not both arrays");
+  }
+}
+
 static jv f_type(jv input) {
   jv out = jv_string(jv_kind_name(jv_get_kind(input)));
   jv_free(input);
@@ -246,6 +266,8 @@ static struct cfunction function_list[] = {
   {(cfunction_ptr)f_type, "type", 1},
   {(cfunction_ptr)f_add, "add", 1},
   {(cfunction_ptr)f_sort, "sort", 1},
+  {(cfunction_ptr)f_sort_by_impl, "_sort_by_impl", 2},
+  {(cfunction_ptr)f_group_by_impl, "_group_by_impl", 2},
 };
 
 static struct symbol_table cbuiltins = {function_list, sizeof(function_list)/sizeof(function_list[0])};
@@ -271,6 +293,8 @@ static block bind_bytecoded_builtins(block b) {
 static const char* jq_builtins[] = {
   "def map(f): [.[] | f];",
   "def select(f): if f then . else empty end;",
+  "def sort_by(f): _sort_by_impl(map([f]));",
+  "def group_by(f): _group_by_impl(map([f]));",
 };
 
 
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 60679ba2..4d228691 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -487,6 +487,55 @@ sections:
             input: '[1, "1", [1]]'
             output: ['"1"', '"1"', '"[1]"']
 
+      - title: `sort, sort_by`
+        body: |
+          
+          The `sort` functions sorts its input, which must be an
+          array. Values are sorted in the following order:
+
+          * `null`
+          * `false`
+          * `true`
+          * numbers
+          * strings, in alphabetical order (by unicode codepoint value)
+          * arrays, in lexical order
+          * objects
+
+          The ordering for objects is a little complex: first they're
+          compared by comparing their sets of keys (as arrays in
+          sorted order), and if their keys are equal then the values
+          are compared key by key.
+
+          `sort_by` may be used to sort by a particular field of an
+          object, or by applying any jq filter. `sort_by(foo)`
+          compares two elements by comparing the result of `foo` on
+          each element.
+
+        examples:
+          - program: 'sort'
+            input: '[8,3,null,6]'
+            output: ['[null,3,6,8]']
+          - program: 'sort_by(.foo)'
+            input: '[{"foo":4, "bar":10}, {"foo":3, "bar":100}, {"foo":2, "bar":1}]'
+            output: ['[{"foo":2, "bar":1}, {"foo":3, "bar":100}, {"foo":4, "bar":10}]']
+
+      - title: `group_by`
+        body: |
+          
+          `group_by(.foo)` takes as input an array, groups the
+          elements having the same `.foo` field into separate arrays,
+          and produces all of these arrays as elements of a larger
+          array, sorted by the value of the `.foo` field.
+
+          Any jq expression, not just a field access, may be used in
+          place of `.foo`. The sorting order is the same as described
+          in the `sort` function above.
+
+        examples:
+          - program: 'group_by(.foo)'
+            input: '[{"foo":1, "bar":10}, {"foo":3, "bar":100}, {"foo":1, "bar":1}]'
+            output: ['[[{"foo":1, "bar":10}, {"foo":1, "bar":1}], [{"foo":3, "bar":100}]]']
+
       - title: `contains`
         body: |
 
@@ -583,6 +632,21 @@ sections:
               end
             input: 2
             output: ['"many"']
+      
+      - title: `>, >=, <=, <`
+        body: |
+          
+          The comparison operators `>`, `>=`, `<=`, `<` return whether
+          their left argument is greater than, greater than or equal
+          to, less than or equal to or less than their right argument
+          (respectively).
+
+          The ordering is the same as that described for `sort`, above.
+
+        examples:
+          - program: '. < 5'
+            input: 2
+            output: ['true']
 
       - title: and/or/not
         body: |
diff --git a/testdata b/testdata
index 30df927b..29bbe7a8 100644
--- a/testdata
+++ b/testdata
@@ -433,3 +433,11 @@ false
 sort
 [42,[2,5,3,11],10,{"a":42,"b":2},{"a":42},true,2,[2,6],"hello",null,[2,5,6],{"a":[],"b":1},"abc","ab",[3,10],{},false,"abcd",null]
 [null,null,false,true,2,10,42,"ab","abc","abcd","hello",[2,5,3,11],[2,5,6],[2,6],[3,10],{},{"a":42},{"a":42,"b":2},{"a":[],"b":1}]
+
+(sort_by(.b) | sort_by(.a)), sort_by(.a, .b), sort_by(.b, .c), group_by(.b), group_by(.a + .b - .c == 2)
+[{"a": 1, "b": 4, "c": 14}, {"a": 4, "b": 1, "c": 3}, {"a": 1, "b": 4, "c": 3}, {"a": 0, "b": 2, "c": 43}]
+[{"a": 0, "b": 2, "c": 43}, {"a": 1, "b": 4, "c": 14}, {"a": 1, "b": 4, "c": 3}, {"a": 4, "b": 1, "c": 3}]
+[{"a": 0, "b": 2, "c": 43}, {"a": 1, "b": 4, "c": 14}, {"a": 1, "b": 4, "c": 3}, {"a": 4, "b": 1, "c": 3}]
+[{"a": 4, "b": 1, "c": 3}, {"a": 0, "b": 2, "c": 43}, {"a": 1, "b": 4, "c": 3}, {"a": 1, "b": 4, "c": 14}]
+[[{"a": 4, "b": 1, "c": 3}], [{"a": 0, "b": 2, "c": 43}], [{"a": 1, "b": 4, "c": 14}, {"a": 1, "b": 4, "c": 3}]]
+[[{"a": 1, "b": 4, "c": 14}, {"a": 0, "b": 2, "c": 43}], [{"a": 4, "b": 1, "c": 3}, {"a": 1, "b": 4, "c": 3}]]

From 5b45184a1a79372630df76c0e840f4fffcce9494 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 2 Dec 2012 23:24:07 +0000
Subject: [PATCH 159/284] Make the -c output more compact. Closes #44.

---
 jv_print.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/jv_print.c b/jv_print.c
index 9e0a8812..2530b23b 100644
--- a/jv_print.c
+++ b/jv_print.c
@@ -144,7 +144,7 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
           put_str(",\n", F, S);
           put_space(indent+INDENT, F, S);
         } else {
-          put_str(", ", F, S);
+          put_str(",", F, S);
         }
       }
       jv_dump_term(C, jv_array_get(jv_copy(x), i), flags, indent + INDENT, F, S);
@@ -173,12 +173,12 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
           put_str(",\n", F, S);
           put_space(indent+INDENT, F, S);
         } else {
-          put_str(", ", F, S);
+          put_str(",", F, S);
         }
       }
       first = 0;
       jv_dump_term(C, jv_object_iter_key(x, i), flags, indent + INDENT, F, S);
-      put_str(": ", F, S);
+      put_str(":", F, S);
       jv_dump_term(C, jv_object_iter_value(x, i), flags, indent + INDENT, F, S);
     }
     if (flags & JV_PRINT_PRETTY) {

From 67f8ad943538e00826966c069d917b5bc99a4e47 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 2 Dec 2012 23:53:55 +0000
Subject: [PATCH 160/284] Ignore a UTF-8 BOM if one appears at the start of a
 JSON document. Closes #45.

---
 jv_parse.c | 20 ++++++++++++++++++++
 jv_parse.h |  1 +
 testdata   |  7 +++++++
 3 files changed, 28 insertions(+)

diff --git a/jv_parse.c b/jv_parse.c
index 63cdf935..738beb94 100644
--- a/jv_parse.c
+++ b/jv_parse.c
@@ -24,6 +24,7 @@ void jv_parser_init(struct jv_parser* p) {
   p->st = JV_PARSER_NORMAL;
   p->curr_buf = 0;
   p->curr_buf_length = p->curr_buf_pos = p->curr_buf_is_partial = 0;
+  p->bom_strip_position = 0;
   jvp_dtoa_context_init(&p->dtoa);
 }
 
@@ -332,9 +333,27 @@ static pfunc scan(struct jv_parser* p, char ch, jv* out) {
   return answer;
 }
 
+static unsigned char UTF8_BOM[] = {0xEF,0xBB,0xBF};
+
 void jv_parser_set_buf(struct jv_parser* p, const char* buf, int length, int is_partial) {
   assert((p->curr_buf == 0 || p->curr_buf_pos == p->curr_buf_length)
          && "previous buffer not exhausted");
+  while (p->bom_strip_position < sizeof(UTF8_BOM)) {
+    if ((unsigned char)*buf == UTF8_BOM[p->bom_strip_position]) {
+      // matched a BOM character
+      buf++;
+      length--;
+      p->bom_strip_position++;
+    } else {
+      if (p->bom_strip_position == 0) {
+        // no BOM in this document
+        p->bom_strip_position = sizeof(UTF8_BOM);
+      } else {
+        // malformed BOM (prefix present, rest missing)
+        p->bom_strip_position = 0xff;
+      }
+    }
+  }
   p->curr_buf = buf;
   p->curr_buf_length = length;
   p->curr_buf_pos = 0;
@@ -343,6 +362,7 @@ void jv_parser_set_buf(struct jv_parser* p, const char* buf, int length, int is_
 
 jv jv_parser_next(struct jv_parser* p) {
   assert(p->curr_buf && "a buffer must be provided");
+  if (p->bom_strip_position == 0xff) return jv_invalid_with_msg(jv_string("Malformed BOM"));
   jv value;
   presult msg = 0;
   while (!msg && p->curr_buf_pos < p->curr_buf_length) {
diff --git a/jv_parse.h b/jv_parse.h
index 5b8e7cdf..5958316a 100644
--- a/jv_parse.h
+++ b/jv_parse.h
@@ -6,6 +6,7 @@ struct jv_parser {
   int curr_buf_length;
   int curr_buf_pos;
   int curr_buf_is_partial;
+  unsigned bom_strip_position;
 
   jv* stack;
   int stackpos;
diff --git a/testdata b/testdata
index 29bbe7a8..e08e6aa5 100644
--- a/testdata
+++ b/testdata
@@ -31,6 +31,13 @@ null
 null
 []
 
+# The input line starts with a 0xFEFF (byte order mark) codepoint
+# No, there is no reason to have a byte order mark in UTF8 text.
+# But apparently people do, so jq shouldn't break on it.
+.
+"byte order mark"
+"byte order mark"
+
 # We test escapes by matching them against Unicode codepoints
 # FIXME: more tests needed for weird unicode stuff (e.g. utf16 pairs)
 "Aa\r\n\t\b\f\u03bc"

From e9c7548b825a4fb56b53111a76cb90e0f6aef4cc Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 3 Dec 2012 01:21:07 +0000
Subject: [PATCH 161/284] Oh alright then, if you insist.

Colo(u)red output for jq. Enabled by default if isatty(stdout).
Closes #11.
---
 docs/content/3.manual/manual.yml |  6 ++++
 jv.h                             |  2 +-
 jv_print.c                       | 49 +++++++++++++++++++++++++++++---
 main.c                           | 13 +++++++--
 4 files changed, 63 insertions(+), 7 deletions(-)

diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 4d228691..0e16a495 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -65,6 +65,12 @@ sections:
         will result in more compact output by instead putting each
         JSON object on a single line.
 
+      * `--colour-output` / `-C` and `--monochrome-output` / `-M`
+      
+        By default, jq outputs colored JSON if writing to a
+        terminal. You can force it to produce color even if writing to
+        a pipe or a file using `-C`, and disable color with `-M`.
+
       * `--ascii-output` / `-a`
 
         jq usually outputs non-ASCII Unicode codepoints as UTF-8, even
diff --git a/jv.h b/jv.h
index 02817681..12e7c790 100644
--- a/jv.h
+++ b/jv.h
@@ -105,7 +105,7 @@ jv jv_object_iter_value(jv, int);
 
 int jv_get_refcnt(jv);
 
-enum { JV_PRINT_PRETTY = 1, JV_PRINT_ASCII = 2 };
+enum { JV_PRINT_PRETTY = 1, JV_PRINT_ASCII = 2, JV_PRINT_COLOUR = 4 };
 void jv_dump(jv, int flags);
 jv jv_dump_string(jv, int flags);
 
diff --git a/jv_print.c b/jv_print.c
index 2530b23b..acade6cd 100644
--- a/jv_print.c
+++ b/jv_print.c
@@ -6,6 +6,20 @@
 #include "jv_dtoa.h"
 #include "jv_unicode.h"
 
+#define ESC "\033"
+#define COL(c) (ESC "[" c "m")
+#define COLRESET (ESC "[0m")
+
+// Colour table. See http://en.wikipedia.org/wiki/ANSI_escape_code#Colors
+// for how to choose these.
+static jv_kind colour_kinds[] = 
+  {JV_KIND_NULL,   JV_KIND_FALSE, JV_KIND_TRUE, JV_KIND_NUMBER,
+   JV_KIND_STRING, JV_KIND_ARRAY, JV_KIND_OBJECT};
+static const char* colours[] =
+  {COL("30;1"),    COL("0"),      COL("0"),     COL("0"),
+   COL("32"),      COL("37"),     COL("37")};
+#define FIELD_COLOUR COL("34;1")
+
 static void put_buf(const char* s, int len, FILE* fout, jv* strout) {
   if (strout) {
     *strout = jv_string_append_buf(*strout, s, len);
@@ -35,6 +49,7 @@ static void jvp_dump_string(jv str, int ascii_only, FILE* F, jv* S) {
   const char* cstart;
   int c = 0;
   char buf[32];
+  put_char('"', F, S);
   while ((i = jvp_utf8_next((cstart = i), end, &c))) {
     assert(c != -1);
     int unicode_escape = 0;
@@ -91,12 +106,23 @@ static void jvp_dump_string(jv str, int ascii_only, FILE* F, jv* S) {
     }
   }
   assert(c != -1);
+  put_char('"', F, S);
 }
 
 enum { INDENT = 2 };
 
 static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FILE* F, jv* S) {
   char buf[JVP_DTOA_FMT_MAX_LEN];
+  const char* colour = 0;
+  if (flags & JV_PRINT_COLOUR) {
+    for (unsigned i=0; i<sizeof(colour_kinds)/sizeof(colour_kinds[0]); i++) {
+      if (jv_get_kind(x) == colour_kinds[i]) {
+        colour = colours[i];
+        put_str(colour, F, S);
+        break;
+      }
+    }
+  }
   switch (jv_get_kind(x)) {
   case JV_KIND_INVALID:
     assert(0 && "Invalid value");
@@ -124,9 +150,7 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
     break;
   }
   case JV_KIND_STRING:
-    put_char('"', F, S);
     jvp_dump_string(x, flags & JV_PRINT_ASCII, F, S);
-    put_char('"', F, S);
     break;
   case JV_KIND_ARRAY: {
     if (jv_array_length(jv_copy(x)) == 0) {
@@ -148,11 +172,13 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
         }
       }
       jv_dump_term(C, jv_array_get(jv_copy(x), i), flags, indent + INDENT, F, S);
+      if (colour) put_str(colour, F, S);
     }
     if (flags & JV_PRINT_PRETTY) {
       put_char('\n', F, S);
       put_space(indent, F, S);
     }
+    if (colour) put_str(colour, F, S);
     put_char(']', F, S);
     break;
   }
@@ -176,19 +202,34 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
           put_str(",", F, S);
         }
       }
+      if (colour) put_str(COLRESET, F, S);
+
       first = 0;
-      jv_dump_term(C, jv_object_iter_key(x, i), flags, indent + INDENT, F, S);
-      put_str(":", F, S);
+      jv key = jv_object_iter_key(x, i);
+      if (colour) put_str(FIELD_COLOUR, F, S);
+      jvp_dump_string(key, flags & JV_PRINT_ASCII, F, S);
+      jv_free(key);
+      if (colour) put_str(COLRESET, F, S);
+
+      if (colour) put_str(colour, F, S);
+      put_str((flags & JV_PRINT_PRETTY) ? ": " : ":", F, S);
+      if (colour) put_str(COLRESET, F, S);
+      
       jv_dump_term(C, jv_object_iter_value(x, i), flags, indent + INDENT, F, S);
+      if (colour) put_str(colour, F, S);
     }
     if (flags & JV_PRINT_PRETTY) {
       put_char('\n', F, S);
       put_space(indent, F, S);
     }
+    if (colour) put_str(colour, F, S);
     put_char('}', F, S);
   }
   }
   jv_free(x);
+  if (colour) {
+    put_str(COLRESET, F, S);
+  }
 }
 
 void jv_dump(jv x, int flags) {
diff --git a/main.c b/main.c
index 74ca0e6e..64cb1fd4 100644
--- a/main.c
+++ b/main.c
@@ -2,6 +2,7 @@
 #include <errno.h>
 #include <string.h>
 #include <ctype.h>
+#include <unistd.h>
 #include "compile.h"
 #include "builtin.h"
 #include "jv.h"
@@ -50,8 +51,10 @@ enum {
   RAW_OUTPUT = 8,
   COMPACT_OUTPUT = 16,
   ASCII_OUTPUT = 32,
+  COLOUR_OUTPUT = 64,
+  NO_COLOUR_OUTPUT = 128,
 
-  FROM_FILE = 64,
+  FROM_FILE = 256,
 };
 static int options = 0;
 static struct bytecode* bc;
@@ -63,9 +66,11 @@ static void process(jv value) {
     if ((options & RAW_OUTPUT) && jv_get_kind(result) == JV_KIND_STRING) {
       fwrite(jv_string_value(result), 1, jv_string_length(jv_copy(result)), stdout);
     } else {
-      int dumpopts = 0;
+      int dumpopts = isatty(fileno(stdout)) ? JV_PRINT_COLOUR : 0;
       if (!(options & COMPACT_OUTPUT)) dumpopts |= JV_PRINT_PRETTY;
       if (options & ASCII_OUTPUT) dumpopts |= JV_PRINT_ASCII;
+      if (options & COLOUR_OUTPUT) dumpopts |= JV_PRINT_COLOUR;
+      if (options & NO_COLOUR_OUTPUT) dumpopts &= ~JV_PRINT_COLOUR;
       jv_dump(result, dumpopts);
     }
     printf("\n");
@@ -111,6 +116,10 @@ int main(int argc, char* argv[]) {
       options |= RAW_OUTPUT;
     } else if (isoption(argv[i], 'c', "compact-output")) {
       options |= COMPACT_OUTPUT;
+    } else if (isoption(argv[i], 'C', "color-output")) {
+      options |= COLOUR_OUTPUT;
+    } else if (isoption(argv[i], 'M', "monochrome-output")) {
+      options |= NO_COLOUR_OUTPUT;
     } else if (isoption(argv[i], 'a', "ascii-output")) {
       options |= ASCII_OUTPUT;
     } else if (isoption(argv[i], 'R', "raw-input")) {

From c8bbfed0410b7181a81952fb9314d5995b0d5e2e Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 3 Dec 2012 02:00:29 +0000
Subject: [PATCH 162/284] See, I told you colour was a bad idea! #11

Last commit broke the build, minor fix needed to testsuite.
---
 jq_test.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/jq_test.c b/jq_test.c
index b4674c81..2960162e 100644
--- a/jq_test.c
+++ b/jq_test.c
@@ -61,7 +61,7 @@ static void run_jq_tests() {
         printf("\n");
         pass = 0;
       }
-      jv as_string = jv_dump_string(jv_copy(expected), rand());
+      jv as_string = jv_dump_string(jv_copy(expected), rand() & ~JV_PRINT_COLOUR);
       jv reparsed = jv_parse_sized(jv_string_value(as_string), jv_string_length(jv_copy(as_string)));
       assert(jv_equal(jv_copy(expected), jv_copy(reparsed)));
       jv_free(as_string);

From fadeb66365cb8da2cddf3993ad139736922852ae Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 3 Dec 2012 02:02:12 +0000
Subject: [PATCH 163/284] Add a `unique` function.

---
 builtin.c                        |  1 +
 docs/content/3.manual/manual.yml | 12 ++++++++++++
 testdata                         |  4 ++++
 3 files changed, 17 insertions(+)

diff --git a/builtin.c b/builtin.c
index 43cfe267..a3c1f78b 100644
--- a/builtin.c
+++ b/builtin.c
@@ -295,6 +295,7 @@ static const char* jq_builtins[] = {
   "def select(f): if f then . else empty end;",
   "def sort_by(f): _sort_by_impl(map([f]));",
   "def group_by(f): _group_by_impl(map([f]));",
+  "def unique: group_by(.) | map(.[0]);",
 };
 
 
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 0e16a495..2e616e14 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -542,6 +542,18 @@ sections:
             input: '[{"foo":1, "bar":10}, {"foo":3, "bar":100}, {"foo":1, "bar":1}]'
             output: ['[[{"foo":1, "bar":10}, {"foo":1, "bar":1}], [{"foo":3, "bar":100}]]']
 
+      - title: `unique`
+        body: |
+          
+          The `unique` function takes as input an array and produces
+          an array of the same elements, in sorted order, with
+          duplicates removed.
+
+        examples:
+          - program: 'unique'
+            input: '[1,2,5,3,5,3,1,3]'
+            output: ['[1,2,3,5]']
+
       - title: `contains`
         body: |
 
diff --git a/testdata b/testdata
index e08e6aa5..cc8263b0 100644
--- a/testdata
+++ b/testdata
@@ -448,3 +448,7 @@ sort
 [{"a": 4, "b": 1, "c": 3}, {"a": 0, "b": 2, "c": 43}, {"a": 1, "b": 4, "c": 3}, {"a": 1, "b": 4, "c": 14}]
 [[{"a": 4, "b": 1, "c": 3}], [{"a": 0, "b": 2, "c": 43}], [{"a": 1, "b": 4, "c": 14}, {"a": 1, "b": 4, "c": 3}]]
 [[{"a": 1, "b": 4, "c": 14}, {"a": 0, "b": 2, "c": 43}], [{"a": 4, "b": 1, "c": 3}, {"a": 1, "b": 4, "c": 3}]]
+
+unique
+[1,2,5,3,5,3,1,3]
+[1,2,3,5]

From 5f6a95c7b574c6d0f52e62e2405c550606a5ce75 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 3 Dec 2012 20:00:36 +0000
Subject: [PATCH 164/284] General cleanup - rename a few things, delete dead
 code.

---
 builtin.c        |  10 ++---
 bytecode.c       |   4 +-
 compile.c        | 106 ++++++++++++++---------------------------------
 compile.h        |   3 +-
 forkable_stack.h |   2 -
 opcode.c         |   8 ++--
 opcode.h         |   3 --
 opcode_list.h    |   7 ++--
 parser.y         |  31 +++++++-------
 9 files changed, 62 insertions(+), 112 deletions(-)

diff --git a/builtin.c b/builtin.c
index a3c1f78b..ef447935 100644
--- a/builtin.c
+++ b/builtin.c
@@ -277,11 +277,11 @@ struct bytecoded_builtin { const char* name; block code; };
 static block bind_bytecoded_builtins(block b) {
   struct bytecoded_builtin builtin_defs[] = {
     {"empty", gen_op_simple(BACKTRACK)},
-    {"false", gen_op_const(LOADK, jv_false())},
-    {"true", gen_op_const(LOADK, jv_true())},
-    {"null", gen_op_const(LOADK, jv_null())},
-    {"not", gen_condbranch(gen_op_const(LOADK, jv_false()),
-                           gen_op_const(LOADK, jv_true()))}
+    {"false", gen_const(jv_false())},
+    {"true", gen_const(jv_true())},
+    {"null", gen_const(jv_null())},
+    {"not", gen_condbranch(gen_const(jv_false()),
+                           gen_const(jv_true()))}
   };
   block builtins = gen_noop();
   for (unsigned i=0; i<sizeof(builtin_defs)/sizeof(builtin_defs[0]); i++) {
diff --git a/bytecode.c b/bytecode.c
index a18f0d90..26f8d36d 100644
--- a/bytecode.c
+++ b/bytecode.c
@@ -6,7 +6,7 @@
 #include "opcode.h"
 
 static int bytecode_operation_length(uint16_t* codeptr) {
-  if (opcode_describe(*codeptr)->flags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
+  if (*codeptr == CALL_JQ) {
     return 4 + codeptr[1] * 2;
   } else {
     return opcode_length(*codeptr);
@@ -41,7 +41,7 @@ void dump_operation(struct bytecode* bc, uint16_t* codeptr) {
   printf("%s", op->name);
   if (op->length > 1) {
     uint16_t imm = bc->code[pc++];
-    if (op->flags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
+    if (op->op == CALL_JQ) {
       for (int i=0; i<imm+1; i++) {
         uint16_t level = bc->code[pc++];
         uint16_t idx = bc->code[pc++];
diff --git a/compile.c b/compile.c
index acc89749..8a493b45 100644
--- a/compile.c
+++ b/compile.c
@@ -109,9 +109,9 @@ block gen_op_simple(opcode op) {
 }
 
 
-block gen_op_const(opcode op, jv constant) {
-  assert(opcode_describe(op)->flags & OP_HAS_CONSTANT);
-  inst* i = inst_new(op);
+block gen_const(jv constant) {
+  assert(opcode_describe(LOADK)->flags & OP_HAS_CONSTANT);
+  inst* i = inst_new(LOADK);
   i->imm.constant = constant;
   return inst_block(i);
 }
@@ -151,13 +151,6 @@ block gen_op_var_bound(opcode op, block binder) {
   return b;
 }
 
-block gen_op_symbol(opcode op, const char* sym) {
-  assert(opcode_describe(op)->flags & OP_HAS_SYMBOL);
-  inst* i = inst_new(op);
-  i->symbol = strdup(sym);
-  return inst_block(i);
-}
-
 block gen_op_block_unbound(opcode op, const char* name) {
   assert(opcode_describe(op)->flags & OP_IS_CALL_PSEUDO);
   inst* i = inst_new(op);
@@ -180,32 +173,6 @@ static void inst_join(inst* a, inst* b) {
   b->prev = a;
 }
 
-static void block_insert_after(inst* i, block b) {
-  if (b.first) {
-    assert(b.last);
-    if (i->next) {
-      inst* j = i->next;
-      i->next = 0;
-      j->prev = 0;
-      inst_join(b.last, j);
-    }
-    inst_join(i, b.first);
-  }
-}
-
-static void block_insert_before(inst* i, block b) {
-  if (b.first) {
-    assert(b.last);
-    if (i->prev) {
-      inst* j = i->prev;
-      i->prev = 0;
-      j->next = 0;
-      inst_join(j, b.first);
-    }
-    inst_join(b.last, i);
-  }
-}
-
 void block_append(block* b, block b2) {
   if (b2.first) {
     if (b->last) {
@@ -248,14 +215,10 @@ static void block_bind_subblock(block binder, block body, int bindflags) {
       // bind this instruction
       i->bound_by = binder.first;
     }
-    if (flags & OP_HAS_BLOCK) {
-      // binding recurses into closures
-      block_bind_subblock(binder, i->subfn, bindflags);
-    }
-    if (flags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
-      // binding recurses into argument list
-      block_bind_subblock(binder, i->arglist, bindflags);
-    }
+    // binding recurses into closures
+    block_bind_subblock(binder, i->subfn, bindflags);
+    // binding recurses into argument list
+    block_bind_subblock(binder, i->arglist, bindflags);
   }
 }
 
@@ -306,7 +269,7 @@ block gen_both(block a, block b) {
 block gen_collect(block expr) {
   block array_var = block_bind(gen_op_var_unbound(STOREV, "collect"),
                                gen_noop(), OP_HAS_VARIABLE);
-  block c = BLOCK(gen_op_simple(DUP), gen_op_const(LOADK, jv_array()), array_var);
+  block c = BLOCK(gen_op_simple(DUP), gen_const(jv_array()), array_var);
 
   block tail = BLOCK(gen_op_simple(DUP),
                      gen_op_var_bound(LOADV, array_var),
@@ -342,7 +305,7 @@ block gen_definedor(block a, block b) {
   // var found := false
   block found_var = block_bind(gen_op_var_unbound(STOREV, "found"),
                                gen_noop(), OP_HAS_VARIABLE);
-  block init = BLOCK(gen_op_simple(DUP), gen_op_const(LOADK, jv_false()), found_var);
+  block init = BLOCK(gen_op_simple(DUP), gen_const(jv_false()), found_var);
 
   // if found, backtrack. Otherwise execute b
   block backtrack = gen_op_simple(BACKTRACK);
@@ -358,7 +321,7 @@ block gen_definedor(block a, block b) {
 
   // found := true, produce result
   block if_found = BLOCK(gen_op_simple(DUP),
-                         gen_op_const(LOADK, jv_true()),
+                         gen_const(jv_true()),
                          gen_op_var_bound(STOREV, found_var),
                          gen_op_target(JUMP, tail));
 
@@ -381,19 +344,19 @@ block gen_and(block a, block b) {
   return BLOCK(gen_op_simple(DUP), a, 
                gen_condbranch(BLOCK(gen_op_simple(POP),
                                     b,
-                                    gen_condbranch(gen_op_const(LOADK, jv_true()),
-                                                   gen_op_const(LOADK, jv_false()))),
-                              BLOCK(gen_op_simple(POP), gen_op_const(LOADK, jv_false()))));
+                                    gen_condbranch(gen_const(jv_true()),
+                                                   gen_const(jv_false()))),
+                              BLOCK(gen_op_simple(POP), gen_const(jv_false()))));
 }
 
 block gen_or(block a, block b) {
   // a or b = if a then true else (if b then true else false)
   return BLOCK(gen_op_simple(DUP), a,
-               gen_condbranch(BLOCK(gen_op_simple(POP), gen_op_const(LOADK, jv_true())),
+               gen_condbranch(BLOCK(gen_op_simple(POP), gen_const(jv_true())),
                               BLOCK(gen_op_simple(POP),
                                     b,
-                                    gen_condbranch(gen_op_const(LOADK, jv_true()),
-                                                   gen_op_const(LOADK, jv_false())))));
+                                    gen_condbranch(gen_const(jv_true()),
+                                                   gen_const(jv_false())))));
 }
 
 block gen_cond(block cond, block iftrue, block iffalse) {
@@ -427,8 +390,7 @@ static int count_cfunctions(block b) {
   int n = 0;
   for (inst* i = b.first; i; i = i->next) {
     if (i->op == CLOSURE_CREATE_C) n++;
-    if (opcode_describe(i->op)->flags & OP_HAS_BLOCK)
-      n += count_cfunctions(i->subfn);
+    n += count_cfunctions(i->subfn);
   }
   return n;
 }
@@ -439,8 +401,7 @@ static int count_cfunctions(block b) {
 static block expand_call_arglist(block b) {
   block ret = gen_noop();
   for (inst* curr; (curr = block_take(&b));) {
-    if (opcode_describe(curr->op)->flags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
-      assert(curr->op == CALL_JQ);
+    if (curr->op == CALL_JQ) {
       inst* seq_end = block_take(&b);
       assert(seq_end && seq_end->op == CALLSEQ_END);
       // We expand the argument list as a series of instructions
@@ -541,11 +502,11 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
         curr->bound_by == curr) {
       curr->imm.intval = var_frame_idx++;
     }
-    if (opflags & OP_HAS_BLOCK) {
+
+    if (curr->op == CLOSURE_CREATE) {
       assert(curr->bound_by == curr);
       curr->imm.intval = bc->nsubfunctions++;
     }
-
     if (curr->op == CLOSURE_PARAM) {
       assert(curr->bound_by == curr);
       curr->imm.intval = bc->nclosures++;
@@ -560,14 +521,14 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
   if (bc->nsubfunctions) {
     bc->subfunctions = malloc(sizeof(struct bytecode*) * bc->nsubfunctions);
     for (inst* curr = b.first; curr; curr = curr->next) {
-      if (!(opcode_describe(curr->op)->flags & OP_HAS_BLOCK))
-        continue;
-      struct bytecode* subfn = malloc(sizeof(struct bytecode));
-      bc->subfunctions[curr->imm.intval] = subfn;
-      subfn->globals = bc->globals;
-      subfn->parent = bc;
-      errors += compile(locations, subfn, curr->subfn);
-      curr->subfn = gen_noop();
+      if (curr->op == CLOSURE_CREATE) {
+        struct bytecode* subfn = malloc(sizeof(struct bytecode));
+        bc->subfunctions[curr->imm.intval] = subfn;
+        subfn->globals = bc->globals;
+        subfn->parent = bc;
+        errors += compile(locations, subfn, curr->subfn);
+        curr->subfn = gen_noop();
+      }
     }
   } else {
     bc->subfunctions = 0;
@@ -583,7 +544,6 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
     if (op->length == 0)
       continue;
     code[pos++] = curr->op;
-    int opflags = op->flags;
     assert(!(op->flags & OP_IS_CALL_PSEUDO));
     if (curr->op == CALL_BUILTIN) {
       int nargs = curr->imm.intval;
@@ -591,12 +551,10 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
       assert(block_is_single(curr->arglist));
       inst* cfunc = curr->arglist.first;
       assert(cfunc && cfunc->bound_by->op == CLOSURE_CREATE_C);
-      //*opcode_rewrite = bc->globals->cfunctions[cfunc->bound_by->imm.intval].callop;
       code[pos++] = cfunc->bound_by->imm.intval;
       // FIXME arg errors
       assert(nargs == bc->globals->cfunctions[cfunc->bound_by->imm.intval].nargs);
-    } else if (opflags & OP_HAS_VARIABLE_LENGTH_ARGLIST) {
-      assert(curr->op == CALL_JQ);
+    } else if (curr->op == CALL_JQ) {
       int nargs = curr->imm.intval;
       assert(nargs >= 0 && nargs < 100); //FIXME
       code[pos++] = (uint16_t)nargs;
@@ -623,15 +581,15 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
         assert(curr->bound_by->op == CLOSURE_CREATE);
         code[pos++] = curr->bound_by->imm.intval | ARG_NEWCLOSURE;
       }
-    } else if (opflags & OP_HAS_CONSTANT) {
+    } else if (op->flags & OP_HAS_CONSTANT) {
       code[pos++] = jv_array_length(jv_copy(constant_pool));
       constant_pool = jv_array_append(constant_pool, jv_copy(curr->imm.constant));
-    } else if (opflags & OP_HAS_VARIABLE) {
+    } else if (op->flags & OP_HAS_VARIABLE) {
       code[pos++] = nesting_level(bc, curr->bound_by);
       uint16_t var = (uint16_t)curr->bound_by->imm.intval;
       code[pos++] = var;
       if (var > maxvar) maxvar = var;
-    } else if (opflags & OP_HAS_BRANCH) {
+    } else if (op->flags & OP_HAS_BRANCH) {
       assert(curr->imm.target->bytecode_pos != -1);
       assert(curr->imm.target->bytecode_pos > pos); // only forward branches
       code[pos] = curr->imm.target->bytecode_pos - (pos + 1);
diff --git a/compile.h b/compile.h
index 9a885159..7ac634ba 100644
--- a/compile.h
+++ b/compile.h
@@ -21,12 +21,11 @@ block gen_location(location, block);
 
 block gen_noop();
 block gen_op_simple(opcode op);
-block gen_op_const(opcode op, jv constant);
+block gen_const(jv constant);
 block gen_op_target(opcode op, block target);
 block gen_op_var_unbound(opcode op, const char* name);
 block gen_op_var_bound(opcode op, block binder);
 block gen_op_block_unbound(opcode op, const char* name);
-block gen_op_symbol(opcode op, const char* name);
 
 block gen_function(const char* name, block body);
 block gen_lambda(block body);
diff --git a/forkable_stack.h b/forkable_stack.h
index 5bfad8a9..a94a1ec3 100644
--- a/forkable_stack.h
+++ b/forkable_stack.h
@@ -15,7 +15,6 @@ struct forkable_stack_header {
 
 struct forkable_stack {
   // Stack grows down from stk+length
-
   char* stk;
 
   // stk+length is just past end of allocated area
@@ -61,7 +60,6 @@ static void* forkable_stack_push(struct forkable_stack* s, size_t sz_size) {
   forkable_stack_check(s);
   int curr = s->pos < s->savedlimit ? s->pos : s->savedlimit;
   if (curr - size < 0) {
-    //assert(0);
     int oldlen = s->length;
     s->length = (size + oldlen + 1024) * 2;
     s->stk = realloc(s->stk, s->length);
diff --git a/opcode.c b/opcode.c
index c4c6356d..9b3e5ca3 100644
--- a/opcode.c
+++ b/opcode.c
@@ -5,12 +5,10 @@
 #define CONSTANT OP_HAS_CONSTANT, 2
 #define VARIABLE (OP_HAS_VARIABLE | OP_HAS_BINDING), 3
 #define BRANCH OP_HAS_BRANCH, 2
-#define CFUNC (OP_HAS_SYMBOL | OP_HAS_CFUNC), 3
-#define UFUNC (OP_HAS_UFUNC | OP_HAS_VARIABLE_LENGTH_ARGLIST), 2
+#define CFUNC OP_HAS_CFUNC, 3
+#define UFUNC OP_HAS_UFUNC, 2
 #define CALLSEQ_END_IMM (OP_IS_CALL_PSEUDO), 0
-#define CLOSURE_PARAM_IMM (OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 0
-#define CLOSURE_CREATE_IMM (OP_HAS_BLOCK | OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 0
-#define CLOSURE_CREATE_C_IMM (OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 0
+#define DEFINITION (OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 0
 #define CLOSURE_REF_IMM (OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 2
 
 #define OP(name, imm, in, out) \
diff --git a/opcode.h b/opcode.h
index 73948cd5..91624788 100644
--- a/opcode.h
+++ b/opcode.h
@@ -19,12 +19,9 @@ enum {
   OP_HAS_CONSTANT = 2,
   OP_HAS_VARIABLE = 4,
   OP_HAS_BRANCH = 8,
-  OP_HAS_SYMBOL = 16,
   OP_HAS_CFUNC = 32,
   OP_HAS_UFUNC = 64,
   OP_IS_CALL_PSEUDO = 128,
-  OP_HAS_VARIABLE_LENGTH_ARGLIST = 256,
-  OP_HAS_BLOCK = 512,
   OP_HAS_BINDING = 1024,
 };
 struct opcode_description {
diff --git a/opcode_list.h b/opcode_list.h
index 27211a2d..a39d30e0 100644
--- a/opcode_list.h
+++ b/opcode_list.h
@@ -5,7 +5,6 @@ OP(POP,   NONE,     1, 0)
 OP(LOADV, VARIABLE, 1, 1)
 OP(STOREV, VARIABLE, 1, 0)
 OP(INDEX, NONE,     2, 1)
-//OP(DISPLAY, NONE,   1, 0)
 OP(YIELD, NONE, 1, 0)
 OP(EACH,  NONE,     1, 1)
 OP(FORK,  BRANCH,   0, 0)
@@ -23,7 +22,7 @@ OP(CALL_JQ, UFUNC, 1, 1)
 OP(RET, NONE, 1, 1)
 
 OP(CALLSEQ_END, CALLSEQ_END_IMM, 0, 0)
-OP(CLOSURE_PARAM, CLOSURE_PARAM_IMM, 0, 0)
+OP(CLOSURE_PARAM, DEFINITION, 0, 0)
 OP(CLOSURE_REF, CLOSURE_REF_IMM, 0, 0)
-OP(CLOSURE_CREATE, CLOSURE_CREATE_IMM, 0, 0)
-OP(CLOSURE_CREATE_C, CLOSURE_CREATE_C_IMM, 0, 0)
+OP(CLOSURE_CREATE, DEFINITION, 0, 0)
+OP(CLOSURE_CREATE_C, DEFINITION, 0, 0)
diff --git a/parser.y b/parser.y
index bdee008b..cee3c9d6 100644
--- a/parser.y
+++ b/parser.y
@@ -297,11 +297,6 @@ Term {
   $$ = $1; 
 }
 
-String:
-QQSTRING_START QQString QQSTRING_END {
-  $$ = $2;
-}
-
 FuncDef:
 "def" IDENT ':' Exp ';' {
   $$ = gen_function(jv_string_value($2), $4);
@@ -315,12 +310,18 @@ FuncDef:
   jv_free($4);
 }
 
+
+String:
+QQSTRING_START QQString QQSTRING_END {
+  $$ = $2;
+}
+
 QQString:
 /* empty */ {
-  $$ = gen_op_const(LOADK, jv_string(""));
+  $$ = gen_const(jv_string(""));
 } |
 QQString QQSTRING_TEXT {
-  $$ = gen_binop($1, gen_op_const(LOADK, $2), '+');
+  $$ = gen_binop($1, gen_const($2), '+');
 } |
 QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END {
   $$ = gen_binop($1, gen_format($3), '+');
@@ -350,10 +351,10 @@ Term:
   $$ = gen_noop(); 
 } |
 Term '.' IDENT {
-  $$ = gen_index($1, gen_op_const(LOADK, $3)); 
+  $$ = gen_index($1, gen_const($3)); 
 } |
 '.' IDENT { 
-  $$ = gen_index(gen_noop(), gen_op_const(LOADK, $2)); 
+  $$ = gen_index(gen_noop(), gen_const($2)); 
 } |
 /* FIXME: string literals */
 Term '[' Exp ']' {
@@ -363,7 +364,7 @@ Term '[' ']' {
   $$ = block_join($1, gen_op_simple(EACH)); 
 } |
 LITERAL {
-  $$ = gen_op_const(LOADK, $1); 
+  $$ = gen_const($1); 
 } |
 String {
   $$ = $1;
@@ -375,10 +376,10 @@ String {
   $$ = gen_collect($2); 
 } |
 '[' ']' { 
-  $$ = gen_op_const(LOADK, jv_array()); 
+  $$ = gen_const(jv_array()); 
 } |
 '{' MkDict '}' { 
-  $$ = BLOCK(gen_subexp(gen_op_const(LOADK, jv_object())), $2, gen_op_simple(POP));
+  $$ = BLOCK(gen_subexp(gen_const(jv_object())), $2, gen_op_simple(POP));
 } |
 '$' IDENT {
   $$ = gen_location(@$, gen_op_var_unbound(LOADV, jv_string_value($2)));
@@ -408,14 +409,14 @@ MkDict:
 
 MkDictPair
 : IDENT ':' ExpD { 
-  $$ = gen_dictpair(gen_op_const(LOADK, $1), $3);
+  $$ = gen_dictpair(gen_const($1), $3);
  }
 | String ':' ExpD {
   $$ = gen_dictpair($1, $3);
   }
 | IDENT {
-  $$ = gen_dictpair(gen_op_const(LOADK, jv_copy($1)),
-                    gen_index(gen_noop(), gen_op_const(LOADK, $1)));
+  $$ = gen_dictpair(gen_const(jv_copy($1)),
+                    gen_index(gen_noop(), gen_const($1)));
   }
 | '(' Exp ')' ':' ExpD {
   $$ = gen_dictpair($2, $5);

From a88d53d2fda9a755c9c972a09a1206d54ca0d8b2 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 3 Dec 2012 20:31:40 +0000
Subject: [PATCH 165/284] Extend `{foo}` syntax to allow `{"foo"}` as well.

Useful when "foo" contains unusual characters. Should help with
the issues #7, #38, #40, #42.
---
 execute.c     | 11 +++++++++++
 opcode_list.h |  1 +
 parser.y      |  4 ++++
 testdata      |  4 ++++
 4 files changed, 20 insertions(+)

diff --git a/execute.c b/execute.c
index 8fadc7e7..8b8036a1 100644
--- a/execute.c
+++ b/execute.c
@@ -208,6 +208,17 @@ jv jq_next() {
       break;
     }
 
+    case DUP2: {
+      stackval keep = stack_pop();
+      stackval v = stack_pop();
+      stackval v2 = v;
+      v2.value = jv_copy(v.value);
+      stack_push(v);
+      stack_push(keep);
+      stack_push(v2);
+      break;
+    }
+
     case SWAP: {
       stackval a = stack_pop();
       stackval b = stack_pop();
diff --git a/opcode_list.h b/opcode_list.h
index a39d30e0..03cdbc8b 100644
--- a/opcode_list.h
+++ b/opcode_list.h
@@ -1,5 +1,6 @@
 OP(LOADK, CONSTANT, 1, 1)
 OP(DUP,   NONE,     1, 2)
+OP(DUP2,  NONE,     2, 3)
 OP(SWAP,  NONE,     2, 2)
 OP(POP,   NONE,     1, 0)
 OP(LOADV, VARIABLE, 1, 1)
diff --git a/parser.y b/parser.y
index cee3c9d6..e3d32e45 100644
--- a/parser.y
+++ b/parser.y
@@ -414,6 +414,10 @@ MkDictPair
 | String ':' ExpD {
   $$ = gen_dictpair($1, $3);
   }
+| String {
+  $$ = gen_dictpair($1, BLOCK(gen_op_simple(POP), gen_op_simple(DUP2),
+                              gen_op_simple(DUP2), gen_op_simple(INDEX)));
+  }
 | IDENT {
   $$ = gen_dictpair(gen_const(jv_copy($1)),
                     gen_index(gen_noop(), gen_const($1)));
diff --git a/testdata b/testdata
index cc8263b0..088d255d 100644
--- a/testdata
+++ b/testdata
@@ -64,6 +64,10 @@ null
 {"a":1, "b":2, "c":3, "d":"c"}
 {"a":1, "b":2, "c":1, "e":2}
 
+{"a",b,"a$\(1+1)"}
+{"a":1, "b":2, "c":3, "a$2":4}
+{"a":1, "b":2, "a$2":4}
+
 #
 # Field access, piping
 #

From 26bbed29f72742ddfb39b0684e78bc4d2780de51 Mon Sep 17 00:00:00 2001
From: Lee Thompson <thompson@dtosolutions.com>
Date: Mon, 3 Dec 2012 16:19:45 -0600
Subject: [PATCH 166/284] start work on getting RPM to work with tarball

---
 rpm/SPECS/jq.spec => jq.spec | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename rpm/SPECS/jq.spec => jq.spec (100%)

diff --git a/rpm/SPECS/jq.spec b/jq.spec
similarity index 100%
rename from rpm/SPECS/jq.spec
rename to jq.spec

From 00e4feba811034b374512c001d01a3e6f6991be8 Mon Sep 17 00:00:00 2001
From: Lee Thompson <thompson@dtosolutions.com>
Date: Mon, 3 Dec 2012 17:27:40 -0600
Subject: [PATCH 167/284] get rpm building from tarball with autoconf

---
 Makefile.am | 15 +++++++--------
 jq.spec     | 37 +++++++++++++++++++++++++------------
 2 files changed, 32 insertions(+), 20 deletions(-)

diff --git a/Makefile.am b/Makefile.am
index 18acb864..bdac3558 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -3,7 +3,7 @@
 # setup is only used by distribution developers, not package developers.
 # Still, as a matter of allowing patching, its not a bad idea to distribute 
 # the developer setup script in the tarball.
-EXTRA_DIST = setup.sh config.h.in ChangeLog VERSION lexer.l lexer.h gen_utf8_tables.py
+EXTRA_DIST = setup.sh config.h.in ChangeLog VERSION lexer.l lexer.h gen_utf8_tables.py jq.spec
 
 # README.md is expected in Github projects, good stuff in it, so we'll 
 # distribute it and install it with the package in the doc directory.
@@ -56,7 +56,7 @@ jv_utf8_tables.gen.h: gen_utf8_tables.py
 jv_unicode.c: jv_utf8_tables.gen.h
 
 ChangeLog:
-	git log --name-status > $@
+	git log --name-status > $@ || echo "no changelog" > $@
 
 main.c: config.h
 
@@ -67,12 +67,11 @@ releasetag:
 RELEASE ?= 1
 rpmbuild: jq
 	@echo "Packaging jq as an RPM ..."
-	mkdir -p rpm/SOURCES rpm/BUILD rpm/BUILDROOT rpm/RPMS
-	rm -rf jq-$$(cat VERSION)
-	mkdir -p jq-$$(cat VERSION)/bin
-	cp jq jq-$$(cat VERSION)/bin
-	tar -zcf rpm/SOURCES/jq-$$(cat VERSION).tgz jq-$$(cat VERSION)/bin/jq
-	rpmbuild --target $$(uname -m) --buildroot ${PWD}/rpm/BUILDROOT/jq-$$(cat VERSION)-${RELEASE}.noarch --define "_topdir ${PWD}/rpm" --define "version $$(cat VERSION)" --define "release ${RELEASE}" -bb --clean rpm/SPECS/jq.spec
+	mkdir -p rpm/SOURCES rpm/BUILD rpm/BUILDROOT rpm/RPMS rpm/SPECS
+	cp jq-$$(cat VERSION).tar.gz rpm/SOURCES/
+	rpmbuild -tb --define "_topdir ${PWD}/rpm" --define "_prefix ${HOME}" --define "version $$(cat VERSION)" --define "release ${RELEASE}" rpm/SOURCES/jq-$$(cat VERSION).tar.gz
+	mv rpm/RPMS/* ./
+	rm -rf rpm
 
 dist-clean-local:
 	rm -f $(BUILT_SOURCES)
diff --git a/jq.spec b/jq.spec
index 71b3e792..ca63aa93 100644
--- a/jq.spec
+++ b/jq.spec
@@ -1,11 +1,15 @@
+# This is spec file maintained by developers of JQ, not by a OS distro.
+# Your OS of choice will likely ignore this RPM spec file.
 Summary: Command-line JSON processor
 Name: jq
 Version: %{version}
 Release: %{release}
-Source0: jq-%{version}.tgz
+Source0: jq-%{version}.tar.gz
 URL: https://github.com/stedolan/jq
- 
-License: Copyright (C) 2012 Stephen Dolan
+License: BSD
+AutoReqProv: no
+BuildPrereq: autoconf, libtool, automake, flex, bison, python
+
 Group: Applications/System
 # Requires:
 
@@ -13,28 +17,37 @@ Group: Applications/System
 %global _enable_debug_package 0
 %global debug_package %{nil}
 %global __os_install_post %{nil}
- 
+
 %description
 jq is a command-line JSON processor
- 
+
 %prep
 
 %setup
 
 %build
- 
+echo "Building in: \"$(pwd)\""
+./configure --prefix=%{_prefix}
+make
+
 %install
-echo "Building in: \"%{buildroot}\""
-rm -rf %{buildroot}
-install -d -m 755 %{buildroot}/usr/bin
-mv %{_builddir}/jq-%{version}/bin/jq %{buildroot}/usr/bin
+echo "Installing to: \"${RPM_BUILD_ROOT}\""
+make install DESTDIR=${RPM_BUILD_ROOT}
 
 %clean
+rm -rf ${RPM_BUILD_ROOT}
 
 %files
 %defattr(-,root,root)
-/usr/bin/jq
- 
+%{_bindir}/jq
+%{_bindir}/jq_test
+%{_datadir}/doc/jq/AUTHORS
+%{_datadir}/doc/jq/COPYING
+%{_datadir}/doc/jq/INSTALL
+%{_datadir}/doc/jq/NEWS
+%{_datadir}/doc/jq/README
+%{_datadir}/doc/jq/README.md
+
 %changelog
 
 %pre

From 616e8f9924ad9df22acf58c79c5d49ef6030fcb8 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 4 Dec 2012 00:39:21 +0000
Subject: [PATCH 168/284] Refactor function argument passing into what it
 always should have been.

Most visible change is that error messages when a function is called
with the wrong number of arguments are much better.
---
 builtin.c     |   3 +-
 bytecode.c    |   6 +-
 compile.c     | 180 +++++++++++++++++++++++++-------------------------
 compile.h     |   2 +-
 opcode.c      |   5 +-
 opcode.h      |   4 --
 opcode_list.h |   1 -
 parser.y      |   7 +-
 8 files changed, 103 insertions(+), 105 deletions(-)

diff --git a/builtin.c b/builtin.c
index ef447935..2c5787da 100644
--- a/builtin.c
+++ b/builtin.c
@@ -285,7 +285,8 @@ static block bind_bytecoded_builtins(block b) {
   };
   block builtins = gen_noop();
   for (unsigned i=0; i<sizeof(builtin_defs)/sizeof(builtin_defs[0]); i++) {
-    builtins = BLOCK(builtins, gen_function(builtin_defs[i].name, builtin_defs[i].code));
+    builtins = BLOCK(builtins, gen_function(builtin_defs[i].name, gen_noop(),
+                                            builtin_defs[i].code));
   }
   return block_bind(builtins, b, OP_IS_CALL_PSEUDO);
 }
diff --git a/bytecode.c b/bytecode.c
index 26f8d36d..e66bffbb 100644
--- a/bytecode.c
+++ b/bytecode.c
@@ -6,11 +6,11 @@
 #include "opcode.h"
 
 static int bytecode_operation_length(uint16_t* codeptr) {
+  int length = opcode_describe(*codeptr)->length;
   if (*codeptr == CALL_JQ) {
-    return 4 + codeptr[1] * 2;
-  } else {
-    return opcode_length(*codeptr);
+    length += codeptr[1] * 2;
   }
+  return length;
 }
 
 void dump_disassembly(int indent, struct bytecode* bc) {
diff --git a/compile.c b/compile.c
index 8a493b45..eb0fe78d 100644
--- a/compile.c
+++ b/compile.c
@@ -12,7 +12,7 @@ struct inst {
 
   opcode op;
   
-  union {
+  struct {
     uint16_t intval;
     struct inst* target;
     jv constant;
@@ -222,33 +222,38 @@ static void block_bind_subblock(block binder, block body, int bindflags) {
   }
 }
 
-block block_bind(block binder, block body, int bindflags) {
+static void block_bind_each(block binder, block body, int bindflags) {
   assert(block_has_only_binders(binder, bindflags));
   bindflags |= OP_HAS_BINDING;
   for (inst* curr = binder.first; curr; curr = curr->next) {
     block_bind_subblock(inst_block(curr), body, bindflags);
   }
+}
+
+block block_bind(block binder, block body, int bindflags) {
+  block_bind_each(binder, body, bindflags);
   return block_join(binder, body);
 }
 
-
-block gen_function(const char* name, block body) {
+block gen_function(const char* name, block formals, block body) {
+  block_bind_each(formals, body, OP_IS_CALL_PSEUDO);
   inst* i = inst_new(CLOSURE_CREATE);
   i->subfn = body;
   i->symbol = strdup(name);
+  i->arglist = formals;
   block b = inst_block(i);
   block_bind_subblock(b, b, OP_IS_CALL_PSEUDO | OP_HAS_BINDING);
   return b;
 }
 
 block gen_lambda(block body) {
-  return gen_function("@lambda", body);
+  return gen_function("@lambda", gen_noop(), body);
 }
 
 block gen_call(const char* name, block args) {
-  inst* i = inst_new(CALL_JQ);
-  i->arglist = BLOCK(gen_op_block_unbound(CLOSURE_REF, name), args);
-  return BLOCK(inst_block(i), inst_block(inst_new(CALLSEQ_END)));
+  block b = gen_op_block_unbound(CALL_JQ, name);
+  b.first->arglist = args;
+  return b;
 }
 
 
@@ -397,28 +402,30 @@ static int count_cfunctions(block b) {
 
 
 // Expands call instructions into a calling sequence
-// Checking for argument count compatibility happens later
-static block expand_call_arglist(block b) {
+static int expand_call_arglist(struct locfile* locations, block* b) {
+  int errors = 0;
   block ret = gen_noop();
-  for (inst* curr; (curr = block_take(&b));) {
-    if (curr->op == CALL_JQ) {
-      inst* seq_end = block_take(&b);
-      assert(seq_end && seq_end->op == CALLSEQ_END);
-      // We expand the argument list as a series of instructions
-      block arglist = curr->arglist;
-      curr->arglist = gen_noop();
-      assert(arglist.first && "zeroth argument (function to call) must be present");
-      inst* function = arglist.first->bound_by;
-      assert(function); // FIXME better errors
+  for (inst* curr; (curr = block_take(b));) {
+    if (opcode_describe(curr->op)->flags & OP_HAS_BINDING) {
+      if (!curr->bound_by) {
+        locfile_locate(locations, curr->source, "error: %s is not defined", curr->symbol);
+        errors++;
+        // don't process this instruction if it's not well-defined
+        ret = BLOCK(ret, inst_block(curr));
+        continue;
+      }
+    }
 
-      switch (function->op) {
-      default: assert(0 && "Unknown parameter type"); break;
+    block prelude = gen_noop();
+    if (curr->op == CALL_JQ) {
+      int actual_args = 0, desired_args = 0;
+      // We expand the argument list as a series of instructions
+      switch (curr->bound_by->op) {
+      default: assert(0 && "Unknown function type"); break;
       case CLOSURE_CREATE: 
       case CLOSURE_PARAM: {
-        block prelude = gen_noop();
         block callargs = gen_noop();
-        int nargs = 0;
-        for (inst* i; (i = block_take(&arglist));) {
+        for (inst* i; (i = block_take(&curr->arglist));) {
           assert(opcode_describe(i->op)->flags & OP_IS_CALL_PSEUDO);
           block b = inst_block(i);
           switch (i->op) {
@@ -431,44 +438,54 @@ static block expand_call_arglist(block b) {
             block_append(&callargs, gen_op_block_bound(CLOSURE_REF, b));
             break;
           }
-          nargs++;
+          actual_args++;
         }
+        curr->imm.intval = actual_args;
+        curr->arglist = callargs;
 
-        assert(!arglist.first);
-        assert(nargs > 0);
-        curr->imm.intval = nargs - 1;
-        ret = BLOCK(ret, prelude, inst_block(curr), callargs, inst_block(seq_end));
+        if (curr->bound_by->op == CLOSURE_CREATE) {
+          for (inst* i = curr->bound_by->arglist.first; i; i = i->next) {
+            assert(i->op == CLOSURE_PARAM);
+            desired_args++;
+          }
+        }
         break;
       }
 
       case CLOSURE_CREATE_C: {
-        // Arguments to C functions not yet supported
-        inst* cfunction_ref = block_take(&arglist);
-        block prelude = gen_noop();
-        int nargs = 1;
-        for (inst* i; (i = block_take(&arglist)); ) {
+        for (inst* i; (i = block_take(&curr->arglist)); ) {
           assert(i->op == CLOSURE_CREATE); // FIXME
           block body = i->subfn;
           i->subfn = gen_noop();
           inst_free(i);
           // arguments should be pushed in reverse order, prepend them to prelude
-          prelude = BLOCK(gen_subexp(expand_call_arglist(body)), prelude);
-          nargs++;
+          errors += expand_call_arglist(locations, &body);
+          prelude = BLOCK(gen_subexp(body), prelude);
+          actual_args++;
         }
         assert(curr->op == CALL_JQ);
         curr->op = CALL_BUILTIN;
-        curr->imm.intval = nargs;
+        curr->imm.intval = actual_args + 1 /* include the implicit input in arg count */;
+        assert(curr->bound_by->op == CLOSURE_CREATE_C);
+        desired_args = curr->bound_by->imm.cfunc->nargs - 1;
         assert(!curr->arglist.first);
-        curr->arglist = inst_block(cfunction_ref);
-        ret = BLOCK(ret, prelude, inst_block(curr), inst_block(seq_end));
         break;
       }
       }
-    } else {
-      ret = BLOCK(ret, inst_block(curr));
+
+      if (actual_args != desired_args) {
+        locfile_locate(locations, curr->source, 
+                       "error: %s arguments to %s (expected %d but got %d)",
+                       actual_args > desired_args ? "too many" : "too few",
+                       curr->symbol, desired_args, actual_args);
+        errors++;
+      }
+
     }
+    ret = BLOCK(ret, prelude, inst_block(curr));
   }
-  return ret;
+  *b = ret;
+  return errors;
 }
 
 static int compile(struct locfile* locations, struct bytecode* bc, block b) {
@@ -476,8 +493,7 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
   int pos = 0;
   int var_frame_idx = 0;
   bc->nsubfunctions = 0;
-  bc->nclosures = 0;
-  b = expand_call_arglist(b);
+  errors += expand_call_arglist(locations, &b);
   if (bc->parent) {
     // functions should end in a return
     b = BLOCK(b, gen_op_simple(RET));
@@ -487,18 +503,19 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
   }
   for (inst* curr = b.first; curr; curr = curr->next) {
     if (!curr->next) assert(curr == b.last);
-    pos += opcode_length(curr->op);
+    int length = opcode_describe(curr->op)->length;
+    if (curr->op == CALL_JQ) {
+      for (inst* arg = curr->arglist.first; arg; arg = arg->next) {
+        length += 2;
+      }
+    }
+    pos += length;
     curr->bytecode_pos = pos;
     curr->compiled = bc;
 
-    int opflags = opcode_describe(curr->op)->flags;
-    if (opflags & OP_HAS_BINDING) {
-      if (!curr->bound_by) {
-        locfile_locate(locations, curr->source, "error: %s is not defined", curr->symbol);
-        errors++;
-      }
-    }
-    if ((opflags & OP_HAS_VARIABLE) &&
+    assert(curr->op != CLOSURE_REF && curr->op != CLOSURE_PARAM);
+
+    if ((opcode_describe(curr->op)->flags & OP_HAS_VARIABLE) &&
         curr->bound_by == curr) {
       curr->imm.intval = var_frame_idx++;
     }
@@ -507,10 +524,6 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
       assert(curr->bound_by == curr);
       curr->imm.intval = bc->nsubfunctions++;
     }
-    if (curr->op == CLOSURE_PARAM) {
-      assert(curr->bound_by == curr);
-      curr->imm.intval = bc->nclosures++;
-    }
     if (curr->op == CLOSURE_CREATE_C) {
       assert(curr->bound_by == curr);
       int idx = bc->globals->ncfunctions++;
@@ -526,6 +539,13 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
         bc->subfunctions[curr->imm.intval] = subfn;
         subfn->globals = bc->globals;
         subfn->parent = bc;
+        subfn->nclosures = 0;
+        for (inst* param = curr->arglist.first; param; param = param->next) {
+          assert(param->op == CLOSURE_PARAM);
+          assert(param->bound_by == param);
+          param->imm.intval = subfn->nclosures++;
+          param->compiled = subfn;
+        }
         errors += compile(locations, subfn, curr->subfn);
         curr->subfn = gen_noop();
       }
@@ -544,42 +564,23 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
     if (op->length == 0)
       continue;
     code[pos++] = curr->op;
-    assert(!(op->flags & OP_IS_CALL_PSEUDO));
+    assert(curr->op != CLOSURE_REF && curr->op != CLOSURE_PARAM);
     if (curr->op == CALL_BUILTIN) {
-      int nargs = curr->imm.intval;
-      code[pos++] = (uint16_t)nargs;
-      assert(block_is_single(curr->arglist));
-      inst* cfunc = curr->arglist.first;
-      assert(cfunc && cfunc->bound_by->op == CLOSURE_CREATE_C);
-      code[pos++] = cfunc->bound_by->imm.intval;
-      // FIXME arg errors
-      assert(nargs == bc->globals->cfunctions[cfunc->bound_by->imm.intval].nargs);
+      assert(curr->bound_by->op == CLOSURE_CREATE_C);
+      assert(!curr->arglist.first);
+      code[pos++] = (uint16_t)curr->imm.intval;
+      code[pos++] = curr->bound_by->imm.intval;
     } else if (curr->op == CALL_JQ) {
-      int nargs = curr->imm.intval;
-      assert(nargs >= 0 && nargs < 100); //FIXME
-      code[pos++] = (uint16_t)nargs;
-      curr = curr->next;
-      assert(curr && opcode_describe(curr->op)->flags & OP_IS_CALL_PSEUDO);
       assert(curr->bound_by->op == CLOSURE_CREATE ||
              curr->bound_by->op == CLOSURE_PARAM);
+      code[pos++] = (uint16_t)curr->imm.intval;
       code[pos++] = nesting_level(bc, curr->bound_by);
-      if (curr->bound_by->op == CLOSURE_CREATE) {
-        code[pos++] = curr->bound_by->imm.intval | ARG_NEWCLOSURE;
-        inst* i = curr->bound_by;
-        // FIXME arg errors
-        assert(nargs == i->compiled->subfunctions[i->imm.intval]->nclosures);
-      } else {
-        code[pos++] = curr->bound_by->imm.intval;
-        // FIXME arg errors
-        assert(nargs == 0);
-      }
-      for (int i=0; i<nargs; i++) {
-        curr = curr->next;
-        assert(curr && opcode_describe(curr->op)->flags & OP_IS_CALL_PSEUDO);
-        assert(curr->op == CLOSURE_REF);
-        code[pos++] = nesting_level(bc, curr->bound_by);
-        assert(curr->bound_by->op == CLOSURE_CREATE);
-        code[pos++] = curr->bound_by->imm.intval | ARG_NEWCLOSURE;
+      code[pos++] = curr->bound_by->imm.intval | 
+        (curr->bound_by->op == CLOSURE_CREATE ? ARG_NEWCLOSURE : 0);
+      for (inst* arg = curr->arglist.first; arg; arg = arg->next) {
+        assert(arg->op == CLOSURE_REF && arg->bound_by->op == CLOSURE_CREATE);
+        code[pos++] = nesting_level(bc, arg->bound_by);
+        code[pos++] = arg->bound_by->imm.intval | ARG_NEWCLOSURE;
       }
     } else if (op->flags & OP_HAS_CONSTANT) {
       code[pos++] = jv_array_length(jv_copy(constant_pool));
@@ -607,6 +608,7 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
 int block_compile(block b, struct locfile* locations, struct bytecode** out) {
   struct bytecode* bc = malloc(sizeof(struct bytecode));
   bc->parent = 0;
+  bc->nclosures = 0;
   bc->globals = malloc(sizeof(struct symbol_table));
   int ncfunc = count_cfunctions(b);
   bc->globals->ncfunctions = 0;
diff --git a/compile.h b/compile.h
index 7ac634ba..e74afce4 100644
--- a/compile.h
+++ b/compile.h
@@ -27,7 +27,7 @@ block gen_op_var_unbound(opcode op, const char* name);
 block gen_op_var_bound(opcode op, block binder);
 block gen_op_block_unbound(opcode op, const char* name);
 
-block gen_function(const char* name, block body);
+block gen_function(const char* name, block formals, block body);
 block gen_lambda(block body);
 block gen_call(const char* name, block body);
 block gen_subexp(block a);
diff --git a/opcode.c b/opcode.c
index 9b3e5ca3..4e785b8f 100644
--- a/opcode.c
+++ b/opcode.c
@@ -5,9 +5,8 @@
 #define CONSTANT OP_HAS_CONSTANT, 2
 #define VARIABLE (OP_HAS_VARIABLE | OP_HAS_BINDING), 3
 #define BRANCH OP_HAS_BRANCH, 2
-#define CFUNC OP_HAS_CFUNC, 3
-#define UFUNC OP_HAS_UFUNC, 2
-#define CALLSEQ_END_IMM (OP_IS_CALL_PSEUDO), 0
+#define CFUNC (OP_HAS_CFUNC | OP_HAS_BINDING), 3
+#define UFUNC (OP_HAS_UFUNC | OP_HAS_BINDING | OP_IS_CALL_PSEUDO), 4
 #define DEFINITION (OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 0
 #define CLOSURE_REF_IMM (OP_IS_CALL_PSEUDO | OP_HAS_BINDING), 2
 
diff --git a/opcode.h b/opcode.h
index 91624788..ee956e27 100644
--- a/opcode.h
+++ b/opcode.h
@@ -38,8 +38,4 @@ struct opcode_description {
 
 const struct opcode_description* opcode_describe(opcode op);
 
-static inline int opcode_length(opcode op) {
-  return opcode_describe(op)->length;
-}
-
 #endif
diff --git a/opcode_list.h b/opcode_list.h
index 03cdbc8b..e6dece6e 100644
--- a/opcode_list.h
+++ b/opcode_list.h
@@ -22,7 +22,6 @@ OP(CALL_BUILTIN, CFUNC, -1, 1)
 OP(CALL_JQ, UFUNC, 1, 1)
 OP(RET, NONE, 1, 1)
 
-OP(CALLSEQ_END, CALLSEQ_END_IMM, 0, 0)
 OP(CLOSURE_PARAM, DEFINITION, 0, 0)
 OP(CLOSURE_REF, CLOSURE_REF_IMM, 0, 0)
 OP(CLOSURE_CREATE, DEFINITION, 0, 0)
diff --git a/parser.y b/parser.y
index e3d32e45..f77d6d92 100644
--- a/parser.y
+++ b/parser.y
@@ -299,13 +299,14 @@ Term {
 
 FuncDef:
 "def" IDENT ':' Exp ';' {
-  $$ = gen_function(jv_string_value($2), $4);
+  $$ = gen_function(jv_string_value($2), gen_noop(), $4);
   jv_free($2);
 } |
 
 "def" IDENT '(' IDENT ')' ':' Exp ';' {
-  block body = block_bind(gen_op_block_unbound(CLOSURE_PARAM, jv_string_value($4)), $7, OP_IS_CALL_PSEUDO);
-  $$ = gen_function(jv_string_value($2), body);
+  $$ = gen_function(jv_string_value($2), 
+                    gen_op_block_unbound(CLOSURE_PARAM, jv_string_value($4)), 
+                    $7);
   jv_free($2);
   jv_free($4);
 }

From 277249ffe6f1e9b70c9877d938209012e34d9726 Mon Sep 17 00:00:00 2001
From: Lee Thompson <thompson@dtosolutions.com>
Date: Tue, 4 Dec 2012 14:49:39 -0600
Subject: [PATCH 169/284] change rpmbuild target to rpm

---
 Makefile.am | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile.am b/Makefile.am
index bdac3558..c05f55e5 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -65,7 +65,7 @@ releasetag:
 
 # can probably delete and have RPM created off autoconf generated tarball releases
 RELEASE ?= 1
-rpmbuild: jq
+rpm: jq jq_test
 	@echo "Packaging jq as an RPM ..."
 	mkdir -p rpm/SOURCES rpm/BUILD rpm/BUILDROOT rpm/RPMS rpm/SPECS
 	cp jq-$$(cat VERSION).tar.gz rpm/SOURCES/

From 76c87061455af3d8d7d0506b153c140d7ee7b62d Mon Sep 17 00:00:00 2001
From: Lee Thompson <thompson@dtosolutions.com>
Date: Tue, 4 Dec 2012 16:29:01 -0600
Subject: [PATCH 170/284] fix rpm mv command when rpm stashes the package in a
 subdirectory

---
 Makefile.am | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile.am b/Makefile.am
index c05f55e5..63fc5eab 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -70,7 +70,7 @@ rpm: jq jq_test
 	mkdir -p rpm/SOURCES rpm/BUILD rpm/BUILDROOT rpm/RPMS rpm/SPECS
 	cp jq-$$(cat VERSION).tar.gz rpm/SOURCES/
 	rpmbuild -tb --define "_topdir ${PWD}/rpm" --define "_prefix ${HOME}" --define "version $$(cat VERSION)" --define "release ${RELEASE}" rpm/SOURCES/jq-$$(cat VERSION).tar.gz
-	mv rpm/RPMS/* ./
+	find rpm/RPMS/ -name "*.rpm" -exec mv {} ./ \;
 	rm -rf rpm
 
 dist-clean-local:

From c0a2f1ab470595d85fd20a643325a16737433a2a Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 4 Dec 2012 22:45:03 +0000
Subject: [PATCH 171/284] Add min, max, min_by, max_by functions.

---
 builtin.c                        | 59 +++++++++++++++++++++++++++++++-
 docs/content/3.manual/manual.yml | 16 +++++++++
 testdata                         |  8 +++++
 3 files changed, 82 insertions(+), 1 deletion(-)

diff --git a/builtin.c b/builtin.c
index 2c5787da..b572dfaf 100644
--- a/builtin.c
+++ b/builtin.c
@@ -241,6 +241,56 @@ static jv f_group_by_impl(jv input, jv keys) {
   }
 }
 
+static jv minmax_by(jv values, jv keys, int is_min) {
+  if (jv_get_kind(values) != JV_KIND_ARRAY)
+    return type_error2(values, keys, "cannot be iterated over");
+  if (jv_get_kind(keys) != JV_KIND_ARRAY)
+    return type_error2(values, keys, "cannot be iterated over");
+  if (jv_array_length(jv_copy(values)) != jv_array_length(jv_copy(keys)))
+    return type_error2(values, keys, "have wrong length");
+
+  if (jv_array_length(jv_copy(values)) == 0) {
+    jv_free(values);
+    jv_free(keys);
+    return jv_null();
+  }
+  jv ret = jv_array_get(jv_copy(values), 0);
+  jv retkey = jv_array_get(jv_copy(keys), 0);
+  for (int i=1; i<jv_array_length(jv_copy(values)); i++) {
+    jv item = jv_array_get(jv_copy(keys), i);
+    int cmp = jv_cmp(jv_copy(item), jv_copy(retkey));
+    if ((cmp < 0) == (is_min == 1)) {
+      jv_free(retkey);
+      retkey = item;
+      jv_free(ret);
+      ret = jv_array_get(jv_copy(values), i);
+    } else {
+      jv_free(item);
+    }
+  }
+  jv_free(values);
+  jv_free(keys);
+  jv_free(retkey);
+  return ret;
+}
+
+static jv f_min(jv x) {
+  return minmax_by(x, jv_copy(x), 1);
+}
+
+static jv f_max(jv x) {
+  return minmax_by(x, jv_copy(x), 0);
+}
+
+static jv f_min_by_impl(jv x, jv y) {
+  return minmax_by(x, y, 1);
+}
+
+static jv f_max_by_impl(jv x, jv y) {
+  return minmax_by(x, y, 0);
+}
+
+
 static jv f_type(jv input) {
   jv out = jv_string(jv_kind_name(jv_get_kind(input)));
   jv_free(input);
@@ -268,9 +318,14 @@ static struct cfunction function_list[] = {
   {(cfunction_ptr)f_sort, "sort", 1},
   {(cfunction_ptr)f_sort_by_impl, "_sort_by_impl", 2},
   {(cfunction_ptr)f_group_by_impl, "_group_by_impl", 2},
+  {(cfunction_ptr)f_min, "min", 1},
+  {(cfunction_ptr)f_max, "max", 1},
+  {(cfunction_ptr)f_min_by_impl, "_min_by_impl", 2},
+  {(cfunction_ptr)f_max_by_impl, "_max_by_impl", 2},
 };
 
-static struct symbol_table cbuiltins = {function_list, sizeof(function_list)/sizeof(function_list[0])};
+static struct symbol_table cbuiltins = 
+  {function_list, sizeof(function_list)/sizeof(function_list[0])};
 
 typedef block (*bytecoded_builtin)();
 struct bytecoded_builtin { const char* name; block code; };
@@ -297,6 +352,8 @@ static const char* jq_builtins[] = {
   "def sort_by(f): _sort_by_impl(map([f]));",
   "def group_by(f): _group_by_impl(map([f]));",
   "def unique: group_by(.) | map(.[0]);",
+  "def max_by(f): _max_by_impl(map([f]));",
+  "def min_by(f): _min_by_impl(map([f]));",
 };
 
 
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 2e616e14..15dcb489 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -542,6 +542,22 @@ sections:
             input: '[{"foo":1, "bar":10}, {"foo":3, "bar":100}, {"foo":1, "bar":1}]'
             output: ['[[{"foo":1, "bar":10}, {"foo":1, "bar":1}], [{"foo":3, "bar":100}]]']
 
+      - title: `min`, `max`, `min_by`, `max_by`
+        body: |
+          
+          Find the minimum or maximum element of the input array. The
+          `_by` versions allow you to specify a particular field or
+          property to examine, e.g. `min_by(.foo)` finds the object
+          with the smallest `foo` field.
+
+        examples:
+          - program: 'min'
+            input: '[5,4,2,7]'
+            output: ['2']
+          - program: 'max_by(.foo)'
+            input: '[{"foo":1, "bar":14}, {"foo":2, "bar":3}]'
+            output: ['{"foo":2, "bar":3}']
+
       - title: `unique`
         body: |
           
diff --git a/testdata b/testdata
index 088d255d..a3e2e49b 100644
--- a/testdata
+++ b/testdata
@@ -456,3 +456,11 @@ sort
 unique
 [1,2,5,3,5,3,1,3]
 [1,2,3,5]
+
+[min, max, min_by(.[1]), max_by(.[1]), min_by(.[2]), max_by(.[2])]
+[[4,2,"a"],[3,1,"a"],[2,4,"a"],[1,3,"a"]]
+[[1,3,"a"],[4,2,"a"],[3,1,"a"],[2,4,"a"],[4,2,"a"],[1,3,"a"]]
+
+[min,max,min_by(.),max_by(.)]
+[]
+[null,null,null,null]

From 99353d8c84bfdfcac20f92b8d3c27f27affc1592 Mon Sep 17 00:00:00 2001
From: Lee Thompson <thompson@dtosolutions.com>
Date: Tue, 4 Dec 2012 16:50:11 -0600
Subject: [PATCH 172/284] remove obsolete line

---
 Makefile.am | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Makefile.am b/Makefile.am
index 63fc5eab..1ebd6d5d 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -32,7 +32,6 @@ jq_CPPFLAGS = -O $(DEVCFLAGS) -DJQ_DEBUG=0
 
 TESTS = jq_test
 jq_test_SOURCES = $(JQ_SRC) jq_test.c
-dist_jq_test_SOURCES = $(DIST_JQ_SRC)
 jq_test_CPPFLAGS = $(DEVCFLAGS) -DJQ_DEBUG=1
 LOG_COMPILER = valgrind
 AM_LOG_FLAGS = --error-exitcode=1 -q --leak-check=full

From dfa9e61aeb7635fb0b6f7ca29ac3bd0c59363c4c Mon Sep 17 00:00:00 2001
From: Lee Thompson <thompson@dtosolutions.com>
Date: Tue, 4 Dec 2012 18:12:53 -0600
Subject: [PATCH 173/284] fixes jq_test core dump

---
 Makefile.am | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/Makefile.am b/Makefile.am
index 1ebd6d5d..2b0abeb7 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -16,7 +16,6 @@ JQ_SRC = opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_pr
 
 if DEVCFLAGS_ENABLED
 DEVCFLAGS = -Wextra -Wall -Wno-missing-field-initializers -Wno-unused-parameter -std=gnu99 -ggdb -Wno-unused-function
-AM_CPPFLAGS = $(DEVCFLAGS)
 endif
 
 # Tell YACC (bison) autoconf macros that you want a header file created.
@@ -27,12 +26,14 @@ AM_YFLAGS = --warnings=all -d
 bin_PROGRAMS = jq jq_test
 BUILT_SOURCES = jv_utf8_tables.gen.h lexer.h lexer.c
 jq_SOURCES = $(JQ_SRC) main.c
-jq_CPPFLAGS = -O $(DEVCFLAGS) -DJQ_DEBUG=0
+jq_CPPFLAGS = $(DEVCFLAGS) -O -DJQ_DEBUG=0
+jq_CFLAGS = $(DEVCFLAGS) -O -DJQ_DEBUG=0
 
 
 TESTS = jq_test
 jq_test_SOURCES = $(JQ_SRC) jq_test.c
 jq_test_CPPFLAGS = $(DEVCFLAGS) -DJQ_DEBUG=1
+jq_test_CFLAGS = $(DEVCFLAGS) -DJQ_DEBUG=1
 LOG_COMPILER = valgrind
 AM_LOG_FLAGS = --error-exitcode=1 -q --leak-check=full
 

From ca862a594cef170c493f60199ca2775c07962fbf Mon Sep 17 00:00:00 2001
From: Lee Thompson <thompson@dtosolutions.com>
Date: Tue, 4 Dec 2012 19:00:59 -0600
Subject: [PATCH 174/284] kill prereq on RPM spec file

---
 jq.spec | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/jq.spec b/jq.spec
index ca63aa93..ea7fe98a 100644
--- a/jq.spec
+++ b/jq.spec
@@ -8,7 +8,7 @@ Source0: jq-%{version}.tar.gz
 URL: https://github.com/stedolan/jq
 License: BSD
 AutoReqProv: no
-BuildPrereq: autoconf, libtool, automake, flex, bison, python
+#BuildPrereq: autoconf, libtool, automake, flex, bison, python
 
 Group: Applications/System
 # Requires:

From a156fb19de017c6d101b0e4cebbe3ea6819e7d40 Mon Sep 17 00:00:00 2001
From: Lee Thompson <thompson@dtosolutions.com>
Date: Tue, 4 Dec 2012 19:50:10 -0600
Subject: [PATCH 175/284] get testing working in autoconf

---
 Makefile.am |  4 +---
 README      |  5 +++++
 jq_test.c   | 13 ++++++++++++-
 setup.sh    |  2 +-
 4 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/Makefile.am b/Makefile.am
index 2b0abeb7..06d9c55a 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -3,7 +3,7 @@
 # setup is only used by distribution developers, not package developers.
 # Still, as a matter of allowing patching, its not a bad idea to distribute 
 # the developer setup script in the tarball.
-EXTRA_DIST = setup.sh config.h.in ChangeLog VERSION lexer.l lexer.h gen_utf8_tables.py jq.spec
+EXTRA_DIST = setup.sh config.h.in ChangeLog VERSION lexer.l lexer.h gen_utf8_tables.py jq.spec testdata
 
 # README.md is expected in Github projects, good stuff in it, so we'll 
 # distribute it and install it with the package in the doc directory.
@@ -27,13 +27,11 @@ bin_PROGRAMS = jq jq_test
 BUILT_SOURCES = jv_utf8_tables.gen.h lexer.h lexer.c
 jq_SOURCES = $(JQ_SRC) main.c
 jq_CPPFLAGS = $(DEVCFLAGS) -O -DJQ_DEBUG=0
-jq_CFLAGS = $(DEVCFLAGS) -O -DJQ_DEBUG=0
 
 
 TESTS = jq_test
 jq_test_SOURCES = $(JQ_SRC) jq_test.c
 jq_test_CPPFLAGS = $(DEVCFLAGS) -DJQ_DEBUG=1
-jq_test_CFLAGS = $(DEVCFLAGS) -DJQ_DEBUG=1
 LOG_COMPILER = valgrind
 AM_LOG_FLAGS = --error-exitcode=1 -q --leak-check=full
 
diff --git a/README b/README
index c6933dae..d84e95ee 100644
--- a/README
+++ b/README
@@ -3,3 +3,8 @@ README file is not used, README.md is the file to READ!
 
 When you checkout the file, run "setup.sh" which gets autoconf initialized.
 Then follow the instructions in INSTALL.  Real standard stuff...
+
+
+   $ ./setup.sh             # initializes Autoconf and builds your release
+   $ ./setup.sh clean       # cleans all the temp files out of your tree
+   $ ./setup.sh superclean  # deletes your release files so you can try again
diff --git a/jq_test.c b/jq_test.c
index b4674c81..dd41a2f9 100644
--- a/jq_test.c
+++ b/jq_test.c
@@ -24,10 +24,21 @@ static int skipline(const char* buf) {
 }
 
 static void run_jq_tests() {
-  FILE* testdata = fopen("testdata","r");
+  FILE* testdata = NULL;
   char buf[4096];
   int tests = 0, passed = 0;
 
+  testdata = fopen("testdata","r");
+  if ( NULL == testdata )
+  {
+    /* in an autoconf distcheck, the binary file will be in a _build subdirectory */
+    testdata = fopen("../testdata", "r");
+    if ( NULL == testdata )
+    {
+      fprintf(stderr, "Could not find testdata file\n");
+      exit(1);
+    }
+  }
   while (1) {
     if (!fgets(buf, sizeof(buf), testdata)) break;
     if (skipline(buf)) continue;
diff --git a/setup.sh b/setup.sh
index bb3c26ce..cf360e7d 100755
--- a/setup.sh
+++ b/setup.sh
@@ -13,7 +13,7 @@ elif [ "superclean" == "$1" ]; then
       chmod -R u+w jq-${ver}
       rm -rf jq-${ver}
     fi
-    rm -f jq-${ver}.*
+    rm -f jq-${ver}*
   fi
 else
   autoreconf --install

From 84026f051347a6c6668e70d120905beee0192535 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Fri, 7 Dec 2012 00:26:00 +0000
Subject: [PATCH 176/284] Change order of evaluation for certain indexing
 operations.

'.foo[.bar]' used to parse like '.foo | .bar as $b | .[$b]',
now it parses like '.bar as $b | .foo | .[$b]'.
---
 parser.y | 2 +-
 testdata | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/parser.y b/parser.y
index f77d6d92..a2c765cd 100644
--- a/parser.y
+++ b/parser.y
@@ -133,7 +133,7 @@ static block gen_dictpair(block k, block v) {
 }
 
 static block gen_index(block obj, block key) {
-  return BLOCK(obj, gen_subexp(key), gen_op_simple(INDEX));
+  return BLOCK(gen_subexp(key), obj, gen_op_simple(INDEX));
 }
 
 static block gen_binop(block a, block b, int op) {
diff --git a/testdata b/testdata
index a3e2e49b..00ecc69f 100644
--- a/testdata
+++ b/testdata
@@ -464,3 +464,7 @@ unique
 [min,max,min_by(.),max_by(.)]
 []
 [null,null,null,null]
+
+.foo[.baz]
+{"foo":{"bar":4},"baz":"bar"}
+4

From c15e51ffb1312b3407fac1f6fd991a8f69cf96ce Mon Sep 17 00:00:00 2001
From: Stephen Shaw <stesh@netsoc.tcd.ie>
Date: Fri, 7 Dec 2012 14:31:59 +0000
Subject: [PATCH 177/284] Add information about installing dev environment on
 OS X

---
 docs/content/2.download/default.yml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/docs/content/2.download/default.yml b/docs/content/2.download/default.yml
index 7834ce72..5acf6bb4 100644
--- a/docs/content/2.download/default.yml
+++ b/docs/content/2.download/default.yml
@@ -58,6 +58,12 @@ body:
       likely already installed. I have no idea how to get these
       installed on OS X, you're on your own there.
 
+      On OS X, these are all included in Apple's command line tools, which
+      can be installed from [Xcode](developer.apple.com/technologies/tools/).
+      However, you may find that you need a newer version of Bison than the one provided
+      by Apple. This can be found in [Homebrew](http://mxcl.github.com/homebrew/)
+      or [MacPorts](http://macports.org/).
+
       `flex` and `bison` are used to generate the lexer and parser for
       jq, and some python scripts generate the UTF8 encoding tables
       needed for JSON parsing.

From 1db51e66bc36a7a4f4422be4549162522ec6fa82 Mon Sep 17 00:00:00 2001
From: Stephen Shaw <stesh@netsoc.tcd.ie>
Date: Fri, 7 Dec 2012 14:40:20 +0000
Subject: [PATCH 178/284] Remove old OS X 'instructions'

---
 docs/content/2.download/default.yml | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/docs/content/2.download/default.yml b/docs/content/2.download/default.yml
index 5acf6bb4..833cac84 100644
--- a/docs/content/2.download/default.yml
+++ b/docs/content/2.download/default.yml
@@ -55,11 +55,10 @@ body:
 
       For Linux systems, these will all be in your system's package
       manager, and if you do development on the machine they're most
-      likely already installed. I have no idea how to get these
-      installed on OS X, you're on your own there.
+      likely already installed.
 
       On OS X, these are all included in Apple's command line tools, which
-      can be installed from [Xcode](developer.apple.com/technologies/tools/).
+      can be installed from [Xcode](http://developer.apple.com/technologies/tools/).
       However, you may find that you need a newer version of Bison than the one provided
       by Apple. This can be found in [Homebrew](http://mxcl.github.com/homebrew/)
       or [MacPorts](http://macports.org/).

From b660bd2be669765c4070b1d8c1f9026e05abdbeb Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 10 Dec 2012 22:25:11 +0000
Subject: [PATCH 179/284] Fix Rack setup so that viewing documentation locally
 is less painful.

---
 docs/Rakefile | 6 ++++--
 docs/site.yml | 2 --
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/Rakefile b/docs/Rakefile
index 62b0139e..51e9b484 100644
--- a/docs/Rakefile
+++ b/docs/Rakefile
@@ -38,11 +38,13 @@ task :serve do
     
     server = fork {        
       app = Rack::Builder.app {
-        use Bonsai::StaticPassThrough, :root => Bonsai.root_dir + "/output", :urls => ["/"]
+        map "/jq" do
+          use Bonsai::StaticPassThrough, :root => Bonsai.root_dir + "/output", :urls => ["/"]
+        end
         run Bonsai::DevelopmentServer
       }
       Rack::Handler.default.run(app, :Port => 5000) do
-        Launchy.open("http://localhost:5000/")
+        Launchy.open("http://localhost:5000/jq")
       end
     }    
     Watch.new("{content,templates,public}/**/*") { Bonsai::Exporter.process! }
diff --git a/docs/site.yml b/docs/site.yml
index 92a690d1..df758cef 100644
--- a/docs/site.yml
+++ b/docs/site.yml
@@ -2,9 +2,7 @@
 
 
 jq_version: 1.1
-# Next line is needed for publishing to github pages
 root: '/jq'
-# root: ''
 footer: |
   
   This website is made with [Bonsai](http://www.tinytree.info) and

From 34ff993059310e362db0cc41bce43670e09e10ac Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 10 Dec 2012 22:30:09 +0000
Subject: [PATCH 180/284] error() function

---
 builtin.c | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/builtin.c b/builtin.c
index b572dfaf..f046e91a 100644
--- a/builtin.c
+++ b/builtin.c
@@ -41,7 +41,6 @@ static jv type_error2(jv bad1, jv bad2, const char* msg) {
   return err;
 }
 
-
 static jv f_plus(jv input, jv a, jv b) {
   jv_free(input);
   if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
@@ -297,6 +296,13 @@ static jv f_type(jv input) {
   return out;
 }
 
+static jv f_error(jv input, jv msg) {
+  jv_free(input);
+  msg = f_tostring(msg);
+  return jv_invalid_with_msg(msg);
+}
+
+
 static struct cfunction function_list[] = {
   {(cfunction_ptr)f_plus, "_plus", 3},
   {(cfunction_ptr)f_minus, "_minus", 3},
@@ -322,6 +328,7 @@ static struct cfunction function_list[] = {
   {(cfunction_ptr)f_max, "max", 1},
   {(cfunction_ptr)f_min_by_impl, "_min_by_impl", 2},
   {(cfunction_ptr)f_max_by_impl, "_max_by_impl", 2},
+  {(cfunction_ptr)f_error, "error", 2},
 };
 
 static struct symbol_table cbuiltins = 

From dcc93042d35135f0aa16fd6de953a1c5c76e0f1a Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 10 Dec 2012 22:35:33 +0000
Subject: [PATCH 181/284] some words explaining struct inst a little

---
 compile.c | 30 ++++++++++++++++++++++--------
 1 file changed, 22 insertions(+), 8 deletions(-)

diff --git a/compile.c b/compile.c
index eb0fe78d..3a094721 100644
--- a/compile.c
+++ b/compile.c
@@ -6,6 +6,18 @@
 #include "bytecode.h"
 #include "locfile.h"
 
+/*
+  The intermediate representation for jq filters is as a sequence of
+  struct inst, which form a doubly-linked list via the next and prev
+  pointers. 
+
+  A "block" represents a sequence of "struct inst", which may be
+  empty.
+
+  Blocks are generated by the parser bottom-up, so may have free
+  variables (refer to things not defined). See inst.bound_by and
+  inst.symbol.
+ */
 struct inst {
   struct inst* next;
   struct inst* prev;
@@ -22,18 +34,20 @@ struct inst {
   location source;
 
   // Binding
-  // An instruction requiring binding (for parameters/variables)
+  // An instruction requiring binding (for parameters/variables/functions)
   // is in one of three states:
-  //   bound_by = NULL  - Unbound free variable
-  //   bound_by = self  - This instruction binds a variable
-  //   bound_by = other - Uses variable bound by other instruction
-  // The immediate field is generally not meaningful until instructions
-  // are bound, and even then only for instructions which bind.
+  //   inst->bound_by = NULL  - Unbound free variable
+  //   inst->bound_by = inst  - This instruction binds a variable
+  //   inst->bound_by = other - Uses variable bound by other instruction
+  // Unbound instructions (references to other things that may or may not 
+  // exist) are created by "gen_foo_unbound", and bindings are created by
+  // block_bind(definition, body), which binds all instructions in
+  // body which are unboudn and refer to "definition" by name.
   struct inst* bound_by;
   char* symbol;
 
-  block subfn;
-  block arglist;
+  block subfn;   // used by CLOSURE_CREATE (body of function)
+  block arglist; // used by CLOSURE_CREATE (formals) and CALL_JQ (arguments)
 
   // This instruction is compiled as part of which function?
   // (only used during block_compile)

From 8ba2cef91356257d8c8415df916480fdba4d17f6 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 10 Dec 2012 22:36:01 +0000
Subject: [PATCH 182/284] Delete autogenerated source from the repository.

This was a horrible hack to fix build issues on OS X some time
ago. There are better ways to fix build issues on OS X :)

See #49.
---
 jv_utf8_tables.gen.h |   35 -
 lexer.gen.c          | 2328 ---------------------------
 lexer.gen.h          |  362 -----
 parser.gen.c         | 2855 ---------------------------------
 parser.gen.h         |  132 --
 parser.gen.info      | 3565 ------------------------------------------
 6 files changed, 9277 deletions(-)
 delete mode 100644 jv_utf8_tables.gen.h
 delete mode 100644 lexer.gen.c
 delete mode 100644 lexer.gen.h
 delete mode 100644 parser.gen.c
 delete mode 100644 parser.gen.h
 delete mode 100644 parser.gen.info

diff --git a/jv_utf8_tables.gen.h b/jv_utf8_tables.gen.h
deleted file mode 100644
index 24d9a63a..00000000
--- a/jv_utf8_tables.gen.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#define UTF8_CONTINUATION_BYTE ((unsigned char)255)
-static const unsigned char utf8_coding_length[] =
- {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-  0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-  0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
-  0x04, 0x04, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-static const unsigned char utf8_coding_bits[] =
- {0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
-  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
-  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
-  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
-  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
-  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
-  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
-  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
-  0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
-  0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
-  0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
-  0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
-  0x00, 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
-  0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
-  0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-  0x07, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
diff --git a/lexer.gen.c b/lexer.gen.c
deleted file mode 100644
index 250fc430..00000000
--- a/lexer.gen.c
+++ /dev/null
@@ -1,2328 +0,0 @@
-#line 2 "lexer.gen.c"
-
-#line 4 "lexer.gen.c"
-
-#define  YY_INT_ALIGNED short int
-
-/* A lexical scanner generated by flex */
-
-#define FLEX_SCANNER
-#define YY_FLEX_MAJOR_VERSION 2
-#define YY_FLEX_MINOR_VERSION 5
-#define YY_FLEX_SUBMINOR_VERSION 35
-#if YY_FLEX_SUBMINOR_VERSION > 0
-#define FLEX_BETA
-#endif
-
-/* First, we deal with  platform-specific or compiler-specific issues. */
-
-/* begin standard C headers. */
-#include <stdio.h>
-#include <string.h>
-#include <errno.h>
-#include <stdlib.h>
-
-/* end standard C headers. */
-
-/* flex integer type definitions */
-
-#ifndef FLEXINT_H
-#define FLEXINT_H
-
-/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
-
-#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-
-/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
- * if you want the limit (max/min) macros for int types. 
- */
-#ifndef __STDC_LIMIT_MACROS
-#define __STDC_LIMIT_MACROS 1
-#endif
-
-#include <inttypes.h>
-typedef int8_t flex_int8_t;
-typedef uint8_t flex_uint8_t;
-typedef int16_t flex_int16_t;
-typedef uint16_t flex_uint16_t;
-typedef int32_t flex_int32_t;
-typedef uint32_t flex_uint32_t;
-#else
-typedef signed char flex_int8_t;
-typedef short int flex_int16_t;
-typedef int flex_int32_t;
-typedef unsigned char flex_uint8_t; 
-typedef unsigned short int flex_uint16_t;
-typedef unsigned int flex_uint32_t;
-
-/* Limits of integral types. */
-#ifndef INT8_MIN
-#define INT8_MIN               (-128)
-#endif
-#ifndef INT16_MIN
-#define INT16_MIN              (-32767-1)
-#endif
-#ifndef INT32_MIN
-#define INT32_MIN              (-2147483647-1)
-#endif
-#ifndef INT8_MAX
-#define INT8_MAX               (127)
-#endif
-#ifndef INT16_MAX
-#define INT16_MAX              (32767)
-#endif
-#ifndef INT32_MAX
-#define INT32_MAX              (2147483647)
-#endif
-#ifndef UINT8_MAX
-#define UINT8_MAX              (255U)
-#endif
-#ifndef UINT16_MAX
-#define UINT16_MAX             (65535U)
-#endif
-#ifndef UINT32_MAX
-#define UINT32_MAX             (4294967295U)
-#endif
-
-#endif /* ! C99 */
-
-#endif /* ! FLEXINT_H */
-
-#ifdef __cplusplus
-
-/* The "const" storage-class-modifier is valid. */
-#define YY_USE_CONST
-
-#else	/* ! __cplusplus */
-
-/* C99 requires __STDC__ to be defined as 1. */
-#if defined (__STDC__)
-
-#define YY_USE_CONST
-
-#endif	/* defined (__STDC__) */
-#endif	/* ! __cplusplus */
-
-#ifdef YY_USE_CONST
-#define yyconst const
-#else
-#define yyconst
-#endif
-
-/* Returned upon end-of-file. */
-#define YY_NULL 0
-
-/* Promotes a possibly negative, possibly signed char to an unsigned
- * integer for use as an array index.  If the signed char is negative,
- * we want to instead treat it as an 8-bit unsigned char, hence the
- * double cast.
- */
-#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
-
-/* An opaque pointer. */
-#ifndef YY_TYPEDEF_YY_SCANNER_T
-#define YY_TYPEDEF_YY_SCANNER_T
-typedef void* yyscan_t;
-#endif
-
-/* For convenience, these vars (plus the bison vars far below)
-   are macros in the reentrant scanner. */
-#define yyin yyg->yyin_r
-#define yyout yyg->yyout_r
-#define yyextra yyg->yyextra_r
-#define yyleng yyg->yyleng_r
-#define yytext yyg->yytext_r
-#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
-#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
-#define yy_flex_debug yyg->yy_flex_debug_r
-
-/* Enter a start condition.  This macro really ought to take a parameter,
- * but we do it the disgusting crufty way forced on us by the ()-less
- * definition of BEGIN.
- */
-#define BEGIN yyg->yy_start = 1 + 2 *
-
-/* Translate the current start state into a value that can be later handed
- * to BEGIN to return to the state.  The YYSTATE alias is for lex
- * compatibility.
- */
-#define YY_START ((yyg->yy_start - 1) / 2)
-#define YYSTATE YY_START
-
-/* Action number for EOF rule of a given start state. */
-#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
-
-/* Special action meaning "start processing a new file". */
-#define YY_NEW_FILE jq_yyrestart(yyin ,yyscanner )
-
-#define YY_END_OF_BUFFER_CHAR 0
-
-/* Size of default input buffer. */
-#ifndef YY_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k.
- * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
- * Ditto for the __ia64__ case accordingly.
- */
-#define YY_BUF_SIZE 32768
-#else
-#define YY_BUF_SIZE 16384
-#endif /* __ia64__ */
-#endif
-
-/* The state buf must be large enough to hold one state per character in the main buffer.
- */
-#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
-
-#ifndef YY_TYPEDEF_YY_BUFFER_STATE
-#define YY_TYPEDEF_YY_BUFFER_STATE
-typedef struct yy_buffer_state *YY_BUFFER_STATE;
-#endif
-
-#define EOB_ACT_CONTINUE_SCAN 0
-#define EOB_ACT_END_OF_FILE 1
-#define EOB_ACT_LAST_MATCH 2
-
-    #define YY_LESS_LINENO(n)
-    
-/* Return all but the first "n" matched characters back to the input stream. */
-#define yyless(n) \
-	do \
-		{ \
-		/* Undo effects of setting up yytext. */ \
-        int yyless_macro_arg = (n); \
-        YY_LESS_LINENO(yyless_macro_arg);\
-		*yy_cp = yyg->yy_hold_char; \
-		YY_RESTORE_YY_MORE_OFFSET \
-		yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
-		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
-		} \
-	while ( 0 )
-
-#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
-
-#ifndef YY_TYPEDEF_YY_SIZE_T
-#define YY_TYPEDEF_YY_SIZE_T
-typedef size_t yy_size_t;
-#endif
-
-#ifndef YY_STRUCT_YY_BUFFER_STATE
-#define YY_STRUCT_YY_BUFFER_STATE
-struct yy_buffer_state
-	{
-	FILE *yy_input_file;
-
-	char *yy_ch_buf;		/* input buffer */
-	char *yy_buf_pos;		/* current position in input buffer */
-
-	/* Size of input buffer in bytes, not including room for EOB
-	 * characters.
-	 */
-	yy_size_t yy_buf_size;
-
-	/* Number of characters read into yy_ch_buf, not including EOB
-	 * characters.
-	 */
-	int yy_n_chars;
-
-	/* Whether we "own" the buffer - i.e., we know we created it,
-	 * and can realloc() it to grow it, and should free() it to
-	 * delete it.
-	 */
-	int yy_is_our_buffer;
-
-	/* Whether this is an "interactive" input source; if so, and
-	 * if we're using stdio for input, then we want to use getc()
-	 * instead of fread(), to make sure we stop fetching input after
-	 * each newline.
-	 */
-	int yy_is_interactive;
-
-	/* Whether we're considered to be at the beginning of a line.
-	 * If so, '^' rules will be active on the next match, otherwise
-	 * not.
-	 */
-	int yy_at_bol;
-
-    int yy_bs_lineno; /**< The line count. */
-    int yy_bs_column; /**< The column count. */
-    
-	/* Whether to try to fill the input buffer when we reach the
-	 * end of it.
-	 */
-	int yy_fill_buffer;
-
-	int yy_buffer_status;
-
-#define YY_BUFFER_NEW 0
-#define YY_BUFFER_NORMAL 1
-	/* When an EOF's been seen but there's still some text to process
-	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
-	 * shouldn't try reading from the input source any more.  We might
-	 * still have a bunch of tokens to match, though, because of
-	 * possible backing-up.
-	 *
-	 * When we actually see the EOF, we change the status to "new"
-	 * (via jq_yyrestart()), so that the user can continue scanning by
-	 * just pointing yyin at a new input file.
-	 */
-#define YY_BUFFER_EOF_PENDING 2
-
-	};
-#endif /* !YY_STRUCT_YY_BUFFER_STATE */
-
-/* We provide macros for accessing buffer states in case in the
- * future we want to put the buffer states in a more general
- * "scanner state".
- *
- * Returns the top of the stack, or NULL.
- */
-#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
-                          ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
-                          : NULL)
-
-/* Same as previous macro, but useful when we know that the buffer stack is not
- * NULL or when we need an lvalue. For internal use only.
- */
-#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
-
-void jq_yyrestart (FILE *input_file ,yyscan_t yyscanner );
-void jq_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
-YY_BUFFER_STATE jq_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
-void jq_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
-void jq_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
-void jq_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
-void jq_yypop_buffer_state (yyscan_t yyscanner );
-
-static void jq_yyensure_buffer_stack (yyscan_t yyscanner );
-static void jq_yy_load_buffer_state (yyscan_t yyscanner );
-static void jq_yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
-
-#define YY_FLUSH_BUFFER jq_yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
-
-YY_BUFFER_STATE jq_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
-YY_BUFFER_STATE jq_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
-YY_BUFFER_STATE jq_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
-
-void *jq_yyalloc (yy_size_t ,yyscan_t yyscanner );
-void *jq_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
-void jq_yyfree (void * ,yyscan_t yyscanner );
-
-#define yy_new_buffer jq_yy_create_buffer
-
-#define yy_set_interactive(is_interactive) \
-	{ \
-	if ( ! YY_CURRENT_BUFFER ){ \
-        jq_yyensure_buffer_stack (yyscanner); \
-		YY_CURRENT_BUFFER_LVALUE =    \
-            jq_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
-	} \
-	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
-	}
-
-#define yy_set_bol(at_bol) \
-	{ \
-	if ( ! YY_CURRENT_BUFFER ){\
-        jq_yyensure_buffer_stack (yyscanner); \
-		YY_CURRENT_BUFFER_LVALUE =    \
-            jq_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
-	} \
-	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
-	}
-
-#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
-
-/* Begin user sect3 */
-
-#define jq_yywrap(n) 1
-#define YY_SKIP_YYWRAP
-
-typedef unsigned char YY_CHAR;
-
-typedef int yy_state_type;
-
-#define yytext_ptr yytext_r
-
-static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
-static yy_state_type yy_try_NUL_trans (yy_state_type current_state  ,yyscan_t yyscanner);
-static int yy_get_next_buffer (yyscan_t yyscanner );
-static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
-
-/* Done after the current pattern has been matched and before the
- * corresponding action - sets up yytext.
- */
-#define YY_DO_BEFORE_ACTION \
-	yyg->yytext_ptr = yy_bp; \
-	yyleng = (size_t) (yy_cp - yy_bp); \
-	yyg->yy_hold_char = *yy_cp; \
-	*yy_cp = '\0'; \
-	yyg->yy_c_buf_p = yy_cp;
-
-#define YY_NUM_RULES 36
-#define YY_END_OF_BUFFER 37
-/* This struct is not used in this scanner,
-   but its presence is necessary. */
-struct yy_trans_info
-	{
-	flex_int32_t yy_verify;
-	flex_int32_t yy_nxt;
-	};
-static yyconst flex_int16_t yy_accept[96] =
-    {   0,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,   37,   35,   34,   34,   35,   27,    1,   23,
-       24,   25,   23,   23,   23,   23,   23,   26,   23,   23,
-       23,   33,   33,   33,   33,   33,   33,   33,   33,   23,
-       31,   31,   29,   32,   34,    2,    1,   17,   15,   26,
-       16,    0,   13,   18,   20,    3,   21,   33,   33,    4,
-       33,   33,   33,   33,    6,   11,   33,   14,   31,   30,
-       28,   30,    0,   26,   19,   10,   33,    5,   33,   33,
-       12,   33,    0,   30,   33,    9,    8,    7,   30,   33,
-       30,   33,   33,   22,    0
-
-    } ;
-
-static yyconst flex_int32_t yy_ec[256] =
-    {   0,
-        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
-        1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    2,    5,    6,    7,    8,    1,    1,    1,    9,
-       10,   11,   12,   13,   14,   15,   16,   17,   17,   17,
-       17,   17,   17,   17,   17,   17,   17,   18,   19,   20,
-       21,   22,    1,    1,   23,   23,   23,   23,   24,   23,
-       23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
-       23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
-       25,   26,   27,    1,   28,    1,   29,   23,   30,   31,
-
-       32,   33,   23,   34,   35,   23,   23,   36,   23,   37,
-       38,   23,   23,   39,   40,   41,   42,   23,   23,   23,
-       23,   23,   43,   44,   45,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1
-    } ;
-
-static yyconst flex_int32_t yy_meta[46] =
-    {   0,
-        1,    1,    2,    2,    1,    3,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    4,    1,    1,    1,
-        1,    1,    4,    4,    1,    5,    1,    6,    4,    4,
-        4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
-        4,    4,    1,    1,    1
-    } ;
-
-static yyconst flex_int16_t yy_base[105] =
-    {   0,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-       43,   44,  152,  153,   49,   51,  130,  153,    0,  153,
-      153,  153,  129,  128,   40,   41,   43,   51,  127,  126,
-      125,    0,   23,  107,  112,   35,  110,   88,   91,  100,
-        0,    0,  153,   39,   74,  153,    0,  153,  153,   63,
-      153,   72,   94,  153,  153,  153,  153,    0,   75,    0,
-       68,   71,   27,   72,    0,    0,   70,  153,    0,   75,
-      153,   74,   82,   81,  153,    0,   56,    0,   63,   62,
-        0,   56,   65,   66,   62,    0,    0,    0,   64,   53,
-       59,   45,   39,    0,  153,  107,  113,  116,  122,  128,
-
-      131,  133,  135,  137
-    } ;
-
-static yyconst flex_int16_t yy_def[105] =
-    {   0,
-       95,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-       96,   96,   95,   95,   95,   95,   95,   95,   97,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   98,   98,   98,   98,   98,   98,   98,   98,   95,
-       99,   99,   95,  100,   95,   95,   97,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   98,   98,   98,
-       98,   98,   98,   98,   98,   98,   98,   95,   99,   95,
-       95,  101,   95,   95,   95,   98,   98,   98,   98,   98,
-       98,   98,  100,  102,   98,   98,   98,   98,  103,   98,
-      104,   98,   98,   98,    0,   95,   95,   95,   95,   95,
-
-       95,   95,   95,   95
-    } ;
-
-static yyconst flex_int16_t yy_nxt[199] =
-    {   0,
-       14,   15,   16,   14,   17,   18,   19,   20,   21,   22,
-       23,   24,   20,   25,   26,   27,   28,   20,   20,   29,
-       30,   31,   32,   32,   21,   14,   22,   32,   33,   34,
-       35,   36,   32,   32,   37,   32,   32,   38,   32,   32,
-       39,   32,   21,   40,   22,   42,   42,   71,   43,   43,
-       45,   45,   45,   45,   50,   50,   50,   50,   53,   59,
-       51,   79,   60,   54,   52,   50,   80,   50,   44,   44,
-       63,   64,   52,   95,   52,   45,   45,   50,   94,   50,
-       72,   93,   52,   73,   83,   73,   52,   92,   74,   83,
-       90,   83,   88,   87,   52,   86,   85,   74,   74,   83,
-
-       83,   82,   81,   78,   77,   76,   72,   41,   41,   41,
-       41,   41,   41,   47,   75,   47,   47,   47,   47,   58,
-       68,   58,   69,   69,   67,   69,   66,   69,   70,   70,
-       70,   70,   70,   70,   84,   84,   89,   89,   91,   91,
-       70,   70,   65,   62,   61,   57,   56,   55,   49,   48,
-       46,   95,   13,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95
-
-    } ;
-
-static yyconst flex_int16_t yy_chk[199] =
-    {   0,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,   11,   12,   44,   11,   12,
-       15,   15,   16,   16,   25,   26,   25,   26,   27,   33,
-       25,   63,   33,   27,   26,   28,   63,   28,   11,   12,
-       36,   36,   26,   83,   28,   45,   45,   50,   93,   50,
-       44,   92,   28,   52,   91,   52,   50,   90,   52,   89,
-       85,   84,   82,   80,   50,   79,   77,   74,   73,   72,
-
-       70,   67,   64,   62,   61,   59,   83,   96,   96,   96,
-       96,   96,   96,   97,   53,   97,   97,   97,   97,   98,
-       40,   98,   99,   99,   39,   99,   38,   99,  100,  100,
-      100,  100,  100,  100,  101,  101,  102,  102,  103,  103,
-      104,  104,   37,   35,   34,   31,   30,   29,   24,   23,
-       17,   13,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95
-
-    } ;
-
-/* The intent behind this definition is that it'll catch
- * any uses of REJECT which flex missed.
- */
-#define REJECT reject_used_but_not_detected
-#define yymore() yymore_used_but_not_detected
-#define YY_MORE_ADJ 0
-#define YY_RESTORE_YY_MORE_OFFSET
-#line 1 "lexer.l"
-#line 2 "lexer.l"
-#include "compile.h"
-
-struct lexer_param;
-
-#include "parser.gen.h"  /* Generated by bison. */
-
-#define YY_USER_ACTION                           \
-  do {                                           \
-    yylloc->start = jq_yyget_extra(yyscanner);      \
-    yylloc->end = yylloc->start + yyleng;        \
-    jq_yyset_extra(yylloc->end,yyscanner);         \
-  } while (0);
-
-
-
-
-
-
-#line 23 "lexer.l"
-  static int enter(int opening, int state, yyscan_t yyscanner);
-  static int try_exit(int closing, int state, yyscan_t yyscanner);
-#define YY_NO_INPUT 1
-#line 542 "lexer.gen.c"
-
-#define INITIAL 0
-#define IN_PAREN 1
-#define IN_BRACKET 2
-#define IN_BRACE 3
-#define IN_QQINTERP 4
-#define IN_QQSTRING 5
-
-#ifndef YY_NO_UNISTD_H
-/* Special case for "unistd.h", since it is non-ANSI. We include it way
- * down here because we want the user's section 1 to have been scanned first.
- * The user has a chance to override it with an option.
- */
-#include <unistd.h>
-#endif
-
-#define YY_EXTRA_TYPE int
-
-/* Holds the entire state of the reentrant scanner. */
-struct yyguts_t
-    {
-
-    /* User-defined. Not touched by flex. */
-    YY_EXTRA_TYPE yyextra_r;
-
-    /* The rest are the same as the globals declared in the non-reentrant scanner. */
-    FILE *yyin_r, *yyout_r;
-    size_t yy_buffer_stack_top; /**< index of top of stack. */
-    size_t yy_buffer_stack_max; /**< capacity of stack. */
-    YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
-    char yy_hold_char;
-    int yy_n_chars;
-    int yyleng_r;
-    char *yy_c_buf_p;
-    int yy_init;
-    int yy_start;
-    int yy_did_buffer_switch_on_eof;
-    int yy_start_stack_ptr;
-    int yy_start_stack_depth;
-    int *yy_start_stack;
-    yy_state_type yy_last_accepting_state;
-    char* yy_last_accepting_cpos;
-
-    int yylineno_r;
-    int yy_flex_debug_r;
-
-    char *yytext_r;
-    int yy_more_flag;
-    int yy_more_len;
-
-    YYSTYPE * yylval_r;
-
-    YYLTYPE * yylloc_r;
-
-    }; /* end struct yyguts_t */
-
-static int yy_init_globals (yyscan_t yyscanner );
-
-    /* This must go here because YYSTYPE and YYLTYPE are included
-     * from bison output in section 1.*/
-    #    define yylval yyg->yylval_r
-    
-    #    define yylloc yyg->yylloc_r
-    
-int jq_yylex_init (yyscan_t* scanner);
-
-int jq_yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
-
-/* Accessor methods to globals.
-   These are made visible to non-reentrant scanners for convenience. */
-
-int jq_yylex_destroy (yyscan_t yyscanner );
-
-int jq_yyget_debug (yyscan_t yyscanner );
-
-void jq_yyset_debug (int debug_flag ,yyscan_t yyscanner );
-
-YY_EXTRA_TYPE jq_yyget_extra (yyscan_t yyscanner );
-
-void jq_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
-
-FILE *jq_yyget_in (yyscan_t yyscanner );
-
-void jq_yyset_in  (FILE * in_str ,yyscan_t yyscanner );
-
-FILE *jq_yyget_out (yyscan_t yyscanner );
-
-void jq_yyset_out  (FILE * out_str ,yyscan_t yyscanner );
-
-int jq_yyget_leng (yyscan_t yyscanner );
-
-char *jq_yyget_text (yyscan_t yyscanner );
-
-int jq_yyget_lineno (yyscan_t yyscanner );
-
-void jq_yyset_lineno (int line_number ,yyscan_t yyscanner );
-
-YYSTYPE * jq_yyget_lval (yyscan_t yyscanner );
-
-void jq_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
-
-       YYLTYPE *jq_yyget_lloc (yyscan_t yyscanner );
-    
-        void jq_yyset_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner );
-    
-/* Macros after this point can all be overridden by user definitions in
- * section 1.
- */
-
-#ifndef YY_SKIP_YYWRAP
-#ifdef __cplusplus
-extern "C" int jq_yywrap (yyscan_t yyscanner );
-#else
-extern int jq_yywrap (yyscan_t yyscanner );
-#endif
-#endif
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
-#endif
-
-#ifndef YY_NO_INPUT
-
-#ifdef __cplusplus
-static int yyinput (yyscan_t yyscanner );
-#else
-static int input (yyscan_t yyscanner );
-#endif
-
-#endif
-
-    static void yy_push_state (int new_state ,yyscan_t yyscanner);
-    
-    static void yy_pop_state (yyscan_t yyscanner );
-    
-    static int yy_top_state (yyscan_t yyscanner );
-    
-/* Amount of stuff to slurp up with each read. */
-#ifndef YY_READ_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k */
-#define YY_READ_BUF_SIZE 16384
-#else
-#define YY_READ_BUF_SIZE 8192
-#endif /* __ia64__ */
-#endif
-
-/* Copy whatever the last rule matched to the standard output. */
-#ifndef ECHO
-/* This used to be an fputs(), but since the string might contain NUL's,
- * we now use fwrite().
- */
-#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
-#endif
-
-/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
- * is returned in "result".
- */
-#ifndef YY_INPUT
-#define YY_INPUT(buf,result,max_size) \
-	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
-		{ \
-		int c = '*'; \
-		size_t n; \
-		for ( n = 0; n < max_size && \
-			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
-			buf[n] = (char) c; \
-		if ( c == '\n' ) \
-			buf[n++] = (char) c; \
-		if ( c == EOF && ferror( yyin ) ) \
-			YY_FATAL_ERROR( "input in flex scanner failed" ); \
-		result = n; \
-		} \
-	else \
-		{ \
-		errno=0; \
-		while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
-			{ \
-			if( errno != EINTR) \
-				{ \
-				YY_FATAL_ERROR( "input in flex scanner failed" ); \
-				break; \
-				} \
-			errno=0; \
-			clearerr(yyin); \
-			} \
-		}\
-\
-
-#endif
-
-/* No semi-colon after return; correct usage is to write "yyterminate();" -
- * we don't want an extra ';' after the "return" because that will cause
- * some compilers to complain about unreachable statements.
- */
-#ifndef yyterminate
-#define yyterminate() return YY_NULL
-#endif
-
-/* Number of entries by which start-condition stack grows. */
-#ifndef YY_START_STACK_INCR
-#define YY_START_STACK_INCR 25
-#endif
-
-/* Report a fatal error. */
-#ifndef YY_FATAL_ERROR
-#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
-#endif
-
-/* end tables serialization structures and prototypes */
-
-/* Default declaration of generated scanner - a define so the user can
- * easily add parameters.
- */
-#ifndef YY_DECL
-#define YY_DECL_IS_OURS 1
-
-extern int jq_yylex \
-               (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner);
-
-#define YY_DECL int jq_yylex \
-               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
-#endif /* !YY_DECL */
-
-/* Code executed at the beginning of each rule, after yytext and yyleng
- * have been set up.
- */
-#ifndef YY_USER_ACTION
-#define YY_USER_ACTION
-#endif
-
-/* Code executed at the end of each rule. */
-#ifndef YY_BREAK
-#define YY_BREAK break;
-#endif
-
-#define YY_RULE_SETUP \
-	YY_USER_ACTION
-
-/** The main scanner function which does all the work.
- */
-YY_DECL
-{
-	register yy_state_type yy_current_state;
-	register char *yy_cp, *yy_bp;
-	register int yy_act;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-#line 35 "lexer.l"
-
-
-#line 798 "lexer.gen.c"
-
-    yylval = yylval_param;
-
-    yylloc = yylloc_param;
-
-	if ( !yyg->yy_init )
-		{
-		yyg->yy_init = 1;
-
-#ifdef YY_USER_INIT
-		YY_USER_INIT;
-#endif
-
-		if ( ! yyg->yy_start )
-			yyg->yy_start = 1;	/* first start state */
-
-		if ( ! yyin )
-			yyin = stdin;
-
-		if ( ! yyout )
-			yyout = stdout;
-
-		if ( ! YY_CURRENT_BUFFER ) {
-			jq_yyensure_buffer_stack (yyscanner);
-			YY_CURRENT_BUFFER_LVALUE =
-				jq_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
-		}
-
-		jq_yy_load_buffer_state(yyscanner );
-		}
-
-	while ( 1 )		/* loops until end-of-file is reached */
-		{
-		yy_cp = yyg->yy_c_buf_p;
-
-		/* Support of yytext. */
-		*yy_cp = yyg->yy_hold_char;
-
-		/* yy_bp points to the position in yy_ch_buf of the start of
-		 * the current run.
-		 */
-		yy_bp = yy_cp;
-
-		yy_current_state = yyg->yy_start;
-yy_match:
-		do
-			{
-			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
-			if ( yy_accept[yy_current_state] )
-				{
-				yyg->yy_last_accepting_state = yy_current_state;
-				yyg->yy_last_accepting_cpos = yy_cp;
-				}
-			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-				{
-				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 96 )
-					yy_c = yy_meta[(unsigned int) yy_c];
-				}
-			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-			++yy_cp;
-			}
-		while ( yy_base[yy_current_state] != 153 );
-
-yy_find_action:
-		yy_act = yy_accept[yy_current_state];
-		if ( yy_act == 0 )
-			{ /* have to back up */
-			yy_cp = yyg->yy_last_accepting_cpos;
-			yy_current_state = yyg->yy_last_accepting_state;
-			yy_act = yy_accept[yy_current_state];
-			}
-
-		YY_DO_BEFORE_ACTION;
-
-do_action:	/* This label is used only to access EOF actions. */
-
-		switch ( yy_act )
-	{ /* beginning of action switch */
-			case 0: /* must back up */
-			/* undo the effects of YY_DO_BEFORE_ACTION */
-			*yy_cp = yyg->yy_hold_char;
-			yy_cp = yyg->yy_last_accepting_cpos;
-			yy_current_state = yyg->yy_last_accepting_state;
-			goto yy_find_action;
-
-case 1:
-YY_RULE_SETUP
-#line 37 "lexer.l"
-{ /* comments */ }
-	YY_BREAK
-case 2:
-YY_RULE_SETUP
-#line 39 "lexer.l"
-{ return NEQ; }
-	YY_BREAK
-case 3:
-YY_RULE_SETUP
-#line 40 "lexer.l"
-{ return EQ; }
-	YY_BREAK
-case 4:
-YY_RULE_SETUP
-#line 41 "lexer.l"
-{ return AS; }
-	YY_BREAK
-case 5:
-YY_RULE_SETUP
-#line 42 "lexer.l"
-{ return DEF; }
-	YY_BREAK
-case 6:
-YY_RULE_SETUP
-#line 43 "lexer.l"
-{ return IF; }
-	YY_BREAK
-case 7:
-YY_RULE_SETUP
-#line 44 "lexer.l"
-{ return THEN; }
-	YY_BREAK
-case 8:
-YY_RULE_SETUP
-#line 45 "lexer.l"
-{ return ELSE; }
-	YY_BREAK
-case 9:
-YY_RULE_SETUP
-#line 46 "lexer.l"
-{ return ELSE_IF; }
-	YY_BREAK
-case 10:
-YY_RULE_SETUP
-#line 47 "lexer.l"
-{ return AND; }
-	YY_BREAK
-case 11:
-YY_RULE_SETUP
-#line 48 "lexer.l"
-{ return OR; }
-	YY_BREAK
-case 12:
-YY_RULE_SETUP
-#line 49 "lexer.l"
-{ return END; }
-	YY_BREAK
-case 13:
-YY_RULE_SETUP
-#line 50 "lexer.l"
-{ return DEFINEDOR; }
-	YY_BREAK
-case 14:
-YY_RULE_SETUP
-#line 51 "lexer.l"
-{ return SETPIPE; }
-	YY_BREAK
-case 15:
-YY_RULE_SETUP
-#line 52 "lexer.l"
-{ return SETPLUS; }
-	YY_BREAK
-case 16:
-YY_RULE_SETUP
-#line 53 "lexer.l"
-{ return SETMINUS; }
-	YY_BREAK
-case 17:
-YY_RULE_SETUP
-#line 54 "lexer.l"
-{ return SETMULT; }
-	YY_BREAK
-case 18:
-YY_RULE_SETUP
-#line 55 "lexer.l"
-{ return SETDIV; }
-	YY_BREAK
-case 19:
-YY_RULE_SETUP
-#line 56 "lexer.l"
-{ return SETDEFINEDOR; }
-	YY_BREAK
-case 20:
-YY_RULE_SETUP
-#line 57 "lexer.l"
-{ return LESSEQ; }
-	YY_BREAK
-case 21:
-YY_RULE_SETUP
-#line 58 "lexer.l"
-{ return GREATEREQ; }
-	YY_BREAK
-case 22:
-YY_RULE_SETUP
-#line 59 "lexer.l"
-{ return CONTAINS; }
-	YY_BREAK
-case 23:
-YY_RULE_SETUP
-#line 60 "lexer.l"
-{ return yytext[0];}
-	YY_BREAK
-case 24:
-YY_RULE_SETUP
-#line 62 "lexer.l"
-{
-  return enter(yytext[0], YY_START, yyscanner);
-}
-	YY_BREAK
-case 25:
-YY_RULE_SETUP
-#line 66 "lexer.l"
-{
-  return try_exit(yytext[0], YY_START, yyscanner);
-}
-	YY_BREAK
-case 26:
-YY_RULE_SETUP
-#line 71 "lexer.l"
-{ 
-   yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; 
-}
-	YY_BREAK
-case 27:
-YY_RULE_SETUP
-#line 75 "lexer.l"
-{
-  yy_push_state(IN_QQSTRING, yyscanner);
-  return QQSTRING_START;
-}
-	YY_BREAK
-
-case 28:
-YY_RULE_SETUP
-#line 81 "lexer.l"
-{
-    return enter(QQSTRING_INTERP_START, YY_START, yyscanner);
-  }
-	YY_BREAK
-case 29:
-YY_RULE_SETUP
-#line 84 "lexer.l"
-{
-    yy_pop_state(yyscanner);
-    return QQSTRING_END;
-  }
-	YY_BREAK
-case 30:
-/* rule 30 can match eol */
-YY_RULE_SETUP
-#line 88 "lexer.l"
-{
-    /* pass escapes to the json parser */
-    jv escapes = jv_string_fmt("\"%.*s\"", yyleng, yytext);
-    yylval->literal = jv_parse_sized(jv_string_value(escapes), jv_string_length(jv_copy(escapes)));
-    jv_free(escapes);
-    return QQSTRING_TEXT;
-  }
-	YY_BREAK
-case 31:
-/* rule 31 can match eol */
-YY_RULE_SETUP
-#line 95 "lexer.l"
-{
-    yylval->literal = jv_string_sized(yytext, yyleng);
-    return QQSTRING_TEXT;
-  }
-	YY_BREAK
-case 32:
-YY_RULE_SETUP
-#line 99 "lexer.l"
-{
-    return INVALID_CHARACTER;
-  }
-	YY_BREAK
-
-case 33:
-YY_RULE_SETUP
-#line 105 "lexer.l"
-{ yylval->literal = jv_string(yytext); return IDENT;}
-	YY_BREAK
-case 34:
-/* rule 34 can match eol */
-YY_RULE_SETUP
-#line 107 "lexer.l"
-{}
-	YY_BREAK
-case 35:
-YY_RULE_SETUP
-#line 109 "lexer.l"
-{ return INVALID_CHARACTER; }
-	YY_BREAK
-case 36:
-YY_RULE_SETUP
-#line 111 "lexer.l"
-YY_FATAL_ERROR( "flex scanner jammed" );
-	YY_BREAK
-#line 1095 "lexer.gen.c"
-case YY_STATE_EOF(INITIAL):
-case YY_STATE_EOF(IN_PAREN):
-case YY_STATE_EOF(IN_BRACKET):
-case YY_STATE_EOF(IN_BRACE):
-case YY_STATE_EOF(IN_QQINTERP):
-case YY_STATE_EOF(IN_QQSTRING):
-	yyterminate();
-
-	case YY_END_OF_BUFFER:
-		{
-		/* Amount of text matched not including the EOB char. */
-		int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
-
-		/* Undo the effects of YY_DO_BEFORE_ACTION. */
-		*yy_cp = yyg->yy_hold_char;
-		YY_RESTORE_YY_MORE_OFFSET
-
-		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
-			{
-			/* We're scanning a new file or input source.  It's
-			 * possible that this happened because the user
-			 * just pointed yyin at a new source and called
-			 * jq_yylex().  If so, then we have to assure
-			 * consistency between YY_CURRENT_BUFFER and our
-			 * globals.  Here is the right place to do so, because
-			 * this is the first action (other than possibly a
-			 * back-up) that will match for the new input source.
-			 */
-			yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
-			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
-			}
-
-		/* Note that here we test for yy_c_buf_p "<=" to the position
-		 * of the first EOB in the buffer, since yy_c_buf_p will
-		 * already have been incremented past the NUL character
-		 * (since all states make transitions on EOB to the
-		 * end-of-buffer state).  Contrast this with the test
-		 * in input().
-		 */
-		if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
-			{ /* This was really a NUL. */
-			yy_state_type yy_next_state;
-
-			yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
-
-			yy_current_state = yy_get_previous_state( yyscanner );
-
-			/* Okay, we're now positioned to make the NUL
-			 * transition.  We couldn't have
-			 * yy_get_previous_state() go ahead and do it
-			 * for us because it doesn't know how to deal
-			 * with the possibility of jamming (and we don't
-			 * want to build jamming into it because then it
-			 * will run more slowly).
-			 */
-
-			yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
-
-			yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
-
-			if ( yy_next_state )
-				{
-				/* Consume the NUL. */
-				yy_cp = ++yyg->yy_c_buf_p;
-				yy_current_state = yy_next_state;
-				goto yy_match;
-				}
-
-			else
-				{
-				yy_cp = yyg->yy_c_buf_p;
-				goto yy_find_action;
-				}
-			}
-
-		else switch ( yy_get_next_buffer( yyscanner ) )
-			{
-			case EOB_ACT_END_OF_FILE:
-				{
-				yyg->yy_did_buffer_switch_on_eof = 0;
-
-				if ( jq_yywrap(yyscanner ) )
-					{
-					/* Note: because we've taken care in
-					 * yy_get_next_buffer() to have set up
-					 * yytext, we can now set up
-					 * yy_c_buf_p so that if some total
-					 * hoser (like flex itself) wants to
-					 * call the scanner after we return the
-					 * YY_NULL, it'll still work - another
-					 * YY_NULL will get returned.
-					 */
-					yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
-
-					yy_act = YY_STATE_EOF(YY_START);
-					goto do_action;
-					}
-
-				else
-					{
-					if ( ! yyg->yy_did_buffer_switch_on_eof )
-						YY_NEW_FILE;
-					}
-				break;
-				}
-
-			case EOB_ACT_CONTINUE_SCAN:
-				yyg->yy_c_buf_p =
-					yyg->yytext_ptr + yy_amount_of_matched_text;
-
-				yy_current_state = yy_get_previous_state( yyscanner );
-
-				yy_cp = yyg->yy_c_buf_p;
-				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
-				goto yy_match;
-
-			case EOB_ACT_LAST_MATCH:
-				yyg->yy_c_buf_p =
-				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
-
-				yy_current_state = yy_get_previous_state( yyscanner );
-
-				yy_cp = yyg->yy_c_buf_p;
-				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
-				goto yy_find_action;
-			}
-		break;
-		}
-
-	default:
-		YY_FATAL_ERROR(
-			"fatal flex scanner internal error--no action found" );
-	} /* end of action switch */
-		} /* end of scanning one token */
-} /* end of jq_yylex */
-
-/* yy_get_next_buffer - try to read in a new buffer
- *
- * Returns a code representing an action:
- *	EOB_ACT_LAST_MATCH -
- *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
- *	EOB_ACT_END_OF_FILE - end of file
- */
-static int yy_get_next_buffer (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
-	register char *source = yyg->yytext_ptr;
-	register int number_to_move, i;
-	int ret_val;
-
-	if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
-		YY_FATAL_ERROR(
-		"fatal flex scanner internal error--end of buffer missed" );
-
-	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
-		{ /* Don't try to fill the buffer, so this is an EOF. */
-		if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
-			{
-			/* We matched a single character, the EOB, so
-			 * treat this as a final EOF.
-			 */
-			return EOB_ACT_END_OF_FILE;
-			}
-
-		else
-			{
-			/* We matched some text prior to the EOB, first
-			 * process it.
-			 */
-			return EOB_ACT_LAST_MATCH;
-			}
-		}
-
-	/* Try to read more data. */
-
-	/* First move last chars to start of buffer. */
-	number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
-
-	for ( i = 0; i < number_to_move; ++i )
-		*(dest++) = *(source++);
-
-	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
-		/* don't do the read, it's not guaranteed to return an EOF,
-		 * just force an EOF
-		 */
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
-
-	else
-		{
-			int num_to_read =
-			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
-
-		while ( num_to_read <= 0 )
-			{ /* Not enough room in the buffer - grow it. */
-
-			/* just a shorter name for the current buffer */
-			YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
-
-			int yy_c_buf_p_offset =
-				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);
-
-			if ( b->yy_is_our_buffer )
-				{
-				int new_size = b->yy_buf_size * 2;
-
-				if ( new_size <= 0 )
-					b->yy_buf_size += b->yy_buf_size / 8;
-				else
-					b->yy_buf_size *= 2;
-
-				b->yy_ch_buf = (char *)
-					/* Include room in for 2 EOB chars. */
-					jq_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
-				}
-			else
-				/* Can't grow it, we don't own it. */
-				b->yy_ch_buf = 0;
-
-			if ( ! b->yy_ch_buf )
-				YY_FATAL_ERROR(
-				"fatal error - scanner input buffer overflow" );
-
-			yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
-
-			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
-						number_to_move - 1;
-
-			}
-
-		if ( num_to_read > YY_READ_BUF_SIZE )
-			num_to_read = YY_READ_BUF_SIZE;
-
-		/* Read in more data. */
-		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
-			yyg->yy_n_chars, (size_t) num_to_read );
-
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
-		}
-
-	if ( yyg->yy_n_chars == 0 )
-		{
-		if ( number_to_move == YY_MORE_ADJ )
-			{
-			ret_val = EOB_ACT_END_OF_FILE;
-			jq_yyrestart(yyin  ,yyscanner);
-			}
-
-		else
-			{
-			ret_val = EOB_ACT_LAST_MATCH;
-			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
-				YY_BUFFER_EOF_PENDING;
-			}
-		}
-
-	else
-		ret_val = EOB_ACT_CONTINUE_SCAN;
-
-	if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
-		/* Extend the array by 50%, plus the number we really need. */
-		yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
-		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) jq_yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
-		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
-			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
-	}
-
-	yyg->yy_n_chars += number_to_move;
-	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
-	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
-
-	yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
-
-	return ret_val;
-}
-
-/* yy_get_previous_state - get the state just before the EOB char was reached */
-
-    static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
-{
-	register yy_state_type yy_current_state;
-	register char *yy_cp;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	yy_current_state = yyg->yy_start;
-
-	for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
-		{
-		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
-		if ( yy_accept[yy_current_state] )
-			{
-			yyg->yy_last_accepting_state = yy_current_state;
-			yyg->yy_last_accepting_cpos = yy_cp;
-			}
-		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-			{
-			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 96 )
-				yy_c = yy_meta[(unsigned int) yy_c];
-			}
-		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-		}
-
-	return yy_current_state;
-}
-
-/* yy_try_NUL_trans - try to make a transition on the NUL character
- *
- * synopsis
- *	next_state = yy_try_NUL_trans( current_state );
- */
-    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
-{
-	register int yy_is_jam;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
-	register char *yy_cp = yyg->yy_c_buf_p;
-
-	register YY_CHAR yy_c = 1;
-	if ( yy_accept[yy_current_state] )
-		{
-		yyg->yy_last_accepting_state = yy_current_state;
-		yyg->yy_last_accepting_cpos = yy_cp;
-		}
-	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-		{
-		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 96 )
-			yy_c = yy_meta[(unsigned int) yy_c];
-		}
-	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-	yy_is_jam = (yy_current_state == 95);
-
-	return yy_is_jam ? 0 : yy_current_state;
-}
-
-#ifndef YY_NO_INPUT
-#ifdef __cplusplus
-    static int yyinput (yyscan_t yyscanner)
-#else
-    static int input  (yyscan_t yyscanner)
-#endif
-
-{
-	int c;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	*yyg->yy_c_buf_p = yyg->yy_hold_char;
-
-	if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
-		{
-		/* yy_c_buf_p now points to the character we want to return.
-		 * If this occurs *before* the EOB characters, then it's a
-		 * valid NUL; if not, then we've hit the end of the buffer.
-		 */
-		if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
-			/* This was really a NUL. */
-			*yyg->yy_c_buf_p = '\0';
-
-		else
-			{ /* need more input */
-			int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
-			++yyg->yy_c_buf_p;
-
-			switch ( yy_get_next_buffer( yyscanner ) )
-				{
-				case EOB_ACT_LAST_MATCH:
-					/* This happens because yy_g_n_b()
-					 * sees that we've accumulated a
-					 * token and flags that we need to
-					 * try matching the token before
-					 * proceeding.  But for input(),
-					 * there's no matching to consider.
-					 * So convert the EOB_ACT_LAST_MATCH
-					 * to EOB_ACT_END_OF_FILE.
-					 */
-
-					/* Reset buffer status. */
-					jq_yyrestart(yyin ,yyscanner);
-
-					/*FALLTHROUGH*/
-
-				case EOB_ACT_END_OF_FILE:
-					{
-					if ( jq_yywrap(yyscanner ) )
-						return EOF;
-
-					if ( ! yyg->yy_did_buffer_switch_on_eof )
-						YY_NEW_FILE;
-#ifdef __cplusplus
-					return yyinput(yyscanner);
-#else
-					return input(yyscanner);
-#endif
-					}
-
-				case EOB_ACT_CONTINUE_SCAN:
-					yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
-					break;
-				}
-			}
-		}
-
-	c = *(unsigned char *) yyg->yy_c_buf_p;	/* cast for 8-bit char's */
-	*yyg->yy_c_buf_p = '\0';	/* preserve yytext */
-	yyg->yy_hold_char = *++yyg->yy_c_buf_p;
-
-	return c;
-}
-#endif	/* ifndef YY_NO_INPUT */
-
-/** Immediately switch to a different input stream.
- * @param input_file A readable stream.
- * @param yyscanner The scanner object.
- * @note This function does not reset the start condition to @c INITIAL .
- */
-    void jq_yyrestart  (FILE * input_file , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	if ( ! YY_CURRENT_BUFFER ){
-        jq_yyensure_buffer_stack (yyscanner);
-		YY_CURRENT_BUFFER_LVALUE =
-            jq_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
-	}
-
-	jq_yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
-	jq_yy_load_buffer_state(yyscanner );
-}
-
-/** Switch to a different input buffer.
- * @param new_buffer The new input buffer.
- * @param yyscanner The scanner object.
- */
-    void jq_yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	/* TODO. We should be able to replace this entire function body
-	 * with
-	 *		jq_yypop_buffer_state();
-	 *		jq_yypush_buffer_state(new_buffer);
-     */
-	jq_yyensure_buffer_stack (yyscanner);
-	if ( YY_CURRENT_BUFFER == new_buffer )
-		return;
-
-	if ( YY_CURRENT_BUFFER )
-		{
-		/* Flush out information for old buffer. */
-		*yyg->yy_c_buf_p = yyg->yy_hold_char;
-		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
-		}
-
-	YY_CURRENT_BUFFER_LVALUE = new_buffer;
-	jq_yy_load_buffer_state(yyscanner );
-
-	/* We don't actually know whether we did this switch during
-	 * EOF (jq_yywrap()) processing, but the only time this flag
-	 * is looked at is after jq_yywrap() is called, so it's safe
-	 * to go ahead and always set it.
-	 */
-	yyg->yy_did_buffer_switch_on_eof = 1;
-}
-
-static void jq_yy_load_buffer_state  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-	yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
-	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
-	yyg->yy_hold_char = *yyg->yy_c_buf_p;
-}
-
-/** Allocate and initialize an input buffer state.
- * @param file A readable stream.
- * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
- * @param yyscanner The scanner object.
- * @return the allocated buffer state.
- */
-    YY_BUFFER_STATE jq_yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
-{
-	YY_BUFFER_STATE b;
-    
-	b = (YY_BUFFER_STATE) jq_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
-	if ( ! b )
-		YY_FATAL_ERROR( "out of dynamic memory in jq_yy_create_buffer()" );
-
-	b->yy_buf_size = size;
-
-	/* yy_ch_buf has to be 2 characters longer than the size given because
-	 * we need to put in 2 end-of-buffer characters.
-	 */
-	b->yy_ch_buf = (char *) jq_yyalloc(b->yy_buf_size + 2 ,yyscanner );
-	if ( ! b->yy_ch_buf )
-		YY_FATAL_ERROR( "out of dynamic memory in jq_yy_create_buffer()" );
-
-	b->yy_is_our_buffer = 1;
-
-	jq_yy_init_buffer(b,file ,yyscanner);
-
-	return b;
-}
-
-/** Destroy the buffer.
- * @param b a buffer created with jq_yy_create_buffer()
- * @param yyscanner The scanner object.
- */
-    void jq_yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	if ( ! b )
-		return;
-
-	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
-		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
-
-	if ( b->yy_is_our_buffer )
-		jq_yyfree((void *) b->yy_ch_buf ,yyscanner );
-
-	jq_yyfree((void *) b ,yyscanner );
-}
-
-#ifndef __cplusplus
-extern int isatty (int );
-#endif /* __cplusplus */
-    
-/* Initializes or reinitializes a buffer.
- * This function is sometimes called more than once on the same buffer,
- * such as during a jq_yyrestart() or at EOF.
- */
-    static void jq_yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
-
-{
-	int oerrno = errno;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	jq_yy_flush_buffer(b ,yyscanner);
-
-	b->yy_input_file = file;
-	b->yy_fill_buffer = 1;
-
-    /* If b is the current buffer, then jq_yy_init_buffer was _probably_
-     * called from jq_yyrestart() or through yy_get_next_buffer.
-     * In that case, we don't want to reset the lineno or column.
-     */
-    if (b != YY_CURRENT_BUFFER){
-        b->yy_bs_lineno = 1;
-        b->yy_bs_column = 0;
-    }
-
-        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
-    
-	errno = oerrno;
-}
-
-/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
- * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
- * @param yyscanner The scanner object.
- */
-    void jq_yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	if ( ! b )
-		return;
-
-	b->yy_n_chars = 0;
-
-	/* We always need two end-of-buffer characters.  The first causes
-	 * a transition to the end-of-buffer state.  The second causes
-	 * a jam in that state.
-	 */
-	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
-	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
-
-	b->yy_buf_pos = &b->yy_ch_buf[0];
-
-	b->yy_at_bol = 1;
-	b->yy_buffer_status = YY_BUFFER_NEW;
-
-	if ( b == YY_CURRENT_BUFFER )
-		jq_yy_load_buffer_state(yyscanner );
-}
-
-/** Pushes the new state onto the stack. The new state becomes
- *  the current state. This function will allocate the stack
- *  if necessary.
- *  @param new_buffer The new state.
- *  @param yyscanner The scanner object.
- */
-void jq_yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	if (new_buffer == NULL)
-		return;
-
-	jq_yyensure_buffer_stack(yyscanner);
-
-	/* This block is copied from jq_yy_switch_to_buffer. */
-	if ( YY_CURRENT_BUFFER )
-		{
-		/* Flush out information for old buffer. */
-		*yyg->yy_c_buf_p = yyg->yy_hold_char;
-		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
-		}
-
-	/* Only push if top exists. Otherwise, replace top. */
-	if (YY_CURRENT_BUFFER)
-		yyg->yy_buffer_stack_top++;
-	YY_CURRENT_BUFFER_LVALUE = new_buffer;
-
-	/* copied from jq_yy_switch_to_buffer. */
-	jq_yy_load_buffer_state(yyscanner );
-	yyg->yy_did_buffer_switch_on_eof = 1;
-}
-
-/** Removes and deletes the top of the stack, if present.
- *  The next element becomes the new top.
- *  @param yyscanner The scanner object.
- */
-void jq_yypop_buffer_state (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	if (!YY_CURRENT_BUFFER)
-		return;
-
-	jq_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
-	YY_CURRENT_BUFFER_LVALUE = NULL;
-	if (yyg->yy_buffer_stack_top > 0)
-		--yyg->yy_buffer_stack_top;
-
-	if (YY_CURRENT_BUFFER) {
-		jq_yy_load_buffer_state(yyscanner );
-		yyg->yy_did_buffer_switch_on_eof = 1;
-	}
-}
-
-/* Allocates the stack if it does not exist.
- *  Guarantees space for at least one push.
- */
-static void jq_yyensure_buffer_stack (yyscan_t yyscanner)
-{
-	int num_to_alloc;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	if (!yyg->yy_buffer_stack) {
-
-		/* First allocation is just for 2 elements, since we don't know if this
-		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
-		 * immediate realloc on the next call.
-         */
-		num_to_alloc = 1;
-		yyg->yy_buffer_stack = (struct yy_buffer_state**)jq_yyalloc
-								(num_to_alloc * sizeof(struct yy_buffer_state*)
-								, yyscanner);
-		if ( ! yyg->yy_buffer_stack )
-			YY_FATAL_ERROR( "out of dynamic memory in jq_yyensure_buffer_stack()" );
-								  
-		memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
-				
-		yyg->yy_buffer_stack_max = num_to_alloc;
-		yyg->yy_buffer_stack_top = 0;
-		return;
-	}
-
-	if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
-
-		/* Increase the buffer to prepare for a possible push. */
-		int grow_size = 8 /* arbitrary grow size */;
-
-		num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
-		yyg->yy_buffer_stack = (struct yy_buffer_state**)jq_yyrealloc
-								(yyg->yy_buffer_stack,
-								num_to_alloc * sizeof(struct yy_buffer_state*)
-								, yyscanner);
-		if ( ! yyg->yy_buffer_stack )
-			YY_FATAL_ERROR( "out of dynamic memory in jq_yyensure_buffer_stack()" );
-
-		/* zero only the new slots.*/
-		memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
-		yyg->yy_buffer_stack_max = num_to_alloc;
-	}
-}
-
-/** Setup the input buffer state to scan directly from a user-specified character buffer.
- * @param base the character buffer
- * @param size the size in bytes of the character buffer
- * @param yyscanner The scanner object.
- * @return the newly allocated buffer state object. 
- */
-YY_BUFFER_STATE jq_yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
-{
-	YY_BUFFER_STATE b;
-    
-	if ( size < 2 ||
-	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
-	     base[size-1] != YY_END_OF_BUFFER_CHAR )
-		/* They forgot to leave room for the EOB's. */
-		return 0;
-
-	b = (YY_BUFFER_STATE) jq_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
-	if ( ! b )
-		YY_FATAL_ERROR( "out of dynamic memory in jq_yy_scan_buffer()" );
-
-	b->yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */
-	b->yy_buf_pos = b->yy_ch_buf = base;
-	b->yy_is_our_buffer = 0;
-	b->yy_input_file = 0;
-	b->yy_n_chars = b->yy_buf_size;
-	b->yy_is_interactive = 0;
-	b->yy_at_bol = 1;
-	b->yy_fill_buffer = 0;
-	b->yy_buffer_status = YY_BUFFER_NEW;
-
-	jq_yy_switch_to_buffer(b ,yyscanner );
-
-	return b;
-}
-
-/** Setup the input buffer state to scan a string. The next call to jq_yylex() will
- * scan from a @e copy of @a str.
- * @param yystr a NUL-terminated string to scan
- * @param yyscanner The scanner object.
- * @return the newly allocated buffer state object.
- * @note If you want to scan bytes that may contain NUL values, then use
- *       jq_yy_scan_bytes() instead.
- */
-YY_BUFFER_STATE jq_yy_scan_string (yyconst char * yystr , yyscan_t yyscanner)
-{
-    
-	return jq_yy_scan_bytes(yystr,strlen(yystr) ,yyscanner);
-}
-
-/** Setup the input buffer state to scan the given bytes. The next call to jq_yylex() will
- * scan from a @e copy of @a bytes.
- * @param yybytes the byte buffer to scan
- * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
- * @param yyscanner The scanner object.
- * @return the newly allocated buffer state object.
- */
-YY_BUFFER_STATE jq_yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
-{
-	YY_BUFFER_STATE b;
-	char *buf;
-	yy_size_t n;
-	int i;
-    
-	/* Get memory for full buffer, including space for trailing EOB's. */
-	n = _yybytes_len + 2;
-	buf = (char *) jq_yyalloc(n ,yyscanner );
-	if ( ! buf )
-		YY_FATAL_ERROR( "out of dynamic memory in jq_yy_scan_bytes()" );
-
-	for ( i = 0; i < _yybytes_len; ++i )
-		buf[i] = yybytes[i];
-
-	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
-
-	b = jq_yy_scan_buffer(buf,n ,yyscanner);
-	if ( ! b )
-		YY_FATAL_ERROR( "bad buffer in jq_yy_scan_bytes()" );
-
-	/* It's okay to grow etc. this buffer, and we should throw it
-	 * away when we're done.
-	 */
-	b->yy_is_our_buffer = 1;
-
-	return b;
-}
-
-    static void yy_push_state (int  new_state , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	if ( yyg->yy_start_stack_ptr >= yyg->yy_start_stack_depth )
-		{
-		yy_size_t new_size;
-
-		yyg->yy_start_stack_depth += YY_START_STACK_INCR;
-		new_size = yyg->yy_start_stack_depth * sizeof( int );
-
-		if ( ! yyg->yy_start_stack )
-			yyg->yy_start_stack = (int *) jq_yyalloc(new_size ,yyscanner );
-
-		else
-			yyg->yy_start_stack = (int *) jq_yyrealloc((void *) yyg->yy_start_stack,new_size ,yyscanner );
-
-		if ( ! yyg->yy_start_stack )
-			YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
-		}
-
-	yyg->yy_start_stack[yyg->yy_start_stack_ptr++] = YY_START;
-
-	BEGIN(new_state);
-}
-
-    static void yy_pop_state  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	if ( --yyg->yy_start_stack_ptr < 0 )
-		YY_FATAL_ERROR( "start-condition stack underflow" );
-
-	BEGIN(yyg->yy_start_stack[yyg->yy_start_stack_ptr]);
-}
-
-    static int yy_top_state  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	return yyg->yy_start_stack[yyg->yy_start_stack_ptr - 1];
-}
-
-#ifndef YY_EXIT_FAILURE
-#define YY_EXIT_FAILURE 2
-#endif
-
-static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
-{
-    	(void) fprintf( stderr, "%s\n", msg );
-	exit( YY_EXIT_FAILURE );
-}
-
-/* Redefine yyless() so it works in section 3 code. */
-
-#undef yyless
-#define yyless(n) \
-	do \
-		{ \
-		/* Undo effects of setting up yytext. */ \
-        int yyless_macro_arg = (n); \
-        YY_LESS_LINENO(yyless_macro_arg);\
-		yytext[yyleng] = yyg->yy_hold_char; \
-		yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
-		yyg->yy_hold_char = *yyg->yy_c_buf_p; \
-		*yyg->yy_c_buf_p = '\0'; \
-		yyleng = yyless_macro_arg; \
-		} \
-	while ( 0 )
-
-/* Accessor  methods (get/set functions) to struct members. */
-
-/** Get the user-defined data for this scanner.
- * @param yyscanner The scanner object.
- */
-YY_EXTRA_TYPE jq_yyget_extra  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yyextra;
-}
-
-/** Get the current line number.
- * @param yyscanner The scanner object.
- */
-int jq_yyget_lineno  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    
-        if (! YY_CURRENT_BUFFER)
-            return 0;
-    
-    return yylineno;
-}
-
-/** Get the current column number.
- * @param yyscanner The scanner object.
- */
-int jq_yyget_column  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    
-        if (! YY_CURRENT_BUFFER)
-            return 0;
-    
-    return yycolumn;
-}
-
-/** Get the input stream.
- * @param yyscanner The scanner object.
- */
-FILE *jq_yyget_in  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yyin;
-}
-
-/** Get the output stream.
- * @param yyscanner The scanner object.
- */
-FILE *jq_yyget_out  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yyout;
-}
-
-/** Get the length of the current token.
- * @param yyscanner The scanner object.
- */
-int jq_yyget_leng  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yyleng;
-}
-
-/** Get the current token.
- * @param yyscanner The scanner object.
- */
-
-char *jq_yyget_text  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yytext;
-}
-
-/** Set the user-defined data. This data is never touched by the scanner.
- * @param user_defined The data to be associated with this scanner.
- * @param yyscanner The scanner object.
- */
-void jq_yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yyextra = user_defined ;
-}
-
-/** Set the current line number.
- * @param line_number
- * @param yyscanner The scanner object.
- */
-void jq_yyset_lineno (int  line_number , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-        /* lineno is only valid if an input buffer exists. */
-        if (! YY_CURRENT_BUFFER )
-           yy_fatal_error( "jq_yyset_lineno called with no buffer" , yyscanner); 
-    
-    yylineno = line_number;
-}
-
-/** Set the current column.
- * @param line_number
- * @param yyscanner The scanner object.
- */
-void jq_yyset_column (int  column_no , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-        /* column is only valid if an input buffer exists. */
-        if (! YY_CURRENT_BUFFER )
-           yy_fatal_error( "jq_yyset_column called with no buffer" , yyscanner); 
-    
-    yycolumn = column_no;
-}
-
-/** Set the input stream. This does not discard the current
- * input buffer.
- * @param in_str A readable stream.
- * @param yyscanner The scanner object.
- * @see jq_yy_switch_to_buffer
- */
-void jq_yyset_in (FILE *  in_str , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yyin = in_str ;
-}
-
-void jq_yyset_out (FILE *  out_str , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yyout = out_str ;
-}
-
-int jq_yyget_debug  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yy_flex_debug;
-}
-
-void jq_yyset_debug (int  bdebug , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yy_flex_debug = bdebug ;
-}
-
-/* Accessor methods for yylval and yylloc */
-
-YYSTYPE * jq_yyget_lval  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yylval;
-}
-
-void jq_yyset_lval (YYSTYPE *  yylval_param , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yylval = yylval_param;
-}
-
-YYLTYPE *jq_yyget_lloc  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yylloc;
-}
-    
-void jq_yyset_lloc (YYLTYPE *  yylloc_param , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yylloc = yylloc_param;
-}
-    
-/* User-visible API */
-
-/* jq_yylex_init is special because it creates the scanner itself, so it is
- * the ONLY reentrant function that doesn't take the scanner as the last argument.
- * That's why we explicitly handle the declaration, instead of using our macros.
- */
-
-int jq_yylex_init(yyscan_t* ptr_yy_globals)
-
-{
-    if (ptr_yy_globals == NULL){
-        errno = EINVAL;
-        return 1;
-    }
-
-    *ptr_yy_globals = (yyscan_t) jq_yyalloc ( sizeof( struct yyguts_t ), NULL );
-
-    if (*ptr_yy_globals == NULL){
-        errno = ENOMEM;
-        return 1;
-    }
-
-    /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
-    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
-
-    return yy_init_globals ( *ptr_yy_globals );
-}
-
-/* jq_yylex_init_extra has the same functionality as jq_yylex_init, but follows the
- * convention of taking the scanner as the last argument. Note however, that
- * this is a *pointer* to a scanner, as it will be allocated by this call (and
- * is the reason, too, why this function also must handle its own declaration).
- * The user defined value in the first argument will be available to jq_yyalloc in
- * the yyextra field.
- */
-
-int jq_yylex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
-
-{
-    struct yyguts_t dummy_yyguts;
-
-    jq_yyset_extra (yy_user_defined, &dummy_yyguts);
-
-    if (ptr_yy_globals == NULL){
-        errno = EINVAL;
-        return 1;
-    }
-	
-    *ptr_yy_globals = (yyscan_t) jq_yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
-	
-    if (*ptr_yy_globals == NULL){
-        errno = ENOMEM;
-        return 1;
-    }
-    
-    /* By setting to 0xAA, we expose bugs in
-    yy_init_globals. Leave at 0x00 for releases. */
-    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
-    
-    jq_yyset_extra (yy_user_defined, *ptr_yy_globals);
-    
-    return yy_init_globals ( *ptr_yy_globals );
-}
-
-static int yy_init_globals (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    /* Initialization is the same as for the non-reentrant scanner.
-     * This function is called from jq_yylex_destroy(), so don't allocate here.
-     */
-
-    yyg->yy_buffer_stack = 0;
-    yyg->yy_buffer_stack_top = 0;
-    yyg->yy_buffer_stack_max = 0;
-    yyg->yy_c_buf_p = (char *) 0;
-    yyg->yy_init = 0;
-    yyg->yy_start = 0;
-
-    yyg->yy_start_stack_ptr = 0;
-    yyg->yy_start_stack_depth = 0;
-    yyg->yy_start_stack =  NULL;
-
-/* Defined in main.c */
-#ifdef YY_STDINIT
-    yyin = stdin;
-    yyout = stdout;
-#else
-    yyin = (FILE *) 0;
-    yyout = (FILE *) 0;
-#endif
-
-    /* For future reference: Set errno on error, since we are called by
-     * jq_yylex_init()
-     */
-    return 0;
-}
-
-/* jq_yylex_destroy is for both reentrant and non-reentrant scanners. */
-int jq_yylex_destroy  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-    /* Pop the buffer stack, destroying each element. */
-	while(YY_CURRENT_BUFFER){
-		jq_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
-		YY_CURRENT_BUFFER_LVALUE = NULL;
-		jq_yypop_buffer_state(yyscanner);
-	}
-
-	/* Destroy the stack itself. */
-	jq_yyfree(yyg->yy_buffer_stack ,yyscanner);
-	yyg->yy_buffer_stack = NULL;
-
-    /* Destroy the start condition stack. */
-        jq_yyfree(yyg->yy_start_stack ,yyscanner );
-        yyg->yy_start_stack = NULL;
-
-    /* Reset the globals. This is important in a non-reentrant scanner so the next time
-     * jq_yylex() is called, initialization will occur. */
-    yy_init_globals( yyscanner);
-
-    /* Destroy the main struct (reentrant only). */
-    jq_yyfree ( yyscanner , yyscanner );
-    yyscanner = NULL;
-    return 0;
-}
-
-/*
- * Internal utility routines.
- */
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
-{
-	register int i;
-	for ( i = 0; i < n; ++i )
-		s1[i] = s2[i];
-}
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
-{
-	register int n;
-	for ( n = 0; s[n]; ++n )
-		;
-
-	return n;
-}
-#endif
-
-void *jq_yyalloc (yy_size_t  size , yyscan_t yyscanner)
-{
-	return (void *) malloc( size );
-}
-
-void *jq_yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
-{
-	/* The cast to (char *) in the following accommodates both
-	 * implementations that use char* generic pointers, and those
-	 * that use void* generic pointers.  It works with the latter
-	 * because both ANSI C and C++ allow castless assignment from
-	 * any pointer type to void*, and deal with argument conversions
-	 * as though doing an assignment.
-	 */
-	return (void *) realloc( (char *) ptr, size );
-}
-
-void jq_yyfree (void * ptr , yyscan_t yyscanner)
-{
-	free( (char *) ptr );	/* see jq_yyrealloc() for (char *) cast */
-}
-
-#define YYTABLES_NAME "yytables"
-
-#line 111 "lexer.l"
-
-
-/* perhaps these should be calls... */
-/*
-"true" { return TRUE; }
-"false" { return FALSE; }
-"null" { return NULL; }
-*/
-static int try_exit(int c, int state, yyscan_t yyscanner) {
-  char match = 0;
-  int ret;
-  switch (state) {
-  case IN_PAREN: match = ret = ')'; break;
-  case IN_BRACKET: match = ret = ']'; break;
-  case IN_BRACE: match = ret = '}'; break;
-
-  case IN_QQINTERP:
-    match = ')'; 
-    ret = QQSTRING_INTERP_END;
-    break;
-
-  default:
-    // may not be the best error to give
-    return INVALID_CHARACTER;
-  }
-  assert(match);
-  if (match == c) {
-    yy_pop_state(yyscanner);
-    return ret;
-  } else {
-    // FIXME: should we pop? Give a better error at least
-    return INVALID_CHARACTER;
-  }
-}
-
-static int enter(int c, int currstate, yyscan_t yyscanner) {
-  int state = 0;
-  switch (c) {
-  case '(': state = IN_PAREN; break;
-  case '[': state = IN_BRACKET; break;
-  case '{': state = IN_BRACE; break;
-  case QQSTRING_INTERP_START: state = IN_QQINTERP; break;
-  }
-  assert(state);
-  yy_push_state(state, yyscanner);
-  return c;
-}
-
diff --git a/lexer.gen.h b/lexer.gen.h
deleted file mode 100644
index 9249586d..00000000
--- a/lexer.gen.h
+++ /dev/null
@@ -1,362 +0,0 @@
-#ifndef jq_yyHEADER_H
-#define jq_yyHEADER_H 1
-#define jq_yyIN_HEADER 1
-
-#line 6 "lexer.gen.h"
-
-#line 8 "lexer.gen.h"
-
-#define  YY_INT_ALIGNED short int
-
-/* A lexical scanner generated by flex */
-
-#define FLEX_SCANNER
-#define YY_FLEX_MAJOR_VERSION 2
-#define YY_FLEX_MINOR_VERSION 5
-#define YY_FLEX_SUBMINOR_VERSION 35
-#if YY_FLEX_SUBMINOR_VERSION > 0
-#define FLEX_BETA
-#endif
-
-/* First, we deal with  platform-specific or compiler-specific issues. */
-
-/* begin standard C headers. */
-#include <stdio.h>
-#include <string.h>
-#include <errno.h>
-#include <stdlib.h>
-
-/* end standard C headers. */
-
-/* flex integer type definitions */
-
-#ifndef FLEXINT_H
-#define FLEXINT_H
-
-/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
-
-#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-
-/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
- * if you want the limit (max/min) macros for int types. 
- */
-#ifndef __STDC_LIMIT_MACROS
-#define __STDC_LIMIT_MACROS 1
-#endif
-
-#include <inttypes.h>
-typedef int8_t flex_int8_t;
-typedef uint8_t flex_uint8_t;
-typedef int16_t flex_int16_t;
-typedef uint16_t flex_uint16_t;
-typedef int32_t flex_int32_t;
-typedef uint32_t flex_uint32_t;
-#else
-typedef signed char flex_int8_t;
-typedef short int flex_int16_t;
-typedef int flex_int32_t;
-typedef unsigned char flex_uint8_t; 
-typedef unsigned short int flex_uint16_t;
-typedef unsigned int flex_uint32_t;
-
-/* Limits of integral types. */
-#ifndef INT8_MIN
-#define INT8_MIN               (-128)
-#endif
-#ifndef INT16_MIN
-#define INT16_MIN              (-32767-1)
-#endif
-#ifndef INT32_MIN
-#define INT32_MIN              (-2147483647-1)
-#endif
-#ifndef INT8_MAX
-#define INT8_MAX               (127)
-#endif
-#ifndef INT16_MAX
-#define INT16_MAX              (32767)
-#endif
-#ifndef INT32_MAX
-#define INT32_MAX              (2147483647)
-#endif
-#ifndef UINT8_MAX
-#define UINT8_MAX              (255U)
-#endif
-#ifndef UINT16_MAX
-#define UINT16_MAX             (65535U)
-#endif
-#ifndef UINT32_MAX
-#define UINT32_MAX             (4294967295U)
-#endif
-
-#endif /* ! C99 */
-
-#endif /* ! FLEXINT_H */
-
-#ifdef __cplusplus
-
-/* The "const" storage-class-modifier is valid. */
-#define YY_USE_CONST
-
-#else	/* ! __cplusplus */
-
-/* C99 requires __STDC__ to be defined as 1. */
-#if defined (__STDC__)
-
-#define YY_USE_CONST
-
-#endif	/* defined (__STDC__) */
-#endif	/* ! __cplusplus */
-
-#ifdef YY_USE_CONST
-#define yyconst const
-#else
-#define yyconst
-#endif
-
-/* An opaque pointer. */
-#ifndef YY_TYPEDEF_YY_SCANNER_T
-#define YY_TYPEDEF_YY_SCANNER_T
-typedef void* yyscan_t;
-#endif
-
-/* For convenience, these vars (plus the bison vars far below)
-   are macros in the reentrant scanner. */
-#define yyin yyg->yyin_r
-#define yyout yyg->yyout_r
-#define yyextra yyg->yyextra_r
-#define yyleng yyg->yyleng_r
-#define yytext yyg->yytext_r
-#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
-#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
-#define yy_flex_debug yyg->yy_flex_debug_r
-
-/* Size of default input buffer. */
-#ifndef YY_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k.
- * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
- * Ditto for the __ia64__ case accordingly.
- */
-#define YY_BUF_SIZE 32768
-#else
-#define YY_BUF_SIZE 16384
-#endif /* __ia64__ */
-#endif
-
-#ifndef YY_TYPEDEF_YY_BUFFER_STATE
-#define YY_TYPEDEF_YY_BUFFER_STATE
-typedef struct yy_buffer_state *YY_BUFFER_STATE;
-#endif
-
-#ifndef YY_TYPEDEF_YY_SIZE_T
-#define YY_TYPEDEF_YY_SIZE_T
-typedef size_t yy_size_t;
-#endif
-
-#ifndef YY_STRUCT_YY_BUFFER_STATE
-#define YY_STRUCT_YY_BUFFER_STATE
-struct yy_buffer_state
-	{
-	FILE *yy_input_file;
-
-	char *yy_ch_buf;		/* input buffer */
-	char *yy_buf_pos;		/* current position in input buffer */
-
-	/* Size of input buffer in bytes, not including room for EOB
-	 * characters.
-	 */
-	yy_size_t yy_buf_size;
-
-	/* Number of characters read into yy_ch_buf, not including EOB
-	 * characters.
-	 */
-	int yy_n_chars;
-
-	/* Whether we "own" the buffer - i.e., we know we created it,
-	 * and can realloc() it to grow it, and should free() it to
-	 * delete it.
-	 */
-	int yy_is_our_buffer;
-
-	/* Whether this is an "interactive" input source; if so, and
-	 * if we're using stdio for input, then we want to use getc()
-	 * instead of fread(), to make sure we stop fetching input after
-	 * each newline.
-	 */
-	int yy_is_interactive;
-
-	/* Whether we're considered to be at the beginning of a line.
-	 * If so, '^' rules will be active on the next match, otherwise
-	 * not.
-	 */
-	int yy_at_bol;
-
-    int yy_bs_lineno; /**< The line count. */
-    int yy_bs_column; /**< The column count. */
-    
-	/* Whether to try to fill the input buffer when we reach the
-	 * end of it.
-	 */
-	int yy_fill_buffer;
-
-	int yy_buffer_status;
-
-	};
-#endif /* !YY_STRUCT_YY_BUFFER_STATE */
-
-void jq_yyrestart (FILE *input_file ,yyscan_t yyscanner );
-void jq_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
-YY_BUFFER_STATE jq_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
-void jq_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
-void jq_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
-void jq_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
-void jq_yypop_buffer_state (yyscan_t yyscanner );
-
-YY_BUFFER_STATE jq_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
-YY_BUFFER_STATE jq_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
-YY_BUFFER_STATE jq_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
-
-void *jq_yyalloc (yy_size_t ,yyscan_t yyscanner );
-void *jq_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
-void jq_yyfree (void * ,yyscan_t yyscanner );
-
-/* Begin user sect3 */
-
-#define jq_yywrap(n) 1
-#define YY_SKIP_YYWRAP
-
-#define yytext_ptr yytext_r
-
-#ifdef YY_HEADER_EXPORT_START_CONDITIONS
-#define INITIAL 0
-#define IN_PAREN 1
-#define IN_BRACKET 2
-#define IN_BRACE 3
-#define IN_QQINTERP 4
-#define IN_QQSTRING 5
-
-#endif
-
-#ifndef YY_NO_UNISTD_H
-/* Special case for "unistd.h", since it is non-ANSI. We include it way
- * down here because we want the user's section 1 to have been scanned first.
- * The user has a chance to override it with an option.
- */
-#include <unistd.h>
-#endif
-
-#define YY_EXTRA_TYPE int
-
-int jq_yylex_init (yyscan_t* scanner);
-
-int jq_yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
-
-/* Accessor methods to globals.
-   These are made visible to non-reentrant scanners for convenience. */
-
-int jq_yylex_destroy (yyscan_t yyscanner );
-
-int jq_yyget_debug (yyscan_t yyscanner );
-
-void jq_yyset_debug (int debug_flag ,yyscan_t yyscanner );
-
-YY_EXTRA_TYPE jq_yyget_extra (yyscan_t yyscanner );
-
-void jq_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
-
-FILE *jq_yyget_in (yyscan_t yyscanner );
-
-void jq_yyset_in  (FILE * in_str ,yyscan_t yyscanner );
-
-FILE *jq_yyget_out (yyscan_t yyscanner );
-
-void jq_yyset_out  (FILE * out_str ,yyscan_t yyscanner );
-
-int jq_yyget_leng (yyscan_t yyscanner );
-
-char *jq_yyget_text (yyscan_t yyscanner );
-
-int jq_yyget_lineno (yyscan_t yyscanner );
-
-void jq_yyset_lineno (int line_number ,yyscan_t yyscanner );
-
-YYSTYPE * jq_yyget_lval (yyscan_t yyscanner );
-
-void jq_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
-
-       YYLTYPE *jq_yyget_lloc (yyscan_t yyscanner );
-    
-        void jq_yyset_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner );
-    
-/* Macros after this point can all be overridden by user definitions in
- * section 1.
- */
-
-#ifndef YY_SKIP_YYWRAP
-#ifdef __cplusplus
-extern "C" int jq_yywrap (yyscan_t yyscanner );
-#else
-extern int jq_yywrap (yyscan_t yyscanner );
-#endif
-#endif
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
-#endif
-
-#ifndef YY_NO_INPUT
-
-#endif
-
-/* Amount of stuff to slurp up with each read. */
-#ifndef YY_READ_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k */
-#define YY_READ_BUF_SIZE 16384
-#else
-#define YY_READ_BUF_SIZE 8192
-#endif /* __ia64__ */
-#endif
-
-/* Number of entries by which start-condition stack grows. */
-#ifndef YY_START_STACK_INCR
-#define YY_START_STACK_INCR 25
-#endif
-
-/* Default declaration of generated scanner - a define so the user can
- * easily add parameters.
- */
-#ifndef YY_DECL
-#define YY_DECL_IS_OURS 1
-
-extern int jq_yylex \
-               (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner);
-
-#define YY_DECL int jq_yylex \
-               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
-#endif /* !YY_DECL */
-
-/* yy_get_previous_state - get the state just before the EOB char was reached */
-
-#undef YY_NEW_FILE
-#undef YY_FLUSH_BUFFER
-#undef yy_set_bol
-#undef yy_new_buffer
-#undef yy_set_interactive
-#undef YY_DO_BEFORE_ACTION
-
-#ifdef YY_DECL_IS_OURS
-#undef YY_DECL_IS_OURS
-#undef YY_DECL
-#endif
-
-#line 111 "lexer.l"
-
-
-#line 361 "lexer.gen.h"
-#undef jq_yyIN_HEADER
-#endif /* jq_yyHEADER_H */
diff --git a/parser.gen.c b/parser.gen.c
deleted file mode 100644
index 0fb39b3c..00000000
--- a/parser.gen.c
+++ /dev/null
@@ -1,2855 +0,0 @@
-/* A Bison parser, made by GNU Bison 2.5.  */
-
-/* Bison implementation for Yacc-like parsers in C
-   
-      Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
-   
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-   
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-   
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
-
-/* As a special exception, you may create a larger work that contains
-   part or all of the Bison parser skeleton and distribute that work
-   under terms of your choice, so long as that work isn't itself a
-   parser generator using the skeleton or a modified version thereof
-   as a parser skeleton.  Alternatively, if you modify or redistribute
-   the parser skeleton itself, you may (at your option) remove this
-   special exception, which will cause the skeleton and the resulting
-   Bison output files to be licensed under the GNU General Public
-   License without this special exception.
-   
-   This special exception was added by the Free Software Foundation in
-   version 2.2 of Bison.  */
-
-/* C LALR(1) parser skeleton written by Richard Stallman, by
-   simplifying the original so-called "semantic" parser.  */
-
-/* All symbols defined below should begin with yy or YY, to avoid
-   infringing on user name space.  This should be done even for local
-   variables, as they might otherwise be expanded by user macros.
-   There are some unavoidable exceptions within include files to
-   define necessary library symbols; they are noted "INFRINGES ON
-   USER NAME SPACE" below.  */
-
-/* Identify Bison output.  */
-#define YYBISON 1
-
-/* Bison version.  */
-#define YYBISON_VERSION "2.5"
-
-/* Skeleton name.  */
-#define YYSKELETON_NAME "yacc.c"
-
-/* Pure parsers.  */
-#define YYPURE 1
-
-/* Push parsers.  */
-#define YYPUSH 0
-
-/* Pull parsers.  */
-#define YYPULL 1
-
-/* Using locations.  */
-#define YYLSP_NEEDED 1
-
-
-
-/* Copy the first part of user declarations.  */
-
-/* Line 268 of yacc.c  */
-#line 1 "parser.y"
-
-#include <stdio.h>
-#include <string.h>
-#include "compile.h"
-
-struct lexer_param;
-
-
-
-/* Line 268 of yacc.c  */
-#line 81 "parser.gen.c"
-
-/* Enabling traces.  */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-
-/* Enabling verbose error messages.  */
-#ifdef YYERROR_VERBOSE
-# undef YYERROR_VERBOSE
-# define YYERROR_VERBOSE 1
-#else
-# define YYERROR_VERBOSE 1
-#endif
-
-/* Enabling the token table.  */
-#ifndef YYTOKEN_TABLE
-# define YYTOKEN_TABLE 0
-#endif
-
-/* "%code requires" blocks.  */
-
-/* Line 288 of yacc.c  */
-#line 9 "parser.y"
-
-#include "locfile.h"
-#define YYLTYPE location
-#define YYLLOC_DEFAULT(Loc, Rhs, N)             \
-  do {                                          \
-    if (N) {                                    \
-      (Loc).start = YYRHSLOC(Rhs, 1).start;     \
-      (Loc).end = YYRHSLOC(Rhs, N).end;         \
-    } else {                                    \
-      (Loc).start = YYRHSLOC(Rhs, 0).end;       \
-      (Loc).end = YYRHSLOC(Rhs, 0).end;         \
-    }                                           \
-  } while (0)
- 
-
-
-/* Line 288 of yacc.c  */
-#line 122 "parser.gen.c"
-
-/* Tokens.  */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
-   /* Put the tokens into the symbol table, so that GDB and other debuggers
-      know about them.  */
-   enum yytokentype {
-     INVALID_CHARACTER = 258,
-     IDENT = 259,
-     LITERAL = 260,
-     EQ = 261,
-     NEQ = 262,
-     DEFINEDOR = 263,
-     AS = 264,
-     DEF = 265,
-     IF = 266,
-     THEN = 267,
-     ELSE = 268,
-     ELSE_IF = 269,
-     END = 270,
-     AND = 271,
-     OR = 272,
-     SETPIPE = 273,
-     SETPLUS = 274,
-     SETMINUS = 275,
-     SETMULT = 276,
-     SETDIV = 277,
-     SETDEFINEDOR = 278,
-     LESSEQ = 279,
-     GREATEREQ = 280,
-     CONTAINS = 281,
-     QQSTRING_START = 282,
-     QQSTRING_TEXT = 283,
-     QQSTRING_INTERP_START = 284,
-     QQSTRING_INTERP_END = 285,
-     QQSTRING_END = 286
-   };
-#endif
-
-
-
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE
-{
-
-/* Line 293 of yacc.c  */
-#line 27 "parser.y"
-
-  jv literal;
-  block blk;
-
-
-
-/* Line 293 of yacc.c  */
-#line 177 "parser.gen.c"
-} YYSTYPE;
-# define YYSTYPE_IS_TRIVIAL 1
-# define yystype YYSTYPE /* obsolescent; will be withdrawn */
-# define YYSTYPE_IS_DECLARED 1
-#endif
-
-#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
-typedef struct YYLTYPE
-{
-  int first_line;
-  int first_column;
-  int last_line;
-  int last_column;
-} YYLTYPE;
-# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
-# define YYLTYPE_IS_DECLARED 1
-# define YYLTYPE_IS_TRIVIAL 1
-#endif
-
-
-/* Copy the second part of user declarations.  */
-
-/* Line 343 of yacc.c  */
-#line 90 "parser.y"
-
-#include "lexer.gen.h"
-struct lexer_param {
-  yyscan_t lexer;
-};
-#define FAIL(loc, msg)                                             \
-  do {                                                             \
-    location l = loc;                                              \
-    yyerror(&l, answer, errors, locations, lexer_param_ptr, msg);  \
-    /*YYERROR*/;                                                   \
-  } while (0)
-
-void yyerror(YYLTYPE* loc, block* answer, int* errors, 
-             struct locfile* locations, struct lexer_param* lexer_param_ptr, const char *s){
-  (*errors)++;
-  locfile_locate(locations, *loc, "error: %s", s);
-}
-
-int yylex(YYSTYPE* yylval, YYLTYPE* yylloc, block* answer, int* errors, 
-          struct locfile* locations, struct lexer_param* lexer_param_ptr) {
-  yyscan_t lexer = lexer_param_ptr->lexer;
-  while (1) {
-    int tok = jq_yylex(yylval, yylloc, lexer);
-    if (tok == INVALID_CHARACTER) {
-      FAIL(*yylloc, "Invalid character");
-    } else {
-      if ((tok == LITERAL || tok == QQSTRING_TEXT) && !jv_is_valid(yylval->literal)) {
-        jv msg = jv_invalid_get_msg(jv_copy(yylval->literal));
-        if (jv_get_kind(msg) == JV_KIND_STRING) {
-          FAIL(*yylloc, jv_string_value(msg));
-        } else {
-          FAIL(*yylloc, "Invalid literal");
-        }
-        jv_free(msg);
-        jv_free(yylval->literal);
-        yylval->literal = jv_null();
-      }
-      return tok;
-    }
-  }
-}
-
-static block gen_dictpair(block k, block v) {
-  return BLOCK(gen_subexp(k), gen_subexp(v), gen_op_simple(INSERT));
-}
-
-static block gen_index(block obj, block key) {
-  return BLOCK(obj, gen_subexp(key), gen_op_simple(INDEX));
-}
-
-static block gen_binop(block a, block b, int op) {
-  const char* funcname = 0;
-  switch (op) {
-  case '+': funcname = "_plus"; break;
-  case '-': funcname = "_minus"; break;
-  case '*': funcname = "_multiply"; break;
-  case '/': funcname = "_divide"; break;
-  case EQ: funcname = "_equal"; break;
-  case NEQ: funcname = "_notequal"; break;
-  case '<': funcname = "_less"; break;
-  case '>': funcname = "_greater"; break;
-  case LESSEQ: funcname = "_lesseq"; break;
-  case GREATEREQ: funcname = "_greatereq"; break;
-  case CONTAINS: funcname = "_contains"; break;
-  }
-  assert(funcname);
-
-  return gen_call(funcname, BLOCK(gen_lambda(a), gen_lambda(b)));
-}
-
-static block gen_format(block a) {
-  return BLOCK(a, gen_call("tostring", gen_noop()));
-}
- 
-static block gen_update(block a, block op, int optype) {
-  if (optype) {
-    op = gen_binop(gen_noop(), op, optype);
-  }
-  return gen_assign(BLOCK(a, gen_op_simple(DUP), op));
-}
-
-
-
-/* Line 343 of yacc.c  */
-#line 286 "parser.gen.c"
-
-#ifdef short
-# undef short
-#endif
-
-#ifdef YYTYPE_UINT8
-typedef YYTYPE_UINT8 yytype_uint8;
-#else
-typedef unsigned char yytype_uint8;
-#endif
-
-#ifdef YYTYPE_INT8
-typedef YYTYPE_INT8 yytype_int8;
-#elif (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-typedef signed char yytype_int8;
-#else
-typedef short int yytype_int8;
-#endif
-
-#ifdef YYTYPE_UINT16
-typedef YYTYPE_UINT16 yytype_uint16;
-#else
-typedef unsigned short int yytype_uint16;
-#endif
-
-#ifdef YYTYPE_INT16
-typedef YYTYPE_INT16 yytype_int16;
-#else
-typedef short int yytype_int16;
-#endif
-
-#ifndef YYSIZE_T
-# ifdef __SIZE_TYPE__
-#  define YYSIZE_T __SIZE_TYPE__
-# elif defined size_t
-#  define YYSIZE_T size_t
-# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-#  define YYSIZE_T size_t
-# else
-#  define YYSIZE_T unsigned int
-# endif
-#endif
-
-#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
-
-#ifndef YY_
-# if defined YYENABLE_NLS && YYENABLE_NLS
-#  if ENABLE_NLS
-#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
-#   define YY_(msgid) dgettext ("bison-runtime", msgid)
-#  endif
-# endif
-# ifndef YY_
-#  define YY_(msgid) msgid
-# endif
-#endif
-
-/* Suppress unused-variable warnings by "using" E.  */
-#if ! defined lint || defined __GNUC__
-# define YYUSE(e) ((void) (e))
-#else
-# define YYUSE(e) /* empty */
-#endif
-
-/* Identity function, used to suppress warnings about constant conditions.  */
-#ifndef lint
-# define YYID(n) (n)
-#else
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static int
-YYID (int yyi)
-#else
-static int
-YYID (yyi)
-    int yyi;
-#endif
-{
-  return yyi;
-}
-#endif
-
-#if ! defined yyoverflow || YYERROR_VERBOSE
-
-/* The parser invokes alloca or malloc; define the necessary symbols.  */
-
-# ifdef YYSTACK_USE_ALLOCA
-#  if YYSTACK_USE_ALLOCA
-#   ifdef __GNUC__
-#    define YYSTACK_ALLOC __builtin_alloca
-#   elif defined __BUILTIN_VA_ARG_INCR
-#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
-#   elif defined _AIX
-#    define YYSTACK_ALLOC __alloca
-#   elif defined _MSC_VER
-#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
-#    define alloca _alloca
-#   else
-#    define YYSTACK_ALLOC alloca
-#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-#     ifndef EXIT_SUCCESS
-#      define EXIT_SUCCESS 0
-#     endif
-#    endif
-#   endif
-#  endif
-# endif
-
-# ifdef YYSTACK_ALLOC
-   /* Pacify GCC's `empty if-body' warning.  */
-#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
-#  ifndef YYSTACK_ALLOC_MAXIMUM
-    /* The OS might guarantee only one guard page at the bottom of the stack,
-       and a page size can be as small as 4096 bytes.  So we cannot safely
-       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
-       to allow for a few compiler-allocated temporary stack slots.  */
-#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
-#  endif
-# else
-#  define YYSTACK_ALLOC YYMALLOC
-#  define YYSTACK_FREE YYFREE
-#  ifndef YYSTACK_ALLOC_MAXIMUM
-#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
-#  endif
-#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
-       && ! ((defined YYMALLOC || defined malloc) \
-	     && (defined YYFREE || defined free)))
-#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-#   ifndef EXIT_SUCCESS
-#    define EXIT_SUCCESS 0
-#   endif
-#  endif
-#  ifndef YYMALLOC
-#   define YYMALLOC malloc
-#   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
-#   endif
-#  endif
-#  ifndef YYFREE
-#   define YYFREE free
-#   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-void free (void *); /* INFRINGES ON USER NAME SPACE */
-#   endif
-#  endif
-# endif
-#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
-
-
-#if (! defined yyoverflow \
-     && (! defined __cplusplus \
-	 || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
-	     && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
-
-/* A type that is properly aligned for any stack member.  */
-union yyalloc
-{
-  yytype_int16 yyss_alloc;
-  YYSTYPE yyvs_alloc;
-  YYLTYPE yyls_alloc;
-};
-
-/* The size of the maximum gap between one aligned stack and the next.  */
-# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
-
-/* The size of an array large to enough to hold all stacks, each with
-   N elements.  */
-# define YYSTACK_BYTES(N) \
-     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
-      + 2 * YYSTACK_GAP_MAXIMUM)
-
-# define YYCOPY_NEEDED 1
-
-/* Relocate STACK from its old location to the new one.  The
-   local variables YYSIZE and YYSTACKSIZE give the old and new number of
-   elements in the stack, and YYPTR gives the new location of the
-   stack.  Advance YYPTR to a properly aligned location for the next
-   stack.  */
-# define YYSTACK_RELOCATE(Stack_alloc, Stack)				\
-    do									\
-      {									\
-	YYSIZE_T yynewbytes;						\
-	YYCOPY (&yyptr->Stack_alloc, Stack, yysize);			\
-	Stack = &yyptr->Stack_alloc;					\
-	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
-	yyptr += yynewbytes / sizeof (*yyptr);				\
-      }									\
-    while (YYID (0))
-
-#endif
-
-#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
-/* Copy COUNT objects from FROM to TO.  The source and destination do
-   not overlap.  */
-# ifndef YYCOPY
-#  if defined __GNUC__ && 1 < __GNUC__
-#   define YYCOPY(To, From, Count) \
-      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
-#  else
-#   define YYCOPY(To, From, Count)		\
-      do					\
-	{					\
-	  YYSIZE_T yyi;				\
-	  for (yyi = 0; yyi < (Count); yyi++)	\
-	    (To)[yyi] = (From)[yyi];		\
-	}					\
-      while (YYID (0))
-#  endif
-# endif
-#endif /* !YYCOPY_NEEDED */
-
-/* YYFINAL -- State number of the termination state.  */
-#define YYFINAL  35
-/* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   854
-
-/* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  51
-/* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  12
-/* YYNRULES -- Number of rules.  */
-#define YYNRULES  70
-/* YYNRULES -- Number of states.  */
-#define YYNSTATES  151
-
-/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
-#define YYUNDEFTOK  2
-#define YYMAXUTOK   286
-
-#define YYTRANSLATE(YYX)						\
-  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
-
-/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
-static const yytype_uint8 yytranslate[] =
-{
-       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,    42,     2,     2,     2,
-      44,    45,    40,    38,    34,    39,    46,    41,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,    43,    32,
-      36,    35,    37,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,    47,     2,    48,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,    49,    33,    50,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31
-};
-
-#if YYDEBUG
-/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
-   YYRHS.  */
-static const yytype_uint16 yyprhs[] =
-{
-       0,     0,     3,     5,     7,     8,    11,    14,    21,    27,
-      31,    35,    39,    43,    47,    51,    55,    59,    63,    67,
-      71,    75,    79,    83,    87,    91,    95,    99,   103,   107,
-     111,   115,   119,   123,   125,   129,   135,   144,   145,   148,
-     153,   159,   163,   167,   169,   171,   175,   178,   183,   187,
-     189,   191,   195,   199,   202,   206,   209,   211,   216,   220,
-     224,   229,   233,   234,   236,   240,   244,   248,   252,   254,
-     260
-};
-
-/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
-static const yytype_int8 yyrhs[] =
-{
-      52,     0,    -1,    54,    -1,    53,    -1,    -1,    56,    53,
-      -1,    56,    54,    -1,    60,     9,    42,     4,    33,    54,
-      -1,    11,    54,    12,    54,    58,    -1,    11,    54,     1,
-      -1,    54,    35,    54,    -1,    54,    17,    54,    -1,    54,
-      16,    54,    -1,    54,     8,    54,    -1,    54,    23,    54,
-      -1,    54,    18,    54,    -1,    54,    33,    54,    -1,    54,
-      34,    54,    -1,    54,    38,    54,    -1,    54,    19,    54,
-      -1,    54,    39,    54,    -1,    54,    20,    54,    -1,    54,
-      40,    54,    -1,    54,    21,    54,    -1,    54,    41,    54,
-      -1,    54,    22,    54,    -1,    54,     6,    54,    -1,    54,
-       7,    54,    -1,    54,    36,    54,    -1,    54,    37,    54,
-      -1,    54,    24,    54,    -1,    54,    25,    54,    -1,    54,
-      26,    54,    -1,    60,    -1,    27,    57,    31,    -1,    10,
-       4,    43,    54,    32,    -1,    10,     4,    44,     4,    45,
-      43,    54,    32,    -1,    -1,    57,    28,    -1,    57,    29,
-      54,    30,    -1,    14,    54,    12,    54,    58,    -1,    13,
-      54,    15,    -1,    59,    33,    59,    -1,    60,    -1,    46,
-      -1,    60,    46,     4,    -1,    46,     4,    -1,    60,    47,
-      54,    48,    -1,    60,    47,    48,    -1,     5,    -1,    55,
-      -1,    44,    54,    45,    -1,    47,    54,    48,    -1,    47,
-      48,    -1,    49,    61,    50,    -1,    42,     4,    -1,     4,
-      -1,     4,    44,    54,    45,    -1,    44,     1,    45,    -1,
-      47,     1,    48,    -1,    60,    47,     1,    48,    -1,    49,
-       1,    50,    -1,    -1,    62,    -1,    62,    34,    61,    -1,
-       1,    34,    61,    -1,     4,    43,    59,    -1,    55,    43,
-      59,    -1,     4,    -1,    44,    54,    45,    43,    59,    -1,
-      44,     1,    45,    43,    59,    -1
-};
-
-/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
-static const yytype_uint16 yyrline[] =
-{
-       0,   175,   175,   178,   183,   186,   191,   195,   202,   205,
-     210,   214,   218,   222,   226,   230,   234,   238,   242,   246,
-     250,   254,   258,   262,   266,   270,   274,   278,   282,   286,
-     290,   294,   298,   302,   307,   312,   317,   325,   328,   331,
-     337,   340,   345,   349,   355,   358,   361,   365,   368,   371,
-     374,   377,   380,   383,   386,   389,   393,   397,   402,   403,
-     404,   405,   408,   411,   412,   413,   416,   419,   422,   426,
-     429
-};
-#endif
-
-#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
-/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
-   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
-static const char *const yytname[] =
-{
-  "$end", "error", "$undefined", "INVALID_CHARACTER", "IDENT", "LITERAL",
-  "\"==\"", "\"!=\"", "\"//\"", "\"as\"", "\"def\"", "\"if\"", "\"then\"",
-  "\"else\"", "\"elif\"", "\"end\"", "\"and\"", "\"or\"", "\"|=\"",
-  "\"+=\"", "\"-=\"", "\"*=\"", "\"/=\"", "\"//=\"", "\"<=\"", "\">=\"",
-  "\"contains\"", "QQSTRING_START", "QQSTRING_TEXT",
-  "QQSTRING_INTERP_START", "QQSTRING_INTERP_END", "QQSTRING_END", "';'",
-  "'|'", "','", "'='", "'<'", "'>'", "'+'", "'-'", "'*'", "'/'", "'$'",
-  "':'", "'('", "')'", "'.'", "'['", "']'", "'{'", "'}'", "$accept",
-  "TopLevel", "FuncDefs", "Exp", "String", "FuncDef", "QQString",
-  "ElseBody", "ExpD", "Term", "MkDict", "MkDictPair", 0
-};
-#endif
-
-# ifdef YYPRINT
-/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
-   token YYLEX-NUM.  */
-static const yytype_uint16 yytoknum[] =
-{
-       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,    59,   124,    44,    61,    60,    62,    43,    45,
-      42,    47,    36,    58,    40,    41,    46,    91,    93,   123,
-     125
-};
-# endif
-
-/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
-static const yytype_uint8 yyr1[] =
-{
-       0,    51,    52,    52,    53,    53,    54,    54,    54,    54,
-      54,    54,    54,    54,    54,    54,    54,    54,    54,    54,
-      54,    54,    54,    54,    54,    54,    54,    54,    54,    54,
-      54,    54,    54,    54,    55,    56,    56,    57,    57,    57,
-      58,    58,    59,    59,    60,    60,    60,    60,    60,    60,
-      60,    60,    60,    60,    60,    60,    60,    60,    60,    60,
-      60,    60,    61,    61,    61,    61,    62,    62,    62,    62,
-      62
-};
-
-/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
-static const yytype_uint8 yyr2[] =
-{
-       0,     2,     1,     1,     0,     2,     2,     6,     5,     3,
-       3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-       3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-       3,     3,     3,     1,     3,     5,     8,     0,     2,     4,
-       5,     3,     3,     1,     1,     3,     2,     4,     3,     1,
-       1,     3,     3,     2,     3,     2,     1,     4,     3,     3,
-       4,     3,     0,     1,     3,     3,     3,     3,     1,     5,
-       5
-};
-
-/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
-   Performed when YYTABLE doesn't specify something else to do.  Zero
-   means the default is an error.  */
-static const yytype_uint8 yydefact[] =
-{
-       4,    56,    49,     0,     0,    37,     0,     0,    44,     0,
-       0,     0,     3,     2,    50,     4,    33,     0,     0,     0,
-       0,     0,    55,     0,     0,    46,     0,    53,     0,     0,
-      68,     0,     0,     0,    63,     1,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
-       6,     0,     0,     0,     0,     0,     0,     9,     0,    38,
-       0,    34,    58,    51,    59,    52,     0,    61,     0,     0,
-       0,     0,    54,     0,    26,    27,    13,    12,    11,    15,
-      19,    21,    23,    25,    14,    30,    31,    32,    16,    17,
-      10,    28,    29,    18,    20,    22,    24,     0,    45,     0,
-      48,     0,    57,     0,     0,     0,     0,     0,    65,    66,
-      43,     0,     0,    67,    64,     0,    60,    47,    35,     0,
-       0,     0,     8,    39,     0,     0,     0,     0,     0,     0,
-       0,    42,    70,    69,     7,     0,    41,     0,    36,     0,
-      40
-};
-
-/* YYDEFGOTO[NTERM-NUM].  */
-static const yytype_int16 yydefgoto[] =
-{
-      -1,    11,    12,    60,    14,    20,    21,   132,   119,    16,
-      33,    34
-};
-
-/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
-   STATE-NUM.  */
-#define YYPACT_NINF -76
-static const yytype_int16 yypact[] =
-{
-     179,   -42,   -76,    10,   179,   -76,    16,   131,    18,    79,
-      65,    28,   -76,   662,   -76,   179,    53,   179,   -28,   302,
-     179,   -18,   -76,   -15,   338,   -76,   -19,   -76,   223,   -29,
-     -11,   155,   -10,    14,     1,   -76,   179,   179,   179,   179,
-     179,   179,   179,   179,   179,   179,   179,   179,   179,   179,
-     179,   179,   179,   179,   179,   179,   179,   179,   179,   -76,
-     662,    -8,    72,   106,   374,   179,    73,   -76,   179,   -76,
-     179,   -76,   -76,   -76,   -76,   -76,    74,   -76,   165,    34,
-     410,   165,   -76,    74,   807,   807,   734,   813,   786,   760,
-     760,   760,   760,   760,   760,   807,   807,   807,   698,   734,
-     760,   807,   807,   -16,   -16,   -76,   -76,    77,   -76,    37,
-     -76,   259,   -76,   482,    41,   446,   518,    48,   -76,    54,
-     -20,    45,    50,    54,   -76,    58,   -76,   -76,   -76,    51,
-     179,   179,   -76,   -76,   165,   165,   165,   179,   179,   554,
-     590,   -76,    54,    54,   698,   626,   -76,   179,   -76,   446,
-     -76
-};
-
-/* YYPGOTO[NTERM-NUM].  */
-static const yytype_int8 yypgoto[] =
-{
-     -76,   -76,    80,     0,    -9,     8,   -76,   -53,   -63,   -75,
-     -64,   -76
-};
-
-/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
-   positive, shift that token.  If negative, reduce the rule which
-   number is the opposite.  If YYTABLE_NINF, syntax error.  */
-#define YYTABLE_NINF -63
-static const yytype_int16 yytable[] =
-{
-      13,    32,    17,   120,    19,    76,   120,    24,    15,    28,
-      69,    70,   118,    71,    18,    65,    66,    64,   123,   124,
-      22,    77,    25,    15,    57,    58,    62,    63,    35,    74,
-      72,    80,    78,    81,   107,    83,    84,    85,    86,    87,
-      88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
-      98,    99,   100,   101,   102,   103,   104,   105,   106,   120,
-     120,   120,    61,   111,    82,   113,    29,    32,   115,    30,
-     116,   141,   142,   143,    32,   117,   108,   114,    30,   121,
-      26,   125,    76,     1,     2,   126,   129,   134,   135,     3,
-       4,   137,     5,   136,   138,    59,   150,     0,     0,    62,
-      63,     5,     0,     0,     0,     0,     5,   109,     0,    31,
-       1,     2,     0,     0,     0,   -62,     3,     4,    31,     0,
-       0,     6,     0,     7,   -62,     8,     9,    27,    10,     0,
-     139,   140,    23,     5,     0,     1,     2,   144,   145,     0,
-       0,     3,     4,     0,     0,     0,     0,   149,     6,     0,
-       7,     0,     8,     9,   110,    10,    79,     0,     5,     1,
-       2,     0,     0,     0,     0,     3,     4,     0,     0,     1,
-       2,     0,     0,     6,     0,     7,     0,     8,     9,     0,
-      10,     0,     5,     1,     2,     0,     0,     0,     0,     3,
-       4,     0,     5,     0,     0,     0,     0,     6,     0,     7,
-       0,     8,     9,     0,    10,     0,     5,     6,     0,     7,
-       0,     8,     9,     0,    10,     0,     0,     0,     0,     0,
-       0,     6,     0,     7,     0,     8,     9,     0,    10,    36,
-      37,    38,     0,     0,     0,     0,     0,     0,     0,    39,
-      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
-       0,     0,     0,     0,     0,     0,    50,    51,    52,    53,
-      54,    55,    56,    57,    58,    36,    37,    38,     0,     0,
-       0,    75,     0,     0,     0,    39,    40,    41,    42,    43,
-      44,    45,    46,    47,    48,    49,     0,     0,     0,     0,
-       0,     0,    50,    51,    52,    53,    54,    55,    56,    57,
-      58,     0,     0,    67,     0,     0,     0,   127,    36,    37,
-      38,     0,     0,     0,    68,     0,     0,     0,    39,    40,
-      41,    42,    43,    44,    45,    46,    47,    48,    49,     0,
-       0,     0,     0,     0,     0,    50,    51,    52,    53,    54,
-      55,    56,    57,    58,    36,    37,    38,     0,     0,     0,
-       0,     0,     0,     0,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    49,     0,     0,     0,     0,     0,
-       0,    50,    51,    52,    53,    54,    55,    56,    57,    58,
-      36,    37,    38,    73,     0,     0,     0,     0,     0,     0,
-      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
-      49,     0,     0,     0,     0,     0,     0,    50,    51,    52,
-      53,    54,    55,    56,    57,    58,    36,    37,    38,   112,
-       0,     0,     0,     0,     0,     0,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,    49,     0,     0,     0,
-       0,     0,     0,    50,    51,    52,    53,    54,    55,    56,
-      57,    58,    36,    37,    38,   122,     0,     0,     0,   130,
-     131,     0,    39,    40,    41,    42,    43,    44,    45,    46,
-      47,    48,    49,     0,     0,     0,     0,     0,     0,    50,
-      51,    52,    53,    54,    55,    56,    57,    58,    36,    37,
-      38,     0,     0,     0,     0,     0,     0,     0,    39,    40,
-      41,    42,    43,    44,    45,    46,    47,    48,    49,     0,
-       0,     0,     0,     0,   128,    50,    51,    52,    53,    54,
-      55,    56,    57,    58,    36,    37,    38,     0,     0,     0,
-       0,     0,     0,     0,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    49,     0,     0,     0,   133,     0,
-       0,    50,    51,    52,    53,    54,    55,    56,    57,    58,
-      36,    37,    38,     0,     0,     0,     0,     0,     0,   146,
-      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
-      49,     0,     0,     0,     0,     0,     0,    50,    51,    52,
-      53,    54,    55,    56,    57,    58,    36,    37,    38,     0,
-       0,     0,   147,     0,     0,     0,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,    49,     0,     0,     0,
-       0,     0,     0,    50,    51,    52,    53,    54,    55,    56,
-      57,    58,    36,    37,    38,     0,     0,     0,     0,     0,
-       0,     0,    39,    40,    41,    42,    43,    44,    45,    46,
-      47,    48,    49,     0,     0,     0,     0,     0,   148,    50,
-      51,    52,    53,    54,    55,    56,    57,    58,    36,    37,
-      38,     0,     0,     0,     0,     0,     0,     0,    39,    40,
-      41,    42,    43,    44,    45,    46,    47,    48,    49,     0,
-       0,     0,     0,     0,     0,    50,    51,    52,    53,    54,
-      55,    56,    57,    58,    36,    37,    38,     0,     0,     0,
-       0,     0,     0,     0,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    49,     0,     0,     0,     0,     0,
-       0,     0,    51,    52,    53,    54,    55,    56,    57,    58,
-      36,    37,    38,     0,     0,     0,     0,     0,     0,     0,
-      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
-      49,     0,     0,     0,     0,     0,    36,    37,     0,    52,
-      53,    54,    55,    56,    57,    58,    39,    40,   -63,   -63,
-     -63,   -63,   -63,   -63,    47,    48,    49,     0,     0,     0,
-       0,     0,    36,    37,     0,   -63,    53,    54,    55,    56,
-      57,    58,    39,     0,     0,     0,     0,     0,     0,     0,
-      47,    48,    49,   -63,   -63,     0,     0,     0,     0,    36,
-      37,     0,    53,    54,    55,    56,    57,    58,     0,     0,
-       0,   -63,   -63,   -63,     0,     0,     0,    47,    48,    49,
-       0,     0,     0,   -63,   -63,    55,    56,    57,    58,    53,
-      54,    55,    56,    57,    58
-};
-
-#define yypact_value_is_default(yystate) \
-  ((yystate) == (-76))
-
-#define yytable_value_is_error(yytable_value) \
-  ((yytable_value) == (-63))
-
-static const yytype_int16 yycheck[] =
-{
-       0,    10,    44,    78,     4,    34,    81,     7,     0,     9,
-      28,    29,    76,    31,     4,    43,    44,    17,    81,    83,
-       4,    50,     4,    15,    40,    41,    46,    47,     0,    48,
-      45,    31,    43,    43,    42,    34,    36,    37,    38,    39,
-      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    57,    58,   134,
-     135,   136,     9,    63,    50,    65,     1,    76,    68,     4,
-      70,   134,   135,   136,    83,     1,     4,     4,     4,    45,
-       1,     4,    34,     4,     5,    48,    45,    33,    43,    10,
-      11,    33,    27,    43,    43,    15,   149,    -1,    -1,    46,
-      47,    27,    -1,    -1,    -1,    -1,    27,     1,    -1,    44,
-       4,     5,    -1,    -1,    -1,    50,    10,    11,    44,    -1,
-      -1,    42,    -1,    44,    50,    46,    47,    48,    49,    -1,
-     130,   131,     1,    27,    -1,     4,     5,   137,   138,    -1,
-      -1,    10,    11,    -1,    -1,    -1,    -1,   147,    42,    -1,
-      44,    -1,    46,    47,    48,    49,     1,    -1,    27,     4,
-       5,    -1,    -1,    -1,    -1,    10,    11,    -1,    -1,     4,
-       5,    -1,    -1,    42,    -1,    44,    -1,    46,    47,    -1,
-      49,    -1,    27,     4,     5,    -1,    -1,    -1,    -1,    10,
-      11,    -1,    27,    -1,    -1,    -1,    -1,    42,    -1,    44,
-      -1,    46,    47,    -1,    49,    -1,    27,    42,    -1,    44,
-      -1,    46,    47,    -1,    49,    -1,    -1,    -1,    -1,    -1,
-      -1,    42,    -1,    44,    -1,    46,    47,    -1,    49,     6,
-       7,     8,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      -1,    -1,    -1,    -1,    -1,    -1,    33,    34,    35,    36,
-      37,    38,    39,    40,    41,     6,     7,     8,    -1,    -1,
-      -1,    48,    -1,    -1,    -1,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    -1,    -1,    -1,    -1,
-      -1,    -1,    33,    34,    35,    36,    37,    38,    39,    40,
-      41,    -1,    -1,     1,    -1,    -1,    -1,    48,     6,     7,
-       8,    -1,    -1,    -1,    12,    -1,    -1,    -1,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
-      -1,    -1,    -1,    -1,    -1,    33,    34,    35,    36,    37,
-      38,    39,    40,    41,     6,     7,     8,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    -1,    -1,    -1,    -1,    -1,
-      -1,    33,    34,    35,    36,    37,    38,    39,    40,    41,
-       6,     7,     8,    45,    -1,    -1,    -1,    -1,    -1,    -1,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    -1,    -1,    -1,    -1,    -1,    -1,    33,    34,    35,
-      36,    37,    38,    39,    40,    41,     6,     7,     8,    45,
-      -1,    -1,    -1,    -1,    -1,    -1,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    26,    -1,    -1,    -1,
-      -1,    -1,    -1,    33,    34,    35,    36,    37,    38,    39,
-      40,    41,     6,     7,     8,    45,    -1,    -1,    -1,    13,
-      14,    -1,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    -1,    -1,    -1,    -1,    -1,    -1,    33,
-      34,    35,    36,    37,    38,    39,    40,    41,     6,     7,
-       8,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
-      -1,    -1,    -1,    -1,    32,    33,    34,    35,    36,    37,
-      38,    39,    40,    41,     6,     7,     8,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    -1,    -1,    -1,    30,    -1,
-      -1,    33,    34,    35,    36,    37,    38,    39,    40,    41,
-       6,     7,     8,    -1,    -1,    -1,    -1,    -1,    -1,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    -1,    -1,    -1,    -1,    -1,    -1,    33,    34,    35,
-      36,    37,    38,    39,    40,    41,     6,     7,     8,    -1,
-      -1,    -1,    12,    -1,    -1,    -1,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    26,    -1,    -1,    -1,
-      -1,    -1,    -1,    33,    34,    35,    36,    37,    38,    39,
-      40,    41,     6,     7,     8,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    -1,    -1,    -1,    -1,    -1,    32,    33,
-      34,    35,    36,    37,    38,    39,    40,    41,     6,     7,
-       8,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
-      -1,    -1,    -1,    -1,    -1,    33,    34,    35,    36,    37,
-      38,    39,    40,    41,     6,     7,     8,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    34,    35,    36,    37,    38,    39,    40,    41,
-       6,     7,     8,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    -1,    -1,    -1,    -1,    -1,     6,     7,    -1,    35,
-      36,    37,    38,    39,    40,    41,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    26,    -1,    -1,    -1,
-      -1,    -1,     6,     7,    -1,    35,    36,    37,    38,    39,
-      40,    41,    16,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      24,    25,    26,     6,     7,    -1,    -1,    -1,    -1,     6,
-       7,    -1,    36,    37,    38,    39,    40,    41,    -1,    -1,
-      -1,    24,    25,    26,    -1,    -1,    -1,    24,    25,    26,
-      -1,    -1,    -1,    36,    37,    38,    39,    40,    41,    36,
-      37,    38,    39,    40,    41
-};
-
-/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
-   symbol of state STATE-NUM.  */
-static const yytype_uint8 yystos[] =
-{
-       0,     4,     5,    10,    11,    27,    42,    44,    46,    47,
-      49,    52,    53,    54,    55,    56,    60,    44,     4,    54,
-      56,    57,     4,     1,    54,     4,     1,    48,    54,     1,
-       4,    44,    55,    61,    62,     0,     6,     7,     8,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      33,    34,    35,    36,    37,    38,    39,    40,    41,    53,
-      54,     9,    46,    47,    54,    43,    44,     1,    12,    28,
-      29,    31,    45,    45,    48,    48,    34,    50,    43,     1,
-      54,    43,    50,    34,    54,    54,    54,    54,    54,    54,
-      54,    54,    54,    54,    54,    54,    54,    54,    54,    54,
-      54,    54,    54,    54,    54,    54,    54,    42,     4,     1,
-      48,    54,    45,    54,     4,    54,    54,     1,    61,    59,
-      60,    45,    45,    59,    61,     4,    48,    48,    32,    45,
-      13,    14,    58,    30,    33,    43,    43,    33,    43,    54,
-      54,    59,    59,    59,    54,    54,    15,    12,    32,    54,
-      58
-};
-
-#define yyerrok		(yyerrstatus = 0)
-#define yyclearin	(yychar = YYEMPTY)
-#define YYEMPTY		(-2)
-#define YYEOF		0
-
-#define YYACCEPT	goto yyacceptlab
-#define YYABORT		goto yyabortlab
-#define YYERROR		goto yyerrorlab
-
-
-/* Like YYERROR except do call yyerror.  This remains here temporarily
-   to ease the transition to the new meaning of YYERROR, for GCC.
-   Once GCC version 2 has supplanted version 1, this can go.  However,
-   YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
-   in Bison 2.4.2's NEWS entry, where a plan to phase it out is
-   discussed.  */
-
-#define YYFAIL		goto yyerrlab
-#if defined YYFAIL
-  /* This is here to suppress warnings from the GCC cpp's
-     -Wunused-macros.  Normally we don't worry about that warning, but
-     some users do, and we want to make it easy for users to remove
-     YYFAIL uses, which will produce warnings from Bison 2.5.  */
-#endif
-
-#define YYRECOVERING()  (!!yyerrstatus)
-
-#define YYBACKUP(Token, Value)					\
-do								\
-  if (yychar == YYEMPTY && yylen == 1)				\
-    {								\
-      yychar = (Token);						\
-      yylval = (Value);						\
-      YYPOPSTACK (1);						\
-      goto yybackup;						\
-    }								\
-  else								\
-    {								\
-      yyerror (&yylloc, answer, errors, locations, lexer_param_ptr, YY_("syntax error: cannot back up")); \
-      YYERROR;							\
-    }								\
-while (YYID (0))
-
-
-#define YYTERROR	1
-#define YYERRCODE	256
-
-
-/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
-   If N is 0, then set CURRENT to the empty location which ends
-   the previous symbol: RHS[0] (always defined).  */
-
-#define YYRHSLOC(Rhs, K) ((Rhs)[K])
-#ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N)				\
-    do									\
-      if (YYID (N))                                                    \
-	{								\
-	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
-	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
-	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
-	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
-	}								\
-      else								\
-	{								\
-	  (Current).first_line   = (Current).last_line   =		\
-	    YYRHSLOC (Rhs, 0).last_line;				\
-	  (Current).first_column = (Current).last_column =		\
-	    YYRHSLOC (Rhs, 0).last_column;				\
-	}								\
-    while (YYID (0))
-#endif
-
-
-/* YY_LOCATION_PRINT -- Print the location on the stream.
-   This macro was not mandated originally: define only if we know
-   we won't break user code: when these are the locations we know.  */
-
-#ifndef YY_LOCATION_PRINT
-# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
-#  define YY_LOCATION_PRINT(File, Loc)			\
-     fprintf (File, "%d.%d-%d.%d",			\
-	      (Loc).first_line, (Loc).first_column,	\
-	      (Loc).last_line,  (Loc).last_column)
-# else
-#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
-# endif
-#endif
-
-
-/* YYLEX -- calling `yylex' with the right arguments.  */
-
-#ifdef YYLEX_PARAM
-# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
-#else
-# define YYLEX yylex (&yylval, &yylloc, answer, errors, locations, lexer_param_ptr)
-#endif
-
-/* Enable debugging if requested.  */
-#if YYDEBUG
-
-# ifndef YYFPRINTF
-#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
-#  define YYFPRINTF fprintf
-# endif
-
-# define YYDPRINTF(Args)			\
-do {						\
-  if (yydebug)					\
-    YYFPRINTF Args;				\
-} while (YYID (0))
-
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location)			  \
-do {									  \
-  if (yydebug)								  \
-    {									  \
-      YYFPRINTF (stderr, "%s ", Title);					  \
-      yy_symbol_print (stderr,						  \
-		  Type, Value, Location, answer, errors, locations, lexer_param_ptr); \
-      YYFPRINTF (stderr, "\n");						  \
-    }									  \
-} while (YYID (0))
-
-
-/*--------------------------------.
-| Print this symbol on YYOUTPUT.  |
-`--------------------------------*/
-
-/*ARGSUSED*/
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr)
-#else
-static void
-yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors, locations, lexer_param_ptr)
-    FILE *yyoutput;
-    int yytype;
-    YYSTYPE const * const yyvaluep;
-    YYLTYPE const * const yylocationp;
-    block* answer;
-    int* errors;
-    struct locfile* locations;
-    struct lexer_param* lexer_param_ptr;
-#endif
-{
-  if (!yyvaluep)
-    return;
-  YYUSE (yylocationp);
-  YYUSE (answer);
-  YYUSE (errors);
-  YYUSE (locations);
-  YYUSE (lexer_param_ptr);
-# ifdef YYPRINT
-  if (yytype < YYNTOKENS)
-    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
-# else
-  YYUSE (yyoutput);
-# endif
-  switch (yytype)
-    {
-      default:
-	break;
-    }
-}
-
-
-/*--------------------------------.
-| Print this symbol on YYOUTPUT.  |
-`--------------------------------*/
-
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr)
-#else
-static void
-yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors, locations, lexer_param_ptr)
-    FILE *yyoutput;
-    int yytype;
-    YYSTYPE const * const yyvaluep;
-    YYLTYPE const * const yylocationp;
-    block* answer;
-    int* errors;
-    struct locfile* locations;
-    struct lexer_param* lexer_param_ptr;
-#endif
-{
-  if (yytype < YYNTOKENS)
-    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
-  else
-    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
-
-  YY_LOCATION_PRINT (yyoutput, *yylocationp);
-  YYFPRINTF (yyoutput, ": ");
-  yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, answer, errors, locations, lexer_param_ptr);
-  YYFPRINTF (yyoutput, ")");
-}
-
-/*------------------------------------------------------------------.
-| yy_stack_print -- Print the state stack from its BOTTOM up to its |
-| TOP (included).                                                   |
-`------------------------------------------------------------------*/
-
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
-#else
-static void
-yy_stack_print (yybottom, yytop)
-    yytype_int16 *yybottom;
-    yytype_int16 *yytop;
-#endif
-{
-  YYFPRINTF (stderr, "Stack now");
-  for (; yybottom <= yytop; yybottom++)
-    {
-      int yybot = *yybottom;
-      YYFPRINTF (stderr, " %d", yybot);
-    }
-  YYFPRINTF (stderr, "\n");
-}
-
-# define YY_STACK_PRINT(Bottom, Top)				\
-do {								\
-  if (yydebug)							\
-    yy_stack_print ((Bottom), (Top));				\
-} while (YYID (0))
-
-
-/*------------------------------------------------.
-| Report that the YYRULE is going to be reduced.  |
-`------------------------------------------------*/
-
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr)
-#else
-static void
-yy_reduce_print (yyvsp, yylsp, yyrule, answer, errors, locations, lexer_param_ptr)
-    YYSTYPE *yyvsp;
-    YYLTYPE *yylsp;
-    int yyrule;
-    block* answer;
-    int* errors;
-    struct locfile* locations;
-    struct lexer_param* lexer_param_ptr;
-#endif
-{
-  int yynrhs = yyr2[yyrule];
-  int yyi;
-  unsigned long int yylno = yyrline[yyrule];
-  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
-	     yyrule - 1, yylno);
-  /* The symbols being reduced.  */
-  for (yyi = 0; yyi < yynrhs; yyi++)
-    {
-      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
-      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
-		       &(yyvsp[(yyi + 1) - (yynrhs)])
-		       , &(yylsp[(yyi + 1) - (yynrhs)])		       , answer, errors, locations, lexer_param_ptr);
-      YYFPRINTF (stderr, "\n");
-    }
-}
-
-# define YY_REDUCE_PRINT(Rule)		\
-do {					\
-  if (yydebug)				\
-    yy_reduce_print (yyvsp, yylsp, Rule, answer, errors, locations, lexer_param_ptr); \
-} while (YYID (0))
-
-/* Nonzero means print parse trace.  It is left uninitialized so that
-   multiple parsers can coexist.  */
-int yydebug;
-#else /* !YYDEBUG */
-# define YYDPRINTF(Args)
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
-# define YY_STACK_PRINT(Bottom, Top)
-# define YY_REDUCE_PRINT(Rule)
-#endif /* !YYDEBUG */
-
-
-/* YYINITDEPTH -- initial size of the parser's stacks.  */
-#ifndef	YYINITDEPTH
-# define YYINITDEPTH 200
-#endif
-
-/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
-   if the built-in stack extension method is used).
-
-   Do not make this value too large; the results are undefined if
-   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
-   evaluated with infinite-precision integer arithmetic.  */
-
-#ifndef YYMAXDEPTH
-# define YYMAXDEPTH 10000
-#endif
-
-
-#if YYERROR_VERBOSE
-
-# ifndef yystrlen
-#  if defined __GLIBC__ && defined _STRING_H
-#   define yystrlen strlen
-#  else
-/* Return the length of YYSTR.  */
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static YYSIZE_T
-yystrlen (const char *yystr)
-#else
-static YYSIZE_T
-yystrlen (yystr)
-    const char *yystr;
-#endif
-{
-  YYSIZE_T yylen;
-  for (yylen = 0; yystr[yylen]; yylen++)
-    continue;
-  return yylen;
-}
-#  endif
-# endif
-
-# ifndef yystpcpy
-#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
-#   define yystpcpy stpcpy
-#  else
-/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
-   YYDEST.  */
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static char *
-yystpcpy (char *yydest, const char *yysrc)
-#else
-static char *
-yystpcpy (yydest, yysrc)
-    char *yydest;
-    const char *yysrc;
-#endif
-{
-  char *yyd = yydest;
-  const char *yys = yysrc;
-
-  while ((*yyd++ = *yys++) != '\0')
-    continue;
-
-  return yyd - 1;
-}
-#  endif
-# endif
-
-# ifndef yytnamerr
-/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
-   quotes and backslashes, so that it's suitable for yyerror.  The
-   heuristic is that double-quoting is unnecessary unless the string
-   contains an apostrophe, a comma, or backslash (other than
-   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
-   null, do not copy; instead, return the length of what the result
-   would have been.  */
-static YYSIZE_T
-yytnamerr (char *yyres, const char *yystr)
-{
-  if (*yystr == '"')
-    {
-      YYSIZE_T yyn = 0;
-      char const *yyp = yystr;
-
-      for (;;)
-	switch (*++yyp)
-	  {
-	  case '\'':
-	  case ',':
-	    goto do_not_strip_quotes;
-
-	  case '\\':
-	    if (*++yyp != '\\')
-	      goto do_not_strip_quotes;
-	    /* Fall through.  */
-	  default:
-	    if (yyres)
-	      yyres[yyn] = *yyp;
-	    yyn++;
-	    break;
-
-	  case '"':
-	    if (yyres)
-	      yyres[yyn] = '\0';
-	    return yyn;
-	  }
-    do_not_strip_quotes: ;
-    }
-
-  if (! yyres)
-    return yystrlen (yystr);
-
-  return yystpcpy (yyres, yystr) - yyres;
-}
-# endif
-
-/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
-   about the unexpected token YYTOKEN for the state stack whose top is
-   YYSSP.
-
-   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
-   not large enough to hold the message.  In that case, also set
-   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
-   required number of bytes is too large to store.  */
-static int
-yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
-                yytype_int16 *yyssp, int yytoken)
-{
-  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
-  YYSIZE_T yysize = yysize0;
-  YYSIZE_T yysize1;
-  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
-  /* Internationalized format string. */
-  const char *yyformat = 0;
-  /* Arguments of yyformat. */
-  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
-  /* Number of reported tokens (one for the "unexpected", one per
-     "expected"). */
-  int yycount = 0;
-
-  /* There are many possibilities here to consider:
-     - Assume YYFAIL is not used.  It's too flawed to consider.  See
-       <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
-       for details.  YYERROR is fine as it does not invoke this
-       function.
-     - If this state is a consistent state with a default action, then
-       the only way this function was invoked is if the default action
-       is an error action.  In that case, don't check for expected
-       tokens because there are none.
-     - The only way there can be no lookahead present (in yychar) is if
-       this state is a consistent state with a default action.  Thus,
-       detecting the absence of a lookahead is sufficient to determine
-       that there is no unexpected or expected token to report.  In that
-       case, just report a simple "syntax error".
-     - Don't assume there isn't a lookahead just because this state is a
-       consistent state with a default action.  There might have been a
-       previous inconsistent state, consistent state with a non-default
-       action, or user semantic action that manipulated yychar.
-     - Of course, the expected token list depends on states to have
-       correct lookahead information, and it depends on the parser not
-       to perform extra reductions after fetching a lookahead from the
-       scanner and before detecting a syntax error.  Thus, state merging
-       (from LALR or IELR) and default reductions corrupt the expected
-       token list.  However, the list is correct for canonical LR with
-       one exception: it will still contain any token that will not be
-       accepted due to an error action in a later state.
-  */
-  if (yytoken != YYEMPTY)
-    {
-      int yyn = yypact[*yyssp];
-      yyarg[yycount++] = yytname[yytoken];
-      if (!yypact_value_is_default (yyn))
-        {
-          /* Start YYX at -YYN if negative to avoid negative indexes in
-             YYCHECK.  In other words, skip the first -YYN actions for
-             this state because they are default actions.  */
-          int yyxbegin = yyn < 0 ? -yyn : 0;
-          /* Stay within bounds of both yycheck and yytname.  */
-          int yychecklim = YYLAST - yyn + 1;
-          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
-          int yyx;
-
-          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
-            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
-                && !yytable_value_is_error (yytable[yyx + yyn]))
-              {
-                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
-                  {
-                    yycount = 1;
-                    yysize = yysize0;
-                    break;
-                  }
-                yyarg[yycount++] = yytname[yyx];
-                yysize1 = yysize + yytnamerr (0, yytname[yyx]);
-                if (! (yysize <= yysize1
-                       && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
-                  return 2;
-                yysize = yysize1;
-              }
-        }
-    }
-
-  switch (yycount)
-    {
-# define YYCASE_(N, S)                      \
-      case N:                               \
-        yyformat = S;                       \
-      break
-      YYCASE_(0, YY_("syntax error"));
-      YYCASE_(1, YY_("syntax error, unexpected %s"));
-      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
-      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
-      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
-      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
-# undef YYCASE_
-    }
-
-  yysize1 = yysize + yystrlen (yyformat);
-  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
-    return 2;
-  yysize = yysize1;
-
-  if (*yymsg_alloc < yysize)
-    {
-      *yymsg_alloc = 2 * yysize;
-      if (! (yysize <= *yymsg_alloc
-             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
-        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
-      return 1;
-    }
-
-  /* Avoid sprintf, as that infringes on the user's name space.
-     Don't have undefined behavior even if the translation
-     produced a string with the wrong number of "%s"s.  */
-  {
-    char *yyp = *yymsg;
-    int yyi = 0;
-    while ((*yyp = *yyformat) != '\0')
-      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
-        {
-          yyp += yytnamerr (yyp, yyarg[yyi++]);
-          yyformat += 2;
-        }
-      else
-        {
-          yyp++;
-          yyformat++;
-        }
-  }
-  return 0;
-}
-#endif /* YYERROR_VERBOSE */
-
-/*-----------------------------------------------.
-| Release the memory associated to this symbol.  |
-`-----------------------------------------------*/
-
-/*ARGSUSED*/
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr)
-#else
-static void
-yydestruct (yymsg, yytype, yyvaluep, yylocationp, answer, errors, locations, lexer_param_ptr)
-    const char *yymsg;
-    int yytype;
-    YYSTYPE *yyvaluep;
-    YYLTYPE *yylocationp;
-    block* answer;
-    int* errors;
-    struct locfile* locations;
-    struct lexer_param* lexer_param_ptr;
-#endif
-{
-  YYUSE (yyvaluep);
-  YYUSE (yylocationp);
-  YYUSE (answer);
-  YYUSE (errors);
-  YYUSE (locations);
-  YYUSE (lexer_param_ptr);
-
-  if (!yymsg)
-    yymsg = "Deleting";
-  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
-
-  switch (yytype)
-    {
-      case 4: /* "IDENT" */
-
-/* Line 1391 of yacc.c  */
-#line 32 "parser.y"
-	{ jv_free((yyvaluep->literal)); };
-
-/* Line 1391 of yacc.c  */
-#line 1531 "parser.gen.c"
-	break;
-      case 5: /* "LITERAL" */
-
-/* Line 1391 of yacc.c  */
-#line 32 "parser.y"
-	{ jv_free((yyvaluep->literal)); };
-
-/* Line 1391 of yacc.c  */
-#line 1540 "parser.gen.c"
-	break;
-      case 28: /* "QQSTRING_TEXT" */
-
-/* Line 1391 of yacc.c  */
-#line 32 "parser.y"
-	{ jv_free((yyvaluep->literal)); };
-
-/* Line 1391 of yacc.c  */
-#line 1549 "parser.gen.c"
-	break;
-      case 53: /* "FuncDefs" */
-
-/* Line 1391 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1558 "parser.gen.c"
-	break;
-      case 54: /* "Exp" */
-
-/* Line 1391 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1567 "parser.gen.c"
-	break;
-      case 55: /* "String" */
-
-/* Line 1391 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1576 "parser.gen.c"
-	break;
-      case 56: /* "FuncDef" */
-
-/* Line 1391 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1585 "parser.gen.c"
-	break;
-      case 57: /* "QQString" */
-
-/* Line 1391 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1594 "parser.gen.c"
-	break;
-      case 58: /* "ElseBody" */
-
-/* Line 1391 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1603 "parser.gen.c"
-	break;
-      case 59: /* "ExpD" */
-
-/* Line 1391 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1612 "parser.gen.c"
-	break;
-      case 60: /* "Term" */
-
-/* Line 1391 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1621 "parser.gen.c"
-	break;
-      case 61: /* "MkDict" */
-
-/* Line 1391 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1630 "parser.gen.c"
-	break;
-      case 62: /* "MkDictPair" */
-
-/* Line 1391 of yacc.c  */
-#line 33 "parser.y"
-	{ block_free((yyvaluep->blk)); };
-
-/* Line 1391 of yacc.c  */
-#line 1639 "parser.gen.c"
-	break;
-
-      default:
-	break;
-    }
-}
-
-
-/* Prevent warnings from -Wmissing-prototypes.  */
-#ifdef YYPARSE_PARAM
-#if defined __STDC__ || defined __cplusplus
-int yyparse (void *YYPARSE_PARAM);
-#else
-int yyparse ();
-#endif
-#else /* ! YYPARSE_PARAM */
-#if defined __STDC__ || defined __cplusplus
-int yyparse (block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr);
-#else
-int yyparse ();
-#endif
-#endif /* ! YYPARSE_PARAM */
-
-
-/*----------.
-| yyparse.  |
-`----------*/
-
-#ifdef YYPARSE_PARAM
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-int
-yyparse (void *YYPARSE_PARAM)
-#else
-int
-yyparse (YYPARSE_PARAM)
-    void *YYPARSE_PARAM;
-#endif
-#else /* ! YYPARSE_PARAM */
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-int
-yyparse (block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr)
-#else
-int
-yyparse (answer, errors, locations, lexer_param_ptr)
-    block* answer;
-    int* errors;
-    struct locfile* locations;
-    struct lexer_param* lexer_param_ptr;
-#endif
-#endif
-{
-/* The lookahead symbol.  */
-int yychar;
-
-/* The semantic value of the lookahead symbol.  */
-YYSTYPE yylval;
-
-/* Location data for the lookahead symbol.  */
-YYLTYPE yylloc;
-
-    /* Number of syntax errors so far.  */
-    int yynerrs;
-
-    int yystate;
-    /* Number of tokens to shift before error messages enabled.  */
-    int yyerrstatus;
-
-    /* The stacks and their tools:
-       `yyss': related to states.
-       `yyvs': related to semantic values.
-       `yyls': related to locations.
-
-       Refer to the stacks thru separate pointers, to allow yyoverflow
-       to reallocate them elsewhere.  */
-
-    /* The state stack.  */
-    yytype_int16 yyssa[YYINITDEPTH];
-    yytype_int16 *yyss;
-    yytype_int16 *yyssp;
-
-    /* The semantic value stack.  */
-    YYSTYPE yyvsa[YYINITDEPTH];
-    YYSTYPE *yyvs;
-    YYSTYPE *yyvsp;
-
-    /* The location stack.  */
-    YYLTYPE yylsa[YYINITDEPTH];
-    YYLTYPE *yyls;
-    YYLTYPE *yylsp;
-
-    /* The locations where the error started and ended.  */
-    YYLTYPE yyerror_range[3];
-
-    YYSIZE_T yystacksize;
-
-  int yyn;
-  int yyresult;
-  /* Lookahead token as an internal (translated) token number.  */
-  int yytoken;
-  /* The variables used to return semantic value and location from the
-     action routines.  */
-  YYSTYPE yyval;
-  YYLTYPE yyloc;
-
-#if YYERROR_VERBOSE
-  /* Buffer for error messages, and its allocated size.  */
-  char yymsgbuf[128];
-  char *yymsg = yymsgbuf;
-  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
-#endif
-
-#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
-
-  /* The number of symbols on the RHS of the reduced rule.
-     Keep to zero when no symbol should be popped.  */
-  int yylen = 0;
-
-  yytoken = 0;
-  yyss = yyssa;
-  yyvs = yyvsa;
-  yyls = yylsa;
-  yystacksize = YYINITDEPTH;
-
-  YYDPRINTF ((stderr, "Starting parse\n"));
-
-  yystate = 0;
-  yyerrstatus = 0;
-  yynerrs = 0;
-  yychar = YYEMPTY; /* Cause a token to be read.  */
-
-  /* Initialize stack pointers.
-     Waste one element of value and location stack
-     so that they stay on the same level as the state stack.
-     The wasted elements are never initialized.  */
-  yyssp = yyss;
-  yyvsp = yyvs;
-  yylsp = yyls;
-
-#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
-  /* Initialize the default location before parsing starts.  */
-  yylloc.first_line   = yylloc.last_line   = 1;
-  yylloc.first_column = yylloc.last_column = 1;
-#endif
-
-  goto yysetstate;
-
-/*------------------------------------------------------------.
-| yynewstate -- Push a new state, which is found in yystate.  |
-`------------------------------------------------------------*/
- yynewstate:
-  /* In all cases, when you get here, the value and location stacks
-     have just been pushed.  So pushing a state here evens the stacks.  */
-  yyssp++;
-
- yysetstate:
-  *yyssp = yystate;
-
-  if (yyss + yystacksize - 1 <= yyssp)
-    {
-      /* Get the current used size of the three stacks, in elements.  */
-      YYSIZE_T yysize = yyssp - yyss + 1;
-
-#ifdef yyoverflow
-      {
-	/* Give user a chance to reallocate the stack.  Use copies of
-	   these so that the &'s don't force the real ones into
-	   memory.  */
-	YYSTYPE *yyvs1 = yyvs;
-	yytype_int16 *yyss1 = yyss;
-	YYLTYPE *yyls1 = yyls;
-
-	/* Each stack pointer address is followed by the size of the
-	   data in use in that stack, in bytes.  This used to be a
-	   conditional around just the two extra args, but that might
-	   be undefined if yyoverflow is a macro.  */
-	yyoverflow (YY_("memory exhausted"),
-		    &yyss1, yysize * sizeof (*yyssp),
-		    &yyvs1, yysize * sizeof (*yyvsp),
-		    &yyls1, yysize * sizeof (*yylsp),
-		    &yystacksize);
-
-	yyls = yyls1;
-	yyss = yyss1;
-	yyvs = yyvs1;
-      }
-#else /* no yyoverflow */
-# ifndef YYSTACK_RELOCATE
-      goto yyexhaustedlab;
-# else
-      /* Extend the stack our own way.  */
-      if (YYMAXDEPTH <= yystacksize)
-	goto yyexhaustedlab;
-      yystacksize *= 2;
-      if (YYMAXDEPTH < yystacksize)
-	yystacksize = YYMAXDEPTH;
-
-      {
-	yytype_int16 *yyss1 = yyss;
-	union yyalloc *yyptr =
-	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
-	if (! yyptr)
-	  goto yyexhaustedlab;
-	YYSTACK_RELOCATE (yyss_alloc, yyss);
-	YYSTACK_RELOCATE (yyvs_alloc, yyvs);
-	YYSTACK_RELOCATE (yyls_alloc, yyls);
-#  undef YYSTACK_RELOCATE
-	if (yyss1 != yyssa)
-	  YYSTACK_FREE (yyss1);
-      }
-# endif
-#endif /* no yyoverflow */
-
-      yyssp = yyss + yysize - 1;
-      yyvsp = yyvs + yysize - 1;
-      yylsp = yyls + yysize - 1;
-
-      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
-		  (unsigned long int) yystacksize));
-
-      if (yyss + yystacksize - 1 <= yyssp)
-	YYABORT;
-    }
-
-  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
-
-  if (yystate == YYFINAL)
-    YYACCEPT;
-
-  goto yybackup;
-
-/*-----------.
-| yybackup.  |
-`-----------*/
-yybackup:
-
-  /* Do appropriate processing given the current state.  Read a
-     lookahead token if we need one and don't already have one.  */
-
-  /* First try to decide what to do without reference to lookahead token.  */
-  yyn = yypact[yystate];
-  if (yypact_value_is_default (yyn))
-    goto yydefault;
-
-  /* Not known => get a lookahead token if don't already have one.  */
-
-  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
-  if (yychar == YYEMPTY)
-    {
-      YYDPRINTF ((stderr, "Reading a token: "));
-      yychar = YYLEX;
-    }
-
-  if (yychar <= YYEOF)
-    {
-      yychar = yytoken = YYEOF;
-      YYDPRINTF ((stderr, "Now at end of input.\n"));
-    }
-  else
-    {
-      yytoken = YYTRANSLATE (yychar);
-      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
-    }
-
-  /* If the proper action on seeing token YYTOKEN is to reduce or to
-     detect an error, take that action.  */
-  yyn += yytoken;
-  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
-    goto yydefault;
-  yyn = yytable[yyn];
-  if (yyn <= 0)
-    {
-      if (yytable_value_is_error (yyn))
-        goto yyerrlab;
-      yyn = -yyn;
-      goto yyreduce;
-    }
-
-  /* Count tokens shifted since error; after three, turn off error
-     status.  */
-  if (yyerrstatus)
-    yyerrstatus--;
-
-  /* Shift the lookahead token.  */
-  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
-
-  /* Discard the shifted token.  */
-  yychar = YYEMPTY;
-
-  yystate = yyn;
-  *++yyvsp = yylval;
-  *++yylsp = yylloc;
-  goto yynewstate;
-
-
-/*-----------------------------------------------------------.
-| yydefault -- do the default action for the current state.  |
-`-----------------------------------------------------------*/
-yydefault:
-  yyn = yydefact[yystate];
-  if (yyn == 0)
-    goto yyerrlab;
-  goto yyreduce;
-
-
-/*-----------------------------.
-| yyreduce -- Do a reduction.  |
-`-----------------------------*/
-yyreduce:
-  /* yyn is the number of a rule to reduce with.  */
-  yylen = yyr2[yyn];
-
-  /* If YYLEN is nonzero, implement the default value of the action:
-     `$$ = $1'.
-
-     Otherwise, the following line sets YYVAL to garbage.
-     This behavior is undocumented and Bison
-     users should not rely upon it.  Assigning to YYVAL
-     unconditionally makes the parser a bit smaller, and it avoids a
-     GCC warning that YYVAL may be used uninitialized.  */
-  yyval = yyvsp[1-yylen];
-
-  /* Default location.  */
-  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
-  YY_REDUCE_PRINT (yyn);
-  switch (yyn)
-    {
-        case 2:
-
-/* Line 1806 of yacc.c  */
-#line 175 "parser.y"
-    {
-  *answer = (yyvsp[(1) - (1)].blk);
-}
-    break;
-
-  case 3:
-
-/* Line 1806 of yacc.c  */
-#line 178 "parser.y"
-    {
-  *answer = (yyvsp[(1) - (1)].blk);
-}
-    break;
-
-  case 4:
-
-/* Line 1806 of yacc.c  */
-#line 183 "parser.y"
-    {
-  (yyval.blk) = gen_noop();
-}
-    break;
-
-  case 5:
-
-/* Line 1806 of yacc.c  */
-#line 186 "parser.y"
-    {
-  (yyval.blk) = block_join((yyvsp[(1) - (2)].blk), (yyvsp[(2) - (2)].blk));
-}
-    break;
-
-  case 6:
-
-/* Line 1806 of yacc.c  */
-#line 191 "parser.y"
-    {
-  (yyval.blk) = block_bind((yyvsp[(1) - (2)].blk), (yyvsp[(2) - (2)].blk), OP_IS_CALL_PSEUDO);
-}
-    break;
-
-  case 7:
-
-/* Line 1806 of yacc.c  */
-#line 195 "parser.y"
-    {
-  (yyval.blk) = BLOCK(gen_op_simple(DUP), (yyvsp[(1) - (6)].blk), 
-             block_bind(gen_op_var_unbound(STOREV, jv_string_value((yyvsp[(4) - (6)].literal))), 
-                        (yyvsp[(6) - (6)].blk), OP_HAS_VARIABLE));
-  jv_free((yyvsp[(4) - (6)].literal));
-}
-    break;
-
-  case 8:
-
-/* Line 1806 of yacc.c  */
-#line 202 "parser.y"
-    {
-  (yyval.blk) = gen_cond((yyvsp[(2) - (5)].blk), (yyvsp[(4) - (5)].blk), (yyvsp[(5) - (5)].blk));
-}
-    break;
-
-  case 9:
-
-/* Line 1806 of yacc.c  */
-#line 205 "parser.y"
-    {
-  FAIL((yyloc), "Possibly unterminated 'if' statment");
-  (yyval.blk) = (yyvsp[(2) - (3)].blk);
-}
-    break;
-
-  case 10:
-
-/* Line 1806 of yacc.c  */
-#line 210 "parser.y"
-    {
-  (yyval.blk) = gen_assign(BLOCK(gen_op_simple(DUP), (yyvsp[(3) - (3)].blk), gen_op_simple(SWAP), (yyvsp[(1) - (3)].blk), gen_op_simple(SWAP)));
-}
-    break;
-
-  case 11:
-
-/* Line 1806 of yacc.c  */
-#line 214 "parser.y"
-    {
-  (yyval.blk) = gen_or((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
-}
-    break;
-
-  case 12:
-
-/* Line 1806 of yacc.c  */
-#line 218 "parser.y"
-    {
-  (yyval.blk) = gen_and((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
-}
-    break;
-
-  case 13:
-
-/* Line 1806 of yacc.c  */
-#line 222 "parser.y"
-    {
-  (yyval.blk) = gen_definedor((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
-}
-    break;
-
-  case 14:
-
-/* Line 1806 of yacc.c  */
-#line 226 "parser.y"
-    {
-  (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), gen_definedor(gen_noop(), (yyvsp[(3) - (3)].blk)), 0);
-}
-    break;
-
-  case 15:
-
-/* Line 1806 of yacc.c  */
-#line 230 "parser.y"
-    {
-  (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), 0);
-}
-    break;
-
-  case 16:
-
-/* Line 1806 of yacc.c  */
-#line 234 "parser.y"
-    { 
-  (yyval.blk) = block_join((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk)); 
-}
-    break;
-
-  case 17:
-
-/* Line 1806 of yacc.c  */
-#line 238 "parser.y"
-    { 
-  (yyval.blk) = gen_both((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk)); 
-}
-    break;
-
-  case 18:
-
-/* Line 1806 of yacc.c  */
-#line 242 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '+');
-}
-    break;
-
-  case 19:
-
-/* Line 1806 of yacc.c  */
-#line 246 "parser.y"
-    {
-  (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '+');
-}
-    break;
-
-  case 20:
-
-/* Line 1806 of yacc.c  */
-#line 250 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '-');
-}
-    break;
-
-  case 21:
-
-/* Line 1806 of yacc.c  */
-#line 254 "parser.y"
-    {
-  (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '-');
-}
-    break;
-
-  case 22:
-
-/* Line 1806 of yacc.c  */
-#line 258 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '*');
-}
-    break;
-
-  case 23:
-
-/* Line 1806 of yacc.c  */
-#line 262 "parser.y"
-    {
-  (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '*');
-}
-    break;
-
-  case 24:
-
-/* Line 1806 of yacc.c  */
-#line 266 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '/');
-}
-    break;
-
-  case 25:
-
-/* Line 1806 of yacc.c  */
-#line 270 "parser.y"
-    {
-  (yyval.blk) = gen_update((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '/');
-}
-    break;
-
-  case 26:
-
-/* Line 1806 of yacc.c  */
-#line 274 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), EQ);
-}
-    break;
-
-  case 27:
-
-/* Line 1806 of yacc.c  */
-#line 278 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), NEQ);
-}
-    break;
-
-  case 28:
-
-/* Line 1806 of yacc.c  */
-#line 282 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '<');
-}
-    break;
-
-  case 29:
-
-/* Line 1806 of yacc.c  */
-#line 286 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), '>');
-}
-    break;
-
-  case 30:
-
-/* Line 1806 of yacc.c  */
-#line 290 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), LESSEQ);
-}
-    break;
-
-  case 31:
-
-/* Line 1806 of yacc.c  */
-#line 294 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), GREATEREQ);
-}
-    break;
-
-  case 32:
-
-/* Line 1806 of yacc.c  */
-#line 298 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk), CONTAINS);
-}
-    break;
-
-  case 33:
-
-/* Line 1806 of yacc.c  */
-#line 302 "parser.y"
-    { 
-  (yyval.blk) = (yyvsp[(1) - (1)].blk); 
-}
-    break;
-
-  case 34:
-
-/* Line 1806 of yacc.c  */
-#line 307 "parser.y"
-    {
-  (yyval.blk) = (yyvsp[(2) - (3)].blk);
-}
-    break;
-
-  case 35:
-
-/* Line 1806 of yacc.c  */
-#line 312 "parser.y"
-    {
-  (yyval.blk) = gen_function(jv_string_value((yyvsp[(2) - (5)].literal)), (yyvsp[(4) - (5)].blk));
-  jv_free((yyvsp[(2) - (5)].literal));
-}
-    break;
-
-  case 36:
-
-/* Line 1806 of yacc.c  */
-#line 317 "parser.y"
-    {
-  block body = block_bind(gen_op_block_unbound(CLOSURE_PARAM, jv_string_value((yyvsp[(4) - (8)].literal))), (yyvsp[(7) - (8)].blk), OP_IS_CALL_PSEUDO);
-  (yyval.blk) = gen_function(jv_string_value((yyvsp[(2) - (8)].literal)), body);
-  jv_free((yyvsp[(2) - (8)].literal));
-  jv_free((yyvsp[(4) - (8)].literal));
-}
-    break;
-
-  case 37:
-
-/* Line 1806 of yacc.c  */
-#line 325 "parser.y"
-    {
-  (yyval.blk) = gen_op_const(LOADK, jv_string(""));
-}
-    break;
-
-  case 38:
-
-/* Line 1806 of yacc.c  */
-#line 328 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (2)].blk), gen_op_const(LOADK, (yyvsp[(2) - (2)].literal)), '+');
-}
-    break;
-
-  case 39:
-
-/* Line 1806 of yacc.c  */
-#line 331 "parser.y"
-    {
-  (yyval.blk) = gen_binop((yyvsp[(1) - (4)].blk), gen_format((yyvsp[(3) - (4)].blk)), '+');
-}
-    break;
-
-  case 40:
-
-/* Line 1806 of yacc.c  */
-#line 337 "parser.y"
-    {
-  (yyval.blk) = gen_cond((yyvsp[(2) - (5)].blk), (yyvsp[(4) - (5)].blk), (yyvsp[(5) - (5)].blk));
-}
-    break;
-
-  case 41:
-
-/* Line 1806 of yacc.c  */
-#line 340 "parser.y"
-    {
-  (yyval.blk) = (yyvsp[(2) - (3)].blk);
-}
-    break;
-
-  case 42:
-
-/* Line 1806 of yacc.c  */
-#line 345 "parser.y"
-    { 
-  (yyval.blk) = block_join((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
-}
-    break;
-
-  case 43:
-
-/* Line 1806 of yacc.c  */
-#line 349 "parser.y"
-    {
-  (yyval.blk) = (yyvsp[(1) - (1)].blk);
-}
-    break;
-
-  case 44:
-
-/* Line 1806 of yacc.c  */
-#line 355 "parser.y"
-    {
-  (yyval.blk) = gen_noop(); 
-}
-    break;
-
-  case 45:
-
-/* Line 1806 of yacc.c  */
-#line 358 "parser.y"
-    {
-  (yyval.blk) = gen_index((yyvsp[(1) - (3)].blk), gen_op_const(LOADK, (yyvsp[(3) - (3)].literal))); 
-}
-    break;
-
-  case 46:
-
-/* Line 1806 of yacc.c  */
-#line 361 "parser.y"
-    { 
-  (yyval.blk) = gen_index(gen_noop(), gen_op_const(LOADK, (yyvsp[(2) - (2)].literal))); 
-}
-    break;
-
-  case 47:
-
-/* Line 1806 of yacc.c  */
-#line 365 "parser.y"
-    {
-  (yyval.blk) = gen_index((yyvsp[(1) - (4)].blk), (yyvsp[(3) - (4)].blk)); 
-}
-    break;
-
-  case 48:
-
-/* Line 1806 of yacc.c  */
-#line 368 "parser.y"
-    {
-  (yyval.blk) = block_join((yyvsp[(1) - (3)].blk), gen_op_simple(EACH)); 
-}
-    break;
-
-  case 49:
-
-/* Line 1806 of yacc.c  */
-#line 371 "parser.y"
-    {
-  (yyval.blk) = gen_op_const(LOADK, (yyvsp[(1) - (1)].literal)); 
-}
-    break;
-
-  case 50:
-
-/* Line 1806 of yacc.c  */
-#line 374 "parser.y"
-    {
-  (yyval.blk) = (yyvsp[(1) - (1)].blk);
-}
-    break;
-
-  case 51:
-
-/* Line 1806 of yacc.c  */
-#line 377 "parser.y"
-    { 
-  (yyval.blk) = (yyvsp[(2) - (3)].blk); 
-}
-    break;
-
-  case 52:
-
-/* Line 1806 of yacc.c  */
-#line 380 "parser.y"
-    { 
-  (yyval.blk) = gen_collect((yyvsp[(2) - (3)].blk)); 
-}
-    break;
-
-  case 53:
-
-/* Line 1806 of yacc.c  */
-#line 383 "parser.y"
-    { 
-  (yyval.blk) = gen_op_const(LOADK, jv_array()); 
-}
-    break;
-
-  case 54:
-
-/* Line 1806 of yacc.c  */
-#line 386 "parser.y"
-    { 
-  (yyval.blk) = BLOCK(gen_subexp(gen_op_const(LOADK, jv_object())), (yyvsp[(2) - (3)].blk), gen_op_simple(POP));
-}
-    break;
-
-  case 55:
-
-/* Line 1806 of yacc.c  */
-#line 389 "parser.y"
-    {
-  (yyval.blk) = gen_location((yyloc), gen_op_var_unbound(LOADV, jv_string_value((yyvsp[(2) - (2)].literal))));
-  jv_free((yyvsp[(2) - (2)].literal));
-}
-    break;
-
-  case 56:
-
-/* Line 1806 of yacc.c  */
-#line 393 "parser.y"
-    {
-  (yyval.blk) = gen_location((yyloc), gen_call(jv_string_value((yyvsp[(1) - (1)].literal)), gen_noop()));
-  jv_free((yyvsp[(1) - (1)].literal));
-}
-    break;
-
-  case 57:
-
-/* Line 1806 of yacc.c  */
-#line 397 "parser.y"
-    {
-  (yyval.blk) = gen_call(jv_string_value((yyvsp[(1) - (4)].literal)), gen_lambda((yyvsp[(3) - (4)].blk)));
-  (yyval.blk) = gen_location((yylsp[(1) - (4)]), (yyval.blk));
-  jv_free((yyvsp[(1) - (4)].literal));
-}
-    break;
-
-  case 58:
-
-/* Line 1806 of yacc.c  */
-#line 402 "parser.y"
-    { (yyval.blk) = gen_noop(); }
-    break;
-
-  case 59:
-
-/* Line 1806 of yacc.c  */
-#line 403 "parser.y"
-    { (yyval.blk) = gen_noop(); }
-    break;
-
-  case 60:
-
-/* Line 1806 of yacc.c  */
-#line 404 "parser.y"
-    { (yyval.blk) = (yyvsp[(1) - (4)].blk); }
-    break;
-
-  case 61:
-
-/* Line 1806 of yacc.c  */
-#line 405 "parser.y"
-    { (yyval.blk) = gen_noop(); }
-    break;
-
-  case 62:
-
-/* Line 1806 of yacc.c  */
-#line 408 "parser.y"
-    { 
-  (yyval.blk)=gen_noop(); 
-}
-    break;
-
-  case 63:
-
-/* Line 1806 of yacc.c  */
-#line 411 "parser.y"
-    { (yyval.blk) = (yyvsp[(1) - (1)].blk); }
-    break;
-
-  case 64:
-
-/* Line 1806 of yacc.c  */
-#line 412 "parser.y"
-    { (yyval.blk)=block_join((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk)); }
-    break;
-
-  case 65:
-
-/* Line 1806 of yacc.c  */
-#line 413 "parser.y"
-    { (yyval.blk) = (yyvsp[(3) - (3)].blk); }
-    break;
-
-  case 66:
-
-/* Line 1806 of yacc.c  */
-#line 416 "parser.y"
-    { 
-  (yyval.blk) = gen_dictpair(gen_op_const(LOADK, (yyvsp[(1) - (3)].literal)), (yyvsp[(3) - (3)].blk));
- }
-    break;
-
-  case 67:
-
-/* Line 1806 of yacc.c  */
-#line 419 "parser.y"
-    {
-  (yyval.blk) = gen_dictpair((yyvsp[(1) - (3)].blk), (yyvsp[(3) - (3)].blk));
-  }
-    break;
-
-  case 68:
-
-/* Line 1806 of yacc.c  */
-#line 422 "parser.y"
-    {
-  (yyval.blk) = gen_dictpair(gen_op_const(LOADK, jv_copy((yyvsp[(1) - (1)].literal))),
-                    gen_index(gen_noop(), gen_op_const(LOADK, (yyvsp[(1) - (1)].literal))));
-  }
-    break;
-
-  case 69:
-
-/* Line 1806 of yacc.c  */
-#line 426 "parser.y"
-    {
-  (yyval.blk) = gen_dictpair((yyvsp[(2) - (5)].blk), (yyvsp[(5) - (5)].blk));
-  }
-    break;
-
-  case 70:
-
-/* Line 1806 of yacc.c  */
-#line 429 "parser.y"
-    { (yyval.blk) = (yyvsp[(5) - (5)].blk); }
-    break;
-
-
-
-/* Line 1806 of yacc.c  */
-#line 2589 "parser.gen.c"
-      default: break;
-    }
-  /* User semantic actions sometimes alter yychar, and that requires
-     that yytoken be updated with the new translation.  We take the
-     approach of translating immediately before every use of yytoken.
-     One alternative is translating here after every semantic action,
-     but that translation would be missed if the semantic action invokes
-     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
-     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
-     incorrect destructor might then be invoked immediately.  In the
-     case of YYERROR or YYBACKUP, subsequent parser actions might lead
-     to an incorrect destructor call or verbose syntax error message
-     before the lookahead is translated.  */
-  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
-
-  YYPOPSTACK (yylen);
-  yylen = 0;
-  YY_STACK_PRINT (yyss, yyssp);
-
-  *++yyvsp = yyval;
-  *++yylsp = yyloc;
-
-  /* Now `shift' the result of the reduction.  Determine what state
-     that goes to, based on the state we popped back to and the rule
-     number reduced by.  */
-
-  yyn = yyr1[yyn];
-
-  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
-  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
-    yystate = yytable[yystate];
-  else
-    yystate = yydefgoto[yyn - YYNTOKENS];
-
-  goto yynewstate;
-
-
-/*------------------------------------.
-| yyerrlab -- here on detecting error |
-`------------------------------------*/
-yyerrlab:
-  /* Make sure we have latest lookahead translation.  See comments at
-     user semantic actions for why this is necessary.  */
-  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
-
-  /* If not already recovering from an error, report this error.  */
-  if (!yyerrstatus)
-    {
-      ++yynerrs;
-#if ! YYERROR_VERBOSE
-      yyerror (&yylloc, answer, errors, locations, lexer_param_ptr, YY_("syntax error"));
-#else
-# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
-                                        yyssp, yytoken)
-      {
-        char const *yymsgp = YY_("syntax error");
-        int yysyntax_error_status;
-        yysyntax_error_status = YYSYNTAX_ERROR;
-        if (yysyntax_error_status == 0)
-          yymsgp = yymsg;
-        else if (yysyntax_error_status == 1)
-          {
-            if (yymsg != yymsgbuf)
-              YYSTACK_FREE (yymsg);
-            yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
-            if (!yymsg)
-              {
-                yymsg = yymsgbuf;
-                yymsg_alloc = sizeof yymsgbuf;
-                yysyntax_error_status = 2;
-              }
-            else
-              {
-                yysyntax_error_status = YYSYNTAX_ERROR;
-                yymsgp = yymsg;
-              }
-          }
-        yyerror (&yylloc, answer, errors, locations, lexer_param_ptr, yymsgp);
-        if (yysyntax_error_status == 2)
-          goto yyexhaustedlab;
-      }
-# undef YYSYNTAX_ERROR
-#endif
-    }
-
-  yyerror_range[1] = yylloc;
-
-  if (yyerrstatus == 3)
-    {
-      /* If just tried and failed to reuse lookahead token after an
-	 error, discard it.  */
-
-      if (yychar <= YYEOF)
-	{
-	  /* Return failure if at end of input.  */
-	  if (yychar == YYEOF)
-	    YYABORT;
-	}
-      else
-	{
-	  yydestruct ("Error: discarding",
-		      yytoken, &yylval, &yylloc, answer, errors, locations, lexer_param_ptr);
-	  yychar = YYEMPTY;
-	}
-    }
-
-  /* Else will try to reuse lookahead token after shifting the error
-     token.  */
-  goto yyerrlab1;
-
-
-/*---------------------------------------------------.
-| yyerrorlab -- error raised explicitly by YYERROR.  |
-`---------------------------------------------------*/
-yyerrorlab:
-
-  /* Pacify compilers like GCC when the user code never invokes
-     YYERROR and the label yyerrorlab therefore never appears in user
-     code.  */
-  if (/*CONSTCOND*/ 0)
-     goto yyerrorlab;
-
-  yyerror_range[1] = yylsp[1-yylen];
-  /* Do not reclaim the symbols of the rule which action triggered
-     this YYERROR.  */
-  YYPOPSTACK (yylen);
-  yylen = 0;
-  YY_STACK_PRINT (yyss, yyssp);
-  yystate = *yyssp;
-  goto yyerrlab1;
-
-
-/*-------------------------------------------------------------.
-| yyerrlab1 -- common code for both syntax error and YYERROR.  |
-`-------------------------------------------------------------*/
-yyerrlab1:
-  yyerrstatus = 3;	/* Each real token shifted decrements this.  */
-
-  for (;;)
-    {
-      yyn = yypact[yystate];
-      if (!yypact_value_is_default (yyn))
-	{
-	  yyn += YYTERROR;
-	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
-	    {
-	      yyn = yytable[yyn];
-	      if (0 < yyn)
-		break;
-	    }
-	}
-
-      /* Pop the current state because it cannot handle the error token.  */
-      if (yyssp == yyss)
-	YYABORT;
-
-      yyerror_range[1] = *yylsp;
-      yydestruct ("Error: popping",
-		  yystos[yystate], yyvsp, yylsp, answer, errors, locations, lexer_param_ptr);
-      YYPOPSTACK (1);
-      yystate = *yyssp;
-      YY_STACK_PRINT (yyss, yyssp);
-    }
-
-  *++yyvsp = yylval;
-
-  yyerror_range[2] = yylloc;
-  /* Using YYLLOC is tempting, but would change the location of
-     the lookahead.  YYLOC is available though.  */
-  YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
-  *++yylsp = yyloc;
-
-  /* Shift the error token.  */
-  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
-
-  yystate = yyn;
-  goto yynewstate;
-
-
-/*-------------------------------------.
-| yyacceptlab -- YYACCEPT comes here.  |
-`-------------------------------------*/
-yyacceptlab:
-  yyresult = 0;
-  goto yyreturn;
-
-/*-----------------------------------.
-| yyabortlab -- YYABORT comes here.  |
-`-----------------------------------*/
-yyabortlab:
-  yyresult = 1;
-  goto yyreturn;
-
-#if !defined(yyoverflow) || YYERROR_VERBOSE
-/*-------------------------------------------------.
-| yyexhaustedlab -- memory exhaustion comes here.  |
-`-------------------------------------------------*/
-yyexhaustedlab:
-  yyerror (&yylloc, answer, errors, locations, lexer_param_ptr, YY_("memory exhausted"));
-  yyresult = 2;
-  /* Fall through.  */
-#endif
-
-yyreturn:
-  if (yychar != YYEMPTY)
-    {
-      /* Make sure we have latest lookahead translation.  See comments at
-         user semantic actions for why this is necessary.  */
-      yytoken = YYTRANSLATE (yychar);
-      yydestruct ("Cleanup: discarding lookahead",
-                  yytoken, &yylval, &yylloc, answer, errors, locations, lexer_param_ptr);
-    }
-  /* Do not reclaim the symbols of the rule which action triggered
-     this YYABORT or YYACCEPT.  */
-  YYPOPSTACK (yylen);
-  YY_STACK_PRINT (yyss, yyssp);
-  while (yyssp != yyss)
-    {
-      yydestruct ("Cleanup: popping",
-		  yystos[*yyssp], yyvsp, yylsp, answer, errors, locations, lexer_param_ptr);
-      YYPOPSTACK (1);
-    }
-#ifndef yyoverflow
-  if (yyss != yyssa)
-    YYSTACK_FREE (yyss);
-#endif
-#if YYERROR_VERBOSE
-  if (yymsg != yymsgbuf)
-    YYSTACK_FREE (yymsg);
-#endif
-  /* Make sure YYID is used.  */
-  return YYID (yyresult);
-}
-
-
-
-/* Line 2067 of yacc.c  */
-#line 430 "parser.y"
-
-
-int jq_parse(struct locfile* locations, block* answer) {
-  struct lexer_param scanner;
-  YY_BUFFER_STATE buf;
-  jq_yylex_init_extra(0, &scanner.lexer);
-  buf = jq_yy_scan_bytes(locations->data, locations->length, scanner.lexer);
-  int errors = 0;
-  *answer = gen_noop();
-  yyparse(answer, &errors, locations, &scanner);
-  jq_yy_delete_buffer(buf, scanner.lexer);
-  jq_yylex_destroy(scanner.lexer);
-  if (errors > 0) {
-    block_free(*answer);
-    *answer = gen_noop();
-  }
-  return errors;
-}
-
-int jq_parse_library(struct locfile* locations, block* answer) {
-  int errs = jq_parse(locations, answer);
-  if (errs) return errs;
-  if (!block_has_only_binders(*answer, OP_IS_CALL_PSEUDO)) {
-    locfile_locate(locations, UNKNOWN_LOCATION, "error: library should only have function definitions, not a main expression");
-    return 1;
-  }
-  return 0;
-}
-
diff --git a/parser.gen.h b/parser.gen.h
deleted file mode 100644
index bf9f9f8c..00000000
--- a/parser.gen.h
+++ /dev/null
@@ -1,132 +0,0 @@
-/* A Bison parser, made by GNU Bison 2.5.  */
-
-/* Bison interface for Yacc-like parsers in C
-   
-      Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
-   
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-   
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-   
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
-
-/* As a special exception, you may create a larger work that contains
-   part or all of the Bison parser skeleton and distribute that work
-   under terms of your choice, so long as that work isn't itself a
-   parser generator using the skeleton or a modified version thereof
-   as a parser skeleton.  Alternatively, if you modify or redistribute
-   the parser skeleton itself, you may (at your option) remove this
-   special exception, which will cause the skeleton and the resulting
-   Bison output files to be licensed under the GNU General Public
-   License without this special exception.
-   
-   This special exception was added by the Free Software Foundation in
-   version 2.2 of Bison.  */
-
-/* "%code requires" blocks.  */
-
-/* Line 2068 of yacc.c  */
-#line 9 "parser.y"
-
-#include "locfile.h"
-#define YYLTYPE location
-#define YYLLOC_DEFAULT(Loc, Rhs, N)             \
-  do {                                          \
-    if (N) {                                    \
-      (Loc).start = YYRHSLOC(Rhs, 1).start;     \
-      (Loc).end = YYRHSLOC(Rhs, N).end;         \
-    } else {                                    \
-      (Loc).start = YYRHSLOC(Rhs, 0).end;       \
-      (Loc).end = YYRHSLOC(Rhs, 0).end;         \
-    }                                           \
-  } while (0)
- 
-
-
-/* Line 2068 of yacc.c  */
-#line 55 "parser.gen.h"
-
-/* Tokens.  */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
-   /* Put the tokens into the symbol table, so that GDB and other debuggers
-      know about them.  */
-   enum yytokentype {
-     INVALID_CHARACTER = 258,
-     IDENT = 259,
-     LITERAL = 260,
-     EQ = 261,
-     NEQ = 262,
-     DEFINEDOR = 263,
-     AS = 264,
-     DEF = 265,
-     IF = 266,
-     THEN = 267,
-     ELSE = 268,
-     ELSE_IF = 269,
-     END = 270,
-     AND = 271,
-     OR = 272,
-     SETPIPE = 273,
-     SETPLUS = 274,
-     SETMINUS = 275,
-     SETMULT = 276,
-     SETDIV = 277,
-     SETDEFINEDOR = 278,
-     LESSEQ = 279,
-     GREATEREQ = 280,
-     CONTAINS = 281,
-     QQSTRING_START = 282,
-     QQSTRING_TEXT = 283,
-     QQSTRING_INTERP_START = 284,
-     QQSTRING_INTERP_END = 285,
-     QQSTRING_END = 286
-   };
-#endif
-
-
-
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE
-{
-
-/* Line 2068 of yacc.c  */
-#line 27 "parser.y"
-
-  jv literal;
-  block blk;
-
-
-
-/* Line 2068 of yacc.c  */
-#line 110 "parser.gen.h"
-} YYSTYPE;
-# define YYSTYPE_IS_TRIVIAL 1
-# define yystype YYSTYPE /* obsolescent; will be withdrawn */
-# define YYSTYPE_IS_DECLARED 1
-#endif
-
-
-
-#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
-typedef struct YYLTYPE
-{
-  int first_line;
-  int first_column;
-  int last_line;
-  int last_column;
-} YYLTYPE;
-# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
-# define YYLTYPE_IS_DECLARED 1
-# define YYLTYPE_IS_TRIVIAL 1
-#endif
-
-
-
diff --git a/parser.gen.info b/parser.gen.info
deleted file mode 100644
index 8f1f5656..00000000
--- a/parser.gen.info
+++ /dev/null
@@ -1,3565 +0,0 @@
-Terminals unused in grammar
-
-   INVALID_CHARACTER
-
-
-Grammar
-
-    0 $accept: TopLevel $end
-
-    1 TopLevel: Exp
-    2         | FuncDefs
-
-    3 FuncDefs: /* empty */
-    4         | FuncDef FuncDefs
-
-    5 Exp: FuncDef Exp
-    6    | Term "as" '$' IDENT '|' Exp
-    7    | "if" Exp "then" Exp ElseBody
-    8    | "if" Exp error
-    9    | Exp '=' Exp
-   10    | Exp "or" Exp
-   11    | Exp "and" Exp
-   12    | Exp "//" Exp
-   13    | Exp "//=" Exp
-   14    | Exp "|=" Exp
-   15    | Exp '|' Exp
-   16    | Exp ',' Exp
-   17    | Exp '+' Exp
-   18    | Exp "+=" Exp
-   19    | Exp '-' Exp
-   20    | Exp "-=" Exp
-   21    | Exp '*' Exp
-   22    | Exp "*=" Exp
-   23    | Exp '/' Exp
-   24    | Exp "/=" Exp
-   25    | Exp "==" Exp
-   26    | Exp "!=" Exp
-   27    | Exp '<' Exp
-   28    | Exp '>' Exp
-   29    | Exp "<=" Exp
-   30    | Exp ">=" Exp
-   31    | Exp "contains" Exp
-   32    | Term
-
-   33 String: QQSTRING_START QQString QQSTRING_END
-
-   34 FuncDef: "def" IDENT ':' Exp ';'
-   35        | "def" IDENT '(' IDENT ')' ':' Exp ';'
-
-   36 QQString: /* empty */
-   37         | QQString QQSTRING_TEXT
-   38         | QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END
-
-   39 ElseBody: "elif" Exp "then" Exp ElseBody
-   40         | "else" Exp "end"
-
-   41 ExpD: ExpD '|' ExpD
-   42     | Term
-
-   43 Term: '.'
-   44     | Term '.' IDENT
-   45     | '.' IDENT
-   46     | Term '[' Exp ']'
-   47     | Term '[' ']'
-   48     | LITERAL
-   49     | String
-   50     | '(' Exp ')'
-   51     | '[' Exp ']'
-   52     | '[' ']'
-   53     | '{' MkDict '}'
-   54     | '$' IDENT
-   55     | IDENT
-   56     | IDENT '(' Exp ')'
-   57     | '(' error ')'
-   58     | '[' error ']'
-   59     | Term '[' error ']'
-   60     | '{' error '}'
-
-   61 MkDict: /* empty */
-   62       | MkDictPair
-   63       | MkDictPair ',' MkDict
-   64       | error ',' MkDict
-
-   65 MkDictPair: IDENT ':' ExpD
-   66           | String ':' ExpD
-   67           | IDENT
-   68           | '(' Exp ')' ':' ExpD
-   69           | '(' error ')' ':' ExpD
-
-
-Terminals, with rules where they appear
-
-$end (0) 0
-'$' (36) 6 54
-'(' (40) 35 50 56 57 68 69
-')' (41) 35 50 56 57 68 69
-'*' (42) 21
-'+' (43) 17
-',' (44) 16 63 64
-'-' (45) 19
-'.' (46) 43 44 45
-'/' (47) 23
-':' (58) 34 35 65 66 68 69
-';' (59) 34 35
-'<' (60) 27
-'=' (61) 9
-'>' (62) 28
-'[' (91) 46 47 51 52 58 59
-']' (93) 46 47 51 52 58 59
-'{' (123) 53 60
-'|' (124) 6 15 41
-'}' (125) 53 60
-error (256) 8 57 58 59 60 64 69
-INVALID_CHARACTER (258)
-IDENT (259) 6 34 35 44 45 54 55 56 65 67
-LITERAL (260) 48
-"==" (261) 25
-"!=" (262) 26
-"//" (263) 12
-"as" (264) 6
-"def" (265) 34 35
-"if" (266) 7 8
-"then" (267) 7 39
-"else" (268) 40
-"elif" (269) 39
-"end" (270) 40
-"and" (271) 11
-"or" (272) 10
-"|=" (273) 14
-"+=" (274) 18
-"-=" (275) 20
-"*=" (276) 22
-"/=" (277) 24
-"//=" (278) 13
-"<=" (279) 29
-">=" (280) 30
-"contains" (281) 31
-QQSTRING_START (282) 33
-QQSTRING_TEXT (283) 37
-QQSTRING_INTERP_START (284) 38
-QQSTRING_INTERP_END (285) 38
-QQSTRING_END (286) 33
-
-
-Nonterminals, with rules where they appear
-
-$accept (51)
-    on left: 0
-TopLevel (52)
-    on left: 1 2, on right: 0
-FuncDefs (53)
-    on left: 3 4, on right: 2 4
-Exp (54)
-    on left: 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
-    25 26 27 28 29 30 31 32, on right: 1 5 6 7 8 9 10 11 12 13 14 15
-    16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 34 35 38 39 40
-    46 50 51 56 68
-String (55)
-    on left: 33, on right: 49 66
-FuncDef (56)
-    on left: 34 35, on right: 4 5
-QQString (57)
-    on left: 36 37 38, on right: 33 37 38
-ElseBody (58)
-    on left: 39 40, on right: 7 39
-ExpD (59)
-    on left: 41 42, on right: 41 65 66 68 69
-Term (60)
-    on left: 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60,
-    on right: 6 32 42 44 46 47 59
-MkDict (61)
-    on left: 61 62 63 64, on right: 53 63 64
-MkDictPair (62)
-    on left: 65 66 67 68 69, on right: 62 63
-
-
-state 0
-
-    0 $accept: . TopLevel $end
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    $default  reduce using rule 3 (FuncDefs)
-
-    TopLevel  go to state 11
-    FuncDefs  go to state 12
-    Exp       go to state 13
-    String    go to state 14
-    FuncDef   go to state 15
-    Term      go to state 16
-
-
-state 1
-
-   55 Term: IDENT .
-   56     | IDENT . '(' Exp ')'
-
-    '('  shift, and go to state 17
-
-    $default  reduce using rule 55 (Term)
-
-
-state 2
-
-   48 Term: LITERAL .
-
-    $default  reduce using rule 48 (Term)
-
-
-state 3
-
-   34 FuncDef: "def" . IDENT ':' Exp ';'
-   35        | "def" . IDENT '(' IDENT ')' ':' Exp ';'
-
-    IDENT  shift, and go to state 18
-
-
-state 4
-
-    7 Exp: "if" . Exp "then" Exp ElseBody
-    8    | "if" . Exp error
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 19
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 5
-
-   33 String: QQSTRING_START . QQString QQSTRING_END
-
-    $default  reduce using rule 36 (QQString)
-
-    QQString  go to state 21
-
-
-state 6
-
-   54 Term: '$' . IDENT
-
-    IDENT  shift, and go to state 22
-
-
-state 7
-
-   50 Term: '(' . Exp ')'
-   57     | '(' . error ')'
-
-    error           shift, and go to state 23
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 24
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 8
-
-   43 Term: '.' .
-   45     | '.' . IDENT
-
-    IDENT  shift, and go to state 25
-
-    $default  reduce using rule 43 (Term)
-
-
-state 9
-
-   51 Term: '[' . Exp ']'
-   52     | '[' . ']'
-   58     | '[' . error ']'
-
-    error           shift, and go to state 26
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    ']'             shift, and go to state 27
-    '{'             shift, and go to state 10
-
-    Exp      go to state 28
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 10
-
-   53 Term: '{' . MkDict '}'
-   60     | '{' . error '}'
-
-    error           shift, and go to state 29
-    IDENT           shift, and go to state 30
-    QQSTRING_START  shift, and go to state 5
-    '('             shift, and go to state 31
-
-    '}'  reduce using rule 61 (MkDict)
-
-    String      go to state 32
-    MkDict      go to state 33
-    MkDictPair  go to state 34
-
-
-state 11
-
-    0 $accept: TopLevel . $end
-
-    $end  shift, and go to state 35
-
-
-state 12
-
-    2 TopLevel: FuncDefs .
-
-    $default  reduce using rule 2 (TopLevel)
-
-
-state 13
-
-    1 TopLevel: Exp .
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    $default  reduce using rule 1 (TopLevel)
-
-
-state 14
-
-   49 Term: String .
-
-    $default  reduce using rule 49 (Term)
-
-
-state 15
-
-    4 FuncDefs: FuncDef . FuncDefs
-    5 Exp: FuncDef . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    $default  reduce using rule 3 (FuncDefs)
-
-    FuncDefs  go to state 59
-    Exp       go to state 60
-    String    go to state 14
-    FuncDef   go to state 15
-    Term      go to state 16
-
-
-state 16
-
-    6 Exp: Term . "as" '$' IDENT '|' Exp
-   32    | Term .
-   44 Term: Term . '.' IDENT
-   46     | Term . '[' Exp ']'
-   47     | Term . '[' ']'
-   59     | Term . '[' error ']'
-
-    "as"  shift, and go to state 61
-    '.'   shift, and go to state 62
-    '['   shift, and go to state 63
-
-    $default  reduce using rule 32 (Exp)
-
-
-state 17
-
-   56 Term: IDENT '(' . Exp ')'
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 64
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 18
-
-   34 FuncDef: "def" IDENT . ':' Exp ';'
-   35        | "def" IDENT . '(' IDENT ')' ':' Exp ';'
-
-    ':'  shift, and go to state 65
-    '('  shift, and go to state 66
-
-
-state 19
-
-    7 Exp: "if" Exp . "then" Exp ElseBody
-    8    | "if" Exp . error
-    9    | Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    error       shift, and go to state 67
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "then"      shift, and go to state 68
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-
-state 20
-
-    5 Exp: FuncDef . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 60
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 21
-
-   33 String: QQSTRING_START QQString . QQSTRING_END
-   37 QQString: QQString . QQSTRING_TEXT
-   38         | QQString . QQSTRING_INTERP_START Exp QQSTRING_INTERP_END
-
-    QQSTRING_TEXT          shift, and go to state 69
-    QQSTRING_INTERP_START  shift, and go to state 70
-    QQSTRING_END           shift, and go to state 71
-
-
-state 22
-
-   54 Term: '$' IDENT .
-
-    $default  reduce using rule 54 (Term)
-
-
-state 23
-
-   57 Term: '(' error . ')'
-
-    ')'  shift, and go to state 72
-
-
-state 24
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   50 Term: '(' Exp . ')'
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-    ')'         shift, and go to state 73
-
-
-state 25
-
-   45 Term: '.' IDENT .
-
-    $default  reduce using rule 45 (Term)
-
-
-state 26
-
-   58 Term: '[' error . ']'
-
-    ']'  shift, and go to state 74
-
-
-state 27
-
-   52 Term: '[' ']' .
-
-    $default  reduce using rule 52 (Term)
-
-
-state 28
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   51 Term: '[' Exp . ']'
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-    ']'         shift, and go to state 75
-
-
-state 29
-
-   60 Term: '{' error . '}'
-   64 MkDict: error . ',' MkDict
-
-    ','  shift, and go to state 76
-    '}'  shift, and go to state 77
-
-
-state 30
-
-   65 MkDictPair: IDENT . ':' ExpD
-   67           | IDENT .
-
-    ':'  shift, and go to state 78
-
-    $default  reduce using rule 67 (MkDictPair)
-
-
-state 31
-
-   68 MkDictPair: '(' . Exp ')' ':' ExpD
-   69           | '(' . error ')' ':' ExpD
-
-    error           shift, and go to state 79
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 80
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 32
-
-   66 MkDictPair: String . ':' ExpD
-
-    ':'  shift, and go to state 81
-
-
-state 33
-
-   53 Term: '{' MkDict . '}'
-
-    '}'  shift, and go to state 82
-
-
-state 34
-
-   62 MkDict: MkDictPair .
-   63       | MkDictPair . ',' MkDict
-
-    ','  shift, and go to state 83
-
-    $default  reduce using rule 62 (MkDict)
-
-
-state 35
-
-    0 $accept: TopLevel $end .
-
-    $default  accept
-
-
-state 36
-
-   25 Exp: Exp "==" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 84
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 37
-
-   26 Exp: Exp "!=" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 85
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 38
-
-   12 Exp: Exp "//" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 86
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 39
-
-   11 Exp: Exp "and" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 87
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 40
-
-   10 Exp: Exp "or" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 88
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 41
-
-   14 Exp: Exp "|=" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 89
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 42
-
-   18 Exp: Exp "+=" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 90
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 43
-
-   20 Exp: Exp "-=" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 91
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 44
-
-   22 Exp: Exp "*=" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 92
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 45
-
-   24 Exp: Exp "/=" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 93
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 46
-
-   13 Exp: Exp "//=" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 94
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 47
-
-   29 Exp: Exp "<=" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 95
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 48
-
-   30 Exp: Exp ">=" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 96
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 49
-
-   31 Exp: Exp "contains" . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 97
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 50
-
-   15 Exp: Exp '|' . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 98
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 51
-
-   16 Exp: Exp ',' . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 99
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 52
-
-    9 Exp: Exp '=' . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 100
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 53
-
-   27 Exp: Exp '<' . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 101
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 54
-
-   28 Exp: Exp '>' . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 102
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 55
-
-   17 Exp: Exp '+' . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 103
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 56
-
-   19 Exp: Exp '-' . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 104
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 57
-
-   21 Exp: Exp '*' . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 105
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 58
-
-   23 Exp: Exp '/' . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 106
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 59
-
-    4 FuncDefs: FuncDef FuncDefs .
-
-    $default  reduce using rule 4 (FuncDefs)
-
-
-state 60
-
-    5 Exp: FuncDef Exp .
-    9    | Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    $default  reduce using rule 5 (Exp)
-
-
-state 61
-
-    6 Exp: Term "as" . '$' IDENT '|' Exp
-
-    '$'  shift, and go to state 107
-
-
-state 62
-
-   44 Term: Term '.' . IDENT
-
-    IDENT  shift, and go to state 108
-
-
-state 63
-
-   46 Term: Term '[' . Exp ']'
-   47     | Term '[' . ']'
-   59     | Term '[' . error ']'
-
-    error           shift, and go to state 109
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    ']'             shift, and go to state 110
-    '{'             shift, and go to state 10
-
-    Exp      go to state 111
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 64
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   56 Term: IDENT '(' Exp . ')'
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-    ')'         shift, and go to state 112
-
-
-state 65
-
-   34 FuncDef: "def" IDENT ':' . Exp ';'
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 113
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 66
-
-   35 FuncDef: "def" IDENT '(' . IDENT ')' ':' Exp ';'
-
-    IDENT  shift, and go to state 114
-
-
-state 67
-
-    8 Exp: "if" Exp error .
-
-    $default  reduce using rule 8 (Exp)
-
-
-state 68
-
-    7 Exp: "if" Exp "then" . Exp ElseBody
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 115
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 69
-
-   37 QQString: QQString QQSTRING_TEXT .
-
-    $default  reduce using rule 37 (QQString)
-
-
-state 70
-
-   38 QQString: QQString QQSTRING_INTERP_START . Exp QQSTRING_INTERP_END
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 116
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 71
-
-   33 String: QQSTRING_START QQString QQSTRING_END .
-
-    $default  reduce using rule 33 (String)
-
-
-state 72
-
-   57 Term: '(' error ')' .
-
-    $default  reduce using rule 57 (Term)
-
-
-state 73
-
-   50 Term: '(' Exp ')' .
-
-    $default  reduce using rule 50 (Term)
-
-
-state 74
-
-   58 Term: '[' error ']' .
-
-    $default  reduce using rule 58 (Term)
-
-
-state 75
-
-   51 Term: '[' Exp ']' .
-
-    $default  reduce using rule 51 (Term)
-
-
-state 76
-
-   64 MkDict: error ',' . MkDict
-
-    error           shift, and go to state 117
-    IDENT           shift, and go to state 30
-    QQSTRING_START  shift, and go to state 5
-    '('             shift, and go to state 31
-
-    '}'  reduce using rule 61 (MkDict)
-
-    String      go to state 32
-    MkDict      go to state 118
-    MkDictPair  go to state 34
-
-
-state 77
-
-   60 Term: '{' error '}' .
-
-    $default  reduce using rule 60 (Term)
-
-
-state 78
-
-   65 MkDictPair: IDENT ':' . ExpD
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    String  go to state 14
-    ExpD    go to state 119
-    Term    go to state 120
-
-
-state 79
-
-   69 MkDictPair: '(' error . ')' ':' ExpD
-
-    ')'  shift, and go to state 121
-
-
-state 80
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   68 MkDictPair: '(' Exp . ')' ':' ExpD
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-    ')'         shift, and go to state 122
-
-
-state 81
-
-   66 MkDictPair: String ':' . ExpD
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    String  go to state 14
-    ExpD    go to state 123
-    Term    go to state 120
-
-
-state 82
-
-   53 Term: '{' MkDict '}' .
-
-    $default  reduce using rule 53 (Term)
-
-
-state 83
-
-   63 MkDict: MkDictPair ',' . MkDict
-
-    error           shift, and go to state 117
-    IDENT           shift, and go to state 30
-    QQSTRING_START  shift, and go to state 5
-    '('             shift, and go to state 31
-
-    '}'  reduce using rule 61 (MkDict)
-
-    String      go to state 32
-    MkDict      go to state 124
-    MkDictPair  go to state 34
-
-
-state 84
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   25    | Exp "==" Exp .
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    '+'  shift, and go to state 55
-    '-'  shift, and go to state 56
-    '*'  shift, and go to state 57
-    '/'  shift, and go to state 58
-
-    "=="        error (nonassociative)
-    "!="        error (nonassociative)
-    "<="        error (nonassociative)
-    ">="        error (nonassociative)
-    "contains"  error (nonassociative)
-    '<'         error (nonassociative)
-    '>'         error (nonassociative)
-
-    $default  reduce using rule 25 (Exp)
-
-
-state 85
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   26    | Exp "!=" Exp .
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    '+'  shift, and go to state 55
-    '-'  shift, and go to state 56
-    '*'  shift, and go to state 57
-    '/'  shift, and go to state 58
-
-    "=="        error (nonassociative)
-    "!="        error (nonassociative)
-    "<="        error (nonassociative)
-    ">="        error (nonassociative)
-    "contains"  error (nonassociative)
-    '<'         error (nonassociative)
-    '>'         error (nonassociative)
-
-    $default  reduce using rule 26 (Exp)
-
-
-state 86
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   12    | Exp "//" Exp .
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    $default  reduce using rule 12 (Exp)
-
-
-state 87
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   11    | Exp "and" Exp .
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    $default  reduce using rule 11 (Exp)
-
-
-state 88
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   10    | Exp "or" Exp .
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "and"       shift, and go to state 39
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    $default  reduce using rule 10 (Exp)
-
-
-state 89
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   14    | Exp "|=" Exp .
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    "|="   error (nonassociative)
-    "+="   error (nonassociative)
-    "-="   error (nonassociative)
-    "*="   error (nonassociative)
-    "/="   error (nonassociative)
-    "//="  error (nonassociative)
-    '='    error (nonassociative)
-
-    $default  reduce using rule 14 (Exp)
-
-
-state 90
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   18    | Exp "+=" Exp .
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    "|="   error (nonassociative)
-    "+="   error (nonassociative)
-    "-="   error (nonassociative)
-    "*="   error (nonassociative)
-    "/="   error (nonassociative)
-    "//="  error (nonassociative)
-    '='    error (nonassociative)
-
-    $default  reduce using rule 18 (Exp)
-
-
-state 91
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   20    | Exp "-=" Exp .
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    "|="   error (nonassociative)
-    "+="   error (nonassociative)
-    "-="   error (nonassociative)
-    "*="   error (nonassociative)
-    "/="   error (nonassociative)
-    "//="  error (nonassociative)
-    '='    error (nonassociative)
-
-    $default  reduce using rule 20 (Exp)
-
-
-state 92
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   22    | Exp "*=" Exp .
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    "|="   error (nonassociative)
-    "+="   error (nonassociative)
-    "-="   error (nonassociative)
-    "*="   error (nonassociative)
-    "/="   error (nonassociative)
-    "//="  error (nonassociative)
-    '='    error (nonassociative)
-
-    $default  reduce using rule 22 (Exp)
-
-
-state 93
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   24    | Exp "/=" Exp .
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    "|="   error (nonassociative)
-    "+="   error (nonassociative)
-    "-="   error (nonassociative)
-    "*="   error (nonassociative)
-    "/="   error (nonassociative)
-    "//="  error (nonassociative)
-    '='    error (nonassociative)
-
-    $default  reduce using rule 24 (Exp)
-
-
-state 94
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   13    | Exp "//=" Exp .
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    "|="   error (nonassociative)
-    "+="   error (nonassociative)
-    "-="   error (nonassociative)
-    "*="   error (nonassociative)
-    "/="   error (nonassociative)
-    "//="  error (nonassociative)
-    '='    error (nonassociative)
-
-    $default  reduce using rule 13 (Exp)
-
-
-state 95
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   29    | Exp "<=" Exp .
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    '+'  shift, and go to state 55
-    '-'  shift, and go to state 56
-    '*'  shift, and go to state 57
-    '/'  shift, and go to state 58
-
-    "=="        error (nonassociative)
-    "!="        error (nonassociative)
-    "<="        error (nonassociative)
-    ">="        error (nonassociative)
-    "contains"  error (nonassociative)
-    '<'         error (nonassociative)
-    '>'         error (nonassociative)
-
-    $default  reduce using rule 29 (Exp)
-
-
-state 96
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   30    | Exp ">=" Exp .
-   31    | Exp . "contains" Exp
-
-    '+'  shift, and go to state 55
-    '-'  shift, and go to state 56
-    '*'  shift, and go to state 57
-    '/'  shift, and go to state 58
-
-    "=="        error (nonassociative)
-    "!="        error (nonassociative)
-    "<="        error (nonassociative)
-    ">="        error (nonassociative)
-    "contains"  error (nonassociative)
-    '<'         error (nonassociative)
-    '>'         error (nonassociative)
-
-    $default  reduce using rule 30 (Exp)
-
-
-state 97
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   31    | Exp "contains" Exp .
-
-    '+'  shift, and go to state 55
-    '-'  shift, and go to state 56
-    '*'  shift, and go to state 57
-    '/'  shift, and go to state 58
-
-    "=="        error (nonassociative)
-    "!="        error (nonassociative)
-    "<="        error (nonassociative)
-    ">="        error (nonassociative)
-    "contains"  error (nonassociative)
-    '<'         error (nonassociative)
-    '>'         error (nonassociative)
-
-    $default  reduce using rule 31 (Exp)
-
-
-state 98
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   15    | Exp '|' Exp .
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    $default  reduce using rule 15 (Exp)
-
-
-state 99
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   16    | Exp ',' Exp .
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    $default  reduce using rule 16 (Exp)
-
-
-state 100
-
-    9 Exp: Exp . '=' Exp
-    9    | Exp '=' Exp .
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    "|="   error (nonassociative)
-    "+="   error (nonassociative)
-    "-="   error (nonassociative)
-    "*="   error (nonassociative)
-    "/="   error (nonassociative)
-    "//="  error (nonassociative)
-    '='    error (nonassociative)
-
-    $default  reduce using rule 9 (Exp)
-
-
-state 101
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   27    | Exp '<' Exp .
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    '+'  shift, and go to state 55
-    '-'  shift, and go to state 56
-    '*'  shift, and go to state 57
-    '/'  shift, and go to state 58
-
-    "=="        error (nonassociative)
-    "!="        error (nonassociative)
-    "<="        error (nonassociative)
-    ">="        error (nonassociative)
-    "contains"  error (nonassociative)
-    '<'         error (nonassociative)
-    '>'         error (nonassociative)
-
-    $default  reduce using rule 27 (Exp)
-
-
-state 102
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   28    | Exp '>' Exp .
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    '+'  shift, and go to state 55
-    '-'  shift, and go to state 56
-    '*'  shift, and go to state 57
-    '/'  shift, and go to state 58
-
-    "=="        error (nonassociative)
-    "!="        error (nonassociative)
-    "<="        error (nonassociative)
-    ">="        error (nonassociative)
-    "contains"  error (nonassociative)
-    '<'         error (nonassociative)
-    '>'         error (nonassociative)
-
-    $default  reduce using rule 28 (Exp)
-
-
-state 103
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   17    | Exp '+' Exp .
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    '*'  shift, and go to state 57
-    '/'  shift, and go to state 58
-
-    $default  reduce using rule 17 (Exp)
-
-
-state 104
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   19    | Exp '-' Exp .
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    '*'  shift, and go to state 57
-    '/'  shift, and go to state 58
-
-    $default  reduce using rule 19 (Exp)
-
-
-state 105
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   21    | Exp '*' Exp .
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    $default  reduce using rule 21 (Exp)
-
-
-state 106
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   23    | Exp '/' Exp .
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    $default  reduce using rule 23 (Exp)
-
-
-state 107
-
-    6 Exp: Term "as" '$' . IDENT '|' Exp
-
-    IDENT  shift, and go to state 125
-
-
-state 108
-
-   44 Term: Term '.' IDENT .
-
-    $default  reduce using rule 44 (Term)
-
-
-state 109
-
-   59 Term: Term '[' error . ']'
-
-    ']'  shift, and go to state 126
-
-
-state 110
-
-   47 Term: Term '[' ']' .
-
-    $default  reduce using rule 47 (Term)
-
-
-state 111
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   46 Term: Term '[' Exp . ']'
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-    ']'         shift, and go to state 127
-
-
-state 112
-
-   56 Term: IDENT '(' Exp ')' .
-
-    $default  reduce using rule 56 (Term)
-
-
-state 113
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   34 FuncDef: "def" IDENT ':' Exp . ';'
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    ';'         shift, and go to state 128
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-
-state 114
-
-   35 FuncDef: "def" IDENT '(' IDENT . ')' ':' Exp ';'
-
-    ')'  shift, and go to state 129
-
-
-state 115
-
-    7 Exp: "if" Exp "then" Exp . ElseBody
-    9    | Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "else"      shift, and go to state 130
-    "elif"      shift, and go to state 131
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    ElseBody  go to state 132
-
-
-state 116
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   38 QQString: QQString QQSTRING_INTERP_START Exp . QQSTRING_INTERP_END
-
-    "=="                 shift, and go to state 36
-    "!="                 shift, and go to state 37
-    "//"                 shift, and go to state 38
-    "and"                shift, and go to state 39
-    "or"                 shift, and go to state 40
-    "|="                 shift, and go to state 41
-    "+="                 shift, and go to state 42
-    "-="                 shift, and go to state 43
-    "*="                 shift, and go to state 44
-    "/="                 shift, and go to state 45
-    "//="                shift, and go to state 46
-    "<="                 shift, and go to state 47
-    ">="                 shift, and go to state 48
-    "contains"           shift, and go to state 49
-    QQSTRING_INTERP_END  shift, and go to state 133
-    '|'                  shift, and go to state 50
-    ','                  shift, and go to state 51
-    '='                  shift, and go to state 52
-    '<'                  shift, and go to state 53
-    '>'                  shift, and go to state 54
-    '+'                  shift, and go to state 55
-    '-'                  shift, and go to state 56
-    '*'                  shift, and go to state 57
-    '/'                  shift, and go to state 58
-
-
-state 117
-
-   64 MkDict: error . ',' MkDict
-
-    ','  shift, and go to state 76
-
-
-state 118
-
-   64 MkDict: error ',' MkDict .
-
-    $default  reduce using rule 64 (MkDict)
-
-
-state 119
-
-   41 ExpD: ExpD . '|' ExpD
-   65 MkDictPair: IDENT ':' ExpD .
-
-    '|'  shift, and go to state 134
-
-    $default  reduce using rule 65 (MkDictPair)
-
-
-state 120
-
-   42 ExpD: Term .
-   44 Term: Term . '.' IDENT
-   46     | Term . '[' Exp ']'
-   47     | Term . '[' ']'
-   59     | Term . '[' error ']'
-
-    '.'  shift, and go to state 62
-    '['  shift, and go to state 63
-
-    $default  reduce using rule 42 (ExpD)
-
-
-state 121
-
-   69 MkDictPair: '(' error ')' . ':' ExpD
-
-    ':'  shift, and go to state 135
-
-
-state 122
-
-   68 MkDictPair: '(' Exp ')' . ':' ExpD
-
-    ':'  shift, and go to state 136
-
-
-state 123
-
-   41 ExpD: ExpD . '|' ExpD
-   66 MkDictPair: String ':' ExpD .
-
-    '|'  shift, and go to state 134
-
-    $default  reduce using rule 66 (MkDictPair)
-
-
-state 124
-
-   63 MkDict: MkDictPair ',' MkDict .
-
-    $default  reduce using rule 63 (MkDict)
-
-
-state 125
-
-    6 Exp: Term "as" '$' IDENT . '|' Exp
-
-    '|'  shift, and go to state 137
-
-
-state 126
-
-   59 Term: Term '[' error ']' .
-
-    $default  reduce using rule 59 (Term)
-
-
-state 127
-
-   46 Term: Term '[' Exp ']' .
-
-    $default  reduce using rule 46 (Term)
-
-
-state 128
-
-   34 FuncDef: "def" IDENT ':' Exp ';' .
-
-    $default  reduce using rule 34 (FuncDef)
-
-
-state 129
-
-   35 FuncDef: "def" IDENT '(' IDENT ')' . ':' Exp ';'
-
-    ':'  shift, and go to state 138
-
-
-state 130
-
-   40 ElseBody: "else" . Exp "end"
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 139
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 131
-
-   39 ElseBody: "elif" . Exp "then" Exp ElseBody
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 140
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 132
-
-    7 Exp: "if" Exp "then" Exp ElseBody .
-
-    $default  reduce using rule 7 (Exp)
-
-
-state 133
-
-   38 QQString: QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END .
-
-    $default  reduce using rule 38 (QQString)
-
-
-state 134
-
-   41 ExpD: ExpD '|' . ExpD
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    String  go to state 14
-    ExpD    go to state 141
-    Term    go to state 120
-
-
-state 135
-
-   69 MkDictPair: '(' error ')' ':' . ExpD
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    String  go to state 14
-    ExpD    go to state 142
-    Term    go to state 120
-
-
-state 136
-
-   68 MkDictPair: '(' Exp ')' ':' . ExpD
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    String  go to state 14
-    ExpD    go to state 143
-    Term    go to state 120
-
-
-state 137
-
-    6 Exp: Term "as" '$' IDENT '|' . Exp
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 144
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 138
-
-   35 FuncDef: "def" IDENT '(' IDENT ')' ':' . Exp ';'
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 145
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 139
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   40 ElseBody: "else" Exp . "end"
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "end"       shift, and go to state 146
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-
-state 140
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   39 ElseBody: "elif" Exp . "then" Exp ElseBody
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "then"      shift, and go to state 147
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-
-state 141
-
-   41 ExpD: ExpD . '|' ExpD
-   41     | ExpD '|' ExpD .
-
-    $default  reduce using rule 41 (ExpD)
-
-
-state 142
-
-   41 ExpD: ExpD . '|' ExpD
-   69 MkDictPair: '(' error ')' ':' ExpD .
-
-    '|'  shift, and go to state 134
-
-    $default  reduce using rule 69 (MkDictPair)
-
-
-state 143
-
-   41 ExpD: ExpD . '|' ExpD
-   68 MkDictPair: '(' Exp ')' ':' ExpD .
-
-    '|'  shift, and go to state 134
-
-    $default  reduce using rule 68 (MkDictPair)
-
-
-state 144
-
-    6 Exp: Term "as" '$' IDENT '|' Exp .
-    9    | Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    $default  reduce using rule 6 (Exp)
-
-
-state 145
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   35 FuncDef: "def" IDENT '(' IDENT ')' ':' Exp . ';'
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    ';'         shift, and go to state 148
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-
-state 146
-
-   40 ElseBody: "else" Exp "end" .
-
-    $default  reduce using rule 40 (ElseBody)
-
-
-state 147
-
-   39 ElseBody: "elif" Exp "then" . Exp ElseBody
-
-    IDENT           shift, and go to state 1
-    LITERAL         shift, and go to state 2
-    "def"           shift, and go to state 3
-    "if"            shift, and go to state 4
-    QQSTRING_START  shift, and go to state 5
-    '$'             shift, and go to state 6
-    '('             shift, and go to state 7
-    '.'             shift, and go to state 8
-    '['             shift, and go to state 9
-    '{'             shift, and go to state 10
-
-    Exp      go to state 149
-    String   go to state 14
-    FuncDef  go to state 20
-    Term     go to state 16
-
-
-state 148
-
-   35 FuncDef: "def" IDENT '(' IDENT ')' ':' Exp ';' .
-
-    $default  reduce using rule 35 (FuncDef)
-
-
-state 149
-
-    9 Exp: Exp . '=' Exp
-   10    | Exp . "or" Exp
-   11    | Exp . "and" Exp
-   12    | Exp . "//" Exp
-   13    | Exp . "//=" Exp
-   14    | Exp . "|=" Exp
-   15    | Exp . '|' Exp
-   16    | Exp . ',' Exp
-   17    | Exp . '+' Exp
-   18    | Exp . "+=" Exp
-   19    | Exp . '-' Exp
-   20    | Exp . "-=" Exp
-   21    | Exp . '*' Exp
-   22    | Exp . "*=" Exp
-   23    | Exp . '/' Exp
-   24    | Exp . "/=" Exp
-   25    | Exp . "==" Exp
-   26    | Exp . "!=" Exp
-   27    | Exp . '<' Exp
-   28    | Exp . '>' Exp
-   29    | Exp . "<=" Exp
-   30    | Exp . ">=" Exp
-   31    | Exp . "contains" Exp
-   39 ElseBody: "elif" Exp "then" Exp . ElseBody
-
-    "=="        shift, and go to state 36
-    "!="        shift, and go to state 37
-    "//"        shift, and go to state 38
-    "else"      shift, and go to state 130
-    "elif"      shift, and go to state 131
-    "and"       shift, and go to state 39
-    "or"        shift, and go to state 40
-    "|="        shift, and go to state 41
-    "+="        shift, and go to state 42
-    "-="        shift, and go to state 43
-    "*="        shift, and go to state 44
-    "/="        shift, and go to state 45
-    "//="       shift, and go to state 46
-    "<="        shift, and go to state 47
-    ">="        shift, and go to state 48
-    "contains"  shift, and go to state 49
-    '|'         shift, and go to state 50
-    ','         shift, and go to state 51
-    '='         shift, and go to state 52
-    '<'         shift, and go to state 53
-    '>'         shift, and go to state 54
-    '+'         shift, and go to state 55
-    '-'         shift, and go to state 56
-    '*'         shift, and go to state 57
-    '/'         shift, and go to state 58
-
-    ElseBody  go to state 150
-
-
-state 150
-
-   39 ElseBody: "elif" Exp "then" Exp ElseBody .
-
-    $default  reduce using rule 39 (ElseBody)

From 2b48ee4a8f894d698b3f726cc58dc9e18a3b27bf Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 12 Dec 2012 23:18:43 +0000
Subject: [PATCH 183/284] Add a Gemfile to make building the documentation
 easier.

Use "bundle install" in the docs folder to install ruby dependencies.
---
 docs/Gemfile      |  4 ++++
 docs/Gemfile.lock | 45 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 49 insertions(+)
 create mode 100644 docs/Gemfile
 create mode 100644 docs/Gemfile.lock

diff --git a/docs/Gemfile b/docs/Gemfile
new file mode 100644
index 00000000..84f2c4e6
--- /dev/null
+++ b/docs/Gemfile
@@ -0,0 +1,4 @@
+source :rubygems
+
+gem "bonsai"
+gem "maruku"
diff --git a/docs/Gemfile.lock b/docs/Gemfile.lock
new file mode 100644
index 00000000..6926b4ad
--- /dev/null
+++ b/docs/Gemfile.lock
@@ -0,0 +1,45 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.2.9)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    addressable (2.3.2)
+    bonsai (1.4.7)
+      activesupport (>= 3.0.3)
+      builder (>= 3.0.0)
+      i18n (>= 0.5.0)
+      launchy (>= 0.3.7)
+      liquid (>= 2.2.2)
+      maruku (>= 0.6.0)
+      rack
+      sass
+      sinatra (>= 1.0)
+      tilt (>= 1.3)
+      watch (>= 0.1.0)
+    builder (3.1.4)
+    i18n (0.6.1)
+    launchy (2.1.2)
+      addressable (~> 2.3)
+    liquid (2.4.1)
+    maruku (0.6.1)
+      syntax (>= 1.0.0)
+    multi_json (1.5.0)
+    rack (1.4.1)
+    rack-protection (1.3.2)
+      rack
+    sass (3.2.3)
+    sinatra (1.3.3)
+      rack (~> 1.3, >= 1.3.6)
+      rack-protection (~> 1.2)
+      tilt (~> 1.3, >= 1.3.3)
+    syntax (1.0.0)
+    tilt (1.3.3)
+    watch (0.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bonsai
+  maruku

From 73c657cdc477a9ec97548991e355b766e06634a2 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 16 Dec 2012 13:06:03 +0000
Subject: [PATCH 184/284] Lots of build system and docs improvements, including
 a manpage.

 - Build binaries for multiple platforms
 - Make a manpage out of the manual (see #19)
 - Extract more tests from the documentation
 - Fix a few documentation bugs uncovered by above.
---
 .gitignore                       |   2 +
 Makefile                         |  54 ++++++++++---
 docs/Gemfile                     |   1 +
 docs/Gemfile.lock                |   8 ++
 docs/Rakefile                    |  42 ++++++++++
 docs/content/3.manual/manual.yml | 132 +++++++++++++++++--------------
 jq_test.c                        |  40 +++++++---
 7 files changed, 197 insertions(+), 82 deletions(-)

diff --git a/.gitignore b/.gitignore
index e43b388c..6caf43c4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,5 +9,7 @@ jv_test
 jv_parse
 parsertest*~
 
+build
+
 # Something delightfully recursive happens otherwise
 docs/content/2.download/source/*
\ No newline at end of file
diff --git a/Makefile b/Makefile
index 0c2d3177..5dfbb7f9 100644
--- a/Makefile
+++ b/Makefile
@@ -1,10 +1,13 @@
-CC=gcc -Wextra -Wall -Wno-missing-field-initializers -Wno-unused-parameter -std=gnu99 -ggdb -Wno-unused-function
+CC=gcc
+CFLAGS=-Wextra -Wall -Wno-missing-field-initializers -Wno-unused-parameter -std=gnu99 -ggdb -Wno-unused-function
+
 prefix=/usr/local
+mandir=$(prefix)/share/man
+
 
 .PHONY: all clean releasedep tarball install uninstall test releasetag
 all: jq
 
-
 lexer.gen.c: lexer.l
 	flex -o lexer.gen.c --header-file=lexer.gen.h lexer.l
 lexer.gen.h: lexer.gen.c
@@ -23,16 +26,45 @@ main.c: version.gen.h
 
 JQ_SRC=parser.gen.c lexer.gen.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c jv_aux.c
 
-
+jq_test: CFLAGS += -DJQ_DEBUG=1
 jq_test: $(JQ_SRC) jq_test.c
-	$(CC) -DJQ_DEBUG=1 -o $@ $^
+	$(CC) $(CFLAGS) $(CFLAGS_DEBUG) -o $@ $^
 
+jq: CFLAGS += -O -DJQ_DEBUG=0
 jq: $(JQ_SRC) main.c
-	$(CC) -O -DJQ_DEBUG=0 -o $@ $^
+	$(CC) $(CFLAGS) $(CFLAGS_OPT) -o $@ $^
 
 test: jq_test
 	valgrind --error-exitcode=1 -q --leak-check=full ./jq_test >/dev/null
 
+BINARIES=jq jq_test
+PLATFORMS=linux32 linux64 osx32 osx64 win32 win64
+
+build/linux32%: CC='x86_64-linux-gnu-gcc -m32'
+build/linux64%: CC='x86_64-linux-gnu-gcc -m64'
+
+# OS X cross compilers can be gotten from
+# https://launchpad.net/~flosoft/+archive/cross-apple
+build/osx32%:   CC='i686-apple-darwin10-gcc -m32'
+build/osx64%:   CC='i686-apple-darwin10-gcc -m64'
+
+# On Debian, you can get windows compilers in the
+# gcc-mingw-w64-i686 and gcc-mingw-w64-x86-64 packages.
+build/win32%:   CC='i686-w64-mingw32-gcc -m32'
+build/win64%:   CC='x86_64-w64-mingw32-gcc -m64'
+
+ALL_BINARIES=$(foreach platform, $(PLATFORMS), $(foreach binary, $(BINARIES), build/$(platform)/$(binary)))
+
+$(ALL_BINARIES): build/%:
+	mkdir -p $(@D)
+	make -B $(BINARIES) CC=$(CC)
+	cp $(BINARIES) $(@D)
+
+binaries: $(ALL_BINARIES)
+
+clean:
+	rm -rf build
+	rm -f $(BINARIES) *.gen.*
 
 releasedep: lexer.gen.c parser.gen.c jv_utf8_tables.gen.h
 
@@ -45,12 +77,16 @@ docs/content/2.download/source/jq.tgz: jq
 
 tarball: docs/content/2.download/source/jq.tgz
 
-install: jq
+jq.1: docs/content/3.manual/manual.yml
+	( cd docs; rake manpage; ) > $@
+
+install: jq jq.1
 	install -d -m 0755 $(prefix)/bin
 	install -m 0755 jq $(prefix)/bin
+	install -d -m 0755 $(mandir)/man1
+	install -m 0755 jq.1 $(mandir)/man1
 
 uninstall:
-	test -d $(prefix)/bin && \
-	cd $(prefix)/bin && \
-	rm -f jq
+	rm -vf $(prefix)/bin/jq
+	rm -vf $(mandir)/man1/jq.1
 
diff --git a/docs/Gemfile b/docs/Gemfile
index 84f2c4e6..f06950f6 100644
--- a/docs/Gemfile
+++ b/docs/Gemfile
@@ -2,3 +2,4 @@ source :rubygems
 
 gem "bonsai"
 gem "maruku"
+gem "ronn"
diff --git a/docs/Gemfile.lock b/docs/Gemfile.lock
index 6926b4ad..ccbc84fe 100644
--- a/docs/Gemfile.lock
+++ b/docs/Gemfile.lock
@@ -18,6 +18,7 @@ GEM
       tilt (>= 1.3)
       watch (>= 0.1.0)
     builder (3.1.4)
+    hpricot (0.8.6)
     i18n (0.6.1)
     launchy (2.1.2)
       addressable (~> 2.3)
@@ -25,9 +26,15 @@ GEM
     maruku (0.6.1)
       syntax (>= 1.0.0)
     multi_json (1.5.0)
+    mustache (0.99.4)
     rack (1.4.1)
     rack-protection (1.3.2)
       rack
+    rdiscount (1.6.8)
+    ronn (0.7.3)
+      hpricot (>= 0.8.2)
+      mustache (>= 0.7.0)
+      rdiscount (>= 1.5.8)
     sass (3.2.3)
     sinatra (1.3.3)
       rack (~> 1.3, >= 1.3.6)
@@ -43,3 +50,4 @@ PLATFORMS
 DEPENDENCIES
   bonsai
   maruku
+  ronn
diff --git a/docs/Rakefile b/docs/Rakefile
index 51e9b484..da2d4cf4 100644
--- a/docs/Rakefile
+++ b/docs/Rakefile
@@ -2,6 +2,8 @@ require 'bonsai'
 require 'liquid'
 require 'maruku'
 require 'json'
+require 'ronn'
+require 'tempfile'
 
 module ExtraFilters
   def markdownify(input)
@@ -59,3 +61,43 @@ task :build do
   Bonsai.root_dir = Dir.pwd
   Bonsai::Exporter.publish!
 end
+
+def load_manual
+  YAML::ENGINE.yamler = 'syck'
+  YAML::load(File.open("content/3.manual/manual.yml"))
+end
+
+task :manpage do
+  Tempfile.open "manpage" do |f|
+    manual = load_manual
+    f.puts manual['manpage_intro']
+    f.puts manual['body']
+    manual['sections'].each do |section|
+      
+      f.puts "## #{section['title'].upcase}\n"
+      f.puts section['body']
+      f.puts ""
+      (section['entries'] || []).each do |entry|
+        f.puts "### #{entry['title']}\n"
+        f.puts entry['body']
+        f.puts ""
+      end
+      f.puts ""
+    end
+    f.close
+    puts Ronn::Document.new(f.path).convert('roff').gsub(/<\/?code>/,"")
+  end  
+end
+
+task :mantests do
+  load_manual['sections'].each do |section|
+    (section['entries'] || []).each do |entry|
+      (entry['examples'] || []).each do |example|
+        puts example['program'].gsub("\n", " ")
+        puts example['input']
+        example['output'].each do |s| puts s end
+        puts
+      end
+    end
+  end
+end
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 15dcb489..f0cedf4f 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -26,6 +26,15 @@ body: |
 
   But that's getting ahead of ourselves. :) Let's start with something
   simpler:
+
+manpage_intro: |
+  jq(1) -- Command-line JSON processor
+  ====================================
+
+  ## SYNOPSIS
+
+  `jq` [<options>...] <filter>
+
   
 sections:
   - title: Invoking jq
@@ -40,51 +49,51 @@ sections:
       You can affect how jq reads and writes its input and output
       using some command-line options:
 
-      * `--slurp`/`-s` 
-
-        Instead of running the filter for each JSON object in the
-        input, read the entire input stream into a large array and run
-        the filter just once.
-      
-      * `--raw-input`/`-R` 
-      
-        Don't parse the input as JSON. Instead, each line of text is
-        passed to the filter as a string. If combined with `--slurp`,
-        then the entire input is passed to the filter as a single long
-        string.
-
-      * `--null-input`/`-n`
-
-        Don't read any input at all! Instead, the filter is run once
-        using `null` as the input. This is useful when using jq as a
-        simple calculator or to construct JSON data from scratch.
-
-      * `--compact-output` / `-c`
-
-        By default, jq pretty-prints JSON output. Using this option
-        will result in more compact output by instead putting each
-        JSON object on a single line.
-
-      * `--colour-output` / `-C` and `--monochrome-output` / `-M`
-      
-        By default, jq outputs colored JSON if writing to a
-        terminal. You can force it to produce color even if writing to
-        a pipe or a file using `-C`, and disable color with `-M`.
-
-      * `--ascii-output` / `-a`
-
-        jq usually outputs non-ASCII Unicode codepoints as UTF-8, even
-        if the input specified them as escape sequences (like
-        "\u03bc"). Using this option, you can force jq to produce pure
-        ASCII output with every non-ASCII character replaced with the
-        equivalent escape sequence.
-
-      * `--raw-output` / `-r`
-
-        With this option, if the filter's result is a string then it
-        will be written directly to standard output rather than being
-        formatted as a JSON string with quotes. This can be useful for
-        making jq filters talk to non-JSON-based systems.
+        * `--slurp`/`-s`:
+  
+          Instead of running the filter for each JSON object in the
+          input, read the entire input stream into a large array and run
+          the filter just once.
+        
+        * `--raw-input`/`-R`:
+        
+          Don't parse the input as JSON. Instead, each line of text is
+          passed to the filter as a string. If combined with `--slurp`,
+          then the entire input is passed to the filter as a single long
+          string.
+  
+        * `--null-input`/`-n`:
+  
+          Don't read any input at all! Instead, the filter is run once
+          using `null` as the input. This is useful when using jq as a
+          simple calculator or to construct JSON data from scratch.
+  
+        * `--compact-output` / `-c`:
+  
+          By default, jq pretty-prints JSON output. Using this option
+          will result in more compact output by instead putting each
+          JSON object on a single line.
+  
+        * `--colour-output` / `-C` and `--monochrome-output` / `-M`:
+        
+          By default, jq outputs colored JSON if writing to a
+          terminal. You can force it to produce color even if writing to
+          a pipe or a file using `-C`, and disable color with `-M`.
+  
+        * `--ascii-output` / `-a`:
+  
+          jq usually outputs non-ASCII Unicode codepoints as UTF-8, even
+          if the input specified them as escape sequences (like
+          "\u03bc"). Using this option, you can force jq to produce pure
+          ASCII output with every non-ASCII character replaced with the
+          equivalent escape sequence.
+  
+        * `--raw-output` / `-r`:
+  
+          With this option, if the filter's result is a string then it
+          will be written directly to standard output rather than being
+          formatted as a JSON string with quotes. This can be useful for
+          making jq filters talk to non-JSON-based systems.
 
   - title: Basic filters
     entries:
@@ -148,7 +157,7 @@ sections:
 
         examples:
           - program: '.[]'
-            input: '[{name":"JSON", "good":true}, {"name":"XML", "good":false}]'
+            input: '[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]'
             output:
               - '{"name":"JSON", "good":true}'
               - '{"name":"XML", "good":false}'
@@ -178,7 +187,7 @@ sections:
             
           - program: '.[4,2]'
             input: '["a","b","c","d","e"]'
-            output: ['"d"', '"c"']
+            output: ['"e"', '"c"']
           
       - title: "`|`"
         body: |
@@ -194,7 +203,7 @@ sections:
 
         examples:
           - program: '.[] | .name'
-            input: '[{name":"JSON", "good":true}, {"name":"XML", "good":false}]'
+            input: '[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]'
             output: ['"JSON"', '"XML"']
 
   - title: Types and Values
@@ -325,7 +334,7 @@ sections:
         examples:
           - program: '.a + 1'
             input: '{"a": 7}'
-            output: '{"a": 8}'
+            output: ['8']
           - program: '.a + .b'
             input: '{"a": [1,2], "b": [3,4]}'
             output: ['[1,2,3,4]']
@@ -409,11 +418,11 @@ sections:
           `foo` returns true for that input, and produces no output
           otherwise.
 
-          It's useful for filtering lists: `[1,2,3] | select(. >= 2)`
+          It's useful for filtering lists: `[1,2,3] | map(select(. >= 2))`
           will give you `[3]`.
 
         examples:
-          - program: 'select(. >= 2)'
+          - program: 'map(select(. >= 2))'
             input: '[1,5,3,0,7]'
             output: ['[5,3,7]']
 
@@ -427,7 +436,7 @@ sections:
         examples:
           - program: '1, empty, 2'
             input: 'null'
-            output: [1,2]
+            output: [1, 2]
           - program: '[1,2,empty,3]'
             input: 'null'
             output: ['[1,2,3]']
@@ -461,7 +470,7 @@ sections:
         examples:
           - program: add
             input: '["a","b","c"]'
-            output: ["abc"]
+            output: ['"abc"']
           - program: add
             input: '[1, 2, 3]'
             output: [6]
@@ -479,7 +488,7 @@ sections:
         examples:
           - program: '.[] | tonumber'
             input: '[1, "1"]'
-            output: [1,1]
+            output: [1, 1]
 
       - title: `tostring`
         body: |
@@ -593,10 +602,10 @@ sections:
             input: '["foobar", "foobaz", "blarp"]'
             output: ['false']
           - program: 'contains({foo: 12, bar: [{barp: 12}]})'
-            input: '{foo: 12, bar:[1,2,{barp:12, blip:13}]}'
+            input: '{"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]}'
             output: ['true']
           - program: 'contains({foo: 12, bar: [{barp: 15}]})'
-            input: '{foo: 12, bar:[1,2,{barp:12, blip:13}]}'
+            input: '{"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]}'
             output: ['false']
 
       - title: "String interpolation - `\(foo)`"
@@ -633,7 +642,7 @@ sections:
         examples:
           - program: '.[] == 1'
             input: '[1, 1.0, "1", "banana"]'
-            output: ['[true, true, false, false]']
+            output: ['true', 'true', 'false', 'false']
       - title: if-then-else
         body: |
 
@@ -854,12 +863,12 @@ sections:
           input's `.foo` field to each element of the array.
 
         examples:
-          - program: 'def addvalue(f): map(. + [$value]); addvalue(.[0])'
+          - program: 'def addvalue(f): . + [f]; map(addvalue(.[0]))'
             input: '[[1,2],[10,20]]'
             output: ['[[1,2,1], [10,20,10]]']
-          - program: 'def addvalue(f): f as $x | map (. + $x); addvalue(.[0])'
+          - program: 'def addvalue(f): f as $x | map(. + $x); addvalue(.[0])'
             input: '[[1,2],[10,20]]'
-            output: ['[[1,2,[1,2]], [10,20,[1,2]]]']
+            output: ['[[1,2,1,2], [10,20,1,2]]']
       
 
   - title: Assignment
@@ -971,4 +980,5 @@ sections:
           "stedolan" wrote, and we can comment on each of them in the same way
           that we did before:
           
-              (.posts[] | select(.author == "stedolan") | .comments) |= . + ["terrible."]
+              (.posts[] | select(.author == "stedolan") | .comments) |=
+                  . + ["terrible."]
diff --git a/jq_test.c b/jq_test.c
index 2960162e..c9bdaef4 100644
--- a/jq_test.c
+++ b/jq_test.c
@@ -8,9 +8,24 @@
 static void jv_test();
 static void run_jq_tests();
 
-int main() {
+FILE* testdata;
+
+int main(int argc, char* argv[]) {
   jv_test();
+  if (argc == 1) {
+    testdata = fopen("testdata", "r");
+  } else if (argc == 2) {
+    if (!strcmp(argv[1], "-")) {
+      testdata = stdin;
+    } else {
+      testdata = fopen(argv[1], "r");
+    }
+  } else {
+    printf("usage: %s OR cat testdata | %s - OR %s testdata\n", argv[0], argv[0], argv[0]);
+    return 127;
+  }
   run_jq_tests();
+  if (testdata != stdin) fclose(testdata);
 }
 
 
@@ -24,37 +39,40 @@ static int skipline(const char* buf) {
 }
 
 static void run_jq_tests() {
-  FILE* testdata = fopen("testdata","r");
   char buf[4096];
-  int tests = 0, passed = 0;
+  int tests = 0, passed = 0, invalid = 0;
 
   while (1) {
     if (!fgets(buf, sizeof(buf), testdata)) break;
     if (skipline(buf)) continue;
+    if (buf[strlen(buf)-1] == '\n') buf[strlen(buf)-1] = 0;
     printf("Testing %s\n", buf);
     int pass = 1;
+    tests++;
     struct bytecode* bc = jq_compile(buf);
-    assert(bc);
+    if (!bc) {invalid++; continue;}
+#if JQ_DEBUG
     printf("Disassembly:\n");
     dump_disassembly(2, bc);
     printf("\n");
+#endif
     fgets(buf, sizeof(buf), testdata);
     jv input = jv_parse(buf);
-    assert(jv_is_valid(input));
+    if (!jv_is_valid(input)){ invalid++; continue; }
     jq_init(bc, input);
 
     while (fgets(buf, sizeof(buf), testdata)) {
       if (skipline(buf)) break;
       jv expected = jv_parse(buf);
-      assert(jv_is_valid(expected));
+      if (!jv_is_valid(expected)){ invalid++; continue; }
       jv actual = jq_next();
       if (!jv_is_valid(actual)) {
         jv_free(actual);
-        printf("Insufficient results\n");
+        printf("*** Insufficient results\n");
         pass = 0;
         break;
       } else if (!jv_equal(jv_copy(expected), jv_copy(actual))) {
-        printf("Expected ");
+        printf("*** Expected ");
         jv_dump(jv_copy(expected), 0);
         printf(", but got ");
         jv_dump(jv_copy(actual), 0);
@@ -72,7 +90,7 @@ static void run_jq_tests() {
     if (pass) {
       jv extra = jq_next();
       if (jv_is_valid(extra)) {
-        printf("Superfluous result: ");
+        printf("*** Superfluous result: ");
         jv_dump(extra, 0);
         printf("\n");
         pass = 0;
@@ -82,11 +100,9 @@ static void run_jq_tests() {
     }
     jq_teardown();
     bytecode_free(bc);
-    tests++;
     passed+=pass;
   }
-  fclose(testdata);
-  printf("%d of %d tests passed\n", passed,tests);
+  printf("%d of %d tests passed (%d malformed)\n", passed,tests,invalid);
   if (passed != tests) exit(1);
 }
 

From 3ae8fb7371085f7507de6324c391c9953fc638e3 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 16 Dec 2012 13:10:48 +0000
Subject: [PATCH 185/284] Fix a bug uncovered by tests extracted from manual.

`null | length` should give 0, and now does.
---
 builtin.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/builtin.c b/builtin.c
index f046e91a..4f9fab59 100644
--- a/builtin.c
+++ b/builtin.c
@@ -191,6 +191,9 @@ static jv f_length(jv input) {
     return jv_number(jv_object_length(input));
   } else if (jv_get_kind(input) == JV_KIND_STRING) {
     return jv_number(jv_string_length(input));
+  } else if (jv_get_kind(input) == JV_KIND_NULL) {
+    jv_free(input);
+    return jv_number(0);
   } else {
     return type_error(input, "has no length");
   }

From b0aa62f2b77b2b97fca3e75030156455381d0df3 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 16 Dec 2012 17:11:40 +0000
Subject: [PATCH 186/284] Improve manpage introduction, add examples to
 manpage.

Closes #19
---
 docs/Rakefile                    |  6 ++++++
 docs/content/3.manual/manual.yml | 11 +++++++++++
 2 files changed, 17 insertions(+)

diff --git a/docs/Rakefile b/docs/Rakefile
index da2d4cf4..375ce408 100644
--- a/docs/Rakefile
+++ b/docs/Rakefile
@@ -81,6 +81,12 @@ task :manpage do
         f.puts "### #{entry['title']}\n"
         f.puts entry['body']
         f.puts ""
+        (entry['examples'] || []).each do |example|
+          f.puts "    jq '#{example['program']}'"
+          f.puts "       #{example['input']}"
+          f.puts "    => #{example['output'].join(", ")}"
+          f.puts
+        end
       end
       f.puts ""
     end
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index f0cedf4f..6e8065c6 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -35,6 +35,17 @@ manpage_intro: |
 
   `jq` [<options>...] <filter>
 
+  `jq` can transform JSON in various ways, by selecting, iterating,
+  reducing and otherwise mangling JSON documents. For instance,
+  running the command `jq 'map(.price) | add'` will take an array of
+  JSON objects as input and return the sum of their "price" fields.
+  
+  The <options> are described in the [INVOKING JQ] section, they
+  mostly concern input and output formatting. The <filter> is written
+  in the jq language and specifies how to transform the input
+  document.
+
+  ## FILTERS
   
 sections:
   - title: Invoking jq

From 75421cbfe32ae6428fe08b6ba83f1f7ac0322c33 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 16 Dec 2012 19:46:41 +0000
Subject: [PATCH 187/284] Add the ability to specify input files on the
 commandline.

See #21.
---
 docs/content/3.manual/manual.yml |  6 +++-
 main.c                           | 58 +++++++++++++++++++++++++++-----
 2 files changed, 54 insertions(+), 10 deletions(-)

diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 6e8065c6..5acb212c 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -33,12 +33,16 @@ manpage_intro: |
 
   ## SYNOPSIS
 
-  `jq` [<options>...] <filter>
+  `jq` [<options>...] <filter> [<files>...]
 
   `jq` can transform JSON in various ways, by selecting, iterating,
   reducing and otherwise mangling JSON documents. For instance,
   running the command `jq 'map(.price) | add'` will take an array of
   JSON objects as input and return the sum of their "price" fields.
+
+  By default, `jq` reads a stream of JSON objects (whitespace
+  separated) from `stdin`. One or more <files> may be specified, in
+  which case `jq` will read input from those instead.
   
   The <options> are described in the [INVOKING JQ] section, they
   mostly concern input and output formatting. The <filter> is written
diff --git a/main.c b/main.c
index 64cb1fd4..252ebd5a 100644
--- a/main.c
+++ b/main.c
@@ -16,10 +16,11 @@ static const char* progname;
 
 static void usage() {
   fprintf(stderr, "\njq - commandline JSON processor [version %s]\n", JQ_VERSION);
-  fprintf(stderr, "Usage: %s [options] <jq filter>\n\n", progname);
+  fprintf(stderr, "Usage: %s [options] <jq filter> [file...]\n\n", progname);
   fprintf(stderr, "For a description of the command line options and\n");
   fprintf(stderr, "how to write jq filters (and why you might want to)\n");
-  fprintf(stderr, "see the jq documentation at http://stedolan.github.com/jq\n\n");
+  fprintf(stderr, "see the jq manpage, or the online documentation at\n");
+  fprintf(stderr, "http://stedolan.github.com/jq\n\n");
   exit(1);
 }
 
@@ -102,14 +103,53 @@ static jv slurp_file(const char* filename) {
   return data;
 }
 
+FILE* current_input;
+const char** input_filenames;
+int ninput_files;
+int next_input_idx;
+static int read_more(char* buf, size_t size) {
+  while (!current_input || feof(current_input)) {
+    if (current_input) {
+      fclose(current_input);
+      current_input = 0;
+    }
+    if (next_input_idx == ninput_files) {
+      return 0;
+    }
+    if (!strcmp(input_filenames[next_input_idx], "-")) {
+      current_input = stdin;
+    } else {
+      current_input = fopen(input_filenames[next_input_idx], "r");
+    }
+    if (!current_input) {
+      fprintf(stderr, "%s: %s: %s\n", progname, input_filenames[next_input_idx], strerror(errno));
+    }
+    next_input_idx++;
+  }
+
+  if (!fgets(buf, sizeof(buf), current_input)) buf[0] = 0;
+  return 1;
+}
+
 int main(int argc, char* argv[]) {
   if (argc) progname = argv[0];
 
   const char* program = 0;
+  input_filenames = malloc(sizeof(const char*) * argc);
+  ninput_files = 0;
+  int further_args_are_files = 0;
   for (int i=1; i<argc; i++) {
-    if (!isoptish(argv[i])) {
-      if (program) usage();
-      program = argv[i];
+    if (further_args_are_files) {
+      input_filenames[ninput_files++] = argv[i];
+    } else if (!strcmp(argv[i], "--")) {
+      if (!program) usage();
+      further_args_are_files = 1;
+    } else if (!isoptish(argv[i])) {
+      if (program) {
+        input_filenames[ninput_files++] = argv[i];
+      } else {
+        program = argv[i];
+      }
     } else if (isoption(argv[i], 's', "slurp")) {
       options |= SLURP;
     } else if (isoption(argv[i], 'r', "raw-output")) {
@@ -139,6 +179,7 @@ int main(int argc, char* argv[]) {
     }
   }
   if (!program) usage();
+  if (ninput_files == 0) current_input = stdin;
 
   if ((options & PROVIDE_NULL) && (options & (RAW_INPUT | SLURP))) {
     fprintf(stderr, "%s: --null-input cannot be used with --raw-input or --slurp\n", progname);
@@ -178,9 +219,8 @@ int main(int argc, char* argv[]) {
     }
     struct jv_parser parser;
     jv_parser_init(&parser);
-    while (!feof(stdin)) {
-      char buf[4096];
-      if (!fgets(buf, sizeof(buf), stdin)) buf[0] = 0;
+    char buf[4096];
+    while (read_more(buf, sizeof(buf))) {
       if (options & RAW_INPUT) {
         int len = strlen(buf);
         if (len > 0) {
@@ -216,7 +256,7 @@ int main(int argc, char* argv[]) {
       process(slurped);
     }
   }
-
+  free(input_filenames);
   bytecode_free(bc);
   return 0;
 }

From 04daafbde36ab696069a9df17ff85629574491c4 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 18 Dec 2012 16:52:47 +0000
Subject: [PATCH 188/284] Add wrappers for malloc/realloc/free. See #43.

---
 Makefile         |  2 +-
 bytecode.c       | 11 ++++++-----
 compile.c        | 20 +++++++++++---------
 execute.c        |  5 +++--
 forkable_stack.h | 10 +++++-----
 jv.c             | 31 ++++++++++++++++---------------
 jv_alloc.c       | 15 +++++++++++++++
 jv_alloc.h       | 10 ++++++++++
 jv_aux.c         | 11 ++++++-----
 jv_dtoa.c        |  7 ++++++-
 jv_parse.c       |  9 +++++----
 lexer.l          | 12 ++++++++++++
 locfile.h        |  5 +++--
 main.c           |  6 ++++--
 parser.y         |  3 +++
 15 files changed, 106 insertions(+), 51 deletions(-)
 create mode 100644 jv_alloc.c
 create mode 100644 jv_alloc.h

diff --git a/Makefile b/Makefile
index 5dfbb7f9..cbaf5040 100644
--- a/Makefile
+++ b/Makefile
@@ -24,7 +24,7 @@ version.gen.h: VERSION
 	sed 's/.*/#define JQ_VERSION "&"/' $^ > $@
 main.c: version.gen.h
 
-JQ_SRC=parser.gen.c lexer.gen.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c jv_aux.c
+JQ_SRC=parser.gen.c lexer.gen.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c jv_aux.c jv_alloc.c
 
 jq_test: CFLAGS += -DJQ_DEBUG=1
 jq_test: $(JQ_SRC) jq_test.c
diff --git a/bytecode.c b/bytecode.c
index e66bffbb..39381204 100644
--- a/bytecode.c
+++ b/bytecode.c
@@ -4,6 +4,7 @@
 
 #include "bytecode.h"
 #include "opcode.h"
+#include "jv_alloc.h"
 
 static int bytecode_operation_length(uint16_t* codeptr) {
   int length = opcode_describe(*codeptr)->length;
@@ -72,17 +73,17 @@ void dump_operation(struct bytecode* bc, uint16_t* codeptr) {
 }
 
 void symbol_table_free(struct symbol_table* syms) {
-  free(syms->cfunctions);
-  free(syms);
+  jv_mem_free(syms->cfunctions);
+  jv_mem_free(syms);
 }
 
 void bytecode_free(struct bytecode* bc) {
-  free(bc->code);
+  jv_mem_free(bc->code);
   jv_free(bc->constants);
   for (int i=0; i<bc->nsubfunctions; i++)
     bytecode_free(bc->subfunctions[i]);
   if (!bc->parent)
     symbol_table_free(bc->globals);
-  free(bc->subfunctions);
-  free(bc);
+  jv_mem_free(bc->subfunctions);
+  jv_mem_free(bc);
 }
diff --git a/compile.c b/compile.c
index 3a094721..139b64bc 100644
--- a/compile.c
+++ b/compile.c
@@ -1,3 +1,4 @@
+#define _GNU_SOURCE // for strdup
 #include <assert.h>
 #include <string.h>
 #include <stdlib.h>
@@ -5,6 +6,7 @@
 #include "compile.h"
 #include "bytecode.h"
 #include "locfile.h"
+#include "jv_alloc.h"
 
 /*
   The intermediate representation for jq filters is as a sequence of
@@ -57,7 +59,7 @@ struct inst {
 };
 
 static inst* inst_new(opcode op) {
-  inst* i = malloc(sizeof(inst));
+  inst* i = jv_mem_alloc(sizeof(inst));
   i->next = i->prev = 0;
   i->op = op;
   i->bytecode_pos = -1;
@@ -70,13 +72,13 @@ static inst* inst_new(opcode op) {
 }
 
 static void inst_free(struct inst* i) {
-  free(i->symbol);
+  jv_mem_free(i->symbol);
   block_free(i->subfn);
   block_free(i->arglist);
   if (opcode_describe(i->op)->flags & OP_HAS_CONSTANT) {
     jv_free(i->imm.constant);
   }
-  free(i);
+  jv_mem_free(i);
 }
 
 static block inst_block(inst* i) {
@@ -546,10 +548,10 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
     }
   }
   if (bc->nsubfunctions) {
-    bc->subfunctions = malloc(sizeof(struct bytecode*) * bc->nsubfunctions);
+    bc->subfunctions = jv_mem_alloc(sizeof(struct bytecode*) * bc->nsubfunctions);
     for (inst* curr = b.first; curr; curr = curr->next) {
       if (curr->op == CLOSURE_CREATE) {
-        struct bytecode* subfn = malloc(sizeof(struct bytecode));
+        struct bytecode* subfn = jv_mem_alloc(sizeof(struct bytecode));
         bc->subfunctions[curr->imm.intval] = subfn;
         subfn->globals = bc->globals;
         subfn->parent = bc;
@@ -568,7 +570,7 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
     bc->subfunctions = 0;
   }
   bc->codelen = pos;
-  uint16_t* code = malloc(sizeof(uint16_t) * bc->codelen);
+  uint16_t* code = jv_mem_alloc(sizeof(uint16_t) * bc->codelen);
   bc->code = code;
   pos = 0;
   jv constant_pool = jv_array();
@@ -620,13 +622,13 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
 }
 
 int block_compile(block b, struct locfile* locations, struct bytecode** out) {
-  struct bytecode* bc = malloc(sizeof(struct bytecode));
+  struct bytecode* bc = jv_mem_alloc(sizeof(struct bytecode));
   bc->parent = 0;
   bc->nclosures = 0;
-  bc->globals = malloc(sizeof(struct symbol_table));
+  bc->globals = jv_mem_alloc(sizeof(struct symbol_table));
   int ncfunc = count_cfunctions(b);
   bc->globals->ncfunctions = 0;
-  bc->globals->cfunctions = malloc(sizeof(struct cfunction) * ncfunc);
+  bc->globals->cfunctions = jv_mem_alloc(sizeof(struct cfunction) * ncfunc);
   int nerrors = compile(locations, bc, b);
   assert(bc->globals->ncfunctions == ncfunc);
   if (nerrors > 0) {
diff --git a/execute.c b/execute.c
index 8b8036a1..a4719aae 100644
--- a/execute.c
+++ b/execute.c
@@ -11,6 +11,7 @@
 #include "forkable_stack.h"
 #include "frame_layout.h"
 
+#include "jv_alloc.h"
 #include "locfile.h"
 #include "jv.h"
 #include "jv_aux.h"
@@ -33,7 +34,7 @@ int path_push(stackval sv, jv val) {
   if (pos == pathsize) {
     int oldpathsize = pathsize;
     pathsize = oldpathsize ? oldpathsize * 2 : 100;
-    pathbuf = realloc(pathbuf, sizeof(pathbuf[0]) * pathsize);
+    pathbuf = jv_mem_realloc(pathbuf, sizeof(pathbuf[0]) * pathsize);
     for (int i=oldpathsize; i<pathsize; i++) {
       pathbuf[i] = jv_invalid();
     }
@@ -491,7 +492,7 @@ void jq_teardown() {
   for (int i=0; i<pathsize; i++) {
     jv_free(pathbuf[i]);
   }
-  free(pathbuf);
+  jv_mem_free(pathbuf);
   pathbuf = 0;
   pathsize = 0;
 }
diff --git a/forkable_stack.h b/forkable_stack.h
index a94a1ec3..041bfac4 100644
--- a/forkable_stack.h
+++ b/forkable_stack.h
@@ -1,9 +1,9 @@
 #ifndef FORKABLE_STACK_H
 #define FORKABLE_STACK_H
-#include <stdlib.h>
 #include <stddef.h>
 #include <assert.h>
 #include <string.h>
+#include "jv_alloc.h"
 
 struct forkable_stack_header {
   /* distance in bytes between this header and the header
@@ -18,7 +18,7 @@ struct forkable_stack {
   char* stk;
 
   // stk+length is just past end of allocated area
-  // stk = malloc(length)
+  // stk = jv_mem_alloc(length)
   int length;
 
   // stk+pos is header of top object, or stk+length if empty
@@ -40,7 +40,7 @@ static int forkable_stack_empty(struct forkable_stack* s) {
 }
 
 static void forkable_stack_init(struct forkable_stack* s, size_t sz) {
-  s->stk = malloc(sz);
+  s->stk = jv_mem_alloc(sz);
   s->length = sz;
   s->pos = s->length;
   s->savedlimit = s->length;
@@ -50,7 +50,7 @@ static void forkable_stack_init(struct forkable_stack* s, size_t sz) {
 static void forkable_stack_free(struct forkable_stack* s) {
   assert(forkable_stack_empty(s));
   assert(s->savedlimit == s->length);
-  free(s->stk);
+  jv_mem_free(s->stk);
   s->stk = 0;
 }
 
@@ -62,7 +62,7 @@ static void* forkable_stack_push(struct forkable_stack* s, size_t sz_size) {
   if (curr - size < 0) {
     int oldlen = s->length;
     s->length = (size + oldlen + 1024) * 2;
-    s->stk = realloc(s->stk, s->length);
+    s->stk = jv_mem_realloc(s->stk, s->length);
     int shift = s->length - oldlen;
     memmove(s->stk + shift, s->stk, oldlen);
     s->pos += shift;
diff --git a/jv.c b/jv.c
index 77937a8d..abbeb6d4 100644
--- a/jv.c
+++ b/jv.c
@@ -6,6 +6,7 @@
 #include <string.h>
 #include <stdarg.h>
 
+#include "jv_alloc.h"
 #include "jv.h"
 
 /*
@@ -86,7 +87,7 @@ jv jv_invalid_with_msg(jv err) {
   jv x;
   x.kind = JV_KIND_INVALID;
   x.val.complex.i[0] = x.val.complex.i[1] = 0;
-  jvp_invalid* i = malloc(sizeof(jvp_invalid));
+  jvp_invalid* i = jv_mem_alloc(sizeof(jvp_invalid));
   x.val.complex.ptr = &i->refcnt;
   i->refcnt.count = 1;
   i->errmsg = err;
@@ -113,7 +114,7 @@ int jv_invalid_has_msg(jv inv) {
 static void jvp_invalid_free(jv_complex* x) {
   if (jvp_refcnt_dec(x)) {
     jv_free(((jvp_invalid*)x->ptr)->errmsg);
-    free(x->ptr);
+    jv_mem_free(x->ptr);
   }
 }
 
@@ -157,7 +158,7 @@ static jvp_array* jvp_array_ptr(jv_complex* a) {
 }
 
 static jvp_array* jvp_array_alloc(unsigned size) {
-  jvp_array* a = malloc(sizeof(jvp_array) + sizeof(jv) * size);
+  jvp_array* a = jv_mem_alloc(sizeof(jvp_array) + sizeof(jv) * size);
   a->refcnt.count = 1;
   a->length = 0;
   a->alloc_length = size;
@@ -175,7 +176,7 @@ static void jvp_array_free(jv_complex* a) {
     for (int i=0; i<array->length; i++) {
       jv_free(array->elements[i]);
     }
-    free(array);
+    jv_mem_free(array);
   }
 }
 
@@ -371,7 +372,7 @@ static jvp_string* jvp_string_ptr(jv_complex* a) {
 }
 
 static jvp_string* jvp_string_alloc(uint32_t size) {
-  jvp_string* s = malloc(sizeof(jvp_string) + size + 1);
+  jvp_string* s = jv_mem_alloc(sizeof(jvp_string) + size + 1);
   s->refcnt.count = 1;
   s->alloc_length = size;
   return s;
@@ -389,7 +390,7 @@ static jv_complex jvp_string_new(const char* data, uint32_t length) {
 static void jvp_string_free(jv_complex* s) {
   if (jvp_refcnt_dec(s)) {
     jvp_string* str = jvp_string_ptr(s);
-    free(str);
+    jv_mem_free(str);
   }
 }
 
@@ -569,17 +570,17 @@ jv jv_string_append_str(jv a, const char* str) {
 jv jv_string_fmt(const char* fmt, ...) {
   int size = 1024;
   while (1) {
-    char* buf = malloc(size);
+    char* buf = jv_mem_alloc(size);
     va_list args;
     va_start(args, fmt);
     int n = vsnprintf(buf, size, fmt, args);
     va_end(args);
     if (n < size) {
       jv ret = jv_string_sized(buf, n);
-      free(buf);
+      jv_mem_free(buf);
       return ret;
     } else {
-      free(buf);
+      jv_mem_free(buf);
       size = n * 2;
     }
   }
@@ -609,9 +610,9 @@ static jv_complex jvp_object_new(int size) {
 
   // size must be a power of two
   assert(size > 0 && (size & (size - 1)) == 0);
-  jvp_object* obj = malloc(sizeof(jvp_object) + 
-                           sizeof(struct object_slot) * size +
-                           sizeof(int) * (size * 2));
+  jvp_object* obj = jv_mem_alloc(sizeof(jvp_object) + 
+                                 sizeof(struct object_slot) * size +
+                                 sizeof(int) * (size * 2));
   obj->refcnt.count = 1;
   for (int i=0; i<size; i++) {
     obj->elements[i].next = i - 1;
@@ -711,7 +712,7 @@ static void jvp_object_free(jv_complex* o) {
         jv_free(slot->value);
       }
     }
-    free(jvp_object_ptr(o));
+    jv_mem_free(jvp_object_ptr(o));
   }
 }
 
@@ -730,7 +731,7 @@ static void jvp_object_rehash(jv_complex* object) {
     new_slot->value = slot->value;
   }
   // references are transported, just drop the old table
-  free(jvp_object_ptr(object));
+  jv_mem_free(jvp_object_ptr(object));
   *object = new_object;
 }
 
@@ -1037,4 +1038,4 @@ int jv_contains(jv a, jv b) {
   jv_free(a);
   jv_free(b);
   return r;
-}
\ No newline at end of file
+}
diff --git a/jv_alloc.c b/jv_alloc.c
new file mode 100644
index 00000000..3e1c8fe7
--- /dev/null
+++ b/jv_alloc.c
@@ -0,0 +1,15 @@
+#include <stdlib.h>
+#include "jv_alloc.h"
+
+
+void* jv_mem_alloc(size_t sz) {
+  return malloc(sz);
+}
+
+void jv_mem_free(void* p) {
+  free(p);
+}
+
+void* jv_mem_realloc(void* p, size_t sz) {
+  return realloc(p, sz);
+}
diff --git a/jv_alloc.h b/jv_alloc.h
new file mode 100644
index 00000000..0613d587
--- /dev/null
+++ b/jv_alloc.h
@@ -0,0 +1,10 @@
+#ifndef JV_ALLOC_H
+#define JV_ALLOC_H
+
+#include <stddef.h>
+
+void* jv_mem_alloc(size_t);
+void jv_mem_free(void*);
+__attribute__((warn_unused_result)) void* jv_mem_realloc(void*, size_t);
+
+#endif
diff --git a/jv_aux.c b/jv_aux.c
index 15bc3de7..a4bfddd2 100644
--- a/jv_aux.c
+++ b/jv_aux.c
@@ -1,6 +1,7 @@
 #include "jv_aux.h"
 #include <string.h>
 #include <stdlib.h>
+#include "jv_alloc.h"
 
 jv jv_lookup(jv t, jv k) {
   jv v;
@@ -78,7 +79,7 @@ static int string_cmp(const void* pa, const void* pb){
 jv jv_keys(jv x) {
   if (jv_get_kind(x) == JV_KIND_OBJECT) {
     int nkeys = jv_object_length(jv_copy(x));
-    jv* keys = malloc(sizeof(jv) * nkeys);
+    jv* keys = jv_mem_alloc(sizeof(jv) * nkeys);
     int kidx = 0;
     jv_object_foreach(i, x) {
       keys[kidx++] = jv_object_iter_key(x, i);
@@ -88,7 +89,7 @@ jv jv_keys(jv x) {
     for (int i = 0; i<nkeys; i++) {
       answer = jv_array_append(answer, keys[i]);
     }
-    free(keys);
+    jv_mem_free(keys);
     jv_free(x);
     return answer;
   } else if (jv_get_kind(x) == JV_KIND_ARRAY) {
@@ -199,7 +200,7 @@ static struct sort_entry* sort_items(jv objects, jv keys) {
   assert(jv_get_kind(keys) == JV_KIND_ARRAY);
   assert(jv_array_length(jv_copy(objects)) == jv_array_length(jv_copy(keys)));
   int n = jv_array_length(jv_copy(objects));
-  struct sort_entry* entries = malloc(sizeof(struct sort_entry) * n);
+  struct sort_entry* entries = jv_mem_alloc(sizeof(struct sort_entry) * n);
   for (int i=0; i<n; i++) {
     entries[i].object = jv_array_get(jv_copy(objects), i);
     entries[i].key = jv_array_get(jv_copy(keys), i);
@@ -221,7 +222,7 @@ jv jv_sort(jv objects, jv keys) {
     jv_free(entries[i].key);
     ret = jv_array_set(ret, i, entries[i].object);
   }
-  free(entries);
+  jv_mem_free(entries);
   return ret;
 }
 
@@ -247,6 +248,6 @@ jv jv_group(jv objects, jv keys) {
   }
   jv_free(curr_key);
   ret = jv_array_append(ret, group);
-  free(entries);
+  jv_mem_free(entries);
   return ret;
 }
diff --git a/jv_dtoa.c b/jv_dtoa.c
index b200c462..251a6916 100644
--- a/jv_dtoa.c
+++ b/jv_dtoa.c
@@ -195,6 +195,11 @@
 
 #include "jv_dtoa.h"
 
+#include "jv_alloc.h"
+#define MALLOC jv_mem_alloc
+#define FREE jv_mem_free
+
+
 
 #ifndef Long
 #define Long long
@@ -572,7 +577,7 @@ void jvp_dtoa_context_free(struct dtoa_context* C) {
     while (C->freelist[k]) {
       Bigint* v = C->freelist[k];
       C->freelist[k] = v->next;
-      free(v);
+      FREE(v);
     }
   }
 }
diff --git a/jv_parse.c b/jv_parse.c
index 738beb94..0d4f1549 100644
--- a/jv_parse.c
+++ b/jv_parse.c
@@ -5,6 +5,7 @@
 #include "jv_dtoa.h"
 #include "jv_parse.h"
 #include "jv_unicode.h"
+#include "jv_alloc.h"
 
 typedef const char* presult;
 
@@ -32,8 +33,8 @@ void jv_parser_free(struct jv_parser* p) {
   jv_free(p->next);
   for (int i=0; i<p->stackpos; i++) 
     jv_free(p->stack[i]);
-  free(p->stack);
-  free(p->tokenbuf);
+  jv_mem_free(p->stack);
+  jv_mem_free(p->tokenbuf);
   jvp_dtoa_context_free(&p->dtoa);
 }
 
@@ -48,7 +49,7 @@ static void push(struct jv_parser* p, jv v) {
   assert(p->stackpos <= p->stacklen);
   if (p->stackpos == p->stacklen) {
     p->stacklen = p->stacklen * 2 + 10;
-    p->stack = realloc(p->stack, p->stacklen * sizeof(jv));
+    p->stack = jv_mem_realloc(p->stack, p->stacklen * sizeof(jv));
   }
   assert(p->stackpos < p->stacklen);
   p->stack[p->stackpos++] = v;
@@ -142,7 +143,7 @@ static void tokenadd(struct jv_parser* p, char c) {
   assert(p->tokenpos <= p->tokenlen);
   if (p->tokenpos == p->tokenlen) {
     p->tokenlen = p->tokenlen*2 + 256;
-    p->tokenbuf = realloc(p->tokenbuf, p->tokenlen);
+    p->tokenbuf = jv_mem_realloc(p->tokenbuf, p->tokenlen);
   }
   assert(p->tokenpos < p->tokenlen);
   p->tokenbuf[p->tokenpos++] = c;
diff --git a/lexer.l b/lexer.l
index b09ccce4..7090de31 100644
--- a/lexer.l
+++ b/lexer.l
@@ -1,4 +1,5 @@
 %{
+#include "jv_alloc.h"
 #include "compile.h"
 
 struct lexer_param;
@@ -25,6 +26,7 @@ struct lexer_param;
 %}
 
 %option noyywrap nounput noinput nodefault
+%option noyyalloc noyyrealloc noyyfree
 %option reentrant
 %option extra-type="int"
 %option bison-bridge bison-locations
@@ -153,3 +155,13 @@ static int enter(int c, int currstate, yyscan_t yyscanner) {
   yy_push_state(state, yyscanner);
   return c;
 }
+
+void* yyalloc(size_t sz, void* extra) {
+  return jv_mem_alloc(sz);
+}
+void* yyrealloc(void* p, size_t sz, void* extra) {
+  return jv_mem_realloc(p, sz);
+}
+void yyfree(void* p, void* extra) {
+  jv_mem_free(p);
+}
diff --git a/locfile.h b/locfile.h
index 77b1aef1..710cfbd1 100644
--- a/locfile.h
+++ b/locfile.h
@@ -4,6 +4,7 @@
 #include <stdio.h>
 #include <assert.h>
 #include <stdarg.h>
+#include "jv_alloc.h"
 typedef struct {
   int start, end;
 } location;
@@ -24,7 +25,7 @@ static void locfile_init(struct locfile* l, const char* data, int length) {
   for (int i=0; i<length; i++) {
     if (data[i] == '\n') l->nlines++;
   }
-  l->linemap = malloc(sizeof(int) * (l->nlines + 1));
+  l->linemap = jv_mem_alloc(sizeof(int) * (l->nlines + 1));
   l->linemap[0] = 0;
   int line = 1;
   for (int i=0; i<length; i++) {
@@ -37,7 +38,7 @@ static void locfile_init(struct locfile* l, const char* data, int length) {
 }
 
 static void locfile_free(struct locfile* l) {
-  free(l->linemap);
+  jv_mem_free(l->linemap);
 }
 
 static int locfile_get_line(struct locfile* l, int pos) {
diff --git a/main.c b/main.c
index 252ebd5a..711d03ad 100644
--- a/main.c
+++ b/main.c
@@ -1,3 +1,4 @@
+#define _POSIX_SOURCE
 #include <stdio.h>
 #include <errno.h>
 #include <string.h>
@@ -10,6 +11,7 @@
 #include "locfile.h"
 #include "parser.h"
 #include "execute.h"
+#include "jv_alloc.h"
 #include "version.gen.h"
 
 static const char* progname;
@@ -135,7 +137,7 @@ int main(int argc, char* argv[]) {
   if (argc) progname = argv[0];
 
   const char* program = 0;
-  input_filenames = malloc(sizeof(const char*) * argc);
+  input_filenames = jv_mem_alloc(sizeof(const char*) * argc);
   ninput_files = 0;
   int further_args_are_files = 0;
   for (int i=1; i<argc; i++) {
@@ -256,7 +258,7 @@ int main(int argc, char* argv[]) {
       process(slurped);
     }
   }
-  free(input_filenames);
+  jv_mem_free(input_filenames);
   bytecode_free(bc);
   return 0;
 }
diff --git a/parser.y b/parser.y
index a2c765cd..807db704 100644
--- a/parser.y
+++ b/parser.y
@@ -2,6 +2,9 @@
 #include <stdio.h>
 #include <string.h>
 #include "compile.h"
+#include "jv_alloc.h"
+#define YYMALLOC jv_mem_alloc
+#define YYFREE jv_mem_free
 
 struct lexer_param;
 

From 8dca3ef10d01fe116d34b2c4768b08e678d180b0 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 18 Dec 2012 17:01:23 +0000
Subject: [PATCH 189/284] Print an error message and abort in out-of-memory
 situations.

Closes #43.

Tested with:

    ulimit -v 5000
    ./jq -n -c 'def f(x): x,f([x,x]); f(0)'
---
 jv_alloc.c | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/jv_alloc.c b/jv_alloc.c
index 3e1c8fe7..320f16e1 100644
--- a/jv_alloc.c
+++ b/jv_alloc.c
@@ -1,9 +1,18 @@
 #include <stdlib.h>
+#include <stdio.h>
 #include "jv_alloc.h"
 
+static void memory_exhausted() {
+  fprintf(stderr, "error: cannot allocate memory\n");
+  abort();
+}
 
 void* jv_mem_alloc(size_t sz) {
-  return malloc(sz);
+  void* p = malloc(sz);
+  if (!p) {
+    memory_exhausted();
+  }
+  return p;
 }
 
 void jv_mem_free(void* p) {
@@ -11,5 +20,9 @@ void jv_mem_free(void* p) {
 }
 
 void* jv_mem_realloc(void* p, size_t sz) {
-  return realloc(p, sz);
+  p = realloc(p, sz);
+  if (!p) {
+    memory_exhausted();
+  }
+  return p;
 }

From 5968f54f55a157aac934b57a9925e95a8b747221 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 18 Dec 2012 17:36:24 +0000
Subject: [PATCH 190/284] Fix a bug in stack reallocation during deep
 recursion.

---
 execute.c        |  6 +++---
 forkable_stack.h | 21 ++++++++++++---------
 testdata         |  5 +++++
 3 files changed, 20 insertions(+), 12 deletions(-)

diff --git a/execute.c b/execute.c
index a4719aae..6d0bf727 100644
--- a/execute.c
+++ b/execute.c
@@ -469,9 +469,9 @@ jv jq_next() {
 
 
 void jq_init(struct bytecode* bc, jv input) {
-  forkable_stack_init(&data_stk, sizeof(stackval) * 1000); // FIXME: lower this number, see if it breaks
-  forkable_stack_init(&frame_stk, 10240); // FIXME: lower this number, see if it breaks
-  forkable_stack_init(&fork_stk, 10240); // FIXME: lower this number, see if it breaks
+  forkable_stack_init(&data_stk, sizeof(stackval) * 100);
+  forkable_stack_init(&frame_stk, 1024);
+  forkable_stack_init(&fork_stk, 1024);
   
   stack_push(stackval_root(input));
   struct closure top = {bc, -1};
diff --git a/forkable_stack.h b/forkable_stack.h
index 041bfac4..c96c132e 100644
--- a/forkable_stack.h
+++ b/forkable_stack.h
@@ -112,21 +112,24 @@ static void forkable_stack_pop(struct forkable_stack* s) {
 
 
 struct forkable_stack_state {
-  int prevpos, prevlimit;
+  // We save the previous pos, savedlimit as
+  // length-pos, length-savedlimit since these
+  // values are stable across stack reallocations.
+  int prev_pos_delta, prev_limit_delta;
 };
 
 static void forkable_stack_save(struct forkable_stack* s, struct forkable_stack_state* state) {
   forkable_stack_check(s);
-  state->prevpos = s->pos;
-  state->prevlimit = s->savedlimit;
+  state->prev_pos_delta = s->length - s->pos;
+  state->prev_limit_delta = s->length - s->savedlimit;
   if (s->pos < s->savedlimit) s->savedlimit = s->pos;
 }
 
 static void forkable_stack_switch(struct forkable_stack* s, struct forkable_stack_state* state) {
   forkable_stack_check(s);
   int curr_pos = s->pos;
-  s->pos = state->prevpos;
-  state->prevpos = curr_pos;
+  s->pos = s->length - state->prev_pos_delta;
+  state->prev_pos_delta = s->length - curr_pos;
 
   int curr_limit = s->savedlimit;
   if (curr_pos < curr_limit) s->savedlimit = curr_pos;
@@ -136,10 +139,10 @@ static void forkable_stack_switch(struct forkable_stack* s, struct forkable_stac
 
 static void forkable_stack_restore(struct forkable_stack* s, struct forkable_stack_state* state) {
   forkable_stack_check(s);
-  assert(s->savedlimit <= state->prevpos);
-  assert(s->savedlimit <= state->prevlimit);
-  s->pos = state->prevpos;
-  s->savedlimit = state->prevlimit;
+  assert(s->savedlimit <= s->length - state->prev_pos_delta);
+  assert(s->savedlimit <= s->length - state->prev_limit_delta);
+  s->pos = s->length - state->prev_pos_delta;
+  s->savedlimit = s->length - state->prev_limit_delta;
   forkable_stack_check(s);
 }
 
diff --git a/testdata b/testdata
index 00ecc69f..a1c72f0d 100644
--- a/testdata
+++ b/testdata
@@ -311,6 +311,11 @@ def fac: if . == 1 then 1 else . * (. - 1 | fac) end; [.[] | fac]
 [1,2,3,4]
 [1,2,6,24]
 
+# test stack overflow and reallocation
+# this test is disabled for now, it takes a realllllly long time.
+# def f: if length > 1000 then . else .+[1]|f end; f | length
+# []
+# 1001
 
 #
 # Assignment

From c85d8d8b4ef210c25f1c3492c7790e0ddbcb2c3b Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 20 Dec 2012 12:16:22 +0000
Subject: [PATCH 191/284] Don't enable coloured output by default on Windows.

---
 Makefile | 6 +++---
 main.c   | 7 ++++++-
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/Makefile b/Makefile
index cbaf5040..cd0fb321 100644
--- a/Makefile
+++ b/Makefile
@@ -1,5 +1,5 @@
 CC=gcc
-CFLAGS=-Wextra -Wall -Wno-missing-field-initializers -Wno-unused-parameter -std=gnu99 -ggdb -Wno-unused-function
+CFLAGS=-Wextra -Wall -Wno-missing-field-initializers -Wno-unused-parameter -std=gnu99 -ggdb -Wno-unused-function $(EXTRA_CFLAGS)
 
 prefix=/usr/local
 mandir=$(prefix)/share/man
@@ -50,8 +50,8 @@ build/osx64%:   CC='i686-apple-darwin10-gcc -m64'
 
 # On Debian, you can get windows compilers in the
 # gcc-mingw-w64-i686 and gcc-mingw-w64-x86-64 packages.
-build/win32%:   CC='i686-w64-mingw32-gcc -m32'
-build/win64%:   CC='x86_64-w64-mingw32-gcc -m64'
+build/win32%:   CC='i686-w64-mingw32-gcc -m32'   EXTRA_CFLAGS=-DJQ_DEFAULT_ENABLE_COLOR=0
+build/win64%:   CC='x86_64-w64-mingw32-gcc -m64' EXTRA_CFLAGS=-DJQ_DEFAULT_ENABLE_COLOR=0
 
 ALL_BINARIES=$(foreach platform, $(PLATFORMS), $(foreach binary, $(BINARIES), build/$(platform)/$(binary)))
 
diff --git a/main.c b/main.c
index 711d03ad..0ab0f3ca 100644
--- a/main.c
+++ b/main.c
@@ -69,7 +69,12 @@ static void process(jv value) {
     if ((options & RAW_OUTPUT) && jv_get_kind(result) == JV_KIND_STRING) {
       fwrite(jv_string_value(result), 1, jv_string_length(jv_copy(result)), stdout);
     } else {
-      int dumpopts = isatty(fileno(stdout)) ? JV_PRINT_COLOUR : 0;
+      int dumpopts;
+#ifdef JQ_DEFAULT_ENABLE_COLOR
+      dumpopts = JQ_DEFAULT_ENABLE_COLOR ? JV_PRINT_COLOUR : 0;
+#else
+      dumpopts = isatty(fileno(stdout)) ? JV_PRINT_COLOUR : 0;
+#endif
       if (!(options & COMPACT_OUTPUT)) dumpopts |= JV_PRINT_PRETTY;
       if (options & ASCII_OUTPUT) dumpopts |= JV_PRINT_ASCII;
       if (options & COLOUR_OUTPUT) dumpopts |= JV_PRINT_COLOUR;

From 6a597b41a671941cf5d1a298795ea2c6c545068a Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 20 Dec 2012 12:17:56 +0000
Subject: [PATCH 192/284] Update download page and build system to handle more
 platforms.

---
 Makefile                                |  10 ++++
 docs/content/2.download/default.yml     |  65 +++++++++++++-----------
 docs/content/2.download/linux_x86_64/jq | Bin 385542 -> 0 bytes
 docs/content/2.download/osx_64/jq       | Bin 190556 -> 0 bytes
 docs/templates/index.liquid             |   4 +-
 5 files changed, 46 insertions(+), 33 deletions(-)
 delete mode 100755 docs/content/2.download/linux_x86_64/jq
 delete mode 100755 docs/content/2.download/osx_64/jq

diff --git a/Makefile b/Makefile
index cd0fb321..30e6d42d 100644
--- a/Makefile
+++ b/Makefile
@@ -90,3 +90,13 @@ uninstall:
 	rm -vf $(prefix)/bin/jq
 	rm -vf $(mandir)/man1/jq.1
 
+
+www: docs/output www_binaries
+
+docs/output:
+	cd docs; rake build
+
+www_binaries: docs/output binaries
+	$(foreach platform, $(PLATFORMS), $(foreach binary, $(BINARIES), \
+	  mkdir -p docs/output/download/$(platform); \
+	  cp build/$(platform)/$(binary) docs/output/download/$(platform)/$(binary); ))
diff --git a/docs/content/2.download/default.yml b/docs/content/2.download/default.yml
index 833cac84..f364277b 100644
--- a/docs/content/2.download/default.yml
+++ b/docs/content/2.download/default.yml
@@ -5,39 +5,46 @@ body:
 
       jq is written in C and has no runtime dependencies, so it should be
       possible to build it for nearly any platform. Prebuilt binaries are
-      available for Linux (64-bit x86) and OS X.
-    
-       * [Download binary for 64-bit Linux](linux_x86_64/jq)
-       * [Download binary for OS X](osx_64/jq)
-         (or use [homebrew](http://mxcl.github.com/homebrew/): `brew install jq`) 
-       * [Download source](source/jq.tgz)
+      available for Linux, OS X and Windows.
 
-      The binaries should just run, but you may need to make them
-      executable first using:
+      The binaries should just run, but on OS X and Linux you may need
+      to make them executable first using `chmod +x jq`.
 
-          chmod +x jq
-       
       jq is licensed under the MIT license. For all of the gory
       details, read the file `COPYING` in the source distribution.
 
-      Arch Linux
-      ----------
 
-      A PKGBUILD for jq-1.1 is in the
-      [AUR](https://aur.archlinux.org/packages.php?ID=63849), as well as a
-      PKGBUILD for the HEAD of master
-      ([jq-git](https://aur.archlinux.org/packages.php?ID=63850)).
+      ### Linux
+      
+       * Binaries for [64-bit](linux64/jq) or [32-bit](linux32/jq) systems.
 
-      You can install jq using [Yaourt](https://wiki.archlinux.org/index.php/Yaourt)
-      or manually by following instructions on
-      [Arch Linux's Wiki](https://wiki.archlinux.org/index.php/Arch_User_Repository).
+       * For Arch users, a PKGBUILD for jq-1.1 is in the
+         [AUR](https://aur.archlinux.org/packages.php?ID=63849), as
+         well as a PKGBUILD for the HEAD of master
+         ([jq-git](https://aur.archlinux.org/packages.php?ID=63850)).
+         You can install them using
+         [Yaourt](https://wiki.archlinux.org/index.php/Yaourt) or
+         manually by following instructions on [Arch Linux's
+         Wiki](https://wiki.archlinux.org/index.php/Arch_UseRepository).
 
-      Hacking on jq
-      =============
+       * Debian/Ubuntu packages are coming Real Soon Now.
 
-      If you want to work on jq, grab the source from
-      [https://github.com/stedolan/jq](https://github.com/stedolan/jq).
-        
+      ### OS X
+
+       * `brew install jq` using [homebrew](http://mxcl.github.com/homebrew/)
+
+       * Or, grab prebuilt [64-bit binaries](osx64/jq) or [32-bit
+         binaries](osx32/jq)
+
+      ### Windows
+
+       * Executables for [64-bit](win64/jq) or [32-bit](win32/jq)
+
+      ### From source on Linux or OS X
+
+          git clone https://github.com/stedolan/jq.git
+          cd jq
+          make && sudo make install
 
       To build it from a git clone, you'll need to install a few
       packages first:
@@ -48,11 +55,6 @@ body:
        * [GCC](http://gcc.gnu.org)
        * [Make](http://www.gnu.org/software/make)
 
-      Most of these aren't necessary if you're just trying to compile
-      jq from the released tarball - that version has the
-      non-platform-specific build steps already done, so you'll only
-      need a C compiler and `make` to finish it off.
-
       For Linux systems, these will all be in your system's package
       manager, and if you do development on the machine they're most
       likely already installed.
@@ -67,9 +69,10 @@ body:
       jq, and some python scripts generate the UTF8 encoding tables
       needed for JSON parsing.
    
-      Building the documentation
-      --
+      #### Building the documentation
 
       jq's documentation is compiled into static HTML using
       [Bonsai](http://www.tinytree.info). To view the documentation
       locally, run `rake serve` from the docs/ subdirectory.
+
+
diff --git a/docs/content/2.download/linux_x86_64/jq b/docs/content/2.download/linux_x86_64/jq
deleted file mode 100755
index 4395acc175d74f4dcd7b93b484cb999cb70c9ed5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 385542
zcmd443w%`7)i!=62@(~Z5u?Vcb=0v2MU9G@2<i-(z=;Np0vZ)08la(oMwn<+F2PAE
zr(=}1v{Gx^)M`t;wA50rO2Rd0t;RdmR-#qAhj>9$j9AV0JZtYWnMpDUegE(O`+c<L
zoW0LlYp=ET+H0?UorT4vV=_D*%l(&OU1TxUa!63J^k2(bvv`oC`6p-<SO?<o$<~S1
z0Z8*p5dZOC(7d_NPD9##W@|7j6VELCSCFAI3NnK7;y#bn*_QisIpnjO69NVK2mgZd
zcj+Ka(0y8#U-F4ZUh@vs-}4T=QS#kq9ht$uf&_8DqzO&DGJ{uU@Z9GT!<hSY<s&)%
zH$fMNXAmi-gM3(F`P=<8#am_XMW*t7N1G<Rqb($m?sL|G8qs~acvk?AeD3c*m(MFr
zdFk}B!^r18P0~7Z){Gm^8*%2Wsi)7HaZ^q0>9qytoqpbkGv?lW#@Qmb4~!6Y>}3;$
zC0CERNRj6p{6`z$_tq0TPXBlN??<g!n!WMC_ZG*_$@`#?-%h}Pq#<&7{8pXEm%+Rf
z@gM&UJMNxir%$}WSGXtUnu-39^mjZ63{6VAuVe7iSAJKT{CR2eOViLlG)?~Z($M)b
zP5!xQ@+YOqe=<$}@HF`sq~WtM4g9TX^3O>_=aw|^0Jr@3ujjv|$mpwH)}+brNR$6U
zn*3AK@Y$RO{<1Xr-%68zVjB9Vq=Da)CjS>{@?T4npOdEC#{hqrb+ol&=#6-@EVtcX
zW%Aeb$bZ-5xAe%jrcC+n?3-_zGB<L=oXC_Z7Mg!0Tl;zVP(5eHO_AwSDywE%(`si#
zkTW+jXKGEgyxdSZlV7GxzhTBKtGXsqS#`r4YtFPAX3e^}(wZBYI^!mQ-7t6VG>{dT
z8FO!lL~ggHPrG@#HT}EOB6IP5+MGEz-8=;tH$-OKe3LbM+U&~N)mG)KX*bNlCjd-O
z;sHc&u8COFS(t!U-wudd=iZbAGh3HGWlCk__UdU<ZX|7TLu%7!%$j!7&DQkW=FEsp
zv!;XBsl-n%;+DBL&k;G3Nlu$R`{rAxSyM_bp8~c?ZVtJeGKIP_ikp1{<eiREZbmtC
zrcJZPmX?eznsW9T=Oo_F8j*PIemm!k?)S6Lpi{6i@V`v?%eM@8RsHP#OPE0>myj-W
zCOoS9?g0dSHUHzk!)MGmgdVpX_QbrUKl~}&?;z_&lg^RvS=MZmjvPG$JyNE1n@QJv
zi|Gt2iZuVVd$rxshbOmd*B;s3o<KnJ&$UP9yMCUZTzh2xNz8En`855(NSh+%OLkIz
zh6{_QFDajWjQcM)Dc|i=`OTk{p9l?*pO=&`{gWY-pOjCY+<yg0`EDEJw_sAf>DmRw
zPRc*XC4y&JQvSh7`Q=IZLz40<lJZfpiGNi|`G+QQEvq^y-<y<Qo0RX`3P0B+<sX&=
zzc?xX@TB}DN%@Qc+<(iG@{e#c@oY-UKQbwQc~bsSN%<?1@)>Km|JEesAMIx1*^-n`
zpYHzKo|J!#n~7&zQhsvKu_Gz}xFq=Yr2KCu<*TIp<CF4tC*}K-^6lsc*=i&#Sv|`?
z=icnG?C6&4&0Xi7nsuVpb@Fih^&TI@8`D+9jJJ2;-^nL3&887=lk~TkW|N4wNO~yK
zYzpxel0JxOHi3APq%)YN>BpBydS52eH2HX)r1vmQQ;%0mdKc3)@py%#-(i}j9WRsg
z8%)!r<3UNk#57Ggo-gTVnWhQH{gU3qG)*_|lk_^KX|i!k(oZr?Q;qNb1{o(m$}~+h
z-Y)5fn5JpQ+a&z}({x4g7D@kzX_{z!g`|JLG)*(!B<Z`Drb)(^Ncs+@X^QbWNzY-L
zCK#`l^!J#i>BTD~eIwH}xp<kRuVtF177t4LN~URI@q9^N!Zb}Q?w9mvrfE`fpQJBf
znx+)DkUs0f66eM1ZRZ_3`tI(s2_>y9?RSJMyLDrkJX$ZD8?w~z0QlLGCA1+sHYn~n
z(Xty_A{kw6VnR!j|4p==_r?>j?!x7$c&p~p^+61Ifc6lQ_M(mgrZ#?+X-7LecHxe>
zf$84k!xoIO#bY~z<^!lJXR83k2Hi}Q!X0zo**54pyn0yNb(1$wpFaHz@A35zfp{0T
zbfE)axsjoa@`ShS$;~zj>S~|7Ihi{xL*Z??3y)q~cUQ<-Hv;e*!gq$O=F9L$-TQS{
zmmRy>XIJixg`dniE$c~<Fm!e3s?fyHgo)$rMIY<{N{REe?UV)zN}X^ZSc*5hz9n+L
zcUU-3<{efVsPGP(5UBPJdoWN3VDGSp154!jc%Vt1D+4R!`Bb0<&l2a0l8qnxL(XTd
z;XpQP9?v29c-oEi0Uw&4jbeOuV>saFTdv($8pz(jCTYhm9Es{w)Bi)h&pi|G&1@R#
zRb+&s|LLmn+p$A(k-d%<DmcwkDCrhR8qWZY;*ry`=O0-To9J5)2um~=9(iNd!ectV
zv$lddV(71RG?$p)1L^2yk6pPrJaXz?Sqnc66;7r;1@_DYtmyM1z=mTZ?kcJLs3dc?
z<-Aque5`JVHI+EZ*|;tWdafLEGfvcnt3t3AcHRyT`y{mH#a1xjB!QJCz=jIgd&PzS
znRiUbsgV9Gd}_WP45-(?0*hNc;li)yAEwJ3gfhdP-Gyr5Yk(X~NYT?1fV3BFVVzz#
zIW#FWIdpw!%4XPaUi71^=r;x4yZ?hv&fc!T=fMSN7qJZ6$qLx9(b=pCw1&|>sT_6D
z+h|a2fK3l_3_+gg7o@WtAU_b03+&jOY&AP#SsnB2m`+V$>LxdJ1ydDns)(s8-PE~E
zh27LCOr7VZj%F&)O&!eCx7^g%bCDY2randr4IqySskNPXw7*Co&vquj9AWjj&Gh5y
z{HtlAPz&-!FG0T9c5EKNVv#_u`W)3_JFlexl@X}ij!g&z?HF2+?X;?AuOr-xDR32p
ztFoO<q~|BSJoOOaqFZXyGNz(ZViHgJBvX*Y(+xc#4A;&!yK!D1Up;%RWi_*(P*-EH
zlfsf=-Gyudq#X+f@+nM#@I^<#Hs6=hLeb7qk-7Z4@KpRg&0D_=kbGO1jlZYX%<Tx`
zdAhg$Zk>N-%?%yrh8A@WLUWCrV_pRIqMETC`N%kuU(UeGQFy62r{mQ18_;GtE?>Wj
z4}1L|`3SB5Js%gWZ{p*e^~?AezP^!<lh?ldW3;p%qreTXBBS{&{80-#ySmoD!0&_B
zZ^uKNgW5WwhdR1dYpUmf$vq%?sP^V-sIY`}ypG9;{`4Cpxbs#sJ56;@c@N+UV;|d^
z>EhIO0Zyv;YJP|Hnri)&_}!JYXbY?9y3Opfs>9CazAB7)kTDV{Xoh+%HMXY$dWg3K
zMKrt_v9-E>I-U&oW&0s#2Q3C|1Wk$Nzm45bazpZw_gvaMfcPesnJ*%cCwwSSzp6k1
z(Jj^2ZLYiM#2R#jpGd*pRabcG_MH+5<Ilo_>h_&j<MkeIb(~hWZ+IlXZr`NH0d{nw
zr{kcy+cPHB9FO-5yP+#`fOpkli*p9EJMMUz85eHL8f-x=ok-LiYdc>EaRdkqp7#8~
z{^CWuG1LWs?cP;KE=Dh9qnqC5seh^F1AAEKr<;@d&gchF)F`-#NFck!dBypwUAfVY
z4d2=h)3cqAIE7-V0+20nTBBcm<E?)g871E4tU%bi`eCaHol(f!yv25A1$@!YRo?o?
zP#w<ZFWziuSw~!N$s3`khanUV4ci)uetp)Ovyd6~UarE09p1(T03PRj^E9il*xUT>
z=*Fy*?8-K8^U|SKL&z$8qb3~v$`iTRUN$}YlvNQ6S(_tgN53BAtq%jmuH0%@zHG-v
zysEj4Z1HJ+7qd6>Z1diA5TMZMplb{j{&V54L(T_4zU@Fqbp^I&*MW8C1L<KqMwK|*
zLQj$5j!b6$n+@y~zJ12G<JM>Y6ptg<7x3X-U(H80KkxVn^|Z5B1(Y;SIJ9dGL-NwX
zJ>I*%j~6?J7BJFx>q&OwkfFAdy@pcTh0oqPOTM&9=qs5W*RnOBC(8>x4H&Cq#Hf>N
z^6KvN%&j@GxbVIC$CW_x7{m=hI2+yf{WMa~Ry(>mqa)j9CPenG%3NG*)wk4a67D(%
z2|KXLU{bdV?T4NsBk`fAWCn?_nrMcn)Olu|ZytNs^U(@~fI^oG2n<k?>}Syj{3fy2
zr)(H`CC&@uoNeQr=SmU3>W=>W(_s=@FJxp>bA}zuw4HhhzCvrig%ZX&?WN8qrOrO-
zM(oC?<eRz$>~yTZFbhbLgD*T94{yUV{4I%%gTn6-AVf%DcWGc5S%?**W!49p@NPRp
zx;s9f`UEjRLyNcJ8bL3{=d1w0feIySJc;Gz1*(;LofQ=hz(b+7@B%L-RZ$<P6Uqj%
zOfCOVLzcOa<pwewsNkDV-Hvjjor7w|CCN;Z=`kj}LS1f5qmt`k)*Zu>h=tY;Pp?3Z
zJo+!~+dD*UY4oAGs0unaUHj#bhV=4F9H<a41$cptBHG4_&ryik2$^JDDR!d14g7@H
zrmfhpm8o_t>*PGqY<*w{K+bBh8|wpQ0$d*m^4VG+u<;cABMdLwPVmOZ17+x3=y+;N
z8+9~a>P&_18y^fT!Pu<Cc?-a^0Bh-1gj5xD0&hMkkk^sL#xgzZoJLPyR?-;0>>Imq
zv-d78F4&8{^qvBPyL;!cEMdFtX|XT#A!i-`*xoU1WFOVoW^ZgC1Ra%~q3-{Ll%Wg^
z!@Tvs1!C#2Pwf}KVoPLxb!lVZ7_^B}XD_=Io8YloAmaJZZk%|Oz2>n;^*{TIckGS3
zvh2nzM2-x^8nZT$KzT`H&aw8!cQV;dDo7)XG%`t}G3P^$R?`wGcZondIsc?eNCc+c
zs+xCqb(M}p02j$Fb-qwbJ_gOkBK(&Fm`Nz!^Rn$hoL3qshXgN@B@h`dIc0{y@Fk+V
z=s%AkVT`pHh}P0Hq)k+mIIqF?pX9B71_1C~-sXDgIjAn_H1>g`=sZ+U&1vJDFH3=l
zNEKr_($BXWR|fKF2XGC35K!|mKmckLF{}m0iCbHQ_hV6Yw;f|w;*)n(U3(Nh`Vg^Q
z);xu#Iz5{f?aM=d<h{FrYN&kH+kDS~(%EdRxz(<G3A_zuN7K-<@UUp-W^a8~u4R3(
zgRFMULW#3H(FuWBsJo@YOo<K#mIm@D8WMhf$v25SNr)}OQ#H=c9@jWEkQ;Kgy0#d<
z6`q?KSyk8a!;r;NXg*6&o0KCM_O4o9@gqce5X}k?Q}!~{WU!<$Yl|K8(e(vUk{v4(
zH)zXy5cz08crR}FFme>TiZ6D=!dtUJygW8B3p`eL92^^$g*qz7f7K8Q<=p)}gmP@m
z=o$;qHI~Ha|EPW^qXhXVVRUx97(n_<DZhBkmr!>6G<?yHqVN*11Qvufut>JzLj*Ag
zei!5962zIR1Qxhk&APk~;GLM7DT(z04y~z!7Sw%L^nvm?P;?}CVIRe_ti>geW(kdm
zjH!iK1tRxtw!_{a9N57|2G+uXcE0&k>+>vUTQld$)N_|Ifr!!V2bKmFBcJKrR6FGC
z#52KlXbq>^*udJ$G+3RayV1A|PPA-!A`&)?y+3Xs#-_gng|5#b*aYgaG_ac*T|+5b
z#-ZNEQOWAP8+E}c^-vEqh*%E3+rcjgRD*|i@fupY0#VI41eL%>^OKQTgw5|M0aZJ{
zfT;pkxs}VrZYHFLPX%RN1MBU+C1!z?Sc#%WK<gZvy5v791wI2Nb!QrUpV3%ux5h|P
ztpp}zZzI7S34*^!5Ii*vLBAoG*MndsFzuKY+m5XihShTu`cUV&=z<b;&Po6ek-!f1
z*7bb=XQu)F&ZIto-^6rgUzF!v)d%n&0IVC|Q)BqKPdm*w(iY&EpiB!LCL}S!?`_*b
zgJTPhD_%&-!th^RvxmK2kGAgbn{|z)zS9@VhnUPw@RX#-ankI1&~HftycJEl7c)QZ
z8#uJ)G@6=Xch{5uihfb1OGn>>rPI@)AoR7=U450Z&)28Op*4bH^;Jr1I+Rmc%CUWw
zvb0~62hjQV690yDD4a-Ct3K)j<&1t&M)Xz6SD4=KqsBvPIHRJ<`YL66I+Rgl?6|&A
zev%I5BBJd2un$>oOoze=9kseIlrz(zaOy|Z_l5Ew%wkDLYK)J*6kV+GrEm57wMD+B
zb;Q5M=Vmx#OPyWB2GM83E;9|g+%#<69kWTlF;=&tI#8gucDuP$?;Q@TaXZeIM8~;Z
zcbxaO0uxb?V8reb_sNcwA*#v|2bJ1<D13TyxBV5}-E)VyLQNi>R;UUi6qj1MV+;y4
zD2-6n2BTIm!ht4NsO1TvR%oHtZey|Anz?GEeqPK(pI)}kP+W|s4p^uPDF>=xIdr*y
zP17T#D!D#TE#nmiDD{C_c{edio#yH!a+OZizvmiG59dZg0}(yoS*ou;WxV?gs-$oT
zCMLNUz#g}P9r3KK<fdK{R3zW4q|>Kyvt*Mn^E597dovh+=U}&G=(r56!pQ6sne`OU
z{es%3X)iG~unf;`E6@&~w(wcJk5)fRN;PeYwU7vI7_Dp=g>kl?>ui!X)w`$kNtC}d
zkSk9!@%e((K%ZP%20mM!7*6#FH^!$&^&8YYdDaJ-jKIr{z&a4@7C5snf$uzsGWHig
zK2qLC?Sus_t?xNmJ|{))CLU@qS__H+m@z>oR*=*Cz&G$!$297~J{Vb_K<>{>sxKmH
zpB1peXl;$rn&y-S^3eNz7|5mjRUUTQN|URDmq>P=EvB&Tcxs^z7oqxeA#DbD2cKx%
zf(++DWIB(GzW94AyYKo`ue{fXH1h%7jQ=cksPNIJhT07u3eWDCj2c=M(qg7m=P=;_
ztsX7kbZ31u+_y&cf%?&4mXOw}UXag;G2?6EeN(%T_+x;fBdUXiX$_Bor=Zhej_ZvU
z%e(PLOH9Ieqi|oGO)zAe5@hQ(X|l|5$u3VOyCRkBha(Bs+hOcB+U=BQE4mYPV;`-A
z;|X-m6EM<(bV1NoTP{ZBWwP?FNJHB?j%8wODbMb)<qv=vUvz-m?E0=J^*j}au8t#E
z^|H}Q9TLeF?K4H>;)wxcwY~9eKgK`h_JJ<|S9vbbQj=k#*?8)<o~F<rZU$@b4;ldK
z9K#xB6D)N^n#SfgtmSFx^%_(dqW4t|`3AV4Z#fDJ|4TWZfqBHg4LP(C4mbEc)fY6y
z+IZ?<twA9BY=~tBxE#;!9*qt0^z{C%!XR;<2|za#vkQ|D>?^UFK3z|>L8`^GJ9-gj
z;eg029nc}czI9n=uovUW=A1sJoB1>;Y|~xpI5Dw4`B`EpF5?rfP)YzNEP<SyeqrC7
zG#R|*@-)41$N(qXq#c{DXs=hCuL&i8>tBTS7F6`PXok9?i~1lCKQi$-(AVcLFx_Da
z(cX-Smc%Gv2R>`!@1NJ3yZG9~=hnVHKOn^Ej=O0imNFxZdGfV)NBs}uQIho#zr0^k
zXUW%oX424R(OTaVCi|@A6{fb<;F%Z`vU>ltvyZ-OBL-CosP2AA)%OLwRDcKSluC>O
z>%eHTlWQ@IZO2pB#H4cx(Wew`26zXb?6&2JZd>wO)unG~VR{zQZtxVI{kcf`{}#AW
z6@Hop)Jwwcfwtp=1j_u-W)h}jo0*>H-KOkLJ~@t%Cx&d2->UKr&&lS{QIw*69c`)u
z`hq+<ZFo1X^219TC!B6w(wKEB7Ev-whHWWz+U;R4mu!3w3xvB$hwYNNavP0Z7j9$C
z9WF>jv;BN8)9-n9<M*=B1(iFOWTX95JEMol+&SmeF?AkQXL(m2%vI$LPY%MWwzv63
z&mO%7z{P?+(?{NO9_RmS4h?&oA3u+C|M7OlOv{+I{6LAfA&n_}+1w}V6p<5|gyCC>
zg$Ha<>t1-kkR`~)0xVhvVS(T-XghCkB|}!UP?KEIQghp7C8NBdrRL&NN{Y<BXJEMi
zq9(u7)rCspJ7)3A!_KZSmXONhlTbuxE!V73X1T}P@DS}7BMM!ZSxzf#jSNyNUWH`%
zBE|pfHPgI65X)9IW9-KCOK-Y>ez<FX8{5~O=ttTHG*Bp}d_N?e3tE&V!&`qHDc+-n
zMkQ0LnKjqpQDrS0B9EG@<Fil|rC40VC==_7wv!Vmh0Y7Ol7tCtjcqsTB^v}(!RAu*
zhHClWrCMcG&{bx~(8OD|`({^ea+j>ITonmmBgTbXL%Qu-cI9^LOpx^>Pt6bj9cb2$
z#+Md;>aBkp^$?ED##+ux-c?TqVM=M4bmCYXY`&gs9R{{aq95d9J7$I*{V?0xe0cnJ
z4F1Dd>nyhguq3(#&0(c1LD|k6dC!yPFb7Rzr7S=pKM#8WAjOPqSj`Ap%@srR;?pc}
zZ^gfaJ%!fJMw$Iot3s`Xo~EgH98(J2RflA|M#rIMZ^8jO&6@ZoGHydkn~;Wx#kdt*
zj7uwekNRm|KqU;>0VNc^6}gO3mzBcKZQI+N30es?mO8_et66LCK_b8Kda4FNsAePE
zN*OI&R)-6>=>^YUy`&pN@21j#FJUZe!}z!`J=H#Eh^$mcaykyyGRKcYtxR8{-Xx7h
zTNI#@SHHP8HTr?y=El@d?M7@E(mmmQ2&`i@Vyf6eG~ZHha%|~rflI+y!0l=FoI#Jy
zo{Os_4xHk6pp<f#-!2lvzMq}y0XPsY<@!pUf2*<Lys?E#4F)HukYlkrYR5*}vANl5
z^`$Q1p9x{1hvsoCc69j3^=7V%BNmz!*v)nHPOzR^;`|4!tFs}dvlR{kn-7HAx;n6_
zR-s=(=27c*VBrW`I47W~l8+l+>FNsp#Y5E{i#ecKf$Y-QRPYU(m7Tw_v8AQ4`$(cR
zc6D%E;fvnrVkAP|RR^v^W4G#`i5%=*^^A8_PGj)rpsd?i@K+&h1v$wXTUF{@UXAUM
z%h)EZCOEy$@e6=}CYJM)7NmjTU474ib-xZ_r&04p@2Wjv&o*oy_BO9PFZd9)6>Y28
z1n{tjt$JwFZ?M>jU03AeF3z!ix*6Mzb7iGH^Xfe89gPM3&e##$L>lAb>R7n)yUD#B
z8_NGXS7&=yS&PT!Z?;><<{=+D7RKh9r{6q-e726Y^#kimOkqWdk8(bMQ(>MMM@t%$
z>ZZ=PrxG^s<+{K8se5<stFN74f|8%V*wv+%&ThdQVPj(_M3u)GJE5WF_Csvvo962K
z(JWR$I;<eauC9n>-PIVj08lC$dbp`<Z0lG*3$$Znv$vTC`Yt9Rv#)jRaMn%hSOn|*
zIwp_%&7pv+a_y0$+F;JuJ+K-3E1*6Y(heF@I}J&dYLkkHN#&t6lsKQ+&dX}z3uvUy
z)^IEz`-HfQ=~l2;>P)j*iwjtk9UGq~L6_a|QUs=71TTlJ5QQpoXlrr4FjG8&%m~o9
zhIb=J(fYmtS%i+K;DM#|U$uBwwK&Cj#ZC<fCYvK&N-iCmA1cV(92?AP?=J8N2#x}C
z^yVqDkQp1DFSaoN&<FyJ&E_B9=GfQ*yokAMb}rKOXmodo=q{Gk#;*6E<|VA594OGK
z&DWK}I`12H4Ph0w4mh<VG_11#1v(2@;JnSwf_W@-33P+Z4f+|odzne=C#b7;o~OBB
zN0;oPUykqES2^#i%V{eOZ`K^4p7<MjN$W@|no5s9ia)mVesdF^>MsO?bAkv*sHi|<
zTG&9=;SFK@x+XlAdm;zYtQu=QPyQ;nw>2X&WO^$nSE8*M(OntH$%-7p49Uuh?#gmr
z+!)Vvo{`%9)P8L5rmV<8-2i(xWke24P}sZ46Up2*7*%`@4C%+vB0QCv#Vz=Ywoon{
zQ5bJKUvb0a5$et7QYHEo05-5>Ez{dX*D?)Ne-zk+OdYrW-xg@3dIbAju9H^P&Q^s6
zHI+VkmTpkkdxv8Rw(}~6CCxzyp-vF~H?vOA_CIQFr?spDk#UvpmO2%=C5`g}*fal;
z>g2XTrzkrWatR<?ivrRF5r{h<v7^bOD!Dgy5@RfE_M}Tk^O<Fu51o$M3|+bAMB|0N
zV+-LYx@s;&6A!M=R^Qhp(sz)zx0-#+z}vS`qTR|0fEz6GOUbQ8xlG4d{dR1o-)=1K
zvI~oHy?6Z<IS6a)N^G1O@gac_TB|$75Q}<H-m(vrW8;C1W(G?P0y^0eFaH0}5*_f2
zrUk>3FaX++FrcB!TOSpkzfiA=oeIy9tHCBBzEN#fq!hj`=v_5FA6s{s83P2}L~MM}
zcFI!nV&g|RWqy2t+%H8A2PkQ5vfwY}@D6>Zq2LUM26ig{m#p0~(QzN_!HHjNxLOA;
z^}!uYBd5(S+!eVFRTn`J;4+*4KVVjiWEi@yvnNCBKl-+GMk6J#^yoL9Tkoiwcm6k4
z4If>2B&`1=8k4hCEDXlmY}3M?LLm}PJLS1(0@&(S;cE>BL_%$NPPxA|n8%FPpzi5{
z1v(`io-~72)dt;k9R4&vbPUmtLGrK}?WAcN=9rRh5zgn>W*u&voq-WBc;?}oTWF-v
z>cOJ%h7T8dJB}@dgRLd!8Q|QzYRKV>haiC3<SBf0;U}>CZQ(qRwJj?T@fLOzqJ?6k
zI;)M%im1zp+KLT35VE_fd6-7Jpc3rzarUrjp}{5Z8ovb{FlH*)me?(@CRA!jXw2C3
zO9x9IMysvCKH;4z6K<k3R+(F}@!ibQ%u3kpoiO}2HdsOUr3+9qC5&ic&=Lt#Xm}GE
z=qMQH8}v!dV49R_x!E|S!v;sWrY%WRij65R95Z3wm}tw<&X{t<H5=Ozp)IJOzd4i|
zIU1%8_g2y2g|M9DyIM@6sKSokSz&4a(?&)85@p4TCfJp`?bxLivGJwRT^{H4jUONH
z+4tf;C+AOSN>0&)##yI(oS70Zu{UwPigsNW8HYa$2S>Z|YEJ67Alh{&&uc~wTGaI|
zXuZbQF<9p5JBG_#I!<&9egr2v?t|Jl1mKjLhto4Zu?^81E2(3U1aYtmbp&d_*>PR!
zPHXmK;^)_~N4K3Pm*Ek;!?tSXwT`w)A$mutRWrDCG;gp#&x%!^8r0CB-#m8$z_D33
zI^U;r9GwGSQcRB-0n|k8eQNR;ij5S%IT=y#zcTI2$*9NqsK;Hp9_NT&GYR+7XBZqd
zTYi)ln+%^-oWD3TR$N-*{KLEIaG32+bO7ImLGn;HfG@7HoymO#@QC<_H0l7p&AWQ(
zPzLbc=6&8(pLo7W4d1t5c;M{wVDF}m-({0+W!v;cPYF_kRa2*j2P_k90&-5SwkwOP
zIAma6sq;u3RD?akFuT%W?>G|+!0_UU`P(v~sma)tn&-XyDs1a;TCg9o{byiAWFwte
zaaG5!?bt7<ed=J-=cubpJJ!IAm@ji;fm4>{CTp{3)EO|a^@C6;@f^@h!u|fhxZ41-
zelT%&U}HxT?j-}`{(!jI#C<Ro_t1fHFC*@O#H~ohWt|To?@;3M@I^e3iu==nabE+-
z`h$t9u;(L5-fIWOeSo+_i2Had?zacVy`H$d;w4_4iu=x|1Il|MalOPHk&64<fpOml
z$ofNw+leSMN#5@bjQc2Y4<PPSskmnhjC&JteZ;Lx#oe=KKzYw5?qS3Yr{b;}7<Vr~
z)(<6ab}H^21LLkE?%~9J4*NBdbam0dxC@AzL);~)xETZEjwbFA#GR0eyA9j)251Wh
z5SM$$;<>4~KNuMIS%9qPCbIZHu(2XZ-pdBYy%!+xLUeQ94Y~23rxG}1U;^U+0$<K~
zgiRZF9q(y#w!QdGf?@%>1N8-h6K8Y$;#Asy!hXL2l=2BcTvDrirj(5v<Hvipzt|b=
z#I*0hpoy1-2SqzQH6!A?F+~>b%#?HKk-^c<tQtSgVa<ndYxpPrKEAI%2AWzkjLFxL
zT>H(#=xq5_ceZD<vkf*gCiqyrj@^Rsy8)G?)Gt3Ckncj_`xoqgV-pMP*k9`KW@9`R
zRIyh`4D<drWe;-}8Y3&bl;Op<o(GxYN2V6Ic;EuJ1B7EZEGS#5i`_^r3H>cQh4YIC
zCbSSBy=&9i)yzmmoq?ze6?tnaSp_8xP?34U-^c21Y;s)B0~qnMQ)xUrFpYNsV#gY(
zN+@+h0qTh=tyqH$OAT!jQ6=PoHY;RK6fcM(!W@fY#fNV`+5AC-lOH02yWxW2X1&?O
zDDe91nV_gmE6~H^C|y5fRm(2{vkT#)uI7ia`JM=US9AZQo&aa-d6X@F2xmUJLx_dY
z-T;bj1_&_vvb<Y=(H~2?zy}XVDe%yN3%raq$}@ZMid5W}J{XYMq20`;w2@2u=QNY0
z?SZK$sb=cHr9BLg_&kIhNoc1Jj5Zq}TEK;=MSjvTpnzuqm(B8G`jjcVIB&VzKCPh+
z_D6q-!*OoBSd19D9WgZG?3gcl$0)1jq}Y{yXCmg4Atui+A~;3t%|IN3{MO(oC;?xJ
zgLZ5jvL_;Y#IqP?VZvkn2pk=~z%JbGz5CAu!h&OgohhXvyoW`8teO<nFgb|z&hD6d
zu%lycE`lcF>Sr<MZC5_S<4-avzCCifv(aR5R^6_Au^V^~jt?h?;GfjI>TP}r<53>f
z<qUds-*|6*H5N8XV~<b^4KI1?Z%0(5kH1Y0I&JY?2pUW?M^m~0H;r`OD)Uno!fW*{
zY*LIaD6ndV+QYWnaQfbc-(ry}J^_D_qqRD`p=H5Q;ugHCMtFjYM__%d#Zwp#3}5(B
zw-$5Spy!O5!&~+AaO-G47_#F3fnw2chog2zebJUVIv3N!_mLQNuNSk-fOH}zwlG@~
zn+TQS1Qd>(qMAwr{!ny&z>18<k<nZnk85~op${8ta9A(X_O#&)WNyb`oD}3sNvsB=
zsco2K+ht=@lwbW5_9Dk6F&H_jBfF%v7+w-3!-NVb{jpMQD9b)=0%p`IUjjv`(u8T`
zw1M{o-}l-WAYN$sxoUEGD<txFi=WjNt<AF{x7(GR+s46ezYz}RGMs)d-)`7jlh<*1
zw}Iurz^=?L^?+NP>sp+3PzlZumyX2b-rQjv`l)BupmsVjb;b3)Xy-vSo8$N4jr@;i
z6PWaGu9eLm5pRH0>dw_Nvu|ef5^T_3H3J<dLzNaLd=mtY0fA6!F_nV)K#518L@)>k
z-`zN<%X~Yt7Mak}2GpmeE=O5T@d%kuB%T*(Bz~2Q7n{ggGOdN^{1H~oSy&t!Zq*#7
zhqWK69Q0zLzj!*1PR2r0gorpi%D*5%+d-|cYGdQjDu;X`MuF8PuE6>2k(cG(8hUXb
zKsb*eRRT^CCAGsp2**4^mt2A!t;Gmklu$)0I1(E>SxRQ{2#AzYJ<C`@+p;pC99JKh
zkE<jU^26}c-5)qr7(~epb!0#KwI?zZe={Q2@IYYx^d<2!L@}+!W%vp#fugOYL<fk%
zT26|8&TyxaC&7$4!oytjE~S|qGz~p|xP(MKn978p#v>it1HO{*u$yI+IDm~6>&XYE
zmfeZ^#Fa1Whv9?7a~%h*pUijuDcIz#zkq=d`=*XomyIF4*r2g#tA^ghqT|<a`k7V|
zUn#3Y^)@n=#Ls0mC$N8n?8L;^Zcco4B0rZC+0N%&B*UFAdf_WaCcZeUJhGr>u$jD$
z-U;_GM9+DBq#orgnw~xX6<-t6gEEmNs}ZrWGW&9kEI4uw3`LY;T3pQ&1T%Bnn$-rm
zQB|1Dl^HWQL&TIYLre@K12@IEv$2@z+Nm!5S7Jt$muPSnUYAppT+VqcC#SD+K;nAI
z*W|HIWoGCwvGy#mIJfpU&Nj9d<!Q$5tRS(qI<G?VK;%PgFA(sZ>X-N=e)~GC0I%`?
z9vwzk?rlRb4ao!4gRI|%tWOiSLM1MCihcmPST6j$^t3ZeUi>=jbYMruh9IzIzD&o5
z*Q3r#Dqn>Yx4f%Im8oBXbu6ayQ0#`Iuo)l;^c;YO(DZXW-g|!!>p_#T8jC#K>9cyo
zXq*QRq4oLpZt-~QzYig%7dPzn*4F{B*t>e~*v45km|rYL$M`bf17(fl(IvhFEbr=^
zvc21Uk)!M0|9HcgRPI{-j0xkM4OgV*K8jpWe>ajF@~(bm!=%)&_uwn8$Ef*HoP&nt
z*^%P`^_u664Hc<yQvnx$8;mZ;c<C-YoBjBs{`n^w8{!U!v2QWD0Ev4MU*H8{GW#RX
z{p>kb@6~=v0K)+RfP-QW;erO$-<MNS67Z6q3~Wr`T_#|9Q^UVrLu<Txc^1|ND&K@g
zuH7&_mD^QMip+Z>XH%M<GB3l|4r=4I4Kq{m7T^n7Ooh9%VsrO&dPwGhqYJXF1#_N;
z=+;^uN1=`Ida9&~zW_8!E8iRE!TQ(xcIG*3B|k-@*B4Gbz5-t}PeS3N0%{7f_XZF1
zM1~+84rE}NJfq_f{jCV!V!<5G*20<D3x7;Up_xiy32PLehht-W#fVjo5r&+78*WaO
z=}}gZ^HCVf)n~w5qw|B-g0T3(;>KBl3|vBEBzb2;T`FcZF?s1paRK7OwlEy>LQ>f5
zDV!W!xGjk%-S96~8~(_$cB)l)UZ>~JQPJ=T7pvd!6TONUK#^-HX!fjr_03Pv*WU@&
zjuYkDY-B|!c2t`z`yxaroEcoGFq@7k=mX*Q^3~no1uq54Hl+sn#QHjB%$L}><HPC1
zq5`%8NZX~mJJ2rt#=DfO^q*?xz|AOZdWm3c=X|9L23UUVP9I!`hV*PzYcQ3MYRZUs
zQJjq(E@f&1%Elciv17Pw-G=oTtQVkII(B`#oNoo@1Gr-#>2|q%Q9-ZU<%mS?unXX-
zaxSe6(F_;9UUN)G@!9|>twrP9a38DZXZWMu{{ux|XcO%qF1{7+tNFO&XbsC)MZ>Nj
z>^j22e7X&XRT9Qf6nofw6dqd0ffjgJ-uYTR1NVub1{b>h5e0um5v1V1k=SeygLc#-
zn6t-~G~tsfe4)Y*A_n+B3E-AT0UVT)QK>GmuM^+jBQd{7fm%kt@@?Gn=aTs*0haw3
zz`lF}0yx*f7_g-R_bOda1_EFpR^<yj?I);E;TGIX6ulDx{Sk<UgQ%sTItj!fMpmga
zv*3%Z7UHVNaa_mtp@%^oURqYnyI?+MIF+kp6<$~7L)wC5`6}g3ksaXb|Dk*TivE0p
zrEYqhc5v?bc-QXbpU6nu`{ze?&wKx#gE9xc_is0=emJW^?nab*|K@-+?-%KL@1MY)
znShmh|Hc5e*S&u`v0m5v-oHDabaxhoz*^dS|0X2Bz9nEu_x=^)lfL(F=VM?o<=(%U
zD6{+CKQAFM*N3enfJ6|;I(2<L?)^)t?@oMU6Dfd?EpcAwR_!{;!ifMpTgL?P7Y`pF
zXtv&Z2MrIKjY6`$LyrKk%`Pn8qa!gGw+kN>Tp0R0)bPuRmb#Da!3U;j+cqZ1!kJY$
zVP|HA?aVA^-U#N!(AvJ(f}5JHNS?O$6JW`(_qqA&4n&LNn596RhYF$lh@x;$Xz!LR
zZk<9iE8J0YAa0?l&JAINO+suGXQDme(;F^N?<ROUk!^S$B1_B<Om{}-a%HkO7`@YX
zL`_d5m5MZ0kbDUwACPiurWhvNl0Ha98VV!~L-J!+WH-+7IJY1;s7Ba1KOgs|U@D>n
zhkh`%0T+Cc?G$3|6)yXBz}yNKb_<Fs11!C<w_yn!n7d=t)jvdlleq~Cw~eE=vO?5&
z7UvWfjDrikzSQ}ON`3+JI^yU@HgmwD&IF8i^`)SU`Bx_k1J{Z9*cE~Qs^CJj8{uRf
z)vlVMaSt?ZI)y*tax82vV_6uiW|vfcZF{=ZKYuTyRTPYAM}7O0uCGB3`oDQF7H`95
z)GxU5)^EWJID-t6(A{)tyCR>bfX`@cjs=qgNJ-^uxB+Y;Ob^?UW8>lAaHqy}=df6r
zZ||l$SKEi6vb7^Gqf>o&c~@6)<8;s7Z3saBf|~HI#(tO8ZQSdP$p&Mfz64Ssjp1e>
zVPDVmA}2fz#zu8VE(Vn>@9LINV|Yvky7DqC(c&MN7TI~3<T0V>7F;g(X5{c<>?Qq%
z5={Gyn)cP9XONa~M53Tta(93fwD<DH2zS!Wh4MdEuVVgxddN8-)L0sTp^PuU-J8+Q
zqar6oJ98s<L_3d&T&Zd0CTOi8t#!XcMPu%1_2}HX=X{_L9%mIh?-xVE4YD~#;tado
zyP75xDzGs#hP{^%rJ!Rvv4EV6wU**}i?QPyJ!U~iQBM#t643On4(4JjP*6|FVPhvM
z1{E~j$w1MmL_*P44=z*1<*^OV!*~(*mSfm8k~4etzk@VduG1276|pkj`7Knq3DGzw
zc~L8uH%?`xxKqx0E_xYwWq^f-g0s6OA=B3@kWkZO_>3=1=)kN#KzmG}w3viX?fnG?
zDIo-Ja2^<%qzmL|)onmh2OH8%kQ{W2OSeqI&qTXP<T0^C68$rcX?nE_Y;a&u!P7;8
zghUk+A}SKqOf-R9d=?bLoqS`vwWCex2N=?eEc8gMr%>Zn85m!&nkQlwV_PN+8Z&*9
zyyNf(%ukAQquAa}+1Qc<(PP01Oi;PDdv2m$cF^7~c?3<haLYVn+2<v`T94!FaC|MP
zd?ob7D`8K2qP&cF3mD$J$?vU491H=Ag47w}yOs#&iQsW?2UzTqY?xem!!rxN9sdkq
z+AJ<e6flKm@z;k@d`c6f*_B~O@g=cH0qkI2z*Yx<3j{|wP>gpqtQal2bQ%TEz{V1o
zou?$)nhRZ)LkR^n8{!<H!r^!p7@>+2W#&<+t5GJJl<R=6LA=~C)OA}O+3s6+J!8O#
zI@iXDK_lLqC^q)aqR>gvmJFwO2;RczqC4>+sf*S!7bVJ{MVVj!4So4;#<Dx8sdh{{
zMvlQooai0-T{Q<q?-<clgS`=V<Z}yk!%H=aDrw)m2Ba<72PK=2fN$ntoUfa!@JXEs
zxoq4C+8WFzsF`_js<54_f*u(k3iO9ykWV3~pj%)S+1Ny1)>@QLz}BJ>e57n@<d8wG
z9rZh3sfizpNB6*6H~j&T0gKn(x`GPc`w%7`cdDy|MyophQ_$j8`UL(Fz=uE0fKC2^
z_%|i+7ZZP##y^ty5FO@3U&pyN+0loq%J7oMxt1+^T+*_Wuz;i9m#J7E6`QLb|40hT
zMnUUYP)(wsH7sZx3WBG1zuuboI*0XiCfWE{-3K3MV{;tKo1n`p;4UW&gs6*>?jqV)
z#QX#iDPq^JMHiQlNNX?`A7MDH>fltyAq?ix{?^ABM=7i|%K&FLsj~~vnqEK_?*Vmo
zP+LAs$SGj;2{1)Drvc1v_z-f+SI$IhA|mHlesyMIT3!aDqRBj&*Hg1J-7H{Q3;}<T
z!1O->x`$}tW+RrM;Xzr)2rc@9o$3^Do=ns1k4w}Jw#9Qp*I-vbKTG&wq68ViJ=O#o
zvAIEzo+{>4UI3Cd^q<V;)(=E{AJ{yLM3yCpl#$KpAOe22A-XnfMo8AtY}RplG)eRV
z5uNq}Bf?d;>bsgcd;cJ*|0+Sfj?}X?^^iavMw=F>rUcXqLcQ}V;bFAl0qz3S(dzI5
z%PK0P^4<cB%hfJ45pYFIgQ1~yCfK=J^ni1g=zfr!P1oz^TON)jBf#Rqi-QUHR<%|p
zer38HU#Yhgt=)&kJQLN_QLaBGI2O6`HOJiZY_xV!5`ULy{y2LfHIb%rPX(A*Zxc&c
zl_)_f_xWFfbf1+Ak)f3lMnJg7$vii}{>8SV1s42HGwJ<3LGOob4GTz*b6)QEHxl0;
z;P>nK-O0C|G1(p1qjx@)5A}gCog2z5X9I*TBb@Ma70x{1;O=5rtL-4VM_OIWS^z$r
zG#yiPOL_N<MJ?Ts>w|bo=;U40^kE*@#-GXe(+R%XX&c*qA&%xdm?Xfd5ABu@MWVZA
zxfgZ^+G0wjgDDgpdJ4p>IQvjdd`p6O9Xt3LAkNnKv!3W^qm00d5SAVp`8H$IGc^G&
zPHFexhs#lUB!GE`ASJc6^poJuI$*rXxqdYUx!rmC1pCgfdvFa)=SAx71=mA?gMb^e
z_8pA5F+$9wc4T+;q(oO1JI!v*WOj#*`GQJx?4n0(I53?4M(Y1T&Z9chq_aT9AXH!g
zfgT$bs*WXh(Ji%RVv=sNQRx=oZFmD8<4@s_7&C0oOtd+#F8Uisu<*}v#Dh~<ClmEb
zpdv^<K^3YRjPhh=?cV}|+l0v}ZOUyNIFBmxS3ONDjC%@VFeGUq&(Jcsb4=^rrtTmA
zc~_TV0Ba<EYG@=Y^EotKvBo4HV9bHLt!cWD9%8hrmGDc3Kg<9ozI5v)i!}uM)t;uR
zyARTa*npvYirGO3coUgIRvkS*Y9>tW`qc=!J7^#5pgYzR?0)3wBUw-M#MUO6z}`#O
zgEoc=)c&iAjkLC}Myh%JJ0j&2UNt*<66I2i$WlJ)(wedH2)lfGe(YhUGldndWeO|e
z0%Xs0N)yOeMFPi|#kIaN%3rRIU;!zb$X7@90!AB)AmCM0OtN#qPX{depbECp?Toa<
z|K{F~L<hjP3RX{*uAWlShub|Q#vqs*T1E@iZLmV!OJ4(#f|_RD?f8b$p&ytRUTo6M
z<{Pwvj!WWob!IQ(O+s{OV0kj}vp`(a9od6dcObV^25}qyh$gHzbKN0!0biTUd5a;w
z9Zz$GD30!~U@nfKvIJUtqx7%ccrw81zEHnHJ;WW_xHh>C2>i$Q#roCU(RoxaHua!z
zsTmK-oiTMlQCE=`Dy*7DQL8V787jPYGvE#!mj)C|qspHO2zD;8bvt+j(+jD>?iN^F
zoZ18DU06{w_R(7EmR>lPm<MjQk!N=~D~#nCE(Z~NR<F9_c2`asat~cHmvdMmcB5j8
z9mDvPD&Z)TIC(vAE|L;g2I_#us}rbS-OR4)#WhbWl170`gTv;p#r`91=L*xTP;tpi
zB}${MP%jwh<Z6iZs>Glv$WAV3si3mapa!cjeyhS)wl!T@?uvu9-#Zzzvq_+VA#8B#
zSU0t|dwxuDAbxc!O44LT^n|RC7Q12fqY3*LEu}_y)dZ?_4WBnn!@<B=x2gx^%s~=c
z`2;OUc+nN8YhCg>2IR>C1PN(t0sN_K=@!D8VeJ`WK~+h^NpWLAb-BsQrxFXAv5g<|
zDI!9GDR;&s#qk8y5x~^O^-wBn?g%@@mju;&tW}gAWJ$I*smz{yi%S6ClsTb<$5JqL
zM|8i*Gkl|$$2_YTc@p0(LS<=Sdos1jf=L4aA9*kvnhVW_0RUYz6bnC2?V>UehG-Q(
z&3HUvH@)03jJZr#)cd!9jCQwR1ux}96AxU$H{*ey=tZv&zp(_YsmD<rn)E8h?I}DY
z`;85ppwLeEbE%OYPB__1xVE@7AQa$)vqkz=mCaU_Qbv<#FR3=oPZ{KZFRhzj_u?z1
z9&vGl(115t4qDpR{#ICY+adMYheskA^*E|k8(Lwna#{dDJ2y4ljIHQ6dDIK6m!o=0
zIv;ffEe7lf8L%g0;Nzv-5iFO1tJ;WZf>fRKa!3Zp5`x{%&t%78=URkYdy#50BJ99Z
ztMkfUFzp70rb_#-*7k7i&Dzx9U$m(qyfPE8b%K$wwu^g_ER*_PihEV4LFsYYfunfj
zfGTMs0k_7a-}$VUS}P0<I^JX&`&hT2Ayxny<W|RVLwoU2ZD`c?ps~u(5cPnDs7J!R
z=VdUIY&ms?#^P=oODM}6q2an5cHWYGogv+BM5I==<;?9xdWj*utOx0%`k;|0V4sZL
zSIX=(bx7V5AOC4SCMzfLu|+<*)6K@?;s+>Dx*n>dhA~GblTH2}V_j_%Ka$Z!!U@Wz
z7wJ*3ziF4Qghq}kdUquWe>+l`aN}jInQMCDl+i)LwZU>Yq#m4tqw_wc!KCyz`D&-+
zB@MkXq@(lIW|+?T21TgkDi`g!9Yvy7p&t1~)uI^Pb_exBZDDP=J_D$_3n41Ms0+zq
zw>v*-7TbYD&;7acw=heP>LS`qF}m^-ZT7b_HNAn`Y)nY@aN_NTs(1pJmXyM)TqM6$
zy)HxcWKHch7@hKzhTei#HIYrxGzo1w!-X}syQj47#JO=QO+q5!RCZx+bE?diX)Wwb
zwEDj<Fg=9u8L(VFA%vhM^+9Kdm%yEY$#VD&Ql30F*)d&T^fPqZ>YqJE5A}h3gHa$)
zkz9=9I<|7i#srI}^oRp!f&-i4Uodx&%9xNzZ;BtH<!D{p(F?VOC8syVC)wz_P4S)?
z<aa<*9N(*$HdBlk3Fw*b;}}D4U{k~Z0z&tw#dbqAohg=bgq%`^yA4K9Q+$?fG{qF_
zswnFIo8lDgvra9mw<&%l_sjMWVjxrejku2<NGYZW18SjMuwU9CqxvgT=KmPmq%*}f
zw(<0)D3+Ntg^BIq3`z6&W1zSj3A02d{uj}boPJOS2Xwx!cjH;E8&R4z#gE^kz93c-
zj`8S-ihYR*sE5S|B>`2CaFr(VXdgsiOB}I-h@V9As16<^NiD3$00qz$i6PMusY4>y
z26~J>?x$ZtTL{W%0<D*-+AP1Dir;>d3!XT01!i)i3$rcny$$#-latN4cvH8&OP)6K
zx7N(Uc}XV4<o4s*Y~@?b&w7pF*d0CDcij@^>_LkhbZcz87)+AJ3=>=NTWz>9YGEC@
z1~{kGqWU+>WJz!bmjtm*tmn-__&KWAO4#9>Nlm?7#1j6vTxf#>tJ#M?ssq~;!8B?d
zu&DZMb=T{dpyj6FqI`E@F*Y;5q;d=PreL?gzcbZp!6}9iIl#fbJnU@d4<=1|6Vuw5
zb1cda7gl6rPW~0na8Ar{XE<v)!};v@G5z`B0^Aj~Q{C|zCcs;Z$&J;KRpLyx^wkj%
zRW2l&8u0U4l{{We#EXCmbUahQ5f_X)LR0w)Gqg2>I;L_y8MDURTlac{UL@mvX0l%f
z+qTWd$fq#*%Gum{`Q*!p91nJL#iV1sHhmt*ZX9gh4SHNndyp(3^ho;2UMx}+jvb=6
zV&c9b9}^F92j^zHajai<oGX}up78arfjVT<<=NOY*?bTFsP*KvD7&x-d#2Y4z`0Py
z1_3A{zymBC7x-lGsprIT0S@<MMla^h#dcgkz3zkr&h^BZPNHM8@w-jt`-zF~)A)T1
zzh6D1;icNF!nXMa=A;Bn-jjeiQDA(jFo6V28DYMu2TxIRImYh9`n0TVe$Gp<8p*Vi
z>CDV_W)5*?!mM|ype&@g_k#c(D>1lRqbIt`WmOdo!M=27{19wN8d>C<pNZq6r12k4
z?WZ0h=#$1PfCCL+W7)$g&cb_wO#kR#JD)b}z5VF5Wvijye2P66nrps`>KhEP_3A>*
z8d*LBTPXzUtOV3zD(CGe$`1M(!<iX!A;%!wgPHmixw$V{twr?3eH3dg7BwNE;TVg0
z5JV{O!4$Z%Xo#Jesn0Q}FC}Q(sn$?UmZxZl+0cx}$P*gs@BAJ+*!gJK^R<Ix<FgB2
z1E2XUVsfI0738xJMTD`JKh!uXzi=O{L4dAL0PP@94uI$_t-^f^aFgM-ag{Blo)+7)
zoz?HIdZ6g9RUWICYs1^P!a0K}NH>N)J<ez=hBmuXy(O>Qb2JgZ``9+;5W5oRn;LU2
zVIs6PhkRZ@7DVgTpTWWp?;_!y>NiA<*7~^UCvd!!M#DW!mCX>i9fmQs6n%sP3{**}
zT&cl*F8oj|%(kk_g=Pz`mElHYURKBzy)Qz}D-AC#7%jWe)oFmiSt4v@AB<x&g`HTF
zT0%B|$>OEGZe;Ph7Ik$EYqcx!b9D19Y)B0k{;LMs=;SI?FGF{&tc`?DO~~;U3H=&`
z)GApqfR*`BdjfS@0;-%^xf4*0MQJUJtwOP3CN46B^Mrl8>Rmll9S-SnJjA=YCgY23
z7P^B-we$I+_qsTkfwp)@4Nhi`tO|0o5IL012pwRqxsGLb)d2uk_r!u&cFR%W(@v_*
zhA-2*i*^&?X9?YWPLZA`0=idUcvw54kz5=yLplGJ#*B6?T_R6w;gj@u(&5QEnC=Cp
znqHu1Tjy<3N+E#4&xFS^3pb%^Dp-7DqWBf$_i_|Ja(tHi_1?tSHhw(|U%9WRC<{N~
zNZY-i5m{=3O`NyDZ+m{N21^s%%C%Y#U}5H$6E6er(b`<ACIsz;V--Vix@Ez+`e+vh
z)E_HZVdrnwvHRrj)p2^68}JyRsUJ_nW+rVnZ6tlD*d}*s=sSy0qv`s6G%a+8dm{$~
z_ioEX^Jrn;Fft)#C&j#EA-ng_)LMj0v6;TYnM1sn%^VUgeDC(rVO)+`)VOj4*FQab
zow+z>i&HTp)fYg47Z1l~W)~0poclSsTNKyyZ&Uxlr?3b3o|(R|=R-%KW@F=r6t=-+
zr1VP@r62Yul>XcTnvAkDPaC$$foF$DLz6yT!Z&!wW1$cPJaR{7k4p&?s)qr8Dzh1w
zY=Gua6Q5z1ZRXq|*dDg={XyVa?SMsLVV%ZR(@EZQVM%!oRn5&&4CZi}V~Dk2v_yB#
zN7VB^VFFF`-{R=hSoldh#-L2@FaWN;!vNKUC3GE{4OzIkR8ChQEEuqMY&ew?XRm6b
zU4gYXWGw>02c=G!0WLMu4FOxA@RA#jRb|77ayJCQG_B_=ZFM{{b@bX5H1kS)(GKtg
z>bPpYrZ1~%5FDI?y0j(kt8#L~P8Dwbs-`9|d<9YIm;6*cLM=2hsvZ{xa}q3yJtT0I
zd2EmQI!?l#J6bA8%90^%_JM2VXJvoF$OkBSI!-I6IRdEK#j7=VZYWRGDL{>O4)!*1
zZwH4pi-jfVJu#G%vbv`geCjm88RTtvBn3y@h8z1c-UfwbLM@C)aR5eWhrgXo7BV%v
zsBJAJLk@EKIjjojq#KUM{BC-vS8kw2cWN6t6O6_`MgTle>8ku1s^I`{!`mq$^{a+}
z;AD9lp4fk!t>9>nclhps7@|6M$*M#;b-WKdq&m0>JH0x#RwSvz4~FCIu(^RsS0&|C
z2M)e(+JDiG5S&2~jAi!Air%}LWn|UdI3PC`h1fr$uTDvlm%oG_mkEshLmm%~;25sJ
z!{$J0fTk1B;3o=roIh+)fc7u*sM`GAxlXG(ZNp_P4+WD07WEC{!Tr?0%LK(4X1&8i
zf~iFxtYD?f5k-lqY9^3an`CMe-y!d&rHhG3oBO^gSIK7%Iq@T-`W^nKKG3P(eeqWZ
zk--COhvde%O?QlLx>QNE$`yycKgGK9O6t8yq$<^5ViIv-eimIv%LJ3~EUwSdqAW8X
zguy10=-$-+Hr#)xaRLqrG|oksQy<W>8Rw;iGtNs(XNp)MlyniS-h?l0NiL!d33azb
zRB0M6g`-WXY!U7rQw{e7eAFdorgT-9odMua*G9cwYs1W`7__re&rc!UDdn%!EBZ)V
zQYS0%`@*DWRx|)#X3{$he7Q-tn{<WX4e4HP_o>ks4$%!P-RxcUCUuoBFj@%(@@`B<
z3KNq#RB+Had_%gx5xK-J>dkHkgX1>@eCmzyEN5`!K<o`ZG`<yxIH_}d7!mPMs*4n;
za!cI{4@R0I3yKq8BZ44-D7ZeLrI1M`mt9k}F28<)x%`Ut49ua-=ql?5mM)XIMl2-I
z%Nn_msBjlW<4xk0T^9P)*gvimN9b+f8SDMj*mA)+Kr}Wa{#T>1Ui$hQDuWdBMb-Us
zaT-8%&(y76X&<h7MQ^Tp|0})CkeT8A(_59%fv#cAvCDz9XqN+@diV-)*AL;r5ii6X
zxFXff8fms5{hdxbxROpA>x?K_TiK~sX{|9wdo%<x@@_1*$t1+9R3o8EQ6Kxs!P&-!
z^OLB%wkZ<2wu#I0Q_Q_zW&ERDGeB-=gg!o@l3J6_HR(E&_M5c8@w^#e1%{V%;$6PW
zNK9d-b_Jki1nth&h7qUM#*Q0u`w3R4@E;h`E$3M0c-Y|v8K9Oi625*84t_Mei)kGB
z>Q8*F;MX9&0@vHH2>C^gIRSvKnTmIB@g`@`leH&UJdZa5bDr;G1aRT+k)b{Sj_nNk
z1>Q#<cOU-FABz*G_z`$O;m2AsPmdA}-Hl(@WCp7l?b0tt>hO|>7syA?0pT#tD?H8y
z%EGlW!Fnvn;Fi(Ypiv|f%gNPa#0k0R&}5Jp&Nad4Y<BvwK{*1qG*Ab&0gLwH?%yE}
z5=-R6gj^pEzy&<$l!Ky19%cxd@Vrc$Sno|IDq9MX?oY-*==?Yaa{E36#t@_cnLLbB
z#d&b)_k+BlyOSdhuzeJtVESqxa{k)E0du@`;w86L|2DvW3@~oT9tqhr`y{J*G=$RC
zJcAW^TXk30hCJjoTZi9hsW)U<c>*=8$35VXS4B_YE**Wa#KwzX1}d&1H0n$)p2=7Y
z_eXOi#^0IXn2E<0gQ&!!Tn%^_mM6f^g?75pg4lq1MBJZLzbFv3uLqIftq7ZX$nF_Z
zW}41g)$K8Ye@?+KO9);^!57?2Yh<Vem5<+$Llp!`^L3fRfn8Q-=|W_wxpD50W<Ni3
z1qlcm_BL63NP@kIOD_r73Jptp={PINvibW4#<J-b#InUZiD`#1UV0Y7>(XDtQXsVT
zEuDH*r~ce=kmlxhSh>}2f6!kJ)u|_R>J822kC0ji0eOdQfzEoGjKc9Iq<oi)v<c2%
zLrMew6@csDK`f_D>k87?<hjgtH1p*qnvx!r%x7b-hRn*|mY7Hqzw%S+{eYXa>}k<;
z?f=kpJFuHHD!LKVBhk)5yc0l-Bn_B-Ia~L}b&sNOx#|h-=$*Ol!Sv;ZoAkv55#B&>
zJM{#4Eq2CmC8b=e`z$Pnio{V$`~bA2n^+aPCzUhXt)needMsDte86>TF{w|nnuyV0
z{p4I6OArdbOr`MBEFM-qjrT4c7~OibK7U@?SeY?B`t^yo9pqiT6}Jm7`Af)Pw<NIF
zQsYYnduE0%>=faF?NVmYAh@1EL-Ru2u`dl~qfb0VoG)T6By<(j2W)va-DsIf_;585
zkeYD0pZfep0K>&G;UX=UcZ0OTBz%gOHHuRbdAB4ueuW&rGZT7>Zq6cMp3>3%L8Hv6
zy3|?cD9R<D$An8hU;Hc(T_zUGyJ2F9Nx&^3G%yM5w}%i&sN*=rL?Pr0tqP?WD0noK
zViJPC#w2ppT;Rp8V#@}l3Pg~a>(_<cJ(6QP_XO%Bwp<#h;uBjD7E8K5P%UYUh9tc*
zP%G(`fo1Ycj_gG%$W>9AHW*@IuB4i*kyO)UwE{{LL_DpY;cOjpgcWIC81oAaS3@SD
zHDnUG>W9E9b^aB<g|lc>7rtmA_mCoTS`s<!rVPTkye&7Bv=&W5YtbZf^>ik9BPADa
zdoo^IGTx2^-shOBByX>B#+RI+UNmod<2fiwP3ijFZfZ?9X)_6*ngE58$Pz=OJwfC!
zBMx&Ip|#ME!KO0l?Iyk3q}!MV8`dC~jTbnXiaiU=p&hgf#?nBxq_N}OQ1D3_BXvn*
zt0bRTu0?o)jW;F%)5qA*B+znung@xi2P!m=Qj)1=DFqE(1eYS*R_{l-YLQH<)(4ny
zwVx;N1|{Dlq}B>dB3Io8JSt93c|h!T)Qi^s4pKx;5U@IDn<;}iRHY?%n8Lf5bhb&C
znY52-P^d^ys5catBV#s$QDxG3CS7gP`G$gp$w$q@XhXrzFGe+j<*G(ds2cTESh^X^
z7mKI*FyX0|(6<+Sm$eEZIIn34Wy`x!n9n49>PaCq*d_E)g3uZg`gpn_Bpfjg098>1
zxF}#k^ngT=3C*|}9J`#uDll3!1oD^|m@W3U73yE&?MpcXhJ})4M0{0rPa;fA!dS2%
z!lW1*3duDh=BjGh>Wx_sX_mUFDbqx?#hHYdPp3)bssiBAe0a*kyLx5@?nSH2LI-ew
z?y}x|huQdHnr%9L|GzN!@UF&>)wHU*x2ZQon|-YZiP^9>yXF#z1RJVL*ig{0T4A~|
z(Os2Ei0-OQLTZADZv8HncT>MhOhP1DW)iwHK|;03{$z9}^2Kx}21+!t!XyNLjY;IH
z?_jTY{6M&jKGg9XL{3)6VyMSe$1Uwp2c|zEs~^>(t$hN|7x2b8F;EPlw3Qb_Yqap|
zsT|sr)T16v@@EP4XbTpl-+l4h-L{;dypQ6sZ6<P*$*D`^yoQ``?BT#Nl0h+qbyZm<
z??#o?CgD@hm1s~BaX}X+gDy#c{u-c0M{|=*W;yhbtfQ&W8FaLlCNplQ=m-P6T9643
zdk0q~T-rEds*F`L&;5D^hmVMSOc`*za84#6W>RJnFq3pjrBZ@uiK;-tEl^AHG`4A?
zVgO|(;ZrZZCqX1`N_D|?U1)GUve(eXzW9g6e)og!rL2B7b8QW;2dP{M)=6Kk*wDl3
zY7VR8KPF|c-vlW&Mh?bN%xQsn>Kxv6&(4fFbQu*C0t($OX#_Wt#&ofy5!{H7DUJj5
z>ew_lj3H{hBxsL*CKe|*#3jiMkzBbZvE0;yZb&Af8<I)ns%(tr^!$?WhytWOg+aG8
z&7GMl-j4#vIs{VVxu=b+i*&kiFP3-LIhX|2zu>YkK$t?MX>cfyOmfaaprAZSBLb8(
zl!vtQU|@&HlA=45sdE|4eFX{WJl`~~W<R(oMD@k5K#YK!fimpINkv)lUjUo!$PK&O
zQL3)%BV|eePF?sgPF>!Ol)Fs=mn>a~zEXKG>wMc_?`r(6*0D3GpMfz6)oIA&s$q~Q
zJ_HQy@%je+;b4!r?j{<`h>NwcFp;nVV;<THOhN`S?XW)e2MjcX2{A>(zP!8an}irn
zr%B{0UN}#qx1c7ih(kCr07jYP7M?BdhLX=DeCp>HVLmp@r9x6bOsFaR)$qcc1O<6_
zDVPK{*<ojntZ9CRIDwaXVW^kA0=LYEyv4Yq8e9xWLz*nLc3qLyT1%4FwkK<?&DEOf
zn22pkTfL1BVSKyCd#ZFKO|VC`4pqDV#kRB9cSma!CR}M%a<RMJV)YQRh2=bniI4cf
zj12ZmMl}grG-L_<K+I84N4&snf3%}s4WW5$?a1Fh@Gy4d4Hk_3gU4or=iz8MtiOt4
z?iWvHC`~<FZj?80H76<WpI|WlJPd}4a0AWhP>i09_!r04-=AcxctHD6)&(+0|4kw5
zZ_|c7Ko@(4ZD@Pm05ccKkmJ^Hw!FLcY!cEO{Ya>G&?E{IE=pc9O1_JtevCP&_|Z^?
zF035$CHtpFLgkv4l&juE5A2$9kSu&`SYX0s!A@qO%w>Vn`q8M>4AYA<;iBXvH~oCK
z>9gztlgKqYvER~R>#_fI&lPUqv>^a#@iKrRvq*0@={%EeGwFPjW=l-;k;_d2Q3&QF
zOkzK+nJC>FdKa@-7>E^^Qv7^Ms8}BmPS8(^a}_p_5Kk%4>`v7k*c#3b=vvg5uBw9|
zA0~Hj)dOb8)CI7g_<eA!S`E#wQ+P88_V2&5+c_=%odoVJR5gClQD(;C*cGiw%HbSL
z3B^By8FY7B@6#wyOF^hy1AbRFsw0AuN<imB%|Kk+q?JjRne=X?`BQgN-t8!lz#2);
zTj4@94D&_3xQra{M8FN~zW7tn)AZ<_8NAs^#)iL0w6p`CL`ysN8p9jlG;e>!JS<5B
zMZ@)hIy6<LZIfPX(q$&i1qjX9E!gdi+4Ou!et_M5^PJtdGEj|Dse(EHccE(T(K(39
zq!@;|guqx%ia~MiGLkMPIkHgWpa8@vA%p=Utmahrnwm>v3mVthLb>ouTeu0P6u-il
z_rS>NkEpG9E9R3@6#2(gMZSEsR%8W=(Tcna#ZcyoM738l2eL6oW)+OntupCsldd*t
zAJf!Yg2EX>0pXcI+!OE%2EsE*FAd}w3QG)yd`YhikSiNY^wdA6WvWbiu}N2(w5%rK
zyG1;}FEihTGo+hLS~x>`In$`c74meCXv1kBt&L*REB^zd5O$M{LfB0*3e9ecQ52w&
zCL4v8SQ~|w))<AxHAYb@a?>cT!N4Xy%CyUYk<|k<q9-xii+O;#h)-u`Vd%E4v~g;K
z5&YSgAh^RH)6t5!l8S&Ys=!<}W-VX^^x*CkMimmJ&f5v-k9cyz;TBAd?Gb8N(BSp#
zq3B1RQm0GZ{sMJtg-2HVYJ8=QmD#cf6*svrJf`DX-Q540uu{btoYN=5i{dOtm%8$0
zvV*;?@9<PenJ(oIl9}K!Y3NlF-I9gH%uwN53!61;lpMu!<Js^RI_C#EM<<?yxbY8+
z!CRtcT^ZR%<<fM0CgD@_(c#5!#5^=StzJ8bHw!kGEf;O!T87?&8M+=f<#JUIi!)zs
zu;#mKP}e{i8>~Fn?k-6rgNI{9Y^10PlIc!E29#nDGHXO@;F_*F8ABi&!%e>nhIvZ^
zmd`i1E?E$z#hgM|Y}O6penGnn|JK6j(Hh=b$As3xDX)^=IXcn8M087;xi(LGi73Wr
z=!W*_g{;QEN$Tje2k<D#hl$GbW8Fkmj|W+c(o9bQ`zQexBv=W-q^Gzz1?=MlSOvjO
zB$(*te1K`Xr}IrvPr_UD!p3V(u&f0^F)LXH&%*jOf8l4)JbXzzrKMIBAmHWF_c(wp
z#74IZOYx$PzY+>)9W;tm@vn8zspbt@!DWKjmA~i%@kqFvi2!!;@3ltb9-erb6!7tg
z8+4urd8~$Ky!S4}i@?hgVBM(9gS<;O;#V_0&&n_6Y+d*Pnp|Gv9k@HX3+J0M)a&E}
zwdrqVDH?YzsSy{yr&{?X+l1fA+Q8op!o9<VTNl2|-v-GO+i-?2u~B|4aqUK)T!QWR
zRObSY;<;mz`qC%+AN&JLg5k>o7K#k=&2C2bY^jCvG2MB)AWvS|oC_N9=N?30#NtED
zG3%x$@jb>n&A@em`Z_=>OeG8B<$3SMQXIo;l;!$X_48-+tV05^?pYY$n~^i4UuCSx
zUK_%tJRjYOpAYqpYjOU*ZYZJ!cWH9$)$Y>dA=D&__N$^YzCkN!tgJ(v8EMX@l;698
z+$WSBUy0SHB}?=bbKIbS9~+4c79H_IH~_*ijP*%lQzxAv!Tkw%z!T~w`srCn=q9TD
z6Pl==8iJ6RE=;#zuZ}qnh|%t=2CD`t{gKmUcw2+ts7|+fUolpOpe>rU3(oA9wfG&d
zvGlagli~*VS6n076^03>xW7^@=`|6@q(nc(wGO9rgZeA(K8)|Wi<>k+aSx)l(@R&5
z;$X{H;URmX;NPgUpfp@{w5imfHUv0SV+pc^pK#A(p`v~yPG9=*BY+s)Ql(Ea;aV5+
zI)L$YoWsH{g;kaE{#x8pjy6<oo4au<aL*yur{%7wxqiOXA_ul;f~=I~E_E$V^<XQq
zw?Tf(40TrR3R-IfHGwwl-=~JV&<&!}{<bl^27T`F9wzgG15kZTKz%rWyT^O|_UYcd
zjjVutRnIB`OKd*!0zq|yLTzBKmA}W!@BOlTI}SIYdT+x+w#xO#^EeHAsldt(xk+LT
z$@h_GOH<mveYX_ibf~N!A^54xcHoHdQl7A_3hib*XYYrE|DcKLBgOxX6+I%B{l8;H
zIm3(<{m$4$zg6-+Vj*sSpWnamOHmE`X+bjt^cotQSk5J^K`8Y9ljU3tHeopz;xVA*
z9Ijyx6Ii{s68#j1NF2CmSMt1=^Zr}TrzDnMi2jw=YCL|w74Z;(5|-m`m``{hY?x2q
z15TF${&&ph)$bVd;jbuDu70`xoeRBVKqqtsRJfle^c{d=8)l7HVu|VAGhj@&p4~AH
zmw;x}_;fnx{qeS-ch%mG^O2iblY<#{I4ykJp7?Uy1~7#w=l^(Wh9-Z$Ul6r*u7m*n
zRP6rwwO^ks*7++u2DHu^4Let0#X2i`S!cd9nf<rUiTw-FzjY2X-DSV^oJAmPz=b|#
z=O{*2+3T>(VW}&*g(hl_(yqgFx1}yl$$}Z-M){O1<XGxxH%p>CxZD1tyt|~ua&sw$
zRp?*+eDUK2y{U9;xV^xk>&9=0AOrDXQIIb_RfGV=y=-VJ!`^<{aa1luP5FtH<zRLo
z=9*4oqrvgDqo9Da0R}CuLfvotVTES5_aIX}$AC5*7=ew)cpxA*H!c*9(FYpS2Aa>o
z^@p5o`eyx(+e#{1Im0%taq8CeOog4j<SVFtXZXSu7`g|vOSB%*De}$7AAm?J8&?(n
zgl3E4`-O=DhNGVf4uvm%CTOk8rG7ak;ql8kVVp;eKy+bgwy7;tqz*a|@adqVj6nx}
zie!YfU>>S-1lH<G8zaHY6715}S0i5<3!jX7gR$@}n{R%;`S^w*8VHJ<poa{Y3q}Qa
zks*Fi<zdl^c9N!KOmyUqEBvhH0rGrP5eGHtg8yexCvmZ%v>-R0Anv0A4@SL<jX$V^
zVsvlim-byBV2<Y6J=!LmyN)8keesF?a-W{r<G?JMIoVB`M@byIt<s0L(so3wHNRSQ
ziZ0#n8hD=3u*3jtk&`gUlFLQXC{5S?O@<EYz!+qL4yvDYa)b_M4${z3N6095bNbp=
zpQ7a!7rqyE-U)dxdzHU4tAEaM#%PRtHx&>2py8#EH@rm;3*>O`{tZg+#UTU^obbaK
zV2;+ylcY3W9waUHbrhxLT6!(5%B=4uRH+*PR7n~-n&L$Twi{+{7u)FHhkp5O9qb*O
zhN<}N{kbo-PSA0t>QM;|(kZ=()~6kAQ2qW|N>Iv%bWfm(JYq7_<{Z9m6B2Qo3$;>5
zL!~GUb6yvv)swo}bbFw!wFA0ZJFpLoNgfk6r4gqwAa$G$cIqDx&eBQrylI)YoAGFc
zZkCQ|W)-f1RwWFyS`1WI;%W%OD)YN+_Nc_P)_Wgfg!udYayE-$M0!6pfa8fDD~{*i
zc+m0OYX(?#C{j!KI||Mzb>wIv`*S>g^&Is1KN9s}Hq=F1Xv8pR6aBWc{sssOW=a>K
zL*EK_{9WaC{?&T??Jj9>2);6~n8KJ*xGZI)+TAP1Xq#wg7P$QpUNyNmF~R9)23cJK
z6-gLeuz!kGM+*Xi+k!pbNr@48Q0-x@^;7jn4$|K%bj9@%XYBeGCB<p;;}FU1CpW8H
zoH$(t##Bv^SQ`t?$owopCu<J8r7fG7?Z8xyu`nhyqgbPqchj})HVOQS;`_vEL0Vmf
zSr?gamY*2fKh}wCfiHEWDUu1d$ZUBxMfyy_hpqrfek9eqGWyqRRxT2))wFo*adP=2
zN{}dj@KXu(<_w!et@Y;8Y&rvc$u|Y%F+m)cvTZ)V)z>FZnflc2=Zj0c3A5(>P$xyw
zwWV*BSXm@5CmLRua0{tQE=1N|rBi(pk``|E-t${b!N!kaErWbZQc-=2t=>iv@{<k&
z)q4{e`XTy95@y0>Xn8V2D@?+tP5?u=O~!lAqZ~2xM_o+@5BsMXb+!R*vd94Y4;+rr
z@1k`Mb)*-0o{ZpQon-W<ZS}LG#Gl@ehZzS}XxaK`e6uy|Oo5eg;0hD>wV*)VqVlAP
zL;Io&UG#RN7h$r^BuvygE|;vPjavKH-3g{f_CwCS=+WY<sE_?J4Yr6naH<}Z?g6Sa
zY-1b;%QXo<6H81&T0~Ql#&y-02CC~O5$@iZpAZ`cC2WNmW0(qsLJ$w=7$bfrZD`S!
zc9bInSy@if7TtgBlp($N|7J%s^9a+?tQMB{%filgaiT`d^al3!k^f~!vqBKcWyHw=
z;SZ7S$C~0dNw3k5lUGg-B}BmZ%l(&dqQ<GYsk_Y?*SVNP;G(plm;?-^9}e_DVsBpm
zf;=Klt{*b0<#5we{uhGWqjCN>1v%d=t_0mkvPZ!C54N8E^r5~ON<lDD@m~nCS>ya~
z3i6%)2lny9MUee!5hsH?%nYA|$ACWf%fkfr3p{K`eD0$r<ZXgEX`j1Ntlsz$NBi9V
zoX_7`Fm#@#PWrEoCyplae#v<kK@$<OxUFT>5?4mO99%77i-_TXHO5xU<edwot{^Gf
zU_S9_bFP0-;N1BGEv(?8nMnuJL;wj3o(2x|ydDpZ6}B41?FN8W+?{Yul!ZCAQCz1%
z7h0CEYrM8!HL(_;IKOMmsl%dpl?gqTB+=`eH})?+5LctvnSzD?!`$1zM^#+?<9G7{
z0Rne{2tm=TxM;$gK|m8h-GvR@Xo69p#)=9C5Nf~(yATBO;wH-Nx@cS5($*^N(-)t%
zwzgFYsE`Cn0N(->#aAMV-eu)Qc!U7T{=eUu+07>M68ro=zuzx>*qJ+b=FFKhXU?3N
zIdd)_q9~-RS_KM@C<+$0%CNc|B9~}Ew(1<X$br=vIuVy_;zDUkT=)>hB_|#iR}_~G
zXrNG~pGRmdg|K=Fue8vIOa_F`5ugZVtg)(6K13@mR`m!1Oji#|wQXjN-6$Tp-zNL9
zT9?)G9lO4mIP6vr)A`V%9_H|YNHZIjT5X?YE$2g>c%zs*sC@d1eZ5C<9Z2c0ooief
z8+W&2Fg`>ZS03NEs%Yb^gV;Kv4*Lo(vBr>;N*-GYmJ{TVC}QUidCrfCb($Ddzq$(b
zV3i6x6q02lCM?a`{TONj85}(S1t&+xG_3AeADW#l$=lKsk6^WI*#u=M1Z;!|!RX+!
zQ?s^w3!cPJjcveF9}W4tf(I3c<M-PKml9sNfCqbzcobI?wb)jSauWfw%T*#B-`RYI
zjp|THcDS<QgZW(*Goz4bCnUt5pJ1U5F4*gs2{mmIVZ(;K5FZ;cT4CR^64~WP&Ph>L
zEh+j)pgl#!{7j3MHd?-&+9_Ht6Oh_9LmX>O;c0xl1L?z$p8@qMfwJmHNWRZvsJ|K%
zs1xP(sK55Z^P>K4k4~XpFCcXS^)a16Jsd;5+u2aJpC9!bI){3f&Z7PhIiMrMbfo&>
z80wSB$ryx!>i#csqzzTEseoV*U<6_oY-99>4aZ`o?JVtw4{7)JqTAZ9R?+_f=1N>m
zmirg^O`B<*C%<K$A9%`{vK|M>=AHsG<S`E)`Kxh!yAiWAbI`3iEWL6d6@;bP!-%X!
zTpEfci%%6R`>+E6e1x6HD9Xlc;V@ziVbH|<vedV2%(B02W0u2_o=qDwn3lQZBvuG3
zZQ;7X4s6%w0*eh_v)x^=uC(qLiuSCnLM3E*2t0l#5ZJhQ^kP^Af_>s>2XfF)3vy&z
z!67(z!hv7D|Leng?H7=#qIuSgM~Qu0A;=&Yzle<)kt6aGhag;Bmg&qgM{N%mS=~i<
zz(U)9D%1DcnGh@@g2mRK1(U=9QV7!YwKt3%$NiT5`bAar*h1Nr^+B`a2pp;tc4a)k
z@M|`l3n0wIUJ8O7P5JN6J#Dt?g^hd(U*4%hC&5dwjBd9!nXTrRJL}>-Xpk=EH=aOc
zs{2@z&6@)Iw9s*o*?Nr}gu}St-HABx%HLgoDj}HkYrKI&q5PmH84XBs!triCjAmb%
zuxiMJ<L`S%!G6*`cU;Xa!=HYA1Lk2(d?#{l>rci!deO*38zAa6YYE^6|57#c{wbef
z4)whOj`X)A`dbsc{r#<p-mbW_=9?J4*sZTw=1i#n+#XIAGXS39`lr4nWn_~|F#>5$
zea-l!kxg?WZ53V!@N?@#g_}JizjB)g-Sr3Uh|N84|F&?gY1LajM{b_GdCXt`(O@>z
z@3)U^cKhG5<(bP<-JDhZ^aRa=5@CWXDVGB4$nCA0zU8o&-nGkJ*3Zx>xto?>Prs&*
zAf9+v%Glx*_>R490~q-gG<t&pKH6A_AM1%s^k~WZMlkJ8Bj{<ihf@WsML)mU-c#=x
zYV@Cucs;1Lr}(lkl!OeIhN_A-qADJL$f}B7LREuV6>z!+B#Bm8zZbqdJa$l3RC_kh
zz~G6mtwg~Ao5grwE41(hG^_sHnni&A@)Vo@L+U}E-0-r`gacVcI^mW&aJ6-v$j7tw
z^SJwkLs@upwpN08;3(lN7MH2u*6|clxGaKP$Oz!f4Qf43KH<gJoCizt<JKr_hrkC>
z0p0w<h0wWN?-B>AofB!C#h)rDxi7UK@d~T2s0hw>_gJZnt}^7^4pJ-GUXa^@t0mc_
zF+F)m8b3iA*I$mz?WzR_Nnh~at_)6oEgxxOZVucD=e3_(3*q15QuzMy{2FpC-fysk
zg2Bnb9pHCm;U&L}{B&`QpXQRETton4Mvi{6@3;7r8$)oEf2@ID@-1T{_ENYCo?J>8
zUk}Eq_2krJ^|1_}#4<d=4DTbuS|q{C`El=%=e5A1l-$KBK1c30-$3iPxF29P7(ri}
z5nP&P9YS6Rj3<Q`-S+G(&PC`x_<sUdSq|=G$*#Q&#~FegIJBglcwcdddB}P(mc{oW
zx>sy?u^SJ^Iq4T(vxB1d@BwMznfj+BF*v3RX07xyGrI6u{|XH8kqv@ukM%C%G((=@
zq*EzKVlc-zC#J;|GCo46YG^*XtX?v8di0YU_?micq@tTASQ2s9ehoJ1K?)bf*km`^
z<d*<zlpF$69guJi!A84_0T=83CYVBkWccpAAh6jWEbN01M$83vqiK9P^EZumh+-vQ
z8o|+va6KMu>CJW+O%nxr2<_s1(?pd$ldyzccSCmWyS~4B%;|7UKV_a~2mw%Fx7*$i
zE{&LPW;NEnUy-(+rJIs|gr<R+8f>{cE5C$Jkq(stXRVw_{jgo9@AuoxQzo)B4X_ro
zNfK$Z*bZ}lylEAqCOB?0(Xpns<!EvVM9pG2_-79`vj=zcn;$I&h*<@w3C`V@!K0e^
zY&clf>r8RuJL|3!>W)a0m5ZpG4zc%Gdoga%byM81qITzQUW8A?b8I{kV_WTIP~CYM
zZmwim?%c-3Lp-LHA6(Wo&0`+njGSWq953^1Um@My=;@lK<=GD8nGd9fy_147$H0@`
zIHy07vDSfx=o4G5BvQuQJRz9mgnRWo^FV<)%vlhemzEz~oW_}mmJ}X<<R?f9Y=>gi
zWV0Ic)A5a-!D-aNtZKp3Lz^Z@&YB<@3j+n(N+~}TGL!zROX<IwMkPYW@x$vC6ebL9
zNCbbR>*7&R7oFeKz2er^{tW{(Y{<a9_P?Mpg|A)v{Z|o;TKg})8@Bc`J`G-{kwmZ&
zRzv?4j%?c?jO^btTk=}243q$AHJZ92BQ7UQQXDo(a9C4UY?@-VfSx{E1~C4)Gmte2
z0WRJL@rpqUo>7rUoSTWrVWtT4tT1@|>^WE!HNh6cgq$p(csE1@0>ZGHcJbwsjSl3p
zwq6?JR;fV7c@u{=$&dEHt6mdZhhCbH(lkM~cLG<(NZBp#v$%Mkiv^rR%%0W-<O*~Q
z3PZI+B$LXTSPW+~CPd3(!8*#n9opU0H3=YbhDy!syiUoJA=+Tz3b|ru_tl`Nl-!x*
z@bM0DH=nC;KOB}*tYKDskY1C%)rh9VE^ST0ts*f-w@KvWsBAxD%>gj@*f)2vVP(-4
zma7&<Hwe&3YX(>v2eH6$HF2C68-+#0@#zc<+uSeU-ST<9jl^28oeWrox1?yfb<<av
zNA@Q^>0}$n7Eyr`1#B^JAF;sAEPxIx_n0k-5(`h(KHFxHn?j{PZC#ju5pWdliP8yT
z6lvP9KwFqbllM|*F~{6=5O9u=O)Ufii8PZEsZ>ZLbSq}9ugsn1JJw0e6i`xvNf%Ka
zNrg~xrkU>>=6eO^L2EqQ+UOaW2JK{4N>iR>qCCMwO?g_f=m4ut>tfC69PN%+|KW=r
zQZ<Xe7Zkh&9lFQ5E5eQiFP@)o-oUJkvkUY|3#qQh=A$z9N%u=6)pM+tqlo$I(%R}r
zgVL?rIUl0mL8wHAm=0k8ga}w&P*2_O;&?b4!pNO%m~vp`#0Cb2kQx|R60tR?8TX=M
z>)Glrnn9&}^E6jlC=bH{e)P-5kA4|7b>3_AEF6gGS@4mhXH9XI=~+)Xt58DE`kmMV
z)3g5KTrHmEmYtp@58cs!SRG^N<(GUwTK?-|*1j3yC563&Ff|*Y5roeIaGb<4C>o6B
z7vNS=N+Fb7*(>Xj16hQ+u@ZpHO*rAL$b=fi&oCUfUciW;>fL7`Z)6|FdY_GoE-b)i
zhpgilVR8yOFA9}{47}<G%AS(9iGF*W#OIcG4?%V~?rch=JdRPzA33dy?-a;y6l9_o
zKy6o)+D44pMWP+nMogV_4Lx98RUNot0py&NBCE&^Ujr5YsngI7#oL9kw_kI>eT26h
zp@wzj2wJ)s8h>thIhF!4u~;xrd5Y%!ES&rjq*X+8X(o3V&nw-oh~ZU6yynGf7I@8M
z&FA8xji@bRouKw7#h=jI1T8RRCFg;Klt>mlXt(~!-CIa2ox`I$sPcq22});oHYeL!
zEu5?fNiG;4#U<mTv=kfA@8g&sg>tMZAdGaenucirPFcaa7%eU!p?G};5RLU-)LkoU
zEVlZK!uVp0(D7H34%IO_q%T7cOuH}=0e?EA_yBHrAg_{XIiHI?5mbuGqiq$fwv*4r
zhiOEY(4*~nd*r9!Jy6G&O5}2^xqu$NmzIDkp#eUO!nc5G(S#S7!v);O$rAS+5~|q<
zc3cjKks|OCerP38AWArCJV=T_yUDQ*q^tfDriq~0DQl1fGL;P&g*XN()|*<zII$Rw
z-qH+C*^Kcz9`pCDXsRGRYLm4ffwlBNEo9icQYyD{)K#mxqE=cMc3kTI<6tBrmbhrg
z4dFXDh(EU~$O?2>RF1xhc%9ZhvijM-wDt_A>dm;c{JFISIOlF&_AkcQ3jCX_F0yK=
zN5{mS|BEunI;%IBfOf@x2o?&EM^OmNkyWe_4Z+BsBCm@TF;+}c7g=`;$oP26aqBij
z@m(kIs@wt$y^L;w$r0blk7sWZ21qRS2T@F#o#ugez~9{YP?nvtfqBqIX``O!K!`5M
zgHC#XN+JB7-pfgGIyi3*Y9I%eG9*INt&#&2ck>7fz0C2~@pE*{=df<0f&%_v1*k}j
zHr6C2jJ!;@|5cl8VHNsC$X5NaE76l|&1lgp@Q1^uT)_vioARN+g1ZJy*3126)(a^Z
z02KD$T^JVUn-j6lJZ}9Liiy!y$F<tWvAMAi*J=m*p_KpCvY51%!dW7B=Gn};2ctsD
zR~N_cEwS+{<k(Y$2z+y_Uy1gphMomhF^ChJ6{jj!;rKw%H=-$qDT@`yhWd2L=^ubq
zBnlc)$ZwCr0HS~<%!!sSi<K{z<)0GesW6E0H^$1>af)~ssxF&QX8kQJ^dCMHTVpWK
z!Dokj=qmXtAg&4*TQ`6i<N{x>sV9r5MgCpL23D{65z+#QG+h#)e)I*iZzdB%@Gj+$
z!-V8uTYequpb_k#Lf~TE!Jb!(sI#-1)#DT|%(He;$)8zC)+VF=RFbj&&wrACl*{_x
z8ZZXJ0}T^94Ps_1wyth#K<y1eTAho2zfl?!n2m!<a2rPz&V7)AEh>w1lw>NQXEvXG
z4J^-*XswQez175C^m^37OU!3&N0)Z11%94o->)D;-w^9N!G0H~q0s<DwK58*PQ(?U
zE$YE;{agSd69_=A7$Cs}|LzMwL1n}EN4SxI9?a)wQQjH?N()v{&nG}?@%gHTcBwI%
zdV5ni{ul!SE>6-z<Iu+i=KlD+jo>u3Lv$s(Pn|$|#e6A51*8n<n}eBI2oDz`nIU=#
zh+(x3Scs9{Lc*+zF_IYRNvb^p{|okG*m<18%qCmJau6*%WmDP$zA(Xp+{KlRVfdsf
z_e-Sz29I?5Bp^%%1TkNffq9SVHMJxw@Gi0rh%wVxK(;nPkJB=lj;Fa%1s$E()yJ^2
zIOJycAwiGCa{r6q+uE`zmU}D*MGkVqemI@WScDFQpvi3z-9?b6n{A%4rOsh`Z2|c>
z+GUrZ3n?#4d$X))W1G!cv4NG;^JqeRmpE0Iuo1$XRW#fgYsYG~<7f=COl(kCPZK(q
zM{NbZ5EXM<7eic>`6^cC2Dau0EYsHI)g0_V5Z!U6E++#SXEj4l5!!Ur!WFV5Y7RiX
zuEyEIUZQFj8)_WB(V@l>935$ScJ-05Ib1cCaqU)K5crF;3J?n5PiBP(<u%Rd37<4{
z!3#B*NzmvRl;cs2!8-ARDobDRo*c~6Dg26KW3ZUiEV7dnHR>dqb3wFa3efHtpyim9
z%uS(Wj)zW_kb<ws%D_teyOb!ihKLe^gV;;xDzJ~x|HQF36&R$IF-;8Fa>l@)(FHj*
z06d(ZI^<pEvepZ6+Zj4Qg?tAhgNj@yvp<dORK^;G{?M61)_;N4Z7s+X1eg6QIY@S|
z<RE$Y3k@{7>Qk(J7JVQQqf7F`g&bYkF@6xj-PKDD4MTF3>H=`B>H@p931e371c>q@
zW95ZR*H~T%skc8tOx}CRv3_dd0ix+L<E$=yLDv8X748WoolV6zD<}u#Fg;6KmO;s2
zj<aL?eddU&Kd}V?F`RCV78qg!xXBvMD2^OV96WGo%GpS@Synxr945#xhcUZlQ&qbR
zxuXFT<if5<jDAri7p<Mp_UIW+Qgl1_R#IZJOYE)uHI=AQ+pF2jwlrBmgk(P<z|KOM
zd&#0|FQgMF97KC13Ux%m)*gkSF%)bHg>T??_k1Yq!Q>xBA?^yP{|k&|XzkdMA4V2`
z0$pvGYzCb6i@1_JtJQ<uDiYXnL$H9@4TA)d+YMC|VZk22of9cOX)~SgH>03@@1gLY
zhxZ)k1a6H1;`wGH_UeWuJ|%P^e5`o+(%AdmpK`2vf8ges)X`<5u-Q`5jMLRy^Mh$`
z<NU-9AlOuv=O_prd`2=*(&+SN)AF~1_uH^Cd=-w0-B=%(jd=JM9x(m=4w=OABI(Zj
z;Iu}2Xb@#-6t$<3DS&psAi`|4YDD=aoDfu+P4$N|Y)#uE*5{uIB}lAV!?V=7H9uIo
zSu=NI^Kv!ei=#$h+j#D!ELkes8bBReG7^LdB013|6!<#Nfu(K?y~rLOOE3GOJ9ke7
z59WC`lOObK1~puYDz0=Oz-I?TBnzt01J<6(H*h45Gb7avGcW@eU{95O(j*aQ5s&$@
zA`&zwS;4f;zzh4WWDu?_1#@ucgoALIKtDRUin*B5Tn@#khAQV`!Dez}UU>eKtR_AG
ztrlgl@E4y#DUPnx;4>>GF=$tMt{t)G&@*z+I-4w*ftJUy=>8P+KR%~H(UOdgJ-;Zd
zf?^vd3g1$0z0fOiz(d?9c?5YwQamVBOpf?YN}W^tq8K}fae8}<bAYjwI$b|H|4{!Q
zU>hCkls3Rg?3zuFqAP@^5T9iNUCDjFI<J5qE!Ii2OoQT#sb1OF;Q_OK)Cf)Zn4;mD
z*s~G#G-A^RySXf8$0UTwWeFA(awdQ?vHw7idJU36_V5#=*R?TviBpM`t{h06n%f_i
zfb^OzV7qk!*w`4b)s$#2b?GcHNypo$MuR=GqvXaYR@?!G0e3_-vEkfDMn?3H(wrcR
zh32I6s_&{c=}>7PB(PJ9wg@eSjgn}bO_3zdW!5uXegGA8k>qG}u@d}M0tA_w`vEju
zJ=A&4X|A9}RQLN2G^d<%Y%=awYQb3vZS5C}HZ}3`Xu9Rw$3Jt<*KShCVcjQqe;PR5
zl%^b+1SP%$oz3GUyOo34Se#(vy?7;3?*j^M|2H<dqtC-3gA0rzE--L5h21s?37k!F
za~mB1@UjB{UNH@tN9w<exiVOEYAu*k^Pfyu49gKH*03JImh~oOE?E7A=x}iU;kb@(
zRXvCiA9ws=tx#G+jWY!>WxX}ZJYDrY#gMH1PGlB)s9=EFXP{;JPbK-55@084Itt3P
zT`TQGZ4IITua!!lDZknbZz>1Yq8<41ofVRwH&(dj!lyaXeHXn#$`B)gHIjMKqt_gP
z_T)d+#XHb{s;ge}FQkc#{!_U6^ETdvc%sRvkWj2Y?iTVDkDM;8Rd|dw`&s0UWqb&4
zu%pFik@E+5mctH?y=%7umZ(Od6UC;M6JqEd0HP33MXTTC;Ip53lbhT(-HKpBlO+U}
zH=nPB%X$MP$RX3&e}c7y)Q6x}OEn0Wb4{VV&j{6PkWxBCwLg4E3IG?zf@odnrz9tu
zq=f?URGfp1+#ZUyuvk35N;8UE5H+!@{kb&>u^4R&P~3bk9|of^x>%lOJz`_^F8xW-
z^P%Aix*+u^v>pRZlvNwzdw_!6tPzO*MsyC8a<y5*tTAMM{yr$fJ<8XadUm?M>|Biu
zRt;w6v+qF?Y8A8HC9)~4Pm(;U38}>}yPll^!bexe9O`Gg9&2S{s~A0y%?)$x@vtV*
zxO~tJJoXrt0TFnIh|(yWDhLuz7C|RR=2nGuC&uK{$ck;wYIP4@xSMzae@1X|(pof4
z)7SKe?T{^aV{_GsZi`d&4Lkh%v%{AJZ+xceM6!CmJ=`mJ<3>LB5$~_5Z%OLb48t>D
z{n1Tp(V$2tPO;wlfP_&36&hCDQhO4_CW$&p2u%pQNn-M~TYmuP^=q-^f?cT_(48tD
z{qhJ|Cmr+Ht+h}GI53coJcyt?GRdJbAxGF!NyQY$+U?BMFn7}yPmsc2>Ck)+qV}_)
z(;w)V4I*#t4(}w15T{2X#7za_gEauB9+Ats^FxW4BZ?S6OT>t3j+hqOW*1Bf#lm1D
zFv$_P-I?1A1C2+UpeS95j@od^CK#+{;m6wZ&FM&Pv+t6iN9%4*a&oy6{hDZHy7imW
zry=9;>C6d^u@jsy*$^Ovk&yu5A&92{LaoYRe+JL0*rtTJj@>Z3OG9q+Mzp7ZGuw@J
zEXuH*+ktZFpd5@C7lU2}xsAZ|F=85wVR|>K8AD7PeHR8_xSDd^TwGw395VuyF6$H#
zFekVI6O6GF3V@|3{^MBjB`kjIYl&sxCYNi)u-*a>qs>%9Orq44Audk^ZZ}lV=rz+Q
zcmg+L`mv3h@4aQ5*V}vCY`vD#te#PYUoCt|TrWNI9^B8u3_)AR>kJ{M5L>Z6{4L)m
z^DS=-gu1kU`}<f~+G>R?<b&<u7@VxQ)(*o-vA(8vPCvbN8`AxUYy!h@AAQY~F2cd<
zwQ2Yi{eR<~k=yDEkzqmbGpiERzqj&`4r8G*`~&!vX-w*kg(5bUP#(=)>@tFtMRc=T
zY;_gaIuTp@6VTBBw-!`gtNA9e(JreyWvLt-vMxi7C#BVb3t-ry>gwAx!C(av^<>c~
z5Ptfdn?!W%Qp0yR)D0s;ZjoR(HOa59HcfJ{T+<{c1K4Q_2$lhY83EL*hH45TVyL24
zjGv|nE@oGiHccoHPySU5@MlPSu$V2FFx88mIR%#%StY}e$*<h{@@SnWHfJ5tl~_pn
zmpinIYo!)YB9`RR*Ki(21aLaz8TKTW;~BQ2@--u{Jl%R377vKHtbZ~RTwY`il87jy
z3s|w=pm{HaDSz&yRBXab=U}-7tR#nZ3uK&?a*{*h8hp{VX_9D{c{Ba-q{QD1fUbx_
z`7ro2j~f2#HE++r#MIo0DV3LmN>OIr0>Zr`2DiKcaGxhiCCx^lhrUJ)qEwH*VP8N{
zmAk5y-89Wr_02H7CX5RKj8$HV-=5x?{H^R6%sW2Lra$^8bU^qPBsre&-iTn3Ui)(-
zh5jrH-KE$3Ma7<|ya4a7)oXqw6Ylgq7<xiRm+Cc-$k=k<w9ryS-5Y=}7-Wx?4W6S0
zLY$nu6BK;GS*70Po#gzn_Rrww0;rR2|LFv;o4<>@!}GYef9TgK^cHbCQLp_8V&Q(#
z)1c1?*^QNJXerX0M59?@s1%RD@=ot~{#FjaFDURa-U-}m3-CVlC34~sSXar|a=oSr
z(g109>9twR@(mR0b4*Sjw~C3c_E+d1p?IJIt0#3GY7}^oBfiaT0R%6$^u!A+A&9*N
zo1D-qFgH3!H4mw3Zcx=sXEoP|kzS)d9?!vE<D8=)i)zZ^tEpx+-#d3TePuN@pP+j%
z!%!n*lyi{B^^F`kJP<nD$l3C5ZUNxB_*#}a`;@*~<b$^Vt8?Zfb+!Q|p>Rt9^Z70*
z-KIw+%$%r%DWil5`CxN-j*723F1o8`L|X$H?Q{b_-^m8T1<o(QFGdNDL4&0v%sx!A
z_k%E0VuWr_r9mi}Qj5tvyGt?AIO}ts(?V*aUDP?m!8er-u`-Za$8<@7eW0DnDb=A4
z6j%uUm6&y^%PtTtLRXCJF8Ul-8!E0MJ(84HcJ_Bsvl5lNxnBgdTrF&#-Fjz-=y1rq
zYRaZ!P({kTXDOS~zM|ZO@*xP7iYcsg8zj|DAW{L;Ipqd92N9@N^!X*YESS_FI85wk
z(VR)_Wx2p}LQw~KO!7LYg9P9L>JS%6$G+S=JUboz_dA58i=yQ((D-xF@(Sn;Y8+e)
zDcWf^soSpD<OoE_IoOe>SR7;&wEur{(=XJ1*ZH~W=jgz5P=KlknY=TsMDgdMT-t}#
z5M>b`WM9=djd;0K6qQSs4_h&u4|bhfF1;uO>TT3|;kl942a-Xftb${AVfc0%n2L-7
zK~Ty)hNTYdHq@LOb_UL=*auwhcD}LJhi|cqF>bN}o_Kwyar2BQP5V$WZkDtkHy?cY
ze|+4$j|E)k$IXo9Sne~*px?&$xigGo{pd|0MfBQ3-${0n;T-5S%PS^@8u1WixXgHl
z%Z@SJYHU=H;l$TV&pttU@TC+=uFf-Dyf(8K2Yal<kLH9f2O~nCfI77wSb$AtKcUy|
zL9`%H;wmV)-zc>0E6n{u_us}ebDzEj5-vE^Hg1|;%Y(f9++F%3UqBG)Yo<bWEl&uJ
z|7hH8`lBNOTwha%@1NJ<x`}&5nlqnfeC9VH8%ntwlbpDKD-*aM$b{5r0{3Q^&@Gzq
zrb_4@P2i3NbM%ZR`~?X{Fs}<`ZE-#}J030pPS%fbz=Wo*n1KhQq_rUUFD(;lUiIk+
z^rpqQa+#OfR$>w|RW0v=h8ZH()u-3yvtV#}iZzKxRjZ8Q+6PFuj>Yvyufa>$5901t
zccWXY5yT8=gFM9*f^f3DNnn0vmED2@tMYBHhI_bI;EJqh^sa*31Ny_yi*50RE`E?E
z>j?Q}HE3f!g3(6-#fK=rJS*a2Lc!j+dVna|V~qr2Qg8K@MOQ9uOO`k#wo1~X_P4-2
zd=1S%QTq2d$V2x}^IhP7X%%Q_^QB5H6>On}d$(z<;bd5Q`g#Q>q>i1CqCb|2sUf^1
zzxo^M#6HNk8fO(s<eS)JmitrrCO&O}_!A;|l07sA_0nQ=0&Yf#w&H~~Alg<u#M&z2
z(YC4wSj<JNv9Ci(JRn4;UGt8@fnx3iu4u%{V-~0)XZO|y%<fkoIE^Dpb+`Lw7JLB(
z+ZUPJzDOd9NHS>NybU*lZ;59eFt8qk3}9>c5XEzgh$}ps)q}wEC$FKpJXA*#zXQ7S
zz;J@FrcjOoFIDhb;^0~F@Hi-h;=p!KAiS@DET;^hHbbEXcGIl4-;k*BA&Odxh%40W
z>Or8^x(%SD$5U#9vfH2oWHY{km5QAt*>7>0ZBL+JNX_L;GPN@dFdBHcH-HPU_Y3m|
z_XZG13so`t3OCw9&tV5yMSm-z&GktAxrp{elS7ZSMR{+|{mPf%zR)5OeTUKeMf6z~
zn=Yc$8J#MkTbbd;wkZ92yI)zs45LN#C1%JHQBmxYw$#2N>SEp$5jDVKp>MEcbiXo$
zm>m&O2U9;6(ZkI9L0fctTePt)`jUup427N-Q5S*zzAg2ah!)^_9X3%xy||NY<y5pz
z^ewj$=~7>uI~~SJvbZz~FTl8eA``zN6JoF2L5|GCpf}EXDF2*PdTNBfSy3c92o4iS
zrv`yFM*&$WIO?qD|7!HtF_%!AYm_Bh$5Cb7f~*@B#q<3~;ACQRe!gd$wJqR#apcgc
z2E-=sf2q;s5QLVi*h~>uD7H=BZ@>r%<9y=TN&8qkDI)A0q!5v|hf;=2u!lYoRO^hi
zv2p=2^v`oqnN4v4W9thDK@yA)QED6UO({|jb}K<N#dr7Fn^F(DZ1{=lkLd(Id8-7^
zhbZ_t@!-p%;MpH#jmRzdwfPH{I~$8+SW;PWu<+S(v58g4V0BYX<U<sP6{=b}8>t7o
zm4OpOD%MTsqg@L!Sii(+CTYiqDBv^8YwH1Unqh`u*}LJ7iax7Rt6UyC6_J<{h4XAY
zg3m`0B#~~~-050JvgNShsD8B$5GW|bZvI(s;{p0Q>`S4@ott<l6Zgl>RF`4CX4G!=
zdW-;+HnP1tx}bH-1+96+kcP_+>)%a8Q|upur@0JPwse?OCfLJ$x$jPoI7h^0oAvT%
zSU>n*mG_U*T`QJ3p@hX=lPOZIa%}1%kGxh74*~E8fjc+-d0;}LaCwXO6=d><ZN9K*
zF0h85idI4Ac3)8oy3tI+HyaCJes{41-C=8!oq(G+Zd~gW9<SagFgMLK0!f22MUTU_
z4H-t(2_6t#Bt?NG;z|@8Ru6XT?gqJJc=UFx%S~#*_APF0T@`-T&j!E^KgE8;#?|<-
zR(=X<nD0SSZ{#k%H3sN~99+)JL~i_B4kq?!OXOLBxXctfmV%sQ%=07l^d@}HQy)?H
zP%3_t?_LcJ_=@la@pZ3*LK^xVAmaNXJ;xve57QT?hWWjb<l%S@r!aOAVq8#AUhw|R
zvGGxCY2N51kb8)hY``E5<EIZ2^UOnT|L3sYdQ4&an6w>$A&?~Flky-Qt&x<BE}7bS
z`%A1BD_dxNPmr1pK$p~PAvIl}aBZp%`qhjQwMh^Hz!B@CrdOrn+^O7@Fxe<-{Za6G
zO(z`TSzM(RlpHR!9fXM-*YErb9Ye%}I+@`1xAIntXvh_KDI4-48?t!s>4-b%YVo(;
zy?8Y84f1xu?=&9<pWu~g$Zow1?Lgn~vVbMit^Y<+=y3@<qoO;?RO+>FAv1ura!26N
z7CZ=+ECT)Fq0L88^?Wb#Sa%bY2cY6J<+o+>GE*)y(OfP*ld~<;0%l5Mrjv-pXNm~%
zBN{WGnGSKAd{>7|@3m#(xUse|)ANYs@jehFK|vPoc)|H4q{1O<Jm2yh&s~juSxu|F
zY~3ahQ!)u~6#9G_B2pNafX3n5+|?G>Z64^q?2|mR-d+7M7kKXK7VT?YbJw?acUN!a
z!p~j3Mca*&j#thBv=@NNW|C)EnRPGFDm3>Q!6!ux1?Dj#I|ieMH)gmL4@0T+%YKY8
z#9hEQjv;2ZMB#1}BdQK(5}{TuPr*#*AN>@o*;WWVPYDgdO!*}atA+6L@J=DOOdrPX
z7*6@3VqqJ3@wcoh$f_joy}`sF65%bw-(o{KCww=^ci5(drwzOdEOTc1n-XNQH3lit
z^1{Ox`1neK_#isIi{!lq*1t~8>rfEhBJ?YfUp{-V{yC1rfpC=bcksQ=_nmHdk#!id
zkL@jrHoTb4g+x&HF47-64coS=E&Q@*&T^GgEtN>6d`z@-o^}%VeJB9`0sO=*#ZF=*
zFNIil3Z&FhOLWLtO{l}bN_Y)_4T4nCD<hub|KK@<=mC<~YK%Q@BpX>j!E@-fgw8XI
zx>m6c^BBp@5hv*pwaQgfUY&SB#@PpjE{<__v6tqu+9|A7GRIQl(iMp@#u?V0al$wN
zY0o%cBc*d4Z9RpV0pDS9Z{$cv$7cHL63CmO*&No87dgVr+<U3QMlf0<;YSJQw1RkS
z&uPE!Gy=+{Kec!(QxT32QNlrTAg&14q8=14!Lr$@m}yoFqm8>sMCW%!;4na2KL9aE
zH$FrWXjOHJi4Y=BVDoJRK0Vf1l6zp3^}~&d>HywJS;S)bC`QRQQ}XjL&D)Nj_kI=E
zEt%G_*yG0KsK(mF=S~eaD_s$S`rAxnRFY8WyvbIV_aRU5aUdkeEvu>fmO;xDE0dq_
zI1{y0v1Mv}t`Kq6iBG5pyIV{sMxdwtV~4gLslr+hW*pYfiK&1VBs4!R631IF!;D3~
zy#jAHY)60dvCOi)EF1W|s6pzQtRu!hb?O1%z{Vk*Sntbv)q-DK+7k6%AX*_#>V$R<
zc_x>eRRV<cVi3E8gmr*u%kf5hwLaoYuK&#byqynP#Mi}Nms0;(ig-HArzE(Z5>It}
zN~r%V0j}u!R)2=vE*Q+z9uqUK?rAu>DbVj&Ls##m0ybTbeg9ZPg177T{bs-CZJX-%
zCz$=#LQZI#M26Y5J5cj})LgSe*1A9CSc5LB+@Ex;AyL-1KY^eC#f$1~X1`6sK@%#Q
zm=?G(Eo+PKnu6d&obPSLN5|+C8N@BPo}RC+O$jXd+VJmB3S0#jW+}PH2h{nuz=NVc
zl$4*lWx-y8NE)nZhbxDpDTz2*c98O|(0=hN%($A*eqUECpN{66Zx;kB(hEvv!$8sF
zOezQtdn7+N70W1`QRe$MCk09$NrICYdMguj%4%?%{rs)nE61$Ep|6%z?}js~ofef2
z?eGoxz(HJHF3df&FnN5y`(O5*2ZP21JNI=vnBVPic$w&azU)OKVbpLSWqe@Df7#6@
z|Dhh<o80S$0;oHy-aN5$U-cUVX*PSztvju5xI$&IiEahrn?*@^fvI2PrF-Xox7lo-
zaPMr%>(-EO))jVZ4);-|cjUu~7K-I}Yc9a(0By*p({R>_`r*cACf!$+(tQ=a7fsJq
zIb8L@#<ExVA_LyY@I6F-tE-}iC+NcY)c5hlsybLArRy86rPDFU>-U(;FnbA8HOU$9
zE4CB8i(@upRlxg5x^*)(Co9Qp$a=5#ef{PJe@h0u$J`$0PyvfVEFZTAevl@3YwY|q
z{qY+q{DR+4_aA`sQjEZf=$+DsQwp)&mF@|69!_zCpWFdYO^P6i`}kor5DWm%AbL#|
z=!hu;j$9<c+;X=K4NUR`5(@RdH5J;L(S)Qzvmw8Jzrzzqcl%o+g;|>lvtBDS-_5TN
zIo$q_Z5}fnu6Dq1yB0RN{mWiR$3{9h<%P8T+{T3in3AUXdJ{!7kZH+q>*+n@hN*a(
zVQz!+YjIz)wyyl4K$4RKfLvxC-U$3O!770shV2Bd!zLN#TSomMN5Jm?7#H5R@w5Ss
zkn0aR{GZuO82S*44;MBYCA(1VlM0b1(+YAAFCrpOo*fa)vq|XIlsFmM&d4#H#zJuB
z_!lez{L7){T^YD7sd_JmR{j38wf6(ntmfLfiuC%Hv}7_R_Dx_Fh~bt7j=Do~6eg@v
zu$3SC0qudCNByU}R$_$XGkr--++|PY;d}`^@uckuUn)$F&3AY13+4$Qj^k<_sLy(B
z*Xf8^oMO&NZE{IpOzH*{n72b!=N#n*y)c*@==tVba&O}<EYxA-?Fp15!6DUPEYJAu
z!&G-QtVAP~9<wCLUH?TIwcc*9KC+9K@Opsx1h`M;4lO)V9J1bodW(cXPzzGm5oZkB
zw|9PKe%S+lhs?rsvwr7(h>_HASL8@Br=~NbId!1_q;0_a{!IzyU1{OV2rZS+ssK%9
zNN>tZ1MB0en?rbICnEhP27l+Ef2ch3^7Ug_7vxa?aK`Yfpz*umDx+jmz+0O}KzpI*
z)_;-=Lr@d5wZ*{>^NVx2sk`kZ0Mz`aFRJLh7T`1(uG#8>Md`UmD*ng($Ql9JCr5#p
z73ts-6CxaIy=g&#is)+!wG~KesM+f6XV9b>f<Yv9=TpsA-$4UkZ^zzYU&(_VMm~V$
zoBs}sPs^Q{wj5`JyC4cYfq7|pkVt70g44!mWA93J>CcESs3!VStfw)ajGzIbeQI)W
z%G&gT-0chdV5~K9Zo=%{fN`>8@s|a`yV46w4onV~K9^nyS5SC3c5~4C0=}a7<-%L@
z&DY(5tbBic5>C6u;&89Pd{>M~^FSD=9tm7!*p7PwwgUZcn{Nz`?g}Y~0g7Y9Lk{yQ
zBe(!{ys`Kl^Pwc16($wtzPb4CaLRbmc>l7s7>0fGF>7Jd%Zszn{Yh^BwVL-!vzY$6
z;)mdE=26LyZ(!J&#p&R4b~_|v)Po45;@4_uz6pgKn!B7`XlK6)g;a?qc_%RRI!a5U
zw%WQS_&@{JKVk5>TZ}N}$zukJdCWO>PhbLkf8Lg!U$UhjI4zKl^HYq_LZnR#;=xE4
zvdI(Z?g{iS%-Wux^(6@lOK=FUH<eKGnB4?fa!)PB;M$sR?#R#GxoAY-S|jVY$c?>6
zCBAZ*5pNgo%|E{5reNBI2GoiCV8M@){7b%u0Oh3a=7fRJpR0L~dQ4Xwy=Xp82MzEj
zJ23^;VHMrc7uK9+Yz_3pfo~wK$uRpF=IADpSco6Ay_AkBXVNWPDc!<(ovnb932^`h
z3(QAL7oo-Piune{vVqh`;8A3oVZ%PfYes$8VIl$YI(KvBr{v$;-0;Sbx@?>qY?<P3
zgv+2qRvHE*F1i}Qa(jM>2LeBsR*O9~Egys0ZiRpzH$RZ^I*gM-%y1=}-R88KbPNkI
zK@^xRMnK*>5?7AwoQg3i^9YC*@X-lU;*1g347bbP0ditZt6lLLwkuH`e8T}gwkhE6
z8JL#m2j;m990WTyJcuE|`hUbBV{V316Bqn{@{dfu`Pe2KHF|E=GS^J-2AZRuObmPA
zy#18-3SoH$?t2}1g}1arRu1wCJ2MFmz`}n=bD}d$`!SvldsGk|zCq2M^{0|??HALw
zGtIV}Vi#_rKn^^o=5DU&2Flv%K=b1~QhfoUOk6l|rDJpr6w`cD5*2z5bK&w7qYTsW
zuLtJCtQpK)z>6l!9>ZMzS%!C_TZrYntS<#KhZ76TI!yi^^Gm2oo^Fk1c0teu?UD-C
zLBX)O?<{`bEK4FXP?g~jB+m->4s?gBO3c2|9EUL5yUlqJwxC)>cv6&}V$!3n$EDV@
z_}YxxJ|lF9W;9L8RAIIXb5!VJC@;rCy5g!Q?6)xjAj=^nC%Aa@@EJP+hU7^1S+6jE
zID^iI&7`5$O>c0Mb=*+;<OxF%qY2-*ygi~xyTeGNIEwEn7!LymDih9~vBi!((NzSC
zzb22foS_kSm6)G4e3ofge=)4e8NL`!zwHs{t~%^nqR1Rdv~UVzh(Mhyg03h(#938t
z!}YFE1-Gm)&Umy<7~y|JGmB1Z1D);5iax}H(bu?a<FdV<)<EgYz7RSUYov=00(0vd
z@?bA>rM~h`yz;l^>W|-w2%PE*UJ@jepDuR$BPo^LF;{58(mBoHo_N+Py9U#K9Gp@F
zZ{zTvFVx(}1X!UIUs(Z1bh#Cc`R0~zB7QJ}pi35J?awo}dob^N`BPSyyLsW|a#PJ+
zRUXOqW#nV{x?x~am}`0ah=;12Z0~_^7n#f7Is&#WXhcEK4Iv|mqHl29^0Qh!7%$$u
ztSt=7v00+m+K^F*0Do(?&p{MbR}=&dl#Zh7f)bzYZSe$)-ty2%u+)a#{*x*CqhG|)
zt03zTUYB`nO$fYhbE|+ITw?QE+1_Pt+X)X;lyrZ@Rx!$LZcD_Z3WYiy)bRu-VRNlD
zr80#iv>ga{_eboN$)KNYNA6p`4?T$}=MLUzgN-Hz=gE}HG(qcOb7ZSUJ>h|I57-7u
zx1&eU18GI!1oK3+WstUD7U{7_-{7)^u`P(a0)lK;u)NtH>83y8fmHnVTYu{;uP*lj
z{H=L<Ee{(o;M2Qp>2_GJIYi0_BwObPC&t(kY(3F7Zm74*xZ%F;;l6TF5$>&Ts8iAY
z?)4}N(LWK}sj}C=eG?NDGLQZlFWE^KpRFD2p-+P4Zz<Fw=$cxTLHPoF4uafV7@QE}
z2*93zPQ9{X1emZgD>!ara9KGFV`a^dYq6Z95i=%}Ti+?n+MUmS>ftt9t0NhcHLaqH
zdo4qc*>rqQUhNK#p4SxaRiK8p!UhD^^xDsXM7J+-PX^!oLI0E^i8_<Nb+TUbu#8mp
z@VDmcwPGaq^|#LT_VTyR*E5jwr^pb#XZ`a$&<HBI0U7pVVd&<4$neV{Yg@mjLyj_$
z!v|eMHqHhK^g96K@+3|eg{}ft>t9&k9{eZ?{-Ri!)^=t1d7WreqjDz{LZTXFE}l44
zp(>0vkM1F}lP}kDpF*Dut}#PL41GvF?!neLS0mBi+O6WUpm7}g8C)5?F@2j`Gj}l0
zwj+9RTt0x&^~b4s1ENdQYZjtb5v_QLLBGnu26PG+R_qco!EGkESY06(imb;Dh&B|X
zD|d?1RXKkxKjAPGh~Yv<yP~^T6r<Ob)c_9+tIh!J2$or_dH=FZj0e~8-OLrM{O*pG
zZ$frl087WJXG<dTgThauZvJ5bzVc5P4Q7LXukO7B+EpB&JCXz{u~zt7FzkBcDCaub
z9_cIV06++4UR@HCqWma|l+#Qk@wM={&SdH@%Z7F8f3U5ZseE+D*r6Q@719M*7$4Cy
zpn};s!`5JDklwryT_UzKu}i{-Qjv}m^F7uKro)5>(eEJ|`ZLPcw<d`Rh8DfUVr_rc
zhLvv#_yBz2fbIqrW;>4iY?YtIh*A9)#o9%Q-=Z3e#4=)_a}1aba+zLzQqxv1(;u~<
zv@!m~vPDsrk3<edSswB*68ZzEj75A=A~>5M#BE>nm>I;2<Gat;XLon#GqjJJEO(-W
zzcoXD`~=`UYxnk0Jn#cNV!I$a)^b6N_~uWKHovy6^7B}uaJnW~$a{Z>=3y6No!Eug
zUc0qovj0Rz#aRD|tM$kKfQnG(Y6SfApBP=yGuE|biQ&uqA;)^QdgtCtn^k+mz1E79
zmP=*9+4}8uI6{{X`Y#*AMi#b1YwCOzonbMfGnp>yM5cJnD)b;UcFszktQO$C0*#~J
zmdDsgNRCW><=+uqiw^<fd^*y*vMchI`|J8(KzcDHmvKH`&$m!Ea<?q+lH2Om3+s%M
z!|tkOW3+5vvVXrV{E7JvtH^4$Vfeap-|^@-pM=hm&gproKzJ=6Q1n$~h#04AOg!FX
zC`t3Ndxq_|+@?yLv9+>TZc{}Da~LIGGSe852`UK}QLW4NF$=MT?qa9h@YkoT&t3UR
zj=AOd{_Q90Ph@0m6B?iYq^&~kCfe$-8pv&^JkGK8EN-`8abnJiu9MO3ZWTYkW^Ffa
z)@HkdH)A;BLMoO6J+V9#$ELfm(<XfK>l+F+e<+(966<;TNi$CX-GSMmAonX@3n240
zD{TLHQzTg08(WUR)39y!j0L@yrG*Pc0{j3acXMxqk%t!E2jGR~!8~)H2ivIF5<O!T
z51<O_k9oOYSALLZeo@Hnjz$XN<L?P^FDR=U4Zt{C_-XY(N|jPx<rtt>4sW}&{jk8w
zH=DTDB$7Es$@tiMli~{dwvBen*8r_Q_?YtrwlVmmJQKuhyIQn)kM)Lt(kPT<LM?~2
zAQp~sh~$G8*hMsdcpjz9CQnuq@W{@?9%fgMtq$yEhl0d`3L_C#<jy+mwryE|HKJMD
z+(Cnmj}1I<0Z;@Hp;ezqz)EHLjq4H-c(UrVwqXcY;y{KkxfVl(Md6{c7$mYP=07p2
zvfsK-u*gQ4cA1UfFuNx>tiRj#Rqkf9L7%+Kle^!o-@FTe9JM<tdSvZ#XYI;r<|Epc
ztyPQx%|PDI*l5~QqtS5GsMz3s@D@3y7^nWsuo6@u+Z5LxsIYT+EK;-3lju6YvuhQ7
z01xwtm>H%Dcujf8-P^<LBK4$9MRr^tWp;<E{^Mx%Cl%mS7=vN~jc@2cl`VBHYmz&i
zv^bY+x*c90V1Pp@Fczbzq8FqlE;SzTriV(pQq<x;fLV*TNYiWoh)qjF$T;q78nsHY
z)viXmlB>`e4p&~MY0r1jANeJc{mZeP+}*z%w~bfwMy60@)ueV6&;@pF*h~O6kp7P!
zM1>uu)zIT8jCZxXIzwb?D5g4Of)Q+-cqfk4*!$F>BJ%n|Kssm;Qad&u3^wblKPJxA
zm}ypbS$si#C~du%5VmcgFgLej-}OlDJ9@1hAPiBM^PZ9Wq;oYe&}({N|4g(xS?uV_
zsV{Eo0M9K$MlJLPPvXu%z2D<y44=v0qGKiY5Zh@Opl(^B{&)qzQOJ&!LR=5_Lt9br
zDu4s3TIeojkmv~fh7-S@q=%ZX6q0Nvm?(X$<OBV&9JHiEogq7bbw~rX!Geb7?F;#4
z)IKKWe7)wg9*|(Yfmu<MKWcU&iA*&nHf>{K2I{;qUPhIDHSp!|sQa9bU+~rD^w`WD
zo`*t@i5y6yTY!#*0-_L{zc`NQ)3(gkGpP&95}1LvVg{~nKlxtd$)!{c?nBST6KojJ
z6oSK(Wns)N3tfZ+$~p>C#j_fA@&)qPRx8DE0p7lhw`u_H{UrL90yYIwj75h&Ch`QP
zrn!esai-PpO}1@=C>c<{7dt%%xsho*!b1<Ye_tfO+paKQ7-qeJgQ6@LE^gyHoFExI
zXhWT#2VhgGFj~OhyU}EO&mS+9CVTqBl$}f|LyDl9UD6KywG5+yC$wD9t!AiLn&Y|I
zi?cU;Jxcfm=+N8kSnba+N{FZ25lmaGuk|5SAG*Tc^9Y`V31KfNrpX`3caWQSm;60}
z89NPqv_;|=zJ>W-h|32iu?w7iSF_NiXDT$1Z!+!^6(c(<UJ^q?@jtx3xU2VZn7gaL
z(X<vA#qn0-hmr&z!p9N@M@(;x=g6ZUvq$d`fQw~zAS)vZc$=mii9EAxQFe5UQ%GRC
z(rezsB|cD#Dse}Z`3;OzjJ8<Sp^K0Z6$W|@P=?hRFkan7e{?q<*w%k85o84+7fitN
zZx|=0Iw4n~TbgxT5!L}mLFhIDVno@KTTm2XJF1gYu_D2-+kQuN10}a7YkwQdk<V~_
zwQY=kj7zL%qX>FCISF+<bh~frx%j66a|`7n8mom~#6x@qRp+Qck(}ZR0+`d5UTfkv
zN-|&NVA0FDn|;0`f;2}2HR7d%WT>=gH?>V<UM?$oPAgZV=+Upch*<KiNLh4whxUX{
z<1O=#i{<|iDQe>V17wn#t$!t=LOpl_Q6)!e5e+SZsSU-*^fuU3_)3LhX+TX7E5+}(
z!Md3MkS<n=<3+kqAg*D$TqzDi)RXu-XBDX8F=dDzUPdKE&Gb-eX@&b3a`0kvUeKEc
z%iy@R%0q>|n_`OG-{8jwIt>_@f{s0=c$w1>qHB@D^F#FKbnzC_8%gZnVus;)R2x|~
zCQ9SD>1TT}`NYH|RX=Pk5~Mhb94e)2bv+LwbGPf0w_{~XbziA3htXInnMS&e)uWi0
z5<RxVSrV~WD?*UlWaV^tY^b<^ALNn>&{3!yB0bDEOZwu?ap9dBv(Y<v2k0K?q{Ij{
zI9LPnRrYcp|Hy-B*&%lUz>g003-H=w74L!C0QK5z@Ys$(&SS?*^!@~iEc0T|G6!$^
z#L8SDIuPg?WNlSoGyvgjBy$~W6^je?!Y8{#<W=oRL0&L6wtH5-iriQxP1WE|30pF#
z4#y+4JM`L*&^=%U7q^MUf{5Q(bMZI}Zt9!D7fjGMOc`TCseG)CvKsW-l_=m2&c~)Q
zRw|lrB*QeDFH3xf48^dFKv`gHV2en)6!L%y4v$`NI7HjmZ(;rtx&b7O$9(cfI1S1@
z?W=ANRc!6&u;tJ$ywN)J;J=Y#lx#->r(6(gp-Z*!YrMp|5L{hKL~`6{2$d7A-q_e2
z(O6c5p862y*QKyUDcKnVhVy9_VcUNLP^#TSRJ#XBD;6Amve}+ouhWp~0;+OhiF-I)
z*`dLQtZmQ;(BJ~|r0A$a);%9$e2xW?e2=sP=N9TF)bFvX)={!nxBhfvp1$Uo+kem&
z&JZ*b)uY8>oa&)Xi19d<I4S<fM5Qs-x(E;Gx9OVqLU6ABcn|bTyA6SpXeoJr5^@zo
zp6<sp1Y2yfBUg6Rx%#8i#6*H=Wg4e%sc(h;Dq&T)B&?dJI|1u8P^6>MH@CywiftOm
z0*Z&)9hFzDLld;D?Of{h5k0W8Md_M8M|i|KOxcmF?P5mUxwp2#mm0qCm~4&BOLc;c
zybpOo{qUnI64M4W>%*0L%^)mgG43vEFB4Pcn9*zgibYj)zVTiNDkQsM=8h>bMll&N
zP*tXeFG`|{XMr%8KGQH0VzkBkIhr>W&pjsr0;;R$O+RFfJMP2b4+M`Fi4;I(49|4P
zBp6Q~a)kOqZne!QVloNe)-hpx$Apm`6EI@htvkN8)kzi;Gt^ql*lM<W4pF9y8EUmi
z7c<mPnJ#CjA0is!x1o6S9+>>KIXOvnA{;Io{)0)@9A@^ncR%F+q8v60z$hIO4Ygw8
z;zz(RWkbiA4zV^9rU`xA@*9+}yoppo2G0z4MGF6zp{<X7->25&YSQ#8&@XXoGJx`B
ztV=-w_Ez?Wf8xY|HW7D&M<F9aKf)&XI_xN`*DtHrH>lSO@LF*VAhln03?W2UQv!Kc
zFtDs)<MXnHuRoAATnP}cQ{<=Nr#MS##50`;%zvM+H?tXLWBtLj>dzuwHC%#bJEp6}
z0`4tvS&qvJG^DEkSS}j2R3GGZ1~AVw)QssEy)!4#>nsiajI*l$q@!X$aAhAvf#39<
z``7itR!Y{FJ6pOng!Od?F|%iV$x6(IoqNsZsCG%qEc}<Nl<E*_w6)a;QN`-mQo~fH
zfshl)mp&lIi3*EVIOI)?ot_tqcR0uJ=)(?!hFrI8S=9T8TOaZ!qYou`VaFi=Pa$CV
zTk5xXNPbBphL1czKrW!Us8=+XXl)7*nZlTP_;_<74vWDROdH5Fa7-`kOXCSC>~zY(
z@-&YPh8UdPi;ygJn0}rteEn1?2VlQqq!%$eMsRvJ{m~%yCKyewNcERG)01A|J2+M(
zp2(V`LIYeGd5J$F^WsX7H6543vT=SA%@)2g79*Ns0z_`?3ynbc*ikv{quvfrh`t02
zJM<ki0uv18E`El(a&VX}GFY!L^b%?iQn-hqg}W;AAoA7s-xF--Kh;Zr)CnHo&dNZ9
zpepoIkfWjuo00w&Jw|4Hq8pp^{CEmC=KJFnmfUY(4chbGc`S!D`t-l!E8*UZ^~j=O
zZ(ir=amf+%a?)3^(+MArCZLs1M?ty#n=TIo!`~C2^I%?ie783rh841g%`6^0r9wY@
z@V)MnNpLTBxlm<b39RY?Lm;E5r_r|kq;H>;5FYcmxf_(6qIoBvW<bDi&zno7vcG5u
z%s?*3YXb^YKi>WcR&bS*{4->b0MH1~+6X5LNKp_&co>HU6!-MXoT<)&0RD5;j`bAg
zQrHjU`XNRm()@d|ir<d8Wip4ujWO7UnMwm%+;l@HWs+=+I2Zv}*Xxfi!qNg6F31r0
z-oA|^LVt7;QbTjl6F@u%TTwqp_XdmLagC>9J@3DtW$sQDhhnM*4n{FwOEkgI_4_kw
zcIY*$P?fv7^(sKnR|fE4Y?ya%zQ6R5eV7+`*k+ici6Q~CowGp#1V%gE!4(>qy8c8G
zu8gYgs23+vZ;Q;)zBu8tKuTFA4qU^Q<O13LH0Nx6%J$j%RP5q>52snZC6=gGbl0$E
zEas3rjT<~j@i%0<SM<*hK46nM6cj<q3w$^#Le^$bYMcJ(9UzjV*;Cl6;2y`yY&6wx
z!BlKYS5C<n{6!S74<3gw+*fAyBC`P(CpC%4jJEKEtpV%GIv}ze&^IYW>athl!PaE6
zLIeZi1H9c0Ag?WYG4w&STN+d^I7vjOU}m!!CS6@|r2Y+Mo|qSa%*7cJ8QE;shNe$L
z&1^QHazjhc+s=-=iS3EiZ{WxwPf`O&yiUHHIXB8gl$&_h^H!t)-0N)P;^goU?7<o^
zk*!)D$@U&~o2NrnkcAQm@KkLK%|jOh0Z0W5gHmk8u2>3q5W~In#~(yYisDq!Dhj1~
zD+3?sOv1P-iXntn+`S$2Lrd7AI}neyDp=IMGeM3WK(ImoWxd+lKy!U#L!V;WgQ@q5
zTnth`=$VYhe0$VjjG{2ai~jIfWDH%5AO9(vZ|>|T;G6|SS_0D4NqWk>^^1k?X#IzN
zRG`-`$M3T?J;SB>9HBBikU|Byt+Su-_4EW6+ZyvCP;sm<#>Hk3F4wyUPoQ0uD`E?|
zkl!B$Yk4!sT7z$y!!Edehw9!tUPa%4eeQl2qyTxzN_QY0Whang#ng7}L^7xjue~1q
z5c&us9}54#n3xa}z&kQ|6sPoMnCgAq*7De7D5gASwBe&q&J-~ZQ0%|Ai|QCe4Dt@t
zDx3)LLB)&FZv(Msl|loAl&sB|aR!PN<iIREBTunbF$Dqa(8uCkF%><Cwa=~R-cjHR
zOqlV(&hK;UL3)Bi4Vl>D<nxof4hu{&!#uITd5B2$q9D|o7+&KQUYV$+NUKOg)*=Ov
zZj1#$xG;6{E?2s(A{A0nOwctuyrZJ=j{4k%$DuTF(+|r3W}6=^p>|RXmZio6i*GNH
z{M=d%9}_^h$ZW9f2cjvq&2sTB5Pd`<ii4OmG%;GFEQ%A*!NhW>Q1MmM7QMk$#F9x=
zN8*=-0^C2*PO5X*d8`ujbhKrOQFUdslb8)W|M(AqG8>-g?aCn8x2*R4@;q5GnKC<y
z*OVw3v9G7l`5Ybs!0A|E4iEP^!+=3iyZiXt5JY?_l%dd2Fq6Bn>qv@NGJV^d-gtwo
z0(ZTpCq@@YIS|_#MbT{y!52m7birm+Qyq-S^_O=d&K^ngVa?0{@gvV39Uade9pdcq
z#P3f>q6bGTbwV}IE^IWXWx$qd8b1sSf2*n*0LNTT9d1f|pX^1S00{>KCIay_d*l>7
z(gY7TZl2Y0brGfG>vTY8Zt|DgArcOwm2LF=xyTRe;E#yW8agT@OTx=EPPKiLAo?a8
zgRr*w#&MAjRE}~-f}>|(u3nP@?n6xuf5S+0>}1f6BR)6}R(7C~AX(@+%vsb&ucrZG
zJ-QbU!rtjc#06}<_D_fkxWZCR)WnW}nux8AFq#&=xZ`WI8*Nvw{T0~P>Ef?QvsG}p
znyytyV>7ntCm6xBkp)03Tg9OMEu5}^gL*)N82}7&Y~DU7m6I#P0ULvg2kL83#fn4&
zU($(d4V{Ydynmu3M~oJ}{*8GWjJRRl-`4b6WENm>!mno5xVKM=w~A&g2>a<Az2+m(
zqHPqZZoLsbC>lYsQndLlZ_C4e7HsGg{fxJQMMGP^Q9g9!iGDQK>Ftu6Q`$qoVeRME
zUiHo{ycCh~a6lvk3%=PW7;H8erfs5ji-XY~2zWC30#G;id$LaE?ySgegRV+G0@!Fn
z_@8a0YokWE4>_5goDv(JVyvjbZ$t^u){7s&MG1QGGW6nA=*59HUwSx8&2K*V3~1!+
zHZqL)Z8QA6MaJcN_lkaqgfA9jHL5Cvd$q4NHf)~ds0L%eTNR84IJI~Okc}MNCrt77
zjM2T48G*VG77OqYPQe@+PQ;Hw|1KngL7-<e3I=g`OxRlR;N1(!jU~Ea4xxu6|EuM3
zn<kK8=^&}LfrcvVo`o3rSid9v+lw(I3cIfmuiCctQ0PVM&MUru2U7zo6~kLzFb>^|
zRkHZL5OxyfHK31q7ZV>w#)+I*`G|Fim5UR9K*5~}07%umT^kdJ8!)%Twq#263GP4m
z28itXn$&(PQgO|xfj3*e480C6_n-J?S%0Gh7OH7Z-rDjvKzVsbUwItO(%1A`f$N`!
zt*XMNd9xZ_wh?$r(ARv=wxTEj6JkFD7NfX_f-5t2_X=EusIx(XI_Pe+&GLu1N19T*
zbxCh`quVwdxe|`Q%cO8OCJbc)#8%2WOq`lq+|BeyN-DdCxTZAg-GCKLGGR~OTJa@p
zbWYZv%s74m>x4Qeakf0HK?;L+*kJOhKYjxWgkAdIwr9NqQ&L-`V{R=Uu-rf>uXbzY
zZa1ul)}l(yqZ`e6=8l_#seK{IQ;3un;>f@a8f0A9sAaRoXq3RSHnQXj^W^azpuQcm
zK|^B#xTL{m<Zko*&+&JRpeKiOzL?d{MC|arwEbn5#3<wI3Ag3m6j4dA9G17O`kL;z
zjU>CL8Lm#49Y$l$;4LtWnPRsAC1Gw3|M>p{FsM|IRoY0z4_Vz0kQsJ^TVc_^Y5je(
zXU{fUkMFNPnP9fow`OED1jmzrB;LC2q`Vl(F#9evcZb$u%MAB(@$mz_=8u9zYr0}*
zxH-S1!K1HPvHEp5TGZEU#Tu+H+$kdiZ1PL$4O^>$%Y&&+3D6s*KfFzaB|Gv4J-qr2
zw}$d{9y7sz!d5X&UxOLG<jtyegoH0#hx_Skym|u7(+f%(-BoL4`ha*yD8Ch*mmp-8
z|Fau#3Bq09(uG$bt}4jg>U-trCefWo#Wxo)u^mM>qyjhWLU24p-~a&oT<`$&k#!mH
z16gs6&-bZ#C%@PbP8JYAGdmo=gPSyeq_Seb^9j`vZh=+k2+>;onL4z^Uzdogm}1u!
z;cKFA!u<!1cC`)JXwya)eyoANhMT`gWo4>s#q~z;Zd-_Z)Dl*u!)zT~2cY$>UHq17
zMHjQx-*SV$u4)C$wS#vjgcr%WDzlMKJIs8ke#^mpgX^$w$6_LLTe$?3OAKGn{MtZd
z=;OESBEJT8g2h$-cICkh(RwkB-koG*9ktkfxR8{)39fHMv#yUdYYv;0_Y`h5(wh@^
zRiloOs%{wWySB|6lK;flz8->v?wm54*C7at%LBIIK3r}glfP}<1vpsTJxOYU=D733
z3sQledB1gN>n~-U?1GKYgR<6_$ctCw`D!;3#496k-2fyA*w!AIBZWDxiWS!0Lg5$W
zs{_BmtI@GnIehgC`DzDWjg7r3<Esk15*{9`nam_{t7pdN@j8mYDkMk*?v|h)We#lb
zE9@<T8WjUIK!VETtcnSRI}}1gqC$X}OK1hwigHeyk|{x%OnHN54!8HK09lq(UKBAW
zqiEE(2X&9YbwhvSfPbfnSiN-z36CZB!E=gU!?~ZeI3xh9m{^^t7`ULQrK4iu&DRuJ
zhyQ7{<J=|aL;&Bpr~t=E^ks{T7~moa_%}hQ!?=-suF9WT3MeHz;qXKf7cQPo{t~z2
zZU`jb3Ot^*yYwfUT>6@bzr|sm^lwW5iSkaK8|F_p;JX%-Z<hWGS`|W5kiB)~Fp2Wn
zX)zT-5H-}kg7DmxTvDmTomG{Gy#80`bi9&e^`;A+uVxx?e!g}iZDbuTz|;iMN#aIS
z^1aVEAakImJ%l9xp@f3q=x;cch;3eZ=8_+nHaw+j>~Oud94m8(<E1utRb;p~-8z64
z7U~;-tTz6br`(pL*Gxs0^>doRt_#_rI5IY%OhD|VhWkl6tiZFs=a)}AG+XE>@~ofF
z+&Ci=xi1vCy{Z15Zy`rYXghN(VU7}&qZPaMybbN|`5bcCLw{qA70fY1<#;=mBY+%^
zP>?x(${e?<952Wm-TXc0B1b}a{`zP5dcJ!7)7a}9@j5Ad^ZGyW^&Itjk$l}<wr4G#
z=rt$MvmY|A{~L3HmZ0x-2YwwLs{dSdTKQ`oj0W;z84PG~5R0BJto_udK+OZFK=L~%
z^=y)N*t3b=%mVY{^_g)He-(o`BL;CNN>L9C;N}i(UCiWPGnc>tT1w4xSkDHMs})ou
z_>?d&Mb}9Duk~R;fL;UnKR3*ej{e@#fMRGiN@0Jy4_!TBHc%qxV`L^z7g;lZh5dfk
z5!#l>#$M3+lml1up>486Gu~Jq{R{&DU7ym35AHE*;DS@g1os$vjSJ7wi~^4~Nq&4g
zG>qD<`pQxO#@@GHvj$~xMe{-<_<{fw#mRbcF)+<z{c&%~Sog2+hC+%D6bLXrsBxC7
z2ZxYr>LHU4Y@uONl+=h1ODSnm<J43x;pINtnzDjmg(Ovl@PPHEDuo9ZA6QDPaj7en
z)K|Tn#P)Y5B}A+pzE9wl6<#Fq<wF#aRU)pW?P~R4w`RZ=GE{^GG&s!vD~D$N?5CI>
zai3O_{ae&Dpu}Ny{bW7#nKnAH57++^klsYok0s9lAW-^elF}V|eT`QlXID4~Vy3GH
zK}?5w_)f$ueXP^O3=d_`$oge3MXMK6QM7uy<-z4w9xN7-9L#TBfJSz*@V{X+NdXLJ
z$(=01TApVuKfpZ3TKEv{zqN`e0>wJ@V7IDP3IR5oBQcw);9X)G9fU`JPqCSZT+tLc
zEWczgnDy%$<K#i$7f}gw%af-&<UawF!k$hx{dHu137t=-8Udh|`zJzIsu@IiB}RP0
zsz~Hmat>bFyf+bP4w@*65F0<k5)*=Xz!_fs6|chm&+uZZAlr3ctU`?!!M&Vh-oTSi
z&Q<Vflr}gMm3Rk+dqYg>wd=*z<_|(IVF+;l+Pdh+5HZ!Sa<+?GBF8*_wmGsfg2Olc
z#DVLfgI{I<10Rbf0EfAk*2*omX6Rcv1zG#tyy<?-sQ(7HQ{S=r{)i&%fOp`?_gNoI
zU0?*~fw#v<+6VAHf<;)^hb_}-)M?<ygPvh<6TK9R{s1>f0$9vrcFx(PzK?aZgG17(
zhPjV^nNT`86L`TwHR2ucQf9Av@kK2UI>R4Mi8LE<4oi26a3&z`9%G$^BGw+Z9VwgG
zZSv2iC1|A&l+2!6I%~unt#t1ES&ngz(&5+7XLO-9&Nu)5`423f??9dz-nkFVzrMRx
z_P|1!r*zi*`@D0s!6Sw&?5+(SvQWF{z6G;pcxNq`^`Lf7>8ynd8LA|ipxra;LEns0
z?Vg!)7tNhHOS@;DuhcuYtaJ%tbLaa2p{x|YWiu8moV8%Y5^c6`e#!h9^JZxam(2Ih
zD0j?Su;76O?H-0XeDi0Om(42i&YI~MyigN4u4OEL{-PPBb7wkA=FC_y1FsjvQcCCI
z30Qa^Sm<3acm91^>5O^z&YYp;5&E@`nR6GG%vdm!FH}m|17&4=oHuLU0}GZoW|hyG
z;ai9bwF#xOX3Y1M#g_r49=LzToLMvC-bTwiXU(6fIeqhI&YBJC&eZZJf6rZz@407!
z;l9;9VM^YuTD~W5@)WHgA8~hqHt4$R25Ez?yb?b%7UBox@H>}3-Z``8BbZgXaFz%}
zBEaKehWLG80iw%Tekgy2^Jj<vCw{Kv?>PQkkDps^xoyg=`I9HzbK4a6ty9__r{opK
zJ>^dZT16f6sMNg4p0;v)xMJ)T+7-+2|2q61hyT~(|4{rNj{igO|4RIK;{UbypNaoj
z_&);w@5KM5S7^=|B_*@UyxNop$_i#JnpLVz1T%PM&0eVGm6t^ySf%X4JWyi%12dQK
ztw)<OYr#CN@P5zS60Zu1X3Sj>W%{`Apxq^&diR#$$N!IqqyHbrue0>KUA1GD3Ky!d
zT7{3R@YgE*vkKR#ut|lxRCq&w*?;*eoTI|qRQP=r&QRg+M$7!sFz*uie2)s3sBo1E
zH><E!g(1jx{y7{nd`N{4Tq>WRQsGt=9#dh>Ao>1ZD*RN1y)TpL9u+QD;h$9ap$hFz
znQwv$7pd^SRrrAl^}#aVcoq6o_^b*WRrsk26EBzfcdPLJO!?fP!kjGmoHay-(^Xih
z!oR3+n+iiJykn@$e?o;<43p1GRk%ilyHt2Wg+;?<zRO0)aDxgTxl%qqFj9sqRrs6=
zUsqvRh25```7%{FRfP*x_=yVbqh!7riZ22xRCD7!_s#O&!zoeg@E3j0cbN0UgczTt
zLE9Z!6X~usXlt+uXKH=4LhT0ZeXWTE64pc-w5##vv&c2J2JJBN9gW;!TN62i*caNq
zNNeP0+KEW2mWbR9$k(}lggi)_q*ZE50X1KgW%)ILD*qXXzo>l``L*pu#0>54+FJ>y
z5^RZ9LfgN;BlWq2w~)fvk;oBI_9o;XjQ_oW<;S)xZKEwQAsf%vY6m03w2|7ih>yd6
z{u?FmW$Z<b|A_tIgh^=iwaE8e!d%h*HQ2ve6N#r-hj_yI|1yzf$k5B3j={sOXv>{-
z$)HOwYkT~5Y<R+mZzsm3T$zy__w;`$YD-8=O77A%rCawNsXcq?_TGK^rd`mlfBJw6
zFB*8UAXRs5h*qE_X%6jXtt(QxX%}i2X*X&YBP|Q>dL#W7#Ix~V*Dlwt(1vN;1RkLc
z)iUru3;!INQyVPaWr{LGMV=Abl_)h*yGk3Sjn>A1SFh1>w1+jnR)h5Gv=nf%4K<Ai
zWRFU}1u2<$=06+$V>1L-dRSK$Fzc=jK%H6Qzpnj=c2bc6qAnTZ?+}s7SR|4y;xZ)@
z@gb;}*b}ozqyju{6FFE%t@a4wtfMXMaq*UE5}pn9M<UEEpXD2-$v;^~1iUQk;G6ig
zE~vMybo`r0M84^-rK3z+jS}u4?Xnn!nbHw1OUs=6?FhFE`nByXV>)(CdPA1<)zY*J
zw0@ebwJlEu=zggdUu!&!5dzwGhe7y~wvosPtqo!ih23|D*ajnt`+o{!XdH$9@54yd
zdIF#S6ptt^7@ix(B^XKP>S+n->@Wrjs+}K3FG!C6oa6q_@yGv`9+F<?r^osFg>e2i
z{UY(`g5GIAiqF&w%oY7RQ;A3<UOKeJ<E2A<y#4&!6a3X%^Fq?xh~ISZ!9Z;Sr2PUd
z5Ax>*&81zhE!N5*gKmOs)x``k4s*k0nxRe9CTl*-O`Lyj)o#<KXj8TCX}4>|+8x^W
zwL7(G+Fjb++CAEIZH9KQR-(<+W@)og3;z{q_iJOdd6>l<+5_4pS{ZbwA8G+SJ*eHM
z%|Xh1%yUbC6?ZTm(w1XZN))pBVa!gP3v#s|i>4%N#D{;$;x|M5%AZ$-<{?wMAgQbN
zY9s~o)J2#vH0@Dsg$8>{{IQP5G@c5uj{dQ<ABh;#<X@qvgSq9Od?V{+imXG!%-K!*
z0qWqJ__R&X6x&M2zrkLxc(W<82{^aaDC=Qrbbe+^N4PBA_SX?E=l=G8)Dk*s0`WP%
ztrf(>$QN0^I}8?ct7?{t`BFZNS83lJVmww7$bSlBlEQ((e+mQE>aoB76viR}ftt^M
zjz<iM^TJqm2L125(6m}qb#889mX-f8O<DSJ{^0LFrKv0}f6oo$iT@=%WF6<H$NAfW
zbJ-4h`FH6TiH8$Gd)=O`r!0y7qn^!N(LcsFVP)608n_%O%oY7>i^u1Rk4JOLFzM=S
zja3ZAV`4%^l0zhq(V&2j(y+3CyE2<d>iCmPDTcpp5MGz&jLf|X(*^!UYZvxR?V<O*
zp#Okg7hhuU-Tk70ebV}+W7Tja<|h8#;2HukbG>%$h(UNtVFUP=<(beGGVd}_pxs{r
zTt6lxbV*J;<Dbozn4F>|B;hrp2}y~z#KeTe1Y1&KVp5`p2c#!c8lUxV<W*OV8a4Xt
ze`Bt``kHI5$;rvhy|&}uSp1FS-<ma(wc{yk-q`f7hBX~3ibQ&7saS9K5-Wu&Z6WkH
z>J+iRq~vbh2V@QzHvGz~MvWeG^|eEiMqhnRl5KR7ZNz9>(vUG@$7x-<wyire9G4Ed
z%sKe-D@Kh@88&=$)(~5d3op8O=+F@(9NAg6(OKD!Gd3lY;D(M)8a>)JHuu`0LvzO_
zjTmvs(A1te12eL+GO|XG&dtpoJ-SzqOGfA1H*5Yq_s*UFKpAm-Zke1B4lb49Kh*Op
zDtt?YyHxn03iqn;a}|D}!Xqj?uENtQOkOVGr>d}z3e#11u?h#N@Cp?UQ{hMzUai7$
zDs-!Gq6(*~utbGRR2Wp@FID)o3J+|Oc>PvA|3QU+QsG}!_zxAXQQ>+OZct%^3L90p
zO@(i&aL510-j~2fRh@m`WoB|SlT0RT3HyYEkU#=qlL&!KLc$s#vM36eJtmONBy7r7
zQQSa5QK_OJZm6{43MwipDy>?nb)mjmsnyo4t$R^x^8NqkoI9Br0{Xsv-|u^WzpodP
z=RV7M&U2o#pXc5i1%IdVdqd&RDf}&kzo+0Q3Vx-au}0c?T;X_hS~Rg}1-mGipkN;b
zlNGevqrH+14fsUFcrp-xVZa9w8OC|!^^@iOjm=E;pOjarwEtSVU}}8Zq_L%?w!Cg7
z!d3`EA?Ss8S*3qaZS^33OKVwceN{uND3FR{)zy|amm%cTQq#D!uF~JwfRr_5%c}g0
zj4>YP7qO&T-nL};8yZ{vW&ZlI+6MZl86h~(wYsVmh^EzP%%DoEFKex+(FQPTH$bZf
z&yR3dLqk=we{orTJ)%;z4NXg1{ZJ9ctS&={u#!5OTQe&f8!APfG`eC53R79tTwT|=
zTw8p8$;y>2>aet-(O*$khh+ZcwXHR<&R@Q?x*Cx<twXM&v2JO7!%5{DVM=4Qzj7tQ
zfVCBV6@i0sBBPQD5pXP#YSYp+?bPyB4J}KXtCV<&u$_r;ojP3!T@;ebPn2KTTGgWT
zmzPzl!qc<Tc&Ri*sKbt6q_GLnJT~-B{SNu+vevS?@S3V+%W42sw4uyQL<Q+W=_7xA
zE#k73DxHw<X9in<ta>HcxJ=dQDgCo@r8pZ$5VkecK|jGRGzY|G*@mkd(SVrCiPyZz
z0YR)(aHoQAE0{P%^5-hJS;3bSw5Cdafr9H4JfPrl1xHPja!m^EQSd_rQ>IIPse;=T
zJgQ*NBFSH>VCD>o-=g4O6r3<q(l1i*u2~XKES7Mtg3l=Ut%9S^ko;B!?>kfCKNV`H
zxODJN^<#i<{)o(}(w~Y)-Q+tIbVlUUu~+3%PwrzqfHC-q#gF$V{=`AfhaWulfpZHD
z=NTPk?uPr&pY9QODDPjn?*Y9$J4nP2%iL4JUVygV-nj3BAD-=#)(<~CpRoCUb)N*t
zRh&&v#ywZ(1M$NptxXSwT-m1KCmlbhs*`{7{{Qh0n!-u00h%8zuRmI=j4^Zrl>ZVG
z?1$Fb@vj@&Z6BP;^+lRE^vwj(H$CWeUC`RP3Q0rBJJ6T=p%3@LNn20+uwTUERLm57
zH-2lNM&WGC2}u6QuQ|{j`EM@H8t44zzj-*1?D#haXOm|l%~>Z&*CA=&F$Hs(uTt1_
z!n1J3DRG{3YA5InEl+5Fv&X|wT4(ns8;?o1d7)#fP5;lp(0oJf{qg%j7-M(}n}M@|
zOVq#famLH@g>;-;l;Y%f9@O-}`E3$Tit*|VPJDS?f^C1kNHGq-^Kf=-r^gGE;OAo>
zKT$~LfkWCQIE^lX9%A?`8vbcQ$2fs&*!zwGuLkGIO*oBSfwSUO+8V_ph-^FmI_}Z9
z=Z--y;Ca0dZ97r?F!q@sqMtoM=>@4?kV?Y8M8s(a1It87GEu_W`00g`3<Guso)|bC
zr|VPUr%aSJ9p%s00yxtii)id=IFTBNkv|!;fggRZ2rb|KHxK=bC+@xR(*r+e1^>+#
zXYf3QXX{*m7-H-RE%e9x&yP#czbD3yx+rh-!pP7C*7bqi97no}QwlqVL&^X_PZqyZ
zgv3CMJv^J{4}Hdend)B_yfGAQW(-;wJ(n(iPKTd{2|3c{;AbMdG!e8Z@a8bw7s0p1
zXlXNn6~MP_Pet(fG(1Hy2`y{_e4T^irEIjMe6(Tv-)OY6(TIVJz)yyVg#=J9{5J#t
z&Ja<L*#aMeeE%mr+}gadq-sTNtA=eOwpB&5@(QMF1@nrvIcMb+YsIsQ1qq|n+*z{=
z&&2bF1%(K{Of4)b&?e2AjS|kAQ7nFyOw#i6CQhG=#}KD$dBw$ifN$!|IfZx_FmKMB
zsgq}F6Z49SO7iDTEt)%ZX36l9;o*c4k%W;pfugeu=V}v+X3d#5yRf7fk2=l>VzUb;
z1@9-$F3g)-7=e~d)RNU>l59*Ty<+dk6FdXI`4c&Ibya){**sg8w1f!0&Et5<t4{=<
zI(Tu6<>gm=2MA1K=iwAwtjRjzlci2Ewaf_pb{Y6Y2d|M4d^>+jvbDe7pQr9R@}>;e
z%)Cxl=_ya$_T^SL6HdbCTASCz2)>;^*WtXTMc5~)a*fXWxe<K3d|bctS`fjfUn#?N
zJFjxZxBY9^3)l3#Y89W4$J@GTBiH-9E{NdUGTaOBx-x=q*CF=_ytXTTAVNRa*Szjf
zeBLu(`-gi8UUw`0I=jJ0GR9?j?F-@4Hv5vXMx46ae7nIY0q!Muy=wC#^z%H8{68r^
z??bPFS)(fbn!jafd3D2rft8CiKOVj=s~5ND4y@Gt6wv(3#BC*?@?IbWTJVf@<s$Le
zcQEZ(w^q?u-^54BE41<oe`=~9r$u;jE^~sSS1K}?<HvWx#M5+3N@`n5T5#l1SCxiS
zV4N$ZYZ4Bvu5E6Cu9lVc<&AY(#nR?xYAGLDSJr|NP(Hjpu*F~7BF@3=hpZ`=IiZ|K
z3?=0&nSvCp0hYD+C-}3}U8a9Hd6iWywarzPC9;qrlVFbWm_imwW?CL;aJrUMhKJ{I
z7@{SWXHLKo+%ly<$3HwP3;w}zSVgObqd7eJj*3WYY^rFitSUji70tEfcA4$6Ha4Ya
zPN=RcgQ=;0x<TBhi*nnTsLpT~g_btUziO38iZejv!BBQ+LTE~YK^-~HDlVBir$h|>
z#d8Yh70lw+QC!0NsNhKRrMJV(K0yf;WU+M&n5W(@XkFP<#WO0@$x<GH4p5G-t*;+y
zH=%MIlnGby{ez_O{><UjBlA0{+yp<QJMv?Cgcn5nsI70Rt72w2o~*{9aBB@3PGb|^
z4B(m604Bl}Sw2xR`J5*!LD+CoIlJQEfhl?L<E)u@z8=r_pG<FreE#gbnG>f_`b0a*
z?YfL~H8ToH*s1*y`J9<Idum>OQDJBKbf$jJ*)#HI6$!IC_fLra@aA)3IXcsyUo;D=
zke{ZX#kK7(DJq;fdG3^wyxEhBrp^&=K1n+hy}JraCcBz7*^_I^T1t4v&iE5Xo)$F%
zWrTD+WmkDc=7jU=8q3S-TF~Ds?Bn<rHVTPKK?buLn=qiUwP^~&@i|5;g~;};)P@u5
z_%e;nk+2piOL)Gnk|`z2%9=}-Hi&*5E+4{|Tt!fWsGXlIK8DPO@Z`!bbVmusc_9`i
zq14IromddY53_)g0mK?moW+f`4Ivq+TQz0aQ;N#fe%|^&^E@_QWMZ%gk7x5W67=;Y
zW#x5M^7tPwJ)r_y5K^hEtF5nXW&MGmp5!L0bqOU@m*;#@jrkGJdY7$4%mB&ZdjEv+
zpeKcEE~%<-YF(MulCBc8RMl0dRdYOVu4*l-tQ3=1mR4K2g2{(-Jmh^&X#N#-jSN^w
z{fOdJEN$i7$`O!RG7ax@LQHO`S{@{E>`SVs7>XIS9ATPPya%<UM3}ElM92rhA~y3C
zh=<7l4dP-V?RYE#T5DQrFQ^J;r7d2@iCMf-m4@F#@w2olJ&fG4%%&zqNDImH$I6HV
z-_CNYj#;Z-(qcPkUMivi1HyDJOIJe-E2c0H!=Y_Cx(2$3pHT`1^aeMHHN|jkAYS>B
zs}PZoYB#7t7R~mWLc^RbBw6DfjUhxlgnD8sd=Ve5AjdD8hOFsk)HFwl1~gfW63UJ$
z%sHWk*m!6aQq-mo@$*hDDX>VWYb^_JA)z^jwk=rB%sJt)m7Gj0r$cH;@D^=dvs>Ot
z%B0wcqjKR`A{uU3Cc)BEK*cKQgK+=SlMG7Al@golsraIUDnGVdfHCy~^bFYxY;>TX
z)W+&G*_=4BhjjK5zLtjtCEHS#RHRzd(xyr_rs~=%L|MyP*&}4vz@h|=3+ti?O|o;R
zD!;Zau@^>Y_#B#+Aa&Xjk<qj>OQvJvjo0S*hMh8>Z9FK~SiacqIke19Fe`sr;Y2x$
zX<CEraYXCHLN%mD(dA{Ywp*Mni_A`9Hr#^o4_0^1hcn7f#Xq6gcCoaVb_B$I_N@~3
z-6i3p3NE`-;+Nbd;rDk-xcdPKFWMtvlfwUWuf#uBaFn9A?UM8{w@cW4w}dGVO8B6%
zqy8a@U-XEC8}^0sZMpw$X#7IvbEC4C18Par(iTiNjF`(??S%Rf5+Db!i2A9hsj9$y
zBvtSUnFxMURn-zT-*9DYKTQx+*O`2Y*sdrMS+iou!eHMVDUW?iYhyE}1-v)gS|avb
z4CQxdh_I)+xv`$3L(l-JpT+E$l7dX!NWN;oCD;$(d4(laC5muDd0QKWc9_swg?D!G
zrgEq<>I)wLs++5-LL@$WO7(yAMQi}7{A!w)y*{tCmE9csgVsj870fr5IWS-oi6LRo
zz?MPwR<q3Cu(ZA$OEskp%gYuaTGrwZ^1`%X{--Jg_o+)IBax#$Y7ILP?1mc1#5Aon
zEX7(06C|FG##B<JiP1+ZUs{W|ryH;!NW$YAcz3x)!wL?Me>A04r;qh77`kAQf0e&_
z(Kx*6tPEUIwX#LyZc9UEbVQg{_S@JYriJl2ua;ps(%6hqlop~0%bPh`YJ;eGkbFR;
zWoc7WV>8Q8z8ITb`B(~MPRI{)1J@*CxK*xT0Wg0enJ7bTwZEDb)8HQp*TAWw<bFKT
zppN(B9?cVak0_{of&~voU~qo_Zb0z+DOm9biSK?#!ZY8N5F>DfR_h<)$M(H;LDnKn
z=4H*zWh?EKpN7e_sTBta6*x#}73T(!l+C3C+lCsnl2re24V(TGi8*SSGeIkFY~(BB
zn$R7w2I8DCfPEVt#l*;W#f34$7r`t(#1Ux{Ut{M^m~V@hOqx1#>YOQs1(;cyN}8*x
zE6_ieHnia7_o~V?SrO@4OI;%mP~;oaoHj^6vANC>ZW0olgffTo*dUGkjztrZ96vLV
z3dIy`E0;51`O=CdRj7KXNW%~@I6XB)91cut#3W@m@&zG0&f8!vl4fY3lY5##Qeh2e
ze9V989WyxA3)n|AR;YI`X)Be=A}S)+;Gy&F;;?yn=DZpCc=KLep>kzma(T07=be2D
zJ*S-C(VoMU1?TqA{LqEMghDl9MIH1yJ|2MG7%C$zm33(Mve3#!p94o$hNzg%)7wdr
zGxoTm>SQ&Bl{4HALDPlDLhTRt>xup<4=bJImwX%$da4!dqhPXvgB2XEV77v}3L<~@
zn-cMr2xtN>hdORmFkS)|ea(J1H;7}z2eV0W@fcZUhb;Ej!YHB77Fphm{w9({^e$Ue
zz@UEY@$tos5S?|k6_|QDvTP9q$cMF6CQt;9Dj}#{o?zo{uHu7!+}O4>l|gq%3qj>G
zrRt?Ds(pnBsjg~sBn;tmeJaL>Pzmyted1FdYU~TiEyQ_97@|))FjQGMUyWAb0wL*}
ztAs})`F1I>Il_rfI5#YR&iyA8sKZNg*gi46t-rnsN7*6e<mfBfoANU8kcE&^)S+MS
z(a|IWU#Y;DfJvjJiic5HRQb!RT9;R0rV|xy?-$c>8q1X&pRE(y77oiHv=VM6G1!KZ
zWJ%J+2`f*aYa5qh)gqp}6epj-@0Z~8D`-a<))_UJPherDumEQO_+rK^F@?AI>+!)8
z?5i7EY5_6xLu_n^nD{1#ERU^6^g4SvqiKUO28q0}B0_nE3M_A=>-c!AoDf6ok&TS`
zz%f|GRr&d$kl;657A~ESOa4am0;`|%xPhb1ejKHjVTB{E6TSk&jh$bm3lR+ZLDD+D
z8pGY7dV*4#B=v^)Tll%mcCc_%IV@>z<bn}1y0{=OR_$W%FHd{WG}y(&R?%iJux}uj
zIbu=RfEhOMhU9<pCcxGz)}lN!3NZky3mZjS31>xeS{s*CHPC9ANT4cF2aAb<9NXm>
zhpU?L%&z^p9UPbO!D2Y3a%lw~L7mqi9z{kU7_@p&D7I)&N3)b|%x(c0gH(fLyHJf1
zzLph(Md;X*H?oM9V>c4pSk)BfHDGeB6{|T_+aZ)`b7sx-qnFpiSUg@W+dD!%&1HVU
zQXMzglsbqS7RqVMYY-V@>t}S!&;0}D+6Vi{_3K+n|FiJ_RzCmJ<@n#O|3B;JXMd#r
zU;7dMkNM-9A4wn8H@w|_pyU%3-5x=jMbH70NN`M1lbz`HnmD%*x7=4U5f2D3?8rEu
z-OEG|L2ysS?-njaba{pRjjyrcL8J_~mf_bfT&<1u%W*SwkVKCR8xTX+$5I+!mm4I@
z^QwY>QShG%#-~aCZUy5qB%U)=!lJ<vp0D8J3MLPc^kWLYUP0JbxwO6s#}615aB;mN
z2x|C{@3Y{m=i>VN+J<TjL>yyUS86lMW@`6NlzPYI{%bH(rT;PbujcdLo!++hzgw?2
z!k-R>XDpF^w&BN%Bp!9HgvS*AhJvzPeU>X>N<hN1B@A3G;bqTCxcIn$>n@g!=}4Cf
zq4eT6ZxFERWqe~?)BGhnjeNilmrWT%xNB>#dceR3+p~57Zti#Jz#D+0QomjjGf`W2
zY|P4M^CoILk6v=tsAUti!!ysTfBN2u+W0M{@6Z3^#K6XfSM<HFdqMHv-+SZzUegP%
zd3}cKmCx1{K(D-1`h*7O!w>JjcGB11=6+<(%APTzZ`QX{mS1#E&QmRG-<j2YsVyD}
z4_toqh6i5Vo-^{U-LEHqGxhZGcYRgxL);xBZoXmTE7oHR22O0;Q<>(fiFYC)pJ!hk
zrr?<Jo9(|KGoWb)(Iei?yKeN(t$?|sKe%tSrX9<b_$w-1F(2l{bv(ChVq?W!m%f_&
z;Nj9M)2?_v_xqJQin|v4E;rnMyMFovL^7?Lg4#NXi}m`_hFXS2FgW4jT@&Ju9j6=}
z6s&l%Rt(RYgiE|1g!g2`;S84B?B+{btFue08YpicGz8PCT{NBp`hR?>f#<&r@HEva
zugJGz9lUI31FrpleC7U&7v8=&<rNokMezzLe?&vk+>6i02^J1g>v7;IKDQ}WiC7d@
z;BCFeX8U=(c`aq<RWVZPU(nbj-tNPZB+}wTotSDSxNW&f+&l59B|JSO<hVKGNw&%Y
ztM3LJ*h&>VZ&nFw8kh4_TkOg4I-1gpRVvS6m)ETHBf5=u#m=i~^)D|&?`UmI7b#n+
zs)TwZscfte59^5MWw=eMX>Dy9J8T%gjM-RM)-d!uy!5xUd?+j#w)lKy@jQ7jo|#!w
zRoCRlzRoXh#QTBD<jhc$u^<o^1pn(<L&HEku$Gz0bM#F4l3RrgfMfTt6z{{y_;+Sz
zbJ=pmM~0c1Ep<zqn`F6pr;#nUF&H>-7GBY6qh&1>wY4@9)FKY<r9zG66lT~DJ;_Qz
z72}htB47}Fgbg|Bz0GlT(VCW_W1<+_)_xi8kB)C^-wPN!p{@Ne;19WN?TL`}=C!qF
z1KtHVA22t+t$hXHXA|4ncLF|K0C~Wvg>CJ}0Lv%0wP)eM&dUL(0Ny{ft$iEdeKl?E
z9|D%tLN6ZdJPeo(Si88by%_LTz#72s0oMTzT7q<d=K$^n+zogba8X@b`)7cqfEHfT
zx&+V<cn@GU;C+C_fDZxI0PY7|2Y3*08{o5mdjbCrco?vEJ?sYb10Dw)2<XFuqv?QY
zfSG^+z|ny70mlP20Tu#Y1~>z7C*T6W{eZa*C?{YWpoIraw>Lr$;5~o=!2L}~4|vx3
zum|u%z=NbW!w$enE%1*|)0zRZ03EF;58x(1{B11lOTcY_i#8x1z$Jiu5cOq1Kj7#~
zkq_Wuz*4{u0apM<U4eW6Zv;FJIP^;B#{;SbfW?3Z0apON0Js_OkAS-YPutkmegtp{
z;D>;}1LO;C&a03Q;MZ3}9`ODfU_apdfX4y<4(RKqY3Jd?@L7O&0Tu%q_(*>fU<=?j
zz{dgi0~X;g9UKGP325QL)-M6G04LuBzXQGlxDGHKe?Vdz;A+5wfJXp71T4Vc8sP)4
zmjEULPTPTWfHwlJ1Dw1Q<pKN%@F3uO_}Kk1z?t}iXLw~myW}qT4=`;H$^~fr0(Js!
zx)0?8Ond<C25|a=@CW%1Asrr&Jr0-#c-g}!AK-O>HGsPS*8$!IxDBu!a6jPHk03qZ
zZva07?6MDj!s6x(z%0P$0gC~D0Bi#6z90DmZU)>BnEoj22FwRM4!97|hnM{J0R{lm
z9z(qYwgIjKT#i5gyc6&{z@va)9Dv=uHEkRItV1?n{gaRf+zGe>@a|{eC%|tHBOk!P
zui;O;G`JHm8}K)P#eh>^L^%PwzJz`NSOB;iunF)mVD8JP7r-&UL4JKP)BOeM0RI5k
z1o+j5@C)Fvk0B3u?kDgE;5mOqJ>V6soqvZs;9H-g9Do;mh4KS#0z5)K;D>+@0^-#d
z?RmgN!1-Up4}j+#hu;8~ehYcPsPEt}z@z^}efjasx!K-c3iw?V{?rfP8c%!sLBJz1
z?d`_^uZ+dB%}MBwUVLo}P>*YG4*=!>&IinnZ*SiT7y#T4I1lg$;3B{e0m}gKiiuVO
zm<U)0m<8AjI0bMeU@73PF754m0q+Dn40s>lF~Fp*NS~}}TLArlzXzNT_z_?eV12jt
z_HBS~0qzI%cW-Y$3V0UaXMmpp`ckmc?*Y33F90kB{5jw{z$XE>0X~?3d;wnu{1EUP
zKx-hzy`Hcaa0K8Kz-@q~fR6&M0DKE@GvN1ty8+93!GD0i1Uv@#B_LlGHF~4`fM)<^
z0j>lr2HXhP1b9s!=mCuH3qJsk1v~<{1@J?_Cjl*-&BpY@w+jK?{gDoEEZ}Cq0>IsX
z#{iE27W<J7@NqyZ4gC`^4X`;0<pA^zKsf-{0A2?8J>Y)8yHa3pI^KK5A2jy^ewPY4
zz&{O!9H5p7Il!c$C?DW;fYxA)3&Wrv@Fu`1fOAH`uYjJB@CV=qz+-?zMnV4&*nJxO
z0JsIP7;xwqln1aL@G`&;$Duv|vvZIRa0%dXz&`;dW@y?)<J;S_0sBrsdjNa@a0TGF
z0NNwqi+~3K=jFi<fY$-ywInU`4CDt`JP-K*UIw@u@C(4hfZfkTet@}vzM<&HfN6ji
zmqI__M}Rv4FDrwe0p9`q5O7*K^bbS71WW|H2QUlpFBPy4a9}0M2RIFIGvMJW<U@Kj
z(q&;>17v*owe#RVz;?hIz=9gc15U3+y9TTTJPx>gG0Hz&({2YW2CQEK`vBAGP(OtA
z&^rS51118#3K#(V;&SK%>~;mp4fx=V&<B`yGs-zq)7}LP01mtb^$s`<a0TF$9jH&h
zZGd|LN9}~a0M`N@1AGARIAGN-=ozJHEAB=*K<gg(3y>G4HF4<|%+~Z3KD~ELl(kux
z?^I)m)aDPz7-rzc>zm|FoEGO<ZmrXDdyN}BG6f@nOkV)#AJv90vEeH4`kK5J-Xp{K
zkDu|Ne+GS8zSnoPk?&2s%FOrrH#zdXX&aq+-mDF-Ja6{;sL9^VhWVQA%?2sYn+6ex
zB1t|}iHo-E!OuIR+uGx)ufUsS#^^R1@6u`7OZfTCX>IL42LykeZfp(Xe+u&CF&Nu}
z{A+`J3@=&?^gadt{nVf5^{qE1dw1&QUAotoXA4qp6!=q4Z)<;!dW4+F?8y)@;n#(b
z`v7uVDW@*_r4{tDv2E==>DN>HrNFzw{6cqk=9fGVRkHpLLEqq<wss6H!vEzkmifF5
z`stvj{dhi;y`Sl3jL}&>REjkaelnmZ9&7M6%xynnHyk&?e6Qch^<_ZCD(HJ^A=WOq
zr@oCwo;PuWndkMdcNBO7#%*3d2yif3fvA7T=Pqh%ucG`MuYaSl!Cdb!&S2fp4=;g#
z8Thx7uP)Nxr`_jbjbIZ2N&hG4!$ChMg5J%<8W42a$o5P?`3%r61sz>V&>N63=>?$g
z0(~aw>S8-t2>MabA0};)H|r{6ley8c!MWaL++epSroR|+RV8ih0Ktp&?I09`jwvg6
zk^T_qi#nmd1o~pook3}7_xqrq)d~HdpcjDdh>-6FLKf(%>j^IN%>dmGI+6u1(hETM
zfNuNiJmr^#p!e^D-U|9i&?D{KsPsqDZwEaV@&Lh$`5pk_TlhDU{u&4$fF5c8r=Y*y
z3EhDVpX-F)2lR(Kp^pOn4$!@{2JK@i%FD7BfqoO{?~{&ZyMgU_y*b%?P&bZ>h8!G5
z#CWv|^0QE`r<DA9!+64O7i{m_!T%fhw~#;Io3+W<Xl`(<cN&*?Em3~(>q<|w<2BIB
zNk{(=v7^B2H=TNf9VrlTxUg0%Yir-Zd^+rgym7rPPPq)o?StHw6Xh<m<!JX@$ob2$
zwxwLC-TS=OD3DsgKLY+$<fGqj;=Hht{eFW3ga3Lb#&%=1Hw^?hP|gA@?;fN}tq5;t
z%<mBBV?n=$`Z~siHS{Izejofj;9pLDc=^_a+8q;xc2?QeUajO%AC-1}6oHlj{v7ZZ
z#{)U_xINi>OgI1NJNdxP@~ncs`laFZ$MS3iy#n-d+-o!86=S_=%#oIm{}A|hfL}vC
z$^$#AZ9B<-4g9}?Z`Tv}SKEB%`xW@5%djV5dUX{5#=u`Sp!dhP$nssqdfCMJdL!#)
z1Ly1Yt^)67-E<pbo<<Et%+svjxzLllqOJW}>ONWhUKC!xOt%r~ZbZ7Rr%JazJe{b2
zr27Wxuw_>Mm}?hT)<5{4f`6gntA5ETrrEB4`XweB{a|Gq|DI^@B0UB4VW4A+8ob!9
zazGyr`aDuY+f|lP6sorpa_2%WbbUm<t3baH^ctqeIAT<ItsLBL1^q?PN3j2P?!RI)
zNe_1fb>Lz<eGTcKxZuBM-9>#VZp=5U+S(7$F+bMs_ZsG<QKxSAt<d+Y^=cl4N?!EG
zM$q2}T`X(_RelrbcF^AheFbTDf2i%~4~M`Xb}{zW<ct1*0c53Ijj?^a5B@Ch7liVS
zxk7;T=s<>7fPcQ?2ir%nQDfI5^<+TqcaWPBrUw~fSf`#M@V^J&?sq{w0V6m*Qmz$p
zm6x=&&sBOt<fhyCQEofrHbZVsq+F>nEmZCh<R1SC`aXr+Um$mVq`qQfldX^S&@Bdg
zG@RM7?$Iubu?!aF%K-gy(0|PCxsZDpa;LJJ`K*H6G03&beEdeEoY%I3o`bW&JV`HI
zg{o%1*aLbM=+B+JUtqa@GnUI?Q-@e6)1RLr{l}N#?1p;7`|D)8{FLh!i?grG+uDB-
zDc5A&Zp+dB9LU`Oxm}bi@HQDY%XR8p(37rcYyVc#u@CtwI3BSbwSxa0`24Gl8dlzh
zS!vn=<ZlIk63#Hka2ysZ^I=9P{~_=fZEkD7%^~;)P4gy)&CdYoHSmvZZEJrE_hIGS
ztQ)_z3qT$&=I6jd=8Egu@b^=IVCFK+^<nv?fdBOkC+8P{UwR|@GwX$`9dk%<V@7)_
z!EeDC=|0?Z{0Lv?mm2qktn=yrt&sl?^50N?kv9;sZa!+4lX3?jcX&Jg_#Wj#>$BKc
zWfzn6^giUWaP|tf1TWJ63HrcJ=-uKptrzH6Mg=eWDFgH<(C3pX#u?*G+aBsG0zVi0
z&E#`Dzf!h`O3?R#o=dtKzqm){MZFh;{|5L4Bq;vU5dQ7pe|L)XhrsW7OI!QWko5M7
zfcoDDzXAL)<O{oP?W+E<!?^@}u^tfoV6nvfnF9W5@K2aO{T=fs>!S#AM<6Hm-=X#4
zH#UdXM=Rv=c3}TYd*CO|*7V;-(DOkT^DOA|Kxg~89rOaw#rPf3ey}c5J47mz<#`SA
zjgS}PxjkQSQ>^%3fqxMEH%OS{4XAzOGnAmey2azYMx4d3B;QWISf(EZ(kSp>0e?OD
zCz+q&nXo~K{;5N{UO3x7&UE4X!MCJ#=mu*m<UWSnos{cbf2ncZiTYncy7{}>+Fxh7
zMc(3&euI@aiE^I(3Ubcdg8SGk?qliam@ZhigC6Yw5?X&v`0l=4fmDKvcIH6-+dDCy
zVtpOiuP1wtm}bBg(zBULrfWsIc*HO!t8qMHJTS-VCnOW~vWNEl5-|ZP677_e)7fJF
zW&3#v{8I3TlCLh(-v@me=%W2{Z?R1F%YTCYd(eMP*`U5>g+8`}K3(yLo)Kdi9^_+!
z;yo_%bHLvUK7A+Ct45;u3&GzB{wqN~?L8c{cNO@v_Nw+k)|XzZ2(nv2A9g=t2<(uk
z|5Kiu?d@v5lz8%U7TWnf^u6$_(0yisx764lT(>yjq-w-Ydayo}AF|9iT?l~0i)GA!
z++4&~K2~yS-69Uj4q?`1N5oPnINvUWybrOKHB<mzaGg_XEVYHH_hRM`xqpW1Ex-w$
z`DMh0mGTcke#9$n?UOiPb?8Nt)6KDltr<LAlz$)cQ-0glKDHD2p%L<<Am6RKrp^8x
zVpEil7;i)-n~f71D6-IsknXY9+uGr7F|N%-YazW7^oKj4uL6B<C-kkL-y1>a_^}7{
zJ3+sO`a8<amB;0Fsf)mR4RXFW+S=o|zWA~BgMI3kr#Sb^fr=DttX?^)&J#KxkFc`%
zA$&kWI$pH966tULeJ6I8cG%5&+6cL*x7yl&8(B}V@wraw=>X(+zunfpq|@<dox@yk
z;`qaSzCybHcn|B5@NrJ;+3$@Q=qR6pm})s<gFL4T@%v=&UejD*+MWjw7yH{>$UlPE
z;cT{Np><ktJw$#h_#Yys_&Dyt->Dl9hK(y*!C(LB$@vd~-w(0K&eF5Jy$1fH;E$tz
z>~b;O;oELl|APKD=-<&U)Z@wa_j`5oMRaE##D{M1MZc#0Q5cst|NX@CwIa~hfsW=E
zyhQs4eRU`Dt3a;@oz-Apl-~;a*`P=6!}owbr4#u>ppOEb&A`5>=WWmjMCf7v_zLuR
z(9@M4PBFg1d#3LcVF`Kui-pX`o!GSy^fy4qc072A`Um|5(3?rM*B99P6D5Bu_&q;E
zESdzHUncpZKza!LTJWck-+6z`S{~6G>5os5ZY9!T`6I@s=}^i3>A-^Pe9$i@J$zjf
zcCM5GxtAeVPq~hBwzFv&?Jfep7h>X*!uZX?aOPhJegOP2<YRqD4%1x>dI{)1C*3aZ
z6(X5j|ABuLe751p@mMbO^QAD@)b|?XKeg>p`j#sR^1lMV%NIE3!ae)*dSg*AJ?-q)
z8|?%9f#er>{iWb?9LNB@ALw6`4!?)5TLQ+1A+rMWSqS+*K_1zueC7x9A%7M4?|`2k
z<n!cQUaXhx;Qtx?F>I&h-r}o`tISP~jm{0O^-*RwIi%3uLy-IW%kcdQ>2HJn9_ZD$
zr@sxfA=1ABJ?pEs_9W8PMS2X3I=vHm3h4Qr&~rea4!Y2<^sroW@$2WH&mc|s*I-i<
z7x}ID#b+W4NfCT3e%8p<2JP4i{wLsL+Y-D;-vj!4pwA+e>$quh9d`)yo?j!*MY_-z
zY__63ybpd7_+nlbd=WCDwBS4NY)3cnUG(!DZ<E>&d_kL$R7(N>JMh;sLFjolvLU|!
z{IkF5ydG(HCHUpwpT+dFd$vrs3iMk+&m>*gwZwLl$ag#VzXX3~kk7=Eg`?OP4uJnQ
z_-*8$bUdHzU1u1tpJX_f<wrd4nt$LKpU`}2JL)3^{9WMV7%h0Qedd6^74+?-!v5g;
zE?``1&x)e_kh6}f@r*@4G3mEepqGNaM5SME6nN8c<jzGT`P;$27yR)d{H$ftF7gk6
ze;E7=Lioi-ix6PGZ-YPJTNOWHzCV}eSYLs@8}tU1F2wFC+iv#vJ{TbW2D#Og>!iOo
zh4gpUM-k-5eb?5$N6jlIn_qY8<_-D@(<?KP?QJXc?D)Q8zfHen8LgsRIgoh>{O`a&
zs`BY1eo}0{(E0f=>+LI~zvhRw_K&!pslxgrY+!j-oJEQ9`_Ucr_V&J!>oF`4;v?2$
z)LR7k0G?e+qFtgr!)~*eE^7=lT$F3|W1Mlc%X7c*cC*Cxzo>u6T>?3=&$jj9Xvc0J
z2f+XEBz(^EZ-YPGiDxg=I{uXN{AS(Uaf)>??aoNTvl)0MYd`KI+WUQ>cF%>}M6131
zLM0bke=Juk__u(6M+m>vxJ8tUe%}gyay0(dVkdq#Bm7Q%hahj@88I=w1pQPT^way`
zpAP=b%x}K8DHun*Sk4EI0a&kspG!XGy9+Q1v7Pk+{T<MkJAiby&Jbsl6^@9d2DONF
z(L$t8^x;_;L6N`MFY%c}tr+x?B%z7${DI}z2>KGxSCAeo$N9l>>;eB-@OO|u(_1Ry
zVw>fV$@DLQpO0tPZX#c#XOAZ$`_-r5KLP%AB-rbW4N`*j8<UKEC7yA+TnD1^Z!%l3
z6b^1{g`J}ycP*ZE+e|${J1-Yf)H4@+6VJX~q4*)=%g^j~LO-m6TovR3l*9adAxvSr
z-3t09(D@85{eFsei^1Jtu8KSP{(lryybpb^C%3mJt9lGww_tl>nq3_sBN-ClqCfkf
zFb4;<ce*|yKL`Ay;4fwZ<%ePfvFI(9Zz1>t(vUCtXjkW=d~DyXpl5<UnDmHowOlx;
zV?9Sbw?lpq<i$A*{8Xp>bO7`K=-oIm{g|In%;V7~_Y+iUF<9_9@Qhp)?(Ood(~WaQ
zfk?we`$s`84|3Z{K)F@@Vn3*N9CVV0i}qJSelO(b35xth`YO=>3c6TND<0`vLC?pt
zc@q_lfb>0}*Mr_SgigB;f!+-Ic(&Ve@076N9K$cW0Mma8xl8e^-vr#-7wgfHioZ7o
zI@qe*YBK_q?J))X2f$xL{ipUb_e)i$+AlG`R_Hr6y1ji7?t}f1hb6ek-wJ+TJcB6K
z1$IAODETb!L*UndUm(jHzAi>wl!~b5ZOC1WXBUUyUe>1y8Um%Be}aEC_=Soe?5F-<
z_(1HNQwG8Jkc;|B<v0G;Su3MGb<ndUn|}oxm*_8N$wC3m!OuqUE5Yxo^66w=&%)o>
z>uk6c_4^Xik2$?vt|!q?YM`Cvd>`~8(0_&di2dEYwgJpPCJpToa*tCE_1yXT#ke>8
zSb)Ol-uNj(`kJwL#_^~4so3~SXMPgxAA0<F)^v){EPt^adq6J+y_}?ueut3-hrsIa
zk?r+0$Xx+BKb?N+_R7Vvncn-<@#++8(9Suly&cns7^k^gWIj2dSAxES8|qW%Q-HC-
z?0<^qK{&2#guVyyjA^q0B(!{4=4nRw@v5lr1CT$CXHWM*+`d@k*Fe7k&!A2sQM5C-
zXssN@=-;ove*%2b-zkHO>0&S-{~GikND%3a@9p-%bQ$39UZUo6v@h=JNG|~W80g!X
z4s-(27lK}iXJ4n25JGPS{RYrO=YLUt&>sN(LAIaJ@~_j)dm_$(>Hh<eAKlR2?v4U-
zYX9SuEyetstFsn|w7A&5VlYq~Z^isi!WrCWmv{r~qvUXE$h|wuH41X2OWWI7P5-|B
z?SX%L;NKqjw+H_1fq#48-yZni=7Dx~*>*+ZHl0f@USjbE7$Y#O_dEe{7pw3z_4lZ8
z9NtLMHX}fwImK_hv*ZehJD0)_8xnUb{A!hvN8t#?iL1MUHZaxAhjC)Hui0y@57iCV
zVZ6BX<CP$RcF+olJDXmra7*z^6^vHU&cCf)mPb?a@RKN??U&CKzCS9UQvTlo#a>zd
z$lTsg_3~#0zfsT?Bkk*<V5)+rDL6^NGZm~>aG8P|6ue%+I~9CH!RHlxL%}~Q_>F?D
zSe3tmsS2K^;3NglRIpmXWeRRk@OlOBRPYf6BmHnPJP<Ga7IzYX-mghJUs3HDj{=En
z@5_>YID)?7prk(;K_Bs?q(2ftfA`mto~pjjYxk=eik`D7Pvd3Nv!0jo!y@Ewc}~*r
zi_m|iqTd}sU!mwbBj{C%zAb`2ThTW~&`&!c^IfIrww?PQm-JB)cD{O4(oc_|Po6k&
ztUqmDIX)h|bXXDo?00jcf7H;^hK|e}zEluLr%PO%tjW$T`|4h=)c7fOTb*6pF&Y}*
zSC{fT#|DI0Tj=pvNJ1%p_UNGed?{~_03o8{R?1&8#+E;*<lnT1ricVm{>pq?e%nH+
z|B3VnL4`{B+A>?dbc2*X6Bc%MN%@N}vgPfXI1{H>on2CX@wK+R@4bK!+cUT`X?e0~
zXn%RamOmIHTj&;XTy<g^ssH*HZTZqvDgT2#v_~Y7^6$PDlpi7GZypyRs8A{Y&}X*1
z)*$7@+bNwSk@A;*ZOi+cr2HUvC&D1Tgo;<~O@A3pNFN=IFfM-VhPPccC?+>{g5i2C
z8@Hwvm5e4}>Q)Jon?_V`uuMl(njpH$1kw3X6wXy0PJCbq37p?KpyCb8iBX$ssjURu
zsH=GEEXS|w@#CUyU5m0T>lWOZx~m47j0yN<4c`k&G#_6(8Xd2%26TUb2{*cnUJizl
zthpy6^XLS9n?No1Zj>iFQK3HfXk;JVQ=y6OH>j<bLjCUPus^!DLetzsskx6rv)tzs
z?W@pi_r0(@x}QP=?uj~3ze1<D`;eQY&|>!%W;8&d^W9r$WD36ULYqt7>zFoGPZDU2
z`zzX<rb^W0PNmHm3T<^iMRcg%Bnr5~eGAi$(0RgTCa=@oW0`oQK3Cuu>2AKN6+KEH
z1l?xxdfn}(e6~JD;Fsy{XQ?hvXN1m7-mJSXVJWBStOzrCo9^C7e7eGS>h5ca7b$$V
z?!J-u42AF2-M12-sWXyqChynX$B7pU>&@hYy1R<`&DO_@{PDi7aThBw?K1p!Zo@DB
zh!%i1DQ|>OqDOlNq?j4d<G~-*6tx^v0gjD1Vh#%)O*WFPm}k(sJfbBT$v!RCglP05
z9w(F}MjxQdW75+=dO~_%i`h*JpOntGV%o8uihibC=<;cn#aCu6i_Ol-)=0l8^DK*o
z3F-`++7+^MfOsiu{E}&l*-GOaPB&j-^*K;Invdt&y6+n_H^X-eD#-M$fLk2C7Ao{T
z0lLe_SbmgdoB>g1SC%*4a&~_bFy<`iaQ2{w(cm>B4oRH}cTvLU?D;8R7kp-2bN1pb
zB)ZgU&fXh@v<361!f3-UXP;l;cUPa&-v=7H&BX%2nIvv?Y8>zdxahKuLGVv}qO;!=
zP-D);oZ{@yqEIuw=BPQ7e-N0Zbzi(pbEYu17Uzg@eh%n60u@>h{ykFNcOUA-=)pfp
zYWiYPDu?f{EQs$y&|N;h;uYoFMUVMDK%!{h6QH<#m$No~4b0oO8TYZiNwCN33n0@t
z-=&c8`Ob%)cwZ0DyZE-@zH1Nuz0q#I7RYq>T>}UA@D<~Cg3k{Pi8QavI7s_Eq6YdP
ziNnWdw=Lg%WbO0yM0S4Pxu6`>d@T1m-PaqYtuuTWnY48d-&n}4qdUuSgK_O^2w^<z
zhaBTAJ*pMjWBT_%EeiqqieK}$F^6WHg=cW|=vk2S`~ms+_1Hs9vmX}eUbZKsiMbJn
z(YjdovtgU$`Di#AcFY<;U99bl<V4LVgI%%FuYj1qTitU%GVsO5v{CC9_!S$=TWWP+
z9*Ffyj74C^2E}9JUdL_XZLr5-u6`ZB_dfEx$nb50%JqitY=Dc69))LUml(b-@aP7k
zN8TLmQlm!!{*3EoMvtkJw95_OXqbP6;d=vVuQYs#(6bSV@CRi#K^)*JqsOe-+SP{d
zIe31v;p1bgTMXaFaOE|I?`OcSHGIDUw$<>(A(!h6Uw$u44u-FwHxA4V-&|y{&G7N{
z&Yv5;-N0@%e7}dXn+)G-5Vspz&qY8J%^k;~t=sv@C{a&VWUunNC3wt_FZyZ*Ma(@c
zr@=Soz01WA@-+(S-P#jsEUQ0$dme^Zz<UdGi^;&fcjvpfr6=#9=q@$a#9V{&dT*1M
zFXng1&AXe4P(LwzQr!CsHWnk<A5#i9dmofoO3ZFhy^l#OEhdM&gA&V#`5a~Qs^KUr
z=5FeIR`N#0{F0J~C6*oYE_uI}SdM1gOk;k|LBg``!0+B);+Hv4=c5h1KR0lnAts65
z+mQ}08Y}?4&k?Lx63r*|aVTZqSop;}sQ-Wx^xZ<Cr*%5BZ!-wyGdi2N)=&Qr<YTOs
z<GbF3bp1g9g)Zt}&)YR@&HX1rgRzDJFo=VEKmBbcEmcWx4JIw^NLtFIek~~#sq~RT
z(q5B%;0=H%uWyicKpiA_Qv_OaK62Mb(is=wCuKVF`zLsMw7Kr0JekO{*3y5Rhz6cU
z@gYLL9)MM;P&S0hQt{nu+)~jXDk%n2r*xXgA(IR_1&|{q2A}4oiu9@A=-Ik$=j*-z
zWwrhIIfxEOd$XAZo7({V{R*IT=@8^Hpt`;lC=1WY!#}tMe%DW*58T{xeD&aGkVMaC
z-uj#&hu~O!B9Wbt<=RjC6Y|fj)$~cEz7482lr`EK7r-q#iGupL1Q;@`5-bPQ?#MbD
zcU_Rl@R_*LhU!rBw2~d5%-8c9ktT~PJ@)dfF1VpxBO(PyjsoXGa7Lx#CfY2u{jLpN
z2JK^%zO!t-1wW_WtzbPs3ofSxqba#aNvyFY3x(7lf>PRP)$oUT$f?^t{&Rc)sWE%N
zHKl0MV;%zn0Xp<d(8jpfv=50D=OXwVI~##hb_-ZzrXpYPtATGrWsix25b!$SJHQ%~
zguxOxhvGX?y6j&=2so?L*rH|gwIQG;sKyqKu<SRM#p<;z4n0X+9yl)2d2buLwo8C!
zXup6T9!5r|<J0(%p@_L<=i1Zpz4IWtd99Z85(@3OP^hqzCUli5zJm%q1}ZSrT^Llb
zEQoAgJGNYNtdg9)&~*U{;n*N_**Xq)le#9ulr_{<1__yB-P+TUTp^#W8Gye+<=DWc
zb^x+N_My~{OX=z_fQqhn71E>Y{qEX42=NOAn&UdD3I!1hC`yRl6RmlfThi-jwT_*_
zBHNNp-2)=I9;<1eD~ompOGhIVws~!G3nU#oY11-D5B78cdTX$};~rrJedZABaeWjd
za&AI?pm6Zcsh9UG!uXXdD>d`DpyR$pGrx6^u1&a-LNQJ~8;EULQjY*IRQhtu<wZ03
zl+7l_Nu_&`$(XT737iVP2A&J6G&9}#7geypjq1iGJPDz^l`9*tU~)2_L?{K`q?z$T
z$vEIzK7C=Sockzf4s#BVL+arsevOFaj_eKUUL+nl2shtSi>6Kd8(UhAQ;dRkNya7y
z1hWqohv(vF%neeA_YFSaqG#neD}n!p_@C*P@y^A-UGcytO1vCeW&tnw8C{SoO0$i4
zH5g_<;D023Ir(`4zZ~u<xQOWsL}@<;Ubqo0)tuzy#~IBn+twD$V^5tbdNMy`n2`m2
zL%@`7s}YPpgE6TTjDpGRr;UO*4Ckx`K59Q-;IoNyZEQ9RoS!X(k`<cSBIU7|gDam+
z2oP$C$}zG!?h$qTCPaYOYUaHni7$bYmc^>WoF{&BHWj5=M-P$X&?f6IqCGm!)opK=
zDdm%);5*2P>A`U>hofsjO6G9nIG3Z*BSbkGInL!^^n0Qlj2tB#i~dQJgOQ_zV^Luu
zRJ8zM1LWrqwSiyKoJ=|Kbw~ZBt^mq)k~T&EIog$@Qt)hpF7Fip3#&RLo`>p6_Ck}R
zlH=xK9F8Pg%({|xwh<L}R?^N<y?_ckD`_X+e~@-o(av2&g`HKj^C-|sn~_Z>z9+9a
z&ST^8V&NCKIWd4+d@@177h&<(I?Ykbk(Gm_Hk9ttdrGlx3Obg22Ekz-{1QSV`Y6Uy
zRh+T)E$3;DI+okqa%@dti{k%5!I3B`^Jxg?Gs0%MZ53cQ1=+B1;5qdBb}@qKO;C`E
z0dzZuAZ@CCIewd~UBb7vPcJ=PT76b;%(`fNa?)AtqWkzBfShzzyXe1{h>J;QwTlkq
zbNge&th3rh59R<b;DX1z+(qv-121G<nHyc4i_9(SRur<b%&T3}=*?>ixFImF5%Pok
zA^mfd-zxB##7*+A7r5?+zGLh>x4LMnx#hFgf*+`Omy2D06Zi#xCjT~p_eg^LMYQKm
z*KehKenC6)zstqOQx1N?W#sP`xN899tBBw0`lFEFTT}2Et7ngkt!oqb1xv{Pg}{d=
z1AmD5?{$3+`4@?gCH{cuW8bIPBf>+%{-%N8pU<J>VSzuE3S10T`vmSBg#3S?{f{Ys
z?Oah{(B8*|zpf&`miSXH9lhS%vUg44V{o*2(6x<V%g!~0VyJvt<Zo`-y{6z3`tz{R
zKQ;}c|6BCu-(7=y2ap2z6U0AurP}!UnBdJ{xihmRf7;7T|Fk>zDB)x7rHY>0o%n>P
zTlz@3+=H}hP1N4L3eRUbGu&s6w)q<H%c7pQ`IpkKSGq@!k^E^dQhu2`cR2m`N-&>{
zgGl!phEh3Ze=Q1j2?{bvgP{f2(ObQuSo`;bSa5`?dq>5?JAVNl*rJN{rh->cQ#Om(
zKPnrVC#U0Az~=T*h1naF@(Za=lp0}khbt+mCrL=~^N-YYnm-_J7AW`+Xks6JS+@6s
zE49D{inTaNiuOUvkxPYF<x+t{W~yZVPQiQ#6@H4sI!+gT+uTB_ql#OdCZ%hFQn?*c
z(>Y|$PL~q@RM0U)zY4;`s=*VwMqHyR>YdZ1WC6cgW{z`n)NVuR3LZi3W{$gD!yG&q
zzceRj74|DpCogDD_Hp(b8)uo>FG6v)TY(#L3C5Zd_*zU>(H4iPvyja3ur7uvdw3c%
zR$Ap5f?Yk5h+zmq9EOg7CWbBG9JX8;@KtXtMjemnaxq+-$3GzA*r$78aSqvHQg}>c
zVQg85On;9y;dowVYG-C2KsO`BpMse_FEV`+G@0r1BGa#c7wB++;{~C0a3(x7_^xQo
z3!dXh8*LuBE{|T*ymX8616bn4L|MdE*hkk2Q`snE48H3cZ5~^%WPd<XF>#*`y71F@
zt?*)KH5VJRq^MfndeealwUxGLfmS$){ozvM0wH?v8l`nE(8B3tU29w?Sf!yXq2(T1
z%QafzL$vKy<Dk^CMQOPasAvPP+oB$=@G4Y@`LOYc5cS)(J!gyJ7)%xeT8DB3c+%(r
zQnb1ABBk{+ihd6746#L_wHvj*YUBw~r>(U&P+`DXxDk#-4507|q&43*>V<6Sl}ha-
zpoM>Ck;j;q36^$AD2oRH=2hlxf)%iHU=e53qX$@b^Q2bSXAFh!t$P&m9<s9Tm56o;
zW=BKILZK`f&v*`l65|<mVC<Ip0oK39(?Ai=aQ^G@3|B`y!}XKn8Brne3@ap_VTH#t
ztnhe-6&}y9!s8iMcs#=jk7ron@eC_Go?(T@Gpz7<h7}&qu)^aRR*L>O1|}m}#xtx`
z{b_;9c!m`o&#=Pd8CG~a!-|M!SP}6IYn1*1$3Q!tVP)%Y3S7lAtcZAq6%o&{BH|fV
zL_EWah-X+4@eC^>o?*?_8456y5zp|LY^0CGI6+9X4$vjBj5k<MNbhK|j5k<MO6ORy
zj5k>7fRFKpi;*BC-oSE+(S}qW28r$RUu`Pm4POEg@rJO&Xk$SPdh?+LXy(RF?DC?Y
zE61%mqBhP1Qy=Ptsm4uU>RCSC@(@&CeLa)#R7!tvCd*>+v^7Q?g6hBHA~TkUp!)0l
zI3^B3V|fUwzqyU6lC4-Cg6c;l=8NSasQwNU;Se;IhoJg<w8KdD$Cknm`iBxriQNsV
z{&$I`#qtnT|5{=hu{;FT{~@ug*t@CoxWq=q@(@)2L1NjlJOtInWAR3^It0~!!wEnh
zg2p|@a?cfqpm85#hSJXzbA->~b}vEFcoCk77vY(B5uS+`;hA_5o{1OXnRpSNiN63!
zRd~kTbp+COvE1D^0md>s;|>qcxD%F9!sqV!IAB+XXWYGb3;%Vk)!ZTB8LANB8F!y;
zxb5b1`#%Bf&hU&oN!&6#;~wxdexp7`c&1CDyI%qv5zFw5yFZIU%?!`DlV1{;rS(8~
z#+~v7ur8J-icyqUMkqX%be`6g5egeq5eiRq668d1AtrhuZe?&GMg$jPVy>hT1{Y#t
zdCS(o;6jX7Vm$gfgLI0=#FgV#1{b{J%Q5uE%iu!13@*gW;6hIkT!@#!g`Og~&{GB%
zdWzseybLbH%iuzMBJ^xDddlEJPZ?b3DS`{}GPn>ggA4H=!&}!F@iMp&|0`fyjd&Sc
zh?l{Ico|%Xm%)X28C-~$!G(AkT!>e}g<c}K;4QfXxp!x9A+{&o-<!dO*j`(3tBK%(
zw~pnE=I7#e>M2Gqwv0M9!8AiT-F+GSr4KP=XR_SSu~FKn&pj7sGkS)>7K{$$-i}6~
zXDZb1zJlDLLamXU=H_4U(1#hf2;nTZ=xtdlqfzb!Ogmhm+3qBoF~X1?HQ?S#?nuR*
z;{J}BM=7+(eVp9U3N3a&#UbM~h0b-S5FMk?`R*5}IomjH(B@M2?JVHw2BX+Ua*g|K
zqGMIQP3}#!IY*^k;hsZuyh2yGKVrVQLfB+*n|~Zf4+yrIjKRK|c%H&H>h5c3$wb2s
zKZ{^?1x+b5QU#7?W?2(4lvoz)&9c}9`h-Uz*mwJ41k;RC)=1xaam(ShA4G42S4=fG
z==?@!-%T*koWT*Z?=#5DoWW}Cn=GiAxYhdWUjQ+>=rSU%{}!qIm!gy)F`55rB*Q(0
zlS)b&?0dg3qN`3Tv;iKLBj2ghiS{BUZ(IN@BwlXKg>Z6D`Xb+%&9QP`%29f*z{v!q
z(48`t6<R2cskQ+hxN_xrhz~fKQlFQ)Z>-ccLg`E?qp~7rFC;%A%3)ayz7DF21^ox7
zZfCx-!-yM#M*N_RkeRfrOtb;>n0S#TMqE4L?>ZD54Jue<$x=uKC8B)#JT0v|6)cR>
z?L_S=@s}`h3M@|NISvF^Uqgms)h~RqFpApBfDhrs^_EKXwSxM&Q5n-fcbgC2FV~?v
zGIN0=#*;~>O^wp+d`9F*H(d-}S0F#Bf2z>W&+QKtUY#CAul5`U4a4*)ICRn%xpX_}
zI;8@&_7*KJCzp+~9P(1%A{Xtw1h~{!;-Ws{TAD_S0xsQFGkUzVXg9di(5k2}AoP7j
zeWOth;A}*LvuynVp}!P(%5USqpD2zbt_LpjD-ij;3|!0753nJuh!S;XXO^upMHx0C
zPucQT2ruaKWSw0ge1JO3(nquH{!D7HQ!eVz@SC89pM_~y-=Se5MD(kq20P_N9U6Sd
zK-zFsn1;<A8oJPJH${owWT(8eL&NN#hMU4P+}xpo%}c*sYOqso?9jjubxIp<57TgG
zhlVey;TN(LcFN5i8r}$M_(hn8`#Lmy3=w@_l!#i`DYtcKNJQ_DHtY-2@Tjd}nEogF
z;b~}4scz~>UCGq9OFjoNeV)|ywA3|M*6XuU*IaG59?kN+7^T}fUQoI|L&MnzWrJt2
zalIHtWjVv`#`mI7*9=@XwwHy%-N2#perEqxly0l~QmOm{*lzF!k7P@DOQ;+?!dCf~
zP+1CGs(f3hydF6E-#l9RNtAA@I^I#@Godj#&nNioA$EyB2`lkm?Gg{uyHWP@DBafa
zLx-+i)O7_)4SuMu&%<<mY3s_;V_1@Z$kt%%(I*68vl!9&p-$=le@G3gUwtbz%tOfn
zbng#Qx}D0|kva>k<bllL2jMHbWIu#i)81jt2ztqB>6|!iJ+U47nyF8WrOvRCIm#ZH
zhw0Z-gU8bCRNXsLKgrY=&>D}$3~XyWQkQC3u~OGuj2M&YM?6KtY1`J*w?iMF6qeS+
zhgs9L!<r~+NU(G})xeI_MNG|b75L1+wk9FWnx3{bBlMSP`9qeNt!+IcmA;qI$gYLL
z!CTlhAF{a7NgQc6%!h=^alo|^dJSq+&y$m%ojf5o!1~tCg~-QLbE_0$m-(J*`bnI;
z;iC|)OQ+ohVk*X2;To)AI8}_$PiJ{kq;gy78%p_kNH{3oR+eH>*@K`VStf4v7?;lZ
z#};o51i-_el7YxZCKGc=jF>}4j|MJ^8YAY6CB#L$h!Jzjt-yz32J(s-=uKeAWHoJj
zRQk_Wev!(=e;Us7kV!gsL=fVNs17ul$)m!bR}&YRJSs~20B|jB86Eyhmu_p?oEHEY
zUv~iatS)wnUkbC%AA_mxZJM!Hn0*&;IaJ&)rn>imr~XNqbh%QL@+uSjS|sR|P1VEo
z-6UP;((TNK<p;>nCV+nrGu7EvE)=DI3p8o=g~ABm>2{{8MW&O0LuCb1yyMhuRR{9}
zpyP`OVE+(Q`HquSlsMK_`Hom&%>*vX@vc~7T?`x!zmSdOn5<P>-R6k_YSkWtNO@PN
znZN<>m<U$5#sL?#dd$TJoI_kV{Ft!(M&PW~_e8ml07E7(vcGqU5>3Ze-mf6QJTzAh
z{<0J^InGMzB9>!cfHrsm+glegB&ChFGwC7*r551Kq+1kAdbhxEQml86+6Im95^vD-
z9#J%~`vhQkyd^<s$_565j?$4%X^?HmG-c32h>Y!q3>koj5Z8yhL6fC)3IkrGn&JA>
z>~SwTbvx<XN(GM$Hc`beju|gHImpidO{#cN)W>?@YE~2V@hEUDZ6B*6D@wODRTTz6
z#^2rpSMLrD)0kzJD9e>#NsU>;sHcHTjU&Wh{SV-&e^(}rR*F*AvMxpo*JO$n?5Oc@
zhT~GPXtT3>QAt-oq7~VW#zPpFmcx$wKsc?pNI>*BQP#fWQjRS{^EGYEBSbGFw-RXf
zbOTQTLIob_h`K{$sE(yb6o*w#oUP;j^g=WMN0YEa{{sko@}r4*`U;iuR%F)1%*O4a
z{Q0*)Ag8&iRdX~`c0BX@8}p+&c>qRK<YZ}HDxPo$tG`0-ko1{7u(1+5pbD`A@{877
zAu1_1KzCP(0DVBL*Q-Tk<%%8Bd18l@E4DwiV*8^_I8N1%J7g)k;v8D4d)z^jrHUsU
zT%zY*&8mJ<JS>v?BvU;l?~_?U2OTU-0PR-Z<vv1*rv)|70kyeF>>eLW!e3E@0Q$q{
z4)%xK-RwzU3RZrusPE$f!Q&qRJUP}w7Kc5=nTcFLmQur=>@e&f*HeSb6s54+!sxRC
zWNL5bqgnMr(-X6_%j7JbUI1LolP;6<WEpYcN0-ThUkqICGA)z4%wxob52H<X*{ceH
zf5!n+;yWe**ND4KI^v4ScGLElbl%!&nl^C<jT~=Ie2sN<hFNev9lFq*I5~h62pa@+
zWZV;qYUrxdgbV%y2`90}8z)Jrbr8~*JG_vaTnc*HbnFfff;hEKVN+M&=3J1cUW}Wq
zyxEMKmw2-sH$#hXb0=<Q<EBtE5Ijo+WgjSeL7A2{N9J@)LB=Yk9tJmg25w%(%_Q8U
zmMZp53Qm0&oK4`cBvASkll={}N0^MUsqQnuo6eJkU(J<SG(irPI{6T2&ERJ4$4%x=
z{F=N6zpiHjEp^pADgA_kQ=Mo}j|rYOWhYdOT;+wHc@EZ;e#Ve5(PgyRGR<lQ^-9NN
z#sIyupxcR?0^FoVN=@wx&Q5TqrYqU0qjB>YDS5a_D~4uV(=Ji9@r{D_u-Zhw3Ya`r
zD5YT0<uK%6QGhA5Be2tv!%uKd{w2t_L16N2xcNPAZp6*_Gf<Hl+TPShf$ah|^$>0*
z%*Igs3T~p!w%gTkq@_MIQ)<0ymV`6EfCn6Ncua?<AJ%fL?->VYJZI^4H<);q6x{)Z
zwJ<}jN}dy|l21UB&Hp*E3h~Z?#lv;(+VnKcwJPZy3JwSRF{(fpP80LyYEYztG%>3_
z2wV>BgT;E_BdO4&O*gu9TT$$MX;c5XSPwv<RB@wFu>>@!V!KdrD{%Dmk7A)>ty~P+
z$?b^On-JkKr&P066eW3{t>$N9)msl-a}I!?=R#79vU9YNr_r!xeKAPUW?+Z(vzNM@
znGjuTi?(Ycf5W!6R=-Y)-lRkuZP9yd(R6L(O!{w!eo%-W+^Ixwq$mw|-4<P-jSO%Q
z-K~EjMAzM_M4tmXGQ$JbKHb%awrRE&vV@l2po?PsQX9FK#duyHE<|_UrnGo~j=Y)~
zyrUNhR$x~MYaFA;9?wE>ygW3V#Xw}#-A}V`>a!S#jJii53`9oVD-kUX0*1B>{Zs`a
zFY>8Cq^i~Z3i{y&!(ljIg6GX6_@z0-I}@gOXTl-gnJ~pW6Q+1)!W8dJnBtuYa~E>4
z%ny(#+7$0h;GrLwYl?R!O!3YHo|uE_W&mc#nc|%ZQ@k@_igzYV@y>)pyfa~ncP32n
z&V(u6nJ^h8P1Kwp!FD4$6WPF0&z}L!$3W^yv`dx_RJ=`Linl3D@iv7yA5uP3yiH-s
zw<%2dHig+6Mz1qW4e8c7%(0MLXKAjxpwMsh+YD+H9_Tds(;-H(W?kAB&`&yIOxB-K
z8e_mNf%z=HBw-AcSU2l=nmI^fiPkG2SRXCgx*loVH{q8@zEu_@UrdYDe-A;uxBeDb
zJ0mKGM|B{3VUXUN2H{vM+B!x}EOs1!F<j>3uS7&pqLSg~_$#TgOFYVnHhE_r(jmbI
z5Q*nklJp)_5N-PJmK=Px5O!;`(Uw$Oc|BgXm4nKh8x{tH4#p2e(Ax2@2d$kQL2Ktv
z30liH?_BXZKg=ZFymN&|s$JocYFBuq+7%wDc7;c(UEz^xS9qk_6&|T}g-5Dg;gM=r
zc%<4D9;tSv=zC$mkz6X?ymO`Me4>WI3BGyfN)u}&BU!$A=L(NhyTT*Yu82srD<V?u
z8l@kA?qH<am8~<#DuNe$^Uf6!sdhy~s$CJ0YF9+0+7%J0c11+0T@jIL*KGY&k-r_O
zcBx3U>i}IMBGs-Zq<1tCsdhanog*XFu4l^82>D)}WvxU48CDfBX_iZjvZS(o2<m$_
zm67TXfyg)GZbRda8i6GtBAB7?PQ^JacP@I*f9*XvtE-DW&$7Cg0g6DZ6&{GS5~fkY
zXZ5@qP`oE+_2MlC8N4TFg#==$LIh&1KK%1UU454SDM0a_oRuVQ8Hlw8TnDNhh>cIQ
z`tdnG5s0<=vnbTeK&+L#Q(*EvIV<IPU~vx9xfM$Om%b-waLhNOzm}GE`G}T^LEiT-
zyfPOf26?mJR1D%>Fs7RQ=>d2tmV><MXN%#31RUhe0p+r}#d4502TH74EC+dWki-&W
zImp{sAI;c<wiRv7MRLnJ2fq{aCHS2f`~@<rDCRGaON@5&ag5kon8rhsY(t`BY(ot4
zVx^HjE#_<F=8KO1Et5^}238l|GTCDk>?*Bd==*%oV@6_8TpZn(ao||~*_-HoyruZ(
z#QH1o*aTup5{rrLPb^q?{u!L;6dKK^C>CLT7d@~>XvvB_hrB@z0?Up)n^>CE5{NCt
zE+Bd^|H!0~JOu{v+{3cO^CuRmmh~n~>=}(jcpHqV@O&@ckz=i7u)tbxJiLL_=Simi
z2)KRfStaMuJALsI*YilM57g~h>fLh!U}N=;MdT+KP5YN)dpeMr?LQN9`x!!-9{3y3
zq$V&^nQ#1Az&OFCG0`4i18B*AsJZV81@%EWSYIXI4VK#ssHt;@ly#mRV8&Ws1@-ir
z4%r0tk%=8zN*3IhR9jz<FgyM6HS!ubMWy+Tf_#ZO2|IQ1e%EZQVp10<&LIT{eU7Tv
zhf>2b@RMpQS0MII^g*D)_*F{u8U^*?U%;R=8lQ7E3>88)^G;i6WCHRQLNydhryKSv
zrk%Ndnh@AZ0j1}t68YTLGq%LmbC6;K*Q$znOu@q};xa_nY4fKL5$0@A+#40t19#eL
z#+?H-!kpV9RO$J`obxCkC7x6gui9z~g~YW&0?qDoDD`qU={bfCLhe=cu4rm~L<_Ol
zLeRL*Be%D1H>&0Z0cN2+1wAi7*ndp$%R#z#fof~L+1CCDOf;@O<RvUrrTb2q(?jXe
z`|$xzVcJZ{Xz6^2b&O(`+CoWbQINU-0_hh(_xwnHOxl$o-%JIx`Fz^s(`{Q_YT5Q{
z@RwkRA#L{2u16Lrn|-vIAAuEhaHY!NPTPPkgON^HIr>~AOTAw)zE_YfwL2A-fh}t2
zX~j8atLPz;Z)0-WcoA)!rrWmlQ8pd|e>-jD`x5#z4l%wGkszH3X6d$|y%wDW?k7kf
zdigAt;!mKY7Abv=3ev#YG_YqWerbcbeRAK;b%m}E=Jv^bk3_V$`eAI*s<0MTtKeI3
z2F^z}?Qe+8+Yq1%tpR(?P9EKq-=I*Rn{Zm(Q@iHlm->i={i%x1zEKhSaSGR_3z0~C
zoWgY#Z=)vR*KYiXmw9x|FHVbkofaA4YnUi9UbAJR@D`%O*@DHs=Ll$8jM&(D#Kta0
zZ0tN@W9JbYJCE4ddBn!fvkMNgJRcxYv`1|0JYr+#5gR*?*w}f*#?B))b{?^@^N5X|
zM{MjoVq+I0Hg+DdvGa(Hokwi!JaS_vCV59R4Thy%4%1RG$$P{k?-4sW56k59h@G5A
z?&LgjC+CqnIgf^P>l~i3ki$+cR!s7ae%t|b<K*a14`9}d<0S9!&wv;v`8ZDUjsf%`
z)|7Fa<Q)Sg)-8^cykn5W65}|@+ZZN!xq!??LN}I-b;!mep560^XZJkf**%YVcF!Z8
z-SdcN_dMd+J<kP5rk>rix{gFzAC`<)0mkw9pA(jh%PD~+BUkcXMyjk{yhUleTrzHx
zWkFk@3bkbXIc~Ac^nVK2h0pF;N#a&68J_{wUNZWyWK2Ydh~u++R(}?Sn&p!5Wr0~*
zS3J9CrF=<DE^m0|;<QHMcQ?HNzq<#2flPI=YI*ZB+{ek~4Np|;Du|A;t3WPqWcA>4
z8EScR50lB|4R4uDE^lOgSjdGd=~%VA8HcevPA+eFOL4ipQQ~oOc_XoyIJvx$m@iH)
zZ)h}@H*s=#lP9!f#mVK(WPxSJ$>ohq7l@O~n;C*P1qQLPIV~30X_4x*_EIN59OE8-
zE(kruhhseP`Vbdp1%5cj(?xta1@<QJ!!e!&{T^AH3A@n}Jc$bRCGf*Bo}LO#On3uQ
zo?Z&|Crrl(<>{@^v;=-Q#?wckSqWSRdip9fJAogL@$^$@Ab}r_@%R-wC4nD~@gym<
zIAIGj8lcem3H)%3Cq@4i>^G826V@?ps{V>VYZAD9^`xm1H6`${*OQ^p)&zby#xqpE
zNEC2I0zVvsfred(&(<Yy&EpxVb9HAXU!*7S!!e#wI=_y<?Q4Rc@_3(J;FswM+`fA9
z^i4v3v!1{Y$9Sgcy9K^YPvD1RJku4vQ%~TBV?0F)->oO`!!e#23g4?I@WU~lj_qp#
zKOEyJ7S{8_F$w%|jAyp~iOApna7;|vX~3iSas_|H=!{k=J{%LPabAw&hht*3YM8}V
zSpf&ym?Q46;L&6bM$bSzR*dr8;3k^%^&_!PG@nGz0lGYn4|02+klxqgxRCZdDV=Y{
z@j-6SGn0faAKKnENZ_>C?8JmXzbW&a77Y{B?`>*VO?)lJUCgHGvy7-AaDN=1&o#sp
z1KYiPKG(+7^SMT}3v#i4Kq9{pdm+>C3nGSB_HIoKsYcu+RYHD2#PIEvHpZ=i{YJdx
zsV|6lqc>1r8S1)5xB8(;#0^H7_2^BwrT>10`B-;L%o0apF>2`WiZylD`9d%;PQ<^u
zvlK>hR@}I*NY-B_%Z`gD=9fJ!5LeY5SkerUZc5xf@&?LIJwJ|bZRu(bDAi)cW5?c@
z$&iiXW5?cD-qJ1yRv})m#5g$772>gDZyZYzpQwA8dzUfHERG{Zmn)c)Pf+_Zn|O{u
zT^?WoyKu~d7CNJ+_{4>|TDC-;>*ii?qh_uax1ztSp}TwW6Bp*1-#`FK=K#U#02R|y
zJYs5=Dh2I91*IJdN~xf?)`wd$hwQQ@zp>Dlb7uxUto7SNd-HTU%3claPzx*^QJw?o
z{#a+_(FgiGKLQW=6m`wJ*1~_S-}5ZkBw>V|?9q<oo0uGFCNYf@36LbIkZyTK7inx+
z@1g*V!Jf7hdpIP*CKVz~Wo#)<Mg;O%A^s`YDTkGQr%ICy`wr<eFu9C62BzYdF;XP3
z^-ff>XG3BlDixpNFh=s`4iE<Avsy>8$^Hk>G)9J}f`=HRZ*Lw|(&_v@hl}Gx(nl=7
zJ{^x+Lzz;1uY&w^&OW3~=MHtB&K9=_q`{(D>=Rbr34Dmy=<OFO{tjH^`GU+d#m-ao
zWfDaXkJVgMoWW1O>)+{ihVPsk5C)E~z~^eP!W}e%HS!%@H@Ff(J+2QViq}ck4$@fN
z-?6ASfGe_PDipPpA$wdYOO(b}6{LT4Vfo8QlG3WkzgBPvS6jLv-0i4>z-Gm`S;3(f
zFi)qR3FSjy=(uNQ!l8ZWT4RXNp#K5Z^hNCqVeRzghf<6oG<TSY*V9x=XNfAyBts5)
ze*;Ij$)~xfB4a8zMz(Id=jGA>Wwmjz@Z4D00J53IifSVGP>PYwVda-Z`Jogeo1I5H
z4;^Uu|KaUDpsOm{w&6Xe<ecQBoFqUFA?2he)X+m{hh9XDG_isKkzS;$6j2mJ6dnuM
z02`oKupuHSViyaRM}4h`kNViLJ$C)C>%M0~`M>qAcfIeoe%2yqu9>^f?AbGW&&=jQ
zDZVc3Re4ZK+r0*`cYl<cVeNQOimwkr3257o!6kkno~3t~==u6HcQkUnj%fGZl+g(!
zv9!zn`no;@!cMzTBnPE*z7MHuKwiVyvDa|}+<3&&=34W8z0+WP=SNVq1C*V&A@ME}
zrN<I>c?~6hp`?~yuTS<Lvb77jZ$Nq*EAK=nw{K_4{T@XfC%}TwXhBy}j<6JS9c4eE
zI;(-oEBcr%?nS+zU7S};NI(K!OoJ|tL3VTQD+dun{^3M>eY_~wN6sWd7P8Tf0cyeR
zo8~2H5Dx>F$ay(03vN9b<(E+7D}pCXwau7X(2NgSM_X{*XpD~o#|J>uEx<lH;A3~p
z?f5OSh=V@X(H|)99y%*QgT2l53I2EwVlLRC9f@9(#y@5n!dzjAR@Ns-gH4RI^lh=^
z4iNNUKU`;tM%iEUhFJ|^oula34uHrjZCRhd4^BL&Pw>Ypkq13ri<rQ4$?E<@eL@m>
zWA&F`Q&)R_6nk2LuJn0Jlx2xp$ZhXuiR)P+sOM_G<4f|fle`$&J@+HCgippozB0t^
zAo5!5V8@ao0lRF5b1hW@^cHaYC?a`l1`4K;FhdGnnhAUpV~`~{crJt|K*&xbTe8L@
zt90);b>c(&%i=sSXB&#~ulw!emEtS=`#dz2%smSW_}co|(Y`^to--i2#nvq7>ng&3
zM{duJR$n*CYCjA5Zaqh(?X<tz2X&V{F4_la8Zz-O=_&jPhFc&KNt~%B%rLq%N*bhV
z$-5>bNbBLQxEh3oa=6kc_8Ddb?{TB#9ygr#xYBDa?RNW%-oTu~;4gu3I5faCVhHQW
z;lw_BSUjhwywi?ldANGRRr22}JBf|4xm3QR?m00*f!=n=<;f`JtkdQ)cA71nkZD1+
zH2_|3vx9*<N4#>3i>-hQL2-f;a1I6hgdDj)FdG-v#(R2+D!mQ$HeXWMR1xNcykmv6
zm;;NPu&ETb0XeN?JTz5iWNTEkJmyXI-(y8HOw(!aKS8ejIw_=IPxX>0vbVX2RWn=k
zI(^4YN{DH{fUOP8k|@lk-fQOKjwtuu*$n1BK=FxG@afSb6wjmLqInP`_u1a2M`O@j
zAc~xVtE{5FAmc$YqUZuD+JPLAe4R?(e}v>kl>7}P%N?B*;!>8EL?L}lK6#cJC%tsC
zx|2B{OJGohXW3>c&A$g3>W#p_0;^MQ>geNL4T&0Nikb{BiBfu-cNn=9;*e7@->Nzl
zq9&qP99lt#enw6OAFG%Z$HVegc)B6}kqVKM1%Ak9m93<IWBK?){ON7#=+A0V<P_|)
zimn6M8&1(`D(ZwMVLE78O&_NKiXu`$QQY?DydeHTf?%BtBjqmN+oX_ct*CM;3a4oJ
zo`j_CjjT^=scOsxK(iL$A^lqVbS<E$A{A7%wW{dTb@b^)5Hz#~`m|mYIRy_{MZSf&
zTR27Qsb~XoG<fT&=%0YCILk2W>49%eLexH`Y7<AOy_sqwi@+mwND8ULOfQKVdYjqg
z*&=2*^=4`U^ypQ<R*p6+b-0CQT!9=lV++l=53rD%3C$L327`Ksrt2V_r)QXZM7R?=
z!U}%_yq7uQ_fYuE#ZLG=6uucyyyBWF1arv|UTvdS?}I?SB87O>$V;Nk-sWq@<{?q+
z6mGGKvzMUCF<}+29-`uH$k7J#5KaFSP!y92iZ>q7U>+ucYcO*1Q#oCH%a|Gv=bwcn
zP0L3ZBq4*$fs{i!wU$t<O~#98r2CkOYziM5XJOv71ZdILE<{a(fS2osOsqggd3`$|
zn(-P?*A!$wX+4WrK69{h9NAS%F+|8gVhj?c#}d_YVO+BRaqAq^;b|14_BPMbqc0?O
z&XO~%<lT@|o`Xt<qhF93EswV<Npm_7$0X%TEvWPIvgp@fxxbjfU}IPY(~*9-Acind
zP`8FvwM*1FHN`U$D8l2gi!d;c*{a&bs!F{WRrL$S?h<1GrK%F3LRCF*L>qaG@_zzB
z+p|djIO(~huI)N1+@o;y;&w9lc!Hz09?P&UO$KOt$-5k|KfRr0z26@I<CD2i)u}VG
z18WW~+R)PrVgYdi@Gg*J>`)Edwk@0N)2af;J!!quMydCRmqf36o7WiWLo!HnE}v^%
z{|VCW08y)tgodIpan;$@AsV~p5>#pzOFh~Cs`cN~`e#v&1&L-ZosZ%m3gkKAg)<W@
z^!@}*r>0n~C{w(s(6AN<${f$(jf<Ph{U9oaUVo_#d4Dh><j>oXm+rJS{B3`AXqhdw
zzaLCC3S^Tgq<BfxJ;0pGVCAZX&ax-0h2iDsbU;;%2A6B?+qifTT3NFOYayb5B8pXn
zW8Haff=ay+5b>uKQQRPc&jTD<Edom#1a^~KQmJ4x@NTUb!ZHi%pl$=}q*~QEHRW?v
z-7Qd8pNp6_rA^gV=$?hNxvfQq7Iv#(X$Om!Eb8_EMb=ondJ&X_sCAGkal+4-uS&j!
zl4l!~46<w+7g5Pzi?%K5R>_t=#Ns`Rx^<z*I*a#H$*&xWovuopaBrb1>9zt-*P3bU
zPq$1<7BX-S9lC%D&vXJ8cI!$n##nq{p?Y<;#qj!b)PvFSA}+;6-KNpNX|{azqHbGg
z;7p4*(!jo?SfU0x!``t5u7H8NVc@_$O5`r-fm><D5-VoO;z2O^LML=FgtjOB3Ki;v
zoxMc8F24+8<vjIThc=kpiPsM8U)W8if-9}a{foNor@$*LK0v$Qq$g`tg%f>fsj8R-
z6&G0*I?`||9C9kIJFKFbKHYeviZN7ryQ*-aOD<Lwd!XXqP%&_v5@~1-Ez(fk-XKOp
z<?#MR4AmxEiq*#h%t)%eTa`HB?^q>iE3uj#1G*}l0(-aNtB}`_Gf;waw-vH&acPYu
zf7brCkY|_oNN*Cp9KF~8Td>>yaxQnT^cy`<jDG{n`wZvt`b@~F-@i<Kodcqz0@N66
zKi;Q3WkMeh9Pi`ffxRH8nmz|s9`EBTnqPoR_&DtZA0MZ+UWF;(eN=Fg%=g9-#~HWb
zg0Babn+%np$9u!wGG$ob_iA!>GNu@%`LMjxsxV9*Y{oKjqkYDi>0Swc3~`&RxudPQ
zbuHxa^%x&{mt29E9I(!vaEUspz3Ev(@B#>qi$KI7OEkz5nX$gkG30l-5*Farxj7kk
zjmUk-N#e9}h`!L~n*d{m=nHKNxE?rVs{${l2yEVM8R)3>V4`lgW%KQ}`{Kp+N7blZ
za8cfFhyV9$Jd;;Vgvs(QJNdt}#?!tp+Xg0G?uqwhJa|Tyd*XdrJ*C+XE#Q6GI)VD3
z1-vg)s2^Iu`!a?4p#{7zQ>Y(W!22?V`k@89FH@)=TEP1<h5Dfdyf0IzA6mfsGKKn~
z1-vg)s2^Iu`!a?4p#{7z)1!BExhLM2Jpp&za!<T3Q;&4HC*GGS)DJD-ec23gP(QSQ
z_htP7`Myj(w1D?z!v)(9E#Q6Gvyk1e+!OE1jyjkK@5?aNLAm|V0^XNhE7*Q$0q@Hc
zZ`2Ph;C-25`=JHAFH>wkv~a}xGWpN~-j~sOzAuvxE#Q6G(FYSn>~hb@;e&}HM;%NQ
zIqG1d$X*S`|ILGm>=8t=Iy4Utw`9#|2#bRFdOAa1?5E1g&?vr{a1QeRXNU3xvs;5V
z3*SuOk+QND^#AqEgmX!OZzep9UpbT~n9C$uHxA`F@|y`1VZWJhHIj{@!T4wRl|y-g
zMUv!;{b2EK<hmF8S@>o`HgaVxXt0p3P%>Za2TPt4q=)hZOTPh%2GWANK%TiDBD@?~
zCX#tCx)fiIEECC0!!SLN`87JSV5Te+$&_UxnYW<Dg)=_^Q*x#(6Ukfwu1KaV6Umfi
zBAK#GBr^du8JV(7BvY1&WXdv;Oj#z9Bg;fGWtm8(EECC;Wg?kzNW<$vt_4j?&WDAt
zH1Z}bwd?=y!dNFg{1I}(;m`0lW`4onrVW3P%{b_S%k-3v7|6?l%XE=~n8?b{^i-}y
z<H}F2NJvj(EchN)7hI-io=G;YNJ!6Ol5AX&kbcC1%fF~aRwSh7e@k-SG1Ci}Bso_k
zq+?d4TDT%1y-1NRxJ<{5PIRVmMM8Qhjdlwz)60GmDZ1b?z2bL4y5KVXs0Ekl%?&F}
z7F?Df;NdVG4u_c=4v#}RD;x^71d`*ILSa>^$1gc#U+;#JL!e8Q*Sn##3&_LQyP<Rq
z6<%~>C=$wWF7fqlD5?kVMAP_sH^jGGbi$J}oHCLxg^XOj-ZgrLQ${M+bjle{8EH&1
zP<)x1k*<gfS*ciFre<WULNfISj5Y%%e2|<QINpv}AH3B5O<4cY3f%UxXU)a~jBM?S
z)l`#XP0g0~1i6Y*)6NH%!6cUIQRCM@e%Q=r^Gn+pL(v>7KP`3yLX7UE@~c^xdI@HV
zQD5*PD#j4Rm!!48u+H^-A<9DA@=|$3a@?2ltfRw55OG@RQY~HDZLr9frY$F$b_SSy
zHq0@v*;`N>_hosw6dONJ!t7@ur171|_BEmfjcJXq@o7w6L4qc1OP;Sa%=hI)z!whF
zf~>f|Q753Z<rqr%8*78}(yj!Vzlr*cn)?NE{W+PS%c}Hu<FUAD)avg}t*Ec;S#v#q
z56Yp3zWs=vzh^JN)JB-fH1dzw+`ux@vZT#`f&P<OO}>&q+7O~qic)dV(IpTcsL^|k
zc@Nxj&{3e~S~!uvkhNdKu3HW|3e>bhu02R8X^h^043|vGK}tzuBsmo%Nn_Y-3*h_h
zK!p!NiK!5JH~yJ=NdhIXX<oP+1jO;}g$gFH<0dT4t&qo7n+d|?h|fFB#3OylG{G_z
zPJ*qzGIKNX9ogc;<jjuat%t9SRVhkXdqpeRtlAq#`IhCFj?v%eV8I#Mrad)0ii{Gz
z?PM+nu<;$e#C$KEcio}_MBl`XV?XE8gp_^<u4-Ii6ceYI?yIdB+2WS$Kd{}3k$WUF
z<sR9{OD9{=6{swHtip-gWX0YEDHmF?EhzREWE9Uj545bH)@$&m=pa2?Y#h%QmUkQq
zc`z4ET1?(;$SCC=ZL^s9p8}SxW#}(ttIYccU^2a1MwkFZ{jm8IJxK-gjT2n8Jb^Oo
z8wW{YL>0^z1;|hZ^F;wgln-NVwUN7rV_a_q<Xz=?b0~n-)rQqI0XfBd?c{4iBh~{-
zT`U6?>Z0!9BZJ6H31WtqPBG=%>C7-`;ZDUrt*SR5i625?Fox0A_|;Z4b0OMuqP3cT
zp{Oawv43sFj09I!s*0IHF}EP2?0v>(8uQ-<WH*3oxSVJ4np4CY$39_20_8Xd1Y|3%
zm{TZb?KO}&n{SU!;pO-eph`WBQvJv)J4B04XH?1oB`P<d45n8*)1_%KQ=$^{(y61o
zh!xNY=cFOLR=>F{0XbN)07*^K=ni^yUng49X)T@^j>k5=&SY2&B&y0m1yzl#s>&5s
z(ku42g57f$cDv7k1*4hu_(LW!CCy8xn)0$HFr}9vnKL2Rn({Z;MmLz!i>4g6jxw$#
zPhWEt${cM6%QFoG%vbaKl4mD*!eRFDRb6wyIZzxodqCD)yc|ff=4^4;JptmX$*jGb
zq@K)=LIx;A@>=*N-aT5dLkOgUkkslOp?H_$rIW9`4Ff$y^f?Q!w3faPv%UenS~`T%
z7hDHOGltNNdx1*1D#bU1Rs0KJWiQKosr{|MqK4yH+WLB|u(%E?2iuax_SbhptA~(%
zHp*MwiNtae()FRo5)Nwh4zjnB@Kq!}LZb3mqSl|FB-y{(H7{uP$}ggmRi-cIyUsap
zWr9Us;0EkNM!tAeMX&0RQ!2MjtT6DrO8})coeC<nru|NGILy1Mv>6sjR5QKw!AMu#
zgIYA#8rFij0~yV61z#)GBj?Lpize)~c@S2awXFMU8HB8(I;pfrsERUFJfVnh?4?s$
z`GqLLIxy;Ye!OY@*#&c7!~j_;&A*U3lW$b_{0r$`Pof!P!O!+~4^SDa(7%X7#OO`9
zkl2F!iwOq;itq11B78sSuB2+KZKM4ydm#o9OX<K8iWob^^IuH!ZUt&N8a7X{l<V!U
ze_5*q$o>oEt@sTMeu$>>SfaKUTavas(4sF$T3?R@UR%0Ka3P|B5~5Tuo$eR)f<b1b
zabY>}@&rh+S|2jnWimV{WpH*PL%aW#?EVh{ipRY{1dqo!MN-eq6fI4>bV@1u6k2?f
zjFbMF)l$B}^PUzh?4l-7PxeOJMNMWU3<9cLWT_vwzh#^V_@*(4i&?(xm~vi9(^<M5
zrTAAKppUiE2{_F!tV&4P*BjAtv((R8>hE$h{Ct(ovbGf{rUQzfvMeUqzsKI`%jEc-
zZq#x+NXq10Ne{wz3ExG(W(E`f1z5qOQOpoF<_@>O;8s@obo*QO2FZJod=kpb_*qob
zm+)plOl&wfsq(`pUy%%?%x0L}oV{`pyIZgP5ni~%q<3<j&A1{#UhgT07?Mp78DqIU
z-ghe?nx1bMo8B8hr80UR#+KgeHd_J1SpoBi#zN5u4!!mOwHpJX<`Bp*pGqS?My}U#
zB~1F%I`qB$^$l-zBeHXEry=DZ(8w`jq%*GHl?fJk^FZ-<gOOuc5l<mY%^E|qeghOk
z&f<WtdXqJ>o<`2zY%7T(&=|M5#wf$D@*_T(;`Gh8dUu2KCoskN6%`rGuYsWlQ61O-
zLhJ}Hyh;sC-h!S1-9UUcC@e#Kazi>+fe$LqX8tA+dR6bC<ptM>By%y?nuBc(i<^T-
z6JU@;n;{5K@E;6l`|7jL#pfVzBq7WhMIoC-h%@8W>k=&TzK50}xM_8`PiU+`9XL4&
zZdMd4ZH0yt+|0@S!*?L2bEs!C^?VK3lHP2)CP8W5UMn_uSI2txb$CbE@f1lMSk$pj
z5_=X^9!uSJGD=GBM8od1PUWn(a$3(59=`X(;KM9~k^X#X!Onr$4a(6U?BBwXIA=!r
zGBaA^#rfpLpRazzJG1lm7tnCunwVUafAj91?B8N9%F3$iRob2Qw=4o*bxUewE9^V%
zm~u2>-J;qCrT8bE7llgag)dvtq)z5j1km5w&?;x|d~5emFpffVk&ydaTf;ll)6>?@
zaF|`qlJHfrHL<G#R|UKpvxO9$M5dFq$;!lB>IR66BNCldgx47&I$IG~v_uhIOd3V>
zGLEh2Ms@yKnDmA4GkU$ONfNK$kd1iVZ{tO&eg0-%ox09)aXrOLr-*QvbJtp97{&pV
z<dl4Am1W<B=ivxX1w;*`sO8A0U?mPB`Bos&Od4qZ$xW0bvR%!Kh_C+)CoJzK_26f4
zan4l6*Ny%&ne1~nswW(t0hwLRm*g7js0UiE1t58<fomMOo+ekV8O%UUWW#Z^IqOx^
z?;uD)Y2{m1NQNy?)pICh#ywy}xSwJWE;o)fV}pv=gyN+Tp)KHYTVdk#KadTl=h^P4
zGY`A<U!fFrEjden!K(YW{q?VI^&7H(fXr^+B4L{(1xdX`ymacSHE-ar|5}Q2cKrOX
z+EaKhm~j1f{~5L6U(2L_&Hky~85;jOg?pxpeT`8D`!2HfRdBR(13TN(w;}jHlVKyH
zR`-DC^=Lx4&~&(8)l^<#{Xby!mdV!hTR0s01N1##wB<E7E5jKGUuU$7CuuZ3KeWK>
z>5B4iQ4+r1CdmtII(Yj&v-8|`o`0XB{WHCuj_?u7@E94+^8BwW$)TB@>plM)3Ra)%
z_591yb-qm%9I^^NQX5vE*Zt07Xga8H+j(A3M>%(sa`ebWB*%iy|G72lTw3^ra_m2^
z^JLHerGi7}b)U?Te`W23ekWzwW|g)I(sUI0GvhS>AzUkv_6xyV1elxof8{N$csq+Q
zSN8wLj=LYA*VBn<yv4c$aS0ie1`S0_097x@OA_<|5e0_imiw0!Qes%<>qQS^-Gy|p
z$<hm<N?@@Q{rerN;-Y4__HJR-H?~x(XZ5LJ<7;B^wpoeXCcrs@Pli-AshJqD6qqLE
z33`c$CgqDsu^lX=Nd;n3SKvOqOChXK?son)tIzj(I#WL0swVvilX~OR<jtMgvwEWv
zT3C*4=O^T0oW2#B35mU-zLhQAe}3g~D`u<x?aj`rjdN}`!t4}%XDM>?;1k!P`@4x3
zuRy5R)0Hm0OU*j7fvUGq{Xo?)vyY3@>;(4<`uiHbS7`nSWVBn2Ywf?l*Gr}n`YNa%
zC4G4Imj5Knxqo)zD@J&j+&SCrgj{}F(m&ifb?E#)@-))n)fZH**rrCcv{$P*IoAb@
zPF`<Iw%Fgl8_ZuL=3fdmIK|GEmOh~J%HV-2TkGO|f!EWOPJK|RP6JhMKJf5wba9=N
zcz}KRErxFbwu)>=y>z>B-QB=-zYE!%-nh6QaCLV<Z(Q9EI;SsCi91B1?@?G==_FlZ
zyQBnnE&87pe@+2Kf~S!ApOLor2yqD;_6vf)1@5~C#`VIO;6;ga#V!cNzaXz~_LXi_
zkctZIXYOL1d}xg8c(?CJ2>F>{n*{3q7@xBo1N7ICHGtnE0;VwE8XKQaWNzwPGX`Jp
zD~_T33**GR_=t+j-;HrM#7U3M1bXZw``EJbbW3!*{iX3git%f}hM5EJ7K6@&=1?PJ
zathJ#rXa~gzPy)c#0R|j@=~G^yZScV{1K7|`-3B(s-EbDVl2R*6iFF<@kZPkUJdGr
zRvM}>rh}DRLAl;>W(Ga|!-(t7jqQ&nD8+jYcFl<+I<v4X7ev&5-eYK0@^QRB4F#hs
zTGS_<b@R8`C3yAXUW}&aV>E99d4j7F{KiMqo&X;5G$Qk@jlv;RqyH~c0X3~YMSlL{
zNW6>00wg-VhJ-9w>l=r#w%-BXi~OG6&IE)ZLiRT$j#2}UenY8Od4kQJWPjVHqNv>-
z6nWn9yqBMBJ-o>N`jdS_<50{S`lLPXhJHdm*c{0!M;h_9YL5JCL54cuVues-NgVaZ
zw@z|+S;~=zm!%wecv*@)ysYjbw(eZsF3?1N$&y<0>UgT6zZn5?54qfSjBZ!H4?-^9
zzfiANmqXg2HaG5aN3c3iv$+YI>m7`u9ebt`T7xc)cr{m-M(nUor5{XCsP{)R5N?D^
zM<0Lne`(`?@bJd};Q!~w|CE3)<#U+xKihTg%iadw)UdB{#NcfXcb)r=KB&l-^CKyu
zzNTG3A-m3fxlH<G*SYVAUFQ@bFQ<KZO_0op`r;Gu8|AKZUy&sFa@tqi6S=rw%NJu(
zW4?lGfaT@1uaK@#GVkENlEEn8tE5cqI`@^%07?lY1$+45?tTz@Sx1~<koEt|83tMZ
zjWZ0Ak~gTOSy$20|MeLLveP~kUJqfx@NM{;Z63nkMh$<E%@8)0o%W%W?@=i4wL=ja
zfN;ut?U37PFYmQOX$&LZayFKo_MyyX=>Fxsb|{NUvhlrkD7(MZ2{*HH`O5$4q={g-
zD>$0u$hLNTKP(wNRgBx(@%=F6_F@A-f$xW5Ld+_SZ9!AR_rnxMW8Bt`?}sUj#oh!J
zz8|JA9^<xld_PQKWsKX}@%=D`)iG{s$M?e&*2K1=tH<}l6eeQa)*f!y)*j=w_He_t
z_ShOKYS`8u<F<BuKWqRb`bx&cmXNpHaOXCb>BP9L9p4XAk7mTUtsUPFQ#d=uZSDAe
z*ivzDevI4N@%^x#fLx{%<F<BuKWwVtr6$I0?f8D!Fv#XIomiaoH8?t$c)5vjTRXlV
zwo2$%n;5sX<NIM-1g|qOZfnQ)!xV2cF>Y(e_rnx#F)?my$M?e&Z!<A&Yd_-qVKHuN
z$M?f%J(uakxUC)E51WW=`F>baKVz}IaS(Nm?}srY_WNNP9nXG0OoQXTAEv?Jw(}?$
zg5hou5*h^^^h;I+Gnef{au>MVY;;2Y(0V{wjNm_Nuen2ZF@istY>j0xf<NsW^6;kb
zcYDqCj4rp=JdKMH{Lvy9g4QmJ5&TE*HBV0d6*6=&LSxz4ot#>k1gYHFot(xbFNQ!0
zP`V;s3{)(O5t1|hMlvN}LZ^Z>G6**eFLD|Fnn+jt^+melR^j)WeZ;I%Gaf|2@D%*b
zYmGni@E_+_{lLO+jJwNp+LeG5?Dg7%=e?jP<S@&8!%O~@Cjei-jZWc}fL_6dQs9S;
zV{7+V0=alnfWn^|*dHc){a(i|a2=pmFb5Xmb7YQf{+<N6y_ZpV0@|r+A5QkkPdavi
zHv`78bbBN_AU;^*{*aRu;Q3fV76tb+PT>7}6O`+{1-8u%g8NbM?5CVyfp-E@@PH!)
z4?HY*G6kP+oWP+^tKb7*>lStvpHIQJKkWnyd>2qo_&UEo49R>()hs+x%_66!_?#zI
zZ0%F}TQUwNE#a+f02oWg!PyIm76T!Szp)Z;FwU5>tx>n2^!x^+ZlF=$AWJJzVCJ)A
ze~#>Hjboc{**l<cX9N3MvM)iFvJ1Rb*w11}t}>2orDcBxg}*kiUq$w;=N!Ahj(}dl
zRBFG{IJWhceH037a0zJ}xRUI*HLweOR@hIV_PNHfRX>w}P&~3j;k*X+xn#fed8b|A
zZa}YKGuhuZj;-hO337WskQNu7YJZ#T)%zT~!0~{^)2y~-&na8!yL9HA{*Z7Z%1iH{
z^mobq24NcEdn`?P5sxl-vQP??a9Q&E%<Y9-uY3uznRSp^H!%wjFGiA8_Zd4IkAEQ{
zWlw<QeuycWfkyHYKM!}$OGIcSg8l_mf})p6l>0ION?swT11McWllN2CC4|ceUnSf{
z_ypl=gx>?kvB~vy0zTpl?|_ITw%LMqwC-u+Ec(z|cET$duYyRU_%!42C9<>y2`u7x
zs*<l1e68f3U~(d!S2Z7yg1v%8l)S+>iQ8UEAQ!U(@T~=<O5Q-pKO##d3vB)>>Sy>q
zCI9P1{cWB^akuJqhMm<kZj+^X#QvJwTBboV_Gds(!3Hwmyi}{V*&8Zo45Xiu>hzaV
zf7xqJzrbmL>`2P3vJ2QlRVY}puzXt*ie>3|3(ecOu>1h>Sn(|x;oHDp9z|gAGQ~(R
z@WqpbrT4QwT9e=#5ETFO6}6|wtNL3q$un(OTK+oz@LvIs;Wp{US^nDF3CW)Ug8Lgh
zNT&yBZ#WMG_5q{^QERmHv6<Fd^s#qQ@L1ynj(krAF96%LG#8q&6x`&WPO!i(fX(@+
z(2P@Q*ap$>9px^vQsT4bVDsZ-t9nuKHe3GZyGqA6O`)UHA*^_(Exp>7GG<e)rHh(h
z%Q~D!oA3y1A$YtH%N8L+h6X;b)oPL?8{Qb5A6wp6O`D*gRSTB;rQGF@{XolqKzZvG
zEdP`2F1z4EElyxe*}6SL^)riI_J7&pRV==T+&{3`Wj8vY-0z^c4Ieo8@xWnfIxY>o
zglNP>wTwL)9q%E@2M+#5{gG_T2M+#xCfl6_s`hw-5hL<CFj*i;T)KB)<j{r>9Q=6T
zaG8}`LAhQ>vz_L&H{z``B>i9lW$1|B^1Sad@EQlLxxG+ei^-zST=QX~_>Y4~cJ>m=
znp^2~cT2NzaajVU?FVZYR9y$T*iU*J4Rr>xYiFH{T@xJ*&En&Vnsdn8+48Pl+?CHK
zu#1W2&jC}nX0Y@W8>5X7fPE5oL3H<S$lnTr?ro6>{TE)yRU#qJC(8GOuEzkt@yPEv
z$#P$2fBCAv$H^$Y52ar5{Wkk$``e=)MW3?>PfKPY-Q}Z%fC2W`bT!?VAiwAx$u6E{
z^S9Vvdfmf}N8tdWkZ~wOCQT4WrZB2)`K-bp$wYP%2c;p-e99eBx>u9Ws)?E=$V&Dn
zWN|BQlV>nm#fB3wEW)$7GAgWhym(1=9jVI9eBq7TT1pxU7-B10<wy-S;ghtLxm8F#
zN4gNOmu~go=-ZfHy4AyigNSd+Rt3FBP(o^#B>YYGk8)2r7Bol4>hYuB_9@3naec}W
zJ(z$AxaXv5<M|4YZ+v`W7AUJhHjXbm3(om{!Ox+@9&hLlEKDI;+tET69xY@co*m?C
zn~#DH^I2dIJk+Df?YW7IQE=3(()T9JO_C2(*rN{_mn1ei4DY-U8Sr!yM<4R0?2c3n
zhYI`@bO3qDDKZreWtw|nM}$++P{UL-!l`H|$2<c<OhqG{iiTnqMkAbxhMHO!i{Qfd
zLb(>kBb<tcnps#G;Z!t~XJK`OQ_)bqg*6dQMMF56Rum;7ebCv3;ua2!a4H%qval|~
zsc5L!!ch@UMMI@#2!4DeV<Jn)TW*F5oDktuG}JH^jc_U&YM6>fI28@GHtR+2{0OI_
zp?1>dITej?DjI5Uq(X7RT7*;4PzN&#vN;vSrWW8DGePij6X8@e)XUrfaojNy;Z!s<
z*gPe8or!QN8amG6jV8jWXlRJVTTFyg(a`Z0Z!-~2MMEc;ON4)iiEt_!Iy@DPa4H%a
zYNm;Pcfwk@@)1;J()0Mk|I!HXU`kF{!z*pjrm@K<du(T%uZ=~PLxD7&u$C;%2UVW7
zH|a2nf*GVCyCWsEiy@b(ZfLhgU#GgE$29ml)eY_KFM2rDZ48EB_#@yXHb}<JnimYy
zFv(rya<f5uF+c`s?O|(dr7~fS1|li1q40mU*CdjC9eD9o<;FkaS03j@nlQ|W2iA=v
ztdX4eNr4kIi-BaXNhFs^P++e~q}hW)&G{`w$m6_7-rq<zibmo?K`47oB1Mwq<Ge_5
zCH}g{d0DYY!6IOJoEIsiE0oN~d6AO#DB$BfegHaBdJ0fh+|=Doa(M%AlBh)0twm2_
zhEfj6eRtxvYKAQ*ebij@YXkkYj-K~jvsNo4oObmQC^hY7qIG2A!>%L>4WljOuoLlo
zn~G6--40~NV&)_>0VNT!WvH>jBS9K7Odi~@w^$Pg9BE-{M3kLuVKl<Q08W9S9A60z
zD_|YZYf#tpBQl?2vXPTAy$B-)e1Z5S>TF(#0zIGx@rs;Q0@zK8s8dYn?wbl>a3aFj
zVy1^r<AX0^gsCAG#RrH}(5}_~-acple7e}jXQLC5c=Q!Y3CKm@Z3;FGNYf^;3STOI
z9l5yyGv413MVT#-xd>-)H-{)+TfLCYB$VXwyTiV=Pr<Ofg-w}!hshGjy#z@xy#pry
zar&Ui+zF=q(W9}f;<#r}isUpTNh!y9`;X&gk|zh)9Y<O?$E&@d3(d+l?)DTrm_Qly
z%?rN^szMA}vYEirc^toq+Ki9IJ;&sTR!7|GV1hhk;&`4+IhHB@EahJ*<c_T4!33#E
zKA7YffnV7lSkLa!<Zv$@i6iR<vj8NHqszer=!BEm<h-H5IySy|d)DA~QRj#g2NUF>
zx_d0scFR<Be;nke8N;UH==vT^fLiE31U>i9pJp7xc-Hxa7^#B55e`0>01}2MZU9^Y
zd7(%|(27>Gk#AB4M|je~1nFrJ_uLj^EWb%4ni0jAe{M3ZP>6kpCBM;|JC)fno%eBq
zyxwFqh&o&prF=04BD%2UUCh$tO1a;#>;vHPDQDx%z6Z3z-a~mYU3k!3jrMQ?aQTF`
zj2IodlyEHI4s#l~)88k=nHi4=>;za=Lgt-j42sVrmd*FiiLwhxJ{jCEh_KrLD{elR
zfLt6naxlRkuN-5<U1G|~AE5Zog9+w(Zy!wXN7;7^`wo=jUobopsxpQnnL!hSVOmzS
zF&}2s`^;JZ7m!6ZFo-I%i>H&Kp>^;|Ec%j-agy$ZcI1~HW_#JPO>%6NJE&);>79b$
zSh`>BZ^nmsX^s3Uw2z%sa~d+L;NMQR<uw4!IcFFJ5)2T#Kh_JmaCx(3|G@sXkZIyB
zHs^Q1Ll4>gNdHD&x!<LG8T>qP$>lU>zR&RRL1)Lre<jG~MGs)T9`ak}76}neIvsf}
zCl(5(RsR4Mt9FABR@FVORzWFys|*edN?OHHmg<*Ua>DPkN}hv&fp~VHN>cq)^593P
zI5e>|KUI7IR590*-)4VV?dek7;UJ1Hv)MP=-!d^V!%y=kg8=_Zvf1<(sjE)=6PEr8
z&|J}A#UiP#caW#9F7i>%pOjN_Dt%w2QXF@`PZHGN#XrVvFV*?7N~BCdUMUw#fQc8>
zEx;{TGN7yQ4jv5^xEu}Z3Ll$T`oC}m{6-a5%3Yu@@mrk0tQH&22lh%f#E~)0XUOk#
z-*0Vr3KWxILn&lV6APlBK*ov1V3{r&`vXgrod+^hS+%P&X(7y%7Lw&<P)@6Xv~|2s
zdy^ZH(;AY;i)63ld=}1DOPmG2SW6~CPaw@jW43TSgglMLY>CE~z-<;o=<Am0P5W!+
z_^P?Ux#&~)=v8txgUOQy<ixl6G{GXTFDM2>O%?7Dd2Btaks<yu7yiw#7m96+S5VYP
zdY++^@tl?Q3|MamS1GQ*kEH+0`V0v3c0~h$L^QWSQ1nruW2S^I$IGCU5<f4lrP@}U
ziqy~4>_rgO4s%~^_e&)@x&H?KgM*-@5}i6?X)8;m<}LxQc+J`xu!3~q_eIh??f?Pw
zmQciPKIvqfzM+;p_BoD%ZP0t0=pBbVt(DtE@AbfCqW5;uyPsIDs7<2g2Vk%5#ndw0
z7$<qA)zIS$T(i(nio4cyxy@aMoQl!5c)I;9m%GeNiSiy0K;pkyHFJ$|lCHI+ACn*B
z6iS>c3~jzd^st?2p5X|Bt5-@&dDRT^Nrq!w`R@b;d*ea=Aq2FPHS>ey(rWRQtxFc5
zE+e)s+fA>>1HlvIax``AN72huBn)O~Iqr+6`l#|2aCi8@+Sl8v;a98KF%1<3e}TlS
zIK!4Lw7)DrUCKLtP1Cd+?n}={>!`sQeY@p21$2C#p~jDv3-Na3wL>(<NHp+dxiZGK
zwn4@=j`3wH;9C%%4FMg+`wg6Qb^Qj9qtM7V@-6}PRzI+hS*GIxb3KS#L;5n2E)S~i
zM3x~@4MK3K*r0b57D%Jd#lg`?x6NWbtTe`H4}OuLpWZU4yf+hW$bfmJG>q4f*HT6o
zD-B1J;crpNGP+nPDiXluFywMEWG+zI1+0%%QhFC~7dn>vxvJ=Ce{nk9G-#@xhqB~D
zsDxt)YOh2|OO$lIkR<*?u8Z(0rdb&W?Qhvz4D4D_I1L<SNpaxo#GuG`Fc0zAAdRjU
z5FWFclgUtKIG=L9r`Q-^Ai>X%6k>Q*CR2hnc<g2tlc7oi;0R|}hG~#lk%i6;yP~To
zaVIjQ2kMMmv|7(uE}b_sr7}{z46^kwqu4=rqb?_M&0$-5m`bWnu-Ikae`N7E2D>kd
zUH0pTi@TY}DSV(|xy$eJrB($zeI5qT(}DdF7K}Z+n-AH@MhLy5yTsBTf?qj!U|Gn0
z2WA9C;+pFT_K{3?`yP)UapjysnzsNjzTjjuVT$9BIfgV&)IKY+_y^X;%WRGph)!4V
z&S4vuQYDmJz&Wxxs}rvLg_ITPAWPiOlEVnQo97sZiwubzbJbVs=vrubj#9vSku_T?
z=xt=8f}%%N5HqEMGQ13O_4)@xxLMkd@i)SJO0Ln(yheK?5L?*S;8403NtSBF4X61e
zYr)4qU^y39OEF?fm0M(+AJHyhPnysV1#0s?l(n)9L+r1~FxB56{}T{Y99vlXD@wvY
zK|5}-rfD4dvqhX!JI+d(37TGQIlTB&-S{20<fCu-lQ-i$9!GEfWE05eS@fEeE`@Z4
zjQwQ5>Pg?#uPY^KFRmf#W1gV$e(Jo_I_c{KMB>OPXn&<K#^zAiPwYdpX(>wkNi0(S
zgUE<x#R*`kA9A67Hro1Wa~sUrYklf!rK53IKac#mV5)u$iR+N){}2-XHQ@~v$CB3`
zM9D6Y)P94+_egYo0|{&ga*e?D_pMH*m*b5FEV~IFa7!;ZUOIsR@{DA>bU8KX{mzlj
zh8^!@VL*GhhpqZ24T%fI=ho=Ue)hb_AX2AsKZ(dUk*6K&PZE{XU$lk%M?%&csLdOQ
z$7NQ;OV0maO!fE3zYhe}pCa)Y5*5c%)&7N&{9oa17;01GK-&QKh@gJ@nC-lFuoRQm
zhBGnin*=M*I|ocZHJJK`nEC+nz_y5Y#B`rzIr52??M;w$&q1Z5ji>9gl{H$a%tfUh
zaPgLltdAK%VYv_n8=R19t+3+Xu<DV*(1LQEu+sWD_>epxy4-0X(Aee5eR~Zs3{0nA
zg(}m@`j?gYAV}V^G7B4I%76zDGAn-<89aK*l&B2Hd+^%?$~^BlknD&-HP0&t5!vSa
zfyt6?{3{h(9z(_;uGTLXgUfx-fHUP!yu{-7a7~4er_lJ<EML?PokNwdm|<P`IOrm)
z<~I9_(yO7Z|9X@Kz_6kEDx`)%RP}NsRxq&;iMx>SD(<jckJ;aH*<aXFTs=q%jLFSM
zj8LVYL3d7N9ZE=H@4v8C7V6re2CIZ3sWW@rMp(N$F%Gr~I$Lz~d6o~imFlKgYb!I-
z3Bri$y%=|f2{IYP^N~L0ZC)HRRe)pMVFhf5;@cV|%ybf3PGSc;Q)CSL+x8HoLt|R9
zr<d4VgL%(vnV;%dc#h02SAbe)7JbYZ3Ynscox;lR62g5K=zeHWJjE%Nu88?iG{Y*=
zF<~Dwlzy!7ORIHauCn5Ofw-2rdI_v?!r=Q?aqwKGJdSq1<(c9c?_BU`^e%H;>icEl
z`vH(Z%0@b}Sfx1b!QZPReq+4P8l)^fTFPRPG9M%ywk`2<#(M*hxJfSdxYkY9{Zh+b
zr<2X&uVKG9(-=QmZ$9qJGkFj3PB1Iz)(w8+jQF=T<`c*s0b2G1H#k$;d<8|DEyc(7
z*WBu_{uTLceelpb(a^)YjFU6+2XzjQ2fQaCkB?yPqV8sX<5m1-Wt?cK^a;y796O)H
z@}SKhV1GGMxwk*mT#8csYx@{$a;wicHLqL3$57r8R|zNUTV*PCQ2_F0+Txw|mve@@
z<>Gzh$l|TGSexTLGBtY-1o+qLA_nq&olqElgqq{|^Yuo8dD8`YBWe2-dx?EM;|yB-
zQ-bVXR?v83^4Y`~r+s2tMUwH_SF*=?MW#SJoV4sX>UkH}Aijiw^0Eg=|DNEhfTi9k
z2=%_lPOvIk{g|K*FWD-id#{Rn+rd&%V~Y>j-?F{b@tU~zHFexed9MpD!Oo&KjNlcP
z_-^}a-t<)uK>jHps5rK;>q#il#VWXV`IMuN`4U;CPOn`Th2N}!t081Jl<I|3=h~S#
z_mVo7u#K9Jt%k})5D23tWK>QP8T3WH42o&>JA?GQJ~T8Xi0A+b^Y0So*7C6EcbSOy
zlS%lW63%`-<KX&B(sljX;g)OumKdNBrZGa-`;4h?5O%!?8z8gx>xGW}*9|hQmEqU9
ztVuGek%VGoBQJwe`k1#!Fi<-I7m3$?PJjX14dC3BXw({!fi5D&V!MMe2@uIp`<@L@
zo7WJ5tN){7F16y!asKK<$gfQ{UjKg~A;YU<scQc~$qbOxhGE(!Br5JXMo=v`$uv$u
zqhMG+w55}snt;E$JMw3Opt>y*S0hnzELH6wlstlxuEUT>_Q$Q|;<&BB4`GS<mp)-J
zpTI+{!G9f5ga10B20zsrl*;%_DnqJ(jE16A>Ph|C26vzu&xkvTJ4B*TPerC7Nk5q*
z?362}pInfS$^}_hg9~YwWY_f*UAskBKZe%qQ5)pq*=rk)Ry_qv)n|Gc)Qr0b4eOy*
z@2dRK-xD7HeT&F^j0UV#-{a`2cQ7_&IbsJ9IwPu<mhc0ceX@VK?FZV6iM{=N<ZXtv
zxf(ie{6%$?T3x2MzxsaUcf)>#{+p1Hc5y6KExXrqK~nny5-%gs^-Uyjr?Hyad;!?*
zSCzf!H~lr=`Ko_G{>oIefny76v*Os3j*_kgNU*2t8bAUgOV^2AX2qRo#nrYz`M)Xa
z23wMFC7n=Gh?Dqgdm}M|i4%}miG=+py#%8pwUFjzFur}vv#hq0wH93T-~KZpOizG&
zDlXn)+^9}&r~^ExbU-gYk|5+`Y!j}C{-Nv_STXE+Pm%8G%ygP#$II;z7t=;HJB`2o
zrK~$a_$9<@{kLh*EtkH7s-0xeo@-;K_o;SL;jJ?;MBuAt(_SQu19pDzkAp2+N5xL-
z)W22xHqa$X)bDIJvMz?-4#di50X33~@AxQ$_A&ctMo6DvJ2{7}yo*4xj`A>o2swGu
zTA2&uU$s+-GI_C^EH8F{rd)Y&*T?i?s66e<ozPicFT@g0Co+xqgB9)_C7ihszQ+pZ
zLnNPExDSFwdxKt6aH-?dS8{pGE7dvmQyi1<VB4oSypV2zMTWFPWg7hqM<u=Gl$z&A
zGjvfL<sV40s0hgqg#hjzU|!wOkt~<Rt98AR`v!CI&$fhz7`qladvk8J@T+@&!q$yt
z8oL%UN<|k_DyJIh=bmb_4UgMGCA(s67i5C>L#+4O5wuoMhqd_yv3cD_aGOt6nbxL%
z7991jxp8s-WJzHDeJoXN6-v&9(%KG4Y+<4&5<f687>TMzNQ^*YG!k8#A%RQ78c~sL
zRMi#sw{|qjuLWU6sm&SfN+zRZCrUI>e9+d%oXd-~Km+9h^sx=pcc9HL*FY5<9jF4C
zj$hH(4wXoS$W*&VCtYM*BJ&hz^ol7G5x)WJQ@%dt-6F8%=sOLk^vr<z(;pkW&a=vM
zoN{U5%!RVJYlQOPwW%1iQ+9>%2~{8CXHVWiJ##|+K^2ZY*WO+$yn_?2RqkMnJsCxG
zQ4x+cE2JXkLqv-T1P47?mj)5Ih8@s0LlPLf+8R5knv-5!2tCB!#xdjCY<E-3su(At
zoRW!F*>Rwo2}y+$al)e+r*|iL%y>4_k5f!{)1Ft}BoXWwlfr5(&L{SsXb>>T3h2ah
z70hHJ-Ya_Ia-Py328{wW+<%1bZ`QG;6V%TN+ys)J=svE!&8{=`daY--@~xO)N-Oo^
z|5h%3L`D*Iz2W^&)PfP^Vv>KM4Zw^AeQQMX3wg%g8Vs81w~ZI`mof?H_aJThO444d
zX=HD#2AUVhJ{@n}8_Q(3_4IZw*>5N#+eGdc{f=ikN76Fzh-p#>9!+I#+%H-Lnr71B
z!%ED|8QATr#|6MGU;G|{XxUub!FCr2_UsPC*h@YvT0YD*UKd7fS+Z8kGb#FOp7hsO
z;YmdXe5h=OQC<=f$0Jek^D&gQO;K_#O7ISW0p4dNR7I?$XZ#OQQUYbyP*Nu(4pP#w
zl(mCV(k2gG%Sa^7Mgov^;6#nI3pCC1{^}*jzX2rGbC8JUL)@`cwJTAw3?;Q|k$4n|
zL1V%g8s7%=J<)2Sdx1_Y0MVmJtV2Tn4c)^4*K|f0GuRl14vYhLAs+fW>#LT@VZGQ6
zZj&V#ebzPaGhElF4)r6~4A=Fk3cRgpm?*(HJPOt=wkM+N<LTpjtWPJEYq-i$8L~#y
z|Gz(dJg{maypiRkf&b3w<9g(HFw>mt!^1BwAPpXU<aqGtBgcbBA2}X8`pEI%(MOI4
zk3Modc=VCu!K05H4<3Ewcrb3((UTHAay)qSk>kOmj~owT#{}&6mFSV<!E(dzo4X^&
zgGV1Z9z6QU@!-)%jt7r9ay)p<k>kM*m?ogB!UEEiIGRqd#=Izaxk-5v%_exvk>kN*
zjvNmjbL4pNm?Ou7#~e8xJp74XIdVLB%#q{4p_ty&o~Mi#@uL|A?E=r>E`~%Fcm{WC
zbaa7d@G%XJF7OQQt(P$K$ngbW(8FToC?)zOhbAzW?L%@8y4-B!{u>~DJp>&6N%jov
z*6sjXq5)iQUKC>p&qU=L;nDRW5J%@DQi13!%8c&DC6N?84}|s`;lAwOQILt<+9M(3
z|GZnfCrUE0TbnCPvv}H|FPBLyD$K&cX3Z`UpLmusMcCciXCax5-P#Z0w~_AFmZa|1
zz6`l=Lw0LtVz>4IV7ptJu28b>*1kqi*lR4iwI2maorEiUU{Vqfhe)eIIw`~?S!Q&c
z<t2ry1SPy66D9aBVGVgr#+D*7;V`o@0-?r(@f*!7Va)zj%$U83w9iZ3f}f3{KpHO3
zwC9ix1z8J_pSBJHLP_=NZrc4U3n@xXTS^pG6iqun2PlOic*b@c^4Vjg<7tnRGF2%{
z)3``8lt%x3C6#FvEX&YqF_E@_D5{hL)BY|7lJ)<-k|Al6FqjEte<6HzS+izid3hT+
z<S$vrRqP_K7u1?$8lMp`fAoVf(Noy}Mtef8i7rO5FFFW+{n1o3oq(6~Eem|60Hm>>
znZDLgyX!-vY1)V4;r3pTG@WoZo_t<QYt4vU-1F9w_+|9*&GtZEE^hnlm=i2S&LQSt
z<;!(!z*We}#RI78S$q}%{^i+?V$5=i`dEc`g5(Ek<lZsy4bSoNWaeHW3tt`Kqn6=6
zU}&F&(Fh(PRxmLM-A7Xy;a52RaF{KiU@-m6!xJg!b?m36tD_si#disX5R+#p=WFB?
z%GRzt!|E+5g7NXk`CPoUacn<X_ES)}&sx!%+_xj6DaLcHtqn!T`EUv%3NT>2^jX!Z
z7d|tk-3GjLiinr9GA}ny^ko@J{VpW7!BtL2FQ<x%VhrIC=gS%AGXO+KPmn;z<wxmY
zrsxQJ>6DQ-nW6YV0_x;vXR4k%A*m&*ka|9#o(?6LGRc(gBet-GgpqRaA7mhVml}LF
z(=#8_QI0fAtI_d13?*z8Uy|fOka%SyqALGF`}-b9ia)0v-*7?m+axM?g<o2tTzO6U
zJsaNdAjrkr+8@}tv@gTV<6%qWh*jEuC~YLl@vp*!8O$u>oV(RJxd7#-Stqlkw#iUo
zs%cMwab&Hs)aH_M<K1D&3rM~P8Rh$|u!yCi!`L3^dH+Ev27BgON;}aQCuXW8Y*k^r
z0z`?8?L=v83y@PN@5@d!4D!9eRr1dDL}{*{5U*5m)X=QbRyT)6sO~Y(s-fDXm?_nb
z6J@EVc`-T5jnub!068t7xm+~27(0PUwxJf%+RLT2x6D8kjb3uCZUaZ_u~YE4zRIw3
zX>|=UT1wsFgehcrZ4}igaxh_G^LpwJ7-2U1sUPh&AWFUJe()EY!YIf1Q}Aj6w$(7m
zZE0E!Eo;ZCCmUs0TMj5UOhR!oh#eS6SC62Q+f~lhR?h8|(|#g4piOK;?Zv~*l9ZOU
zg~?WzfVw>_+Dct*I-JTj^BBY2;V;U3qDHcRDn|NQrUi=o|0UjIv)u~vj53B-fve_V
zu~y1SsH_!uqR;9cB|*QU%2wZX$VT;@Ypbu5babbR6l{lID2L-=VK%iq1)gRz5WCI{
z%NY{9am}&It3C3bvMp;P()i$37k)-Pvjt`(Cn9k?6aA3*4T)w9f9-huscvb!QV*_w
z8o_(=dB`zmc4Oms%?jg@?Wpm^DDLt!^3z+RS(gpXR<Fj}-}NZ2U5?^wSlnz0n7UsJ
zSVKk6S)y$eRb#q*fxLa7>+%s2joQGR11RbGBT%ycLf429-)2#W?S4D*Yhs`npQlRe
zkZTgAOBM14lYKR{w*$HgsJ0sttE!P0fW((bl=7_ea}ea(laaHjEjXe?X8~2U1K|`T
z9zdd5g4y$dhPQ_s=!#y-SCzR1`dfP`3ioIs3A7cm0;LtEd+Ds>jwXjKVS%;;*8(cb
zRYr0L;~kIrOO-4*TOgPE%gED9eSuu+fsV%Ow3Y4dJj2@-_6uLoL)yhcX&1F9FPm(e
zR+CZ{+#EtX$u5w^w(%TT=#>vG)6%9^eNTBNu+}xNMKm`|O&ir*XQrD$T>@1XH<-Io
z%zX`cUh5N&^YFdBD^Zrtwwd5`Eqn(Dz{Vul{e<sS;IZBLyc;o_x6`#Ph!3Z0W2{kU
zv{NJZGzXz>5cKH=L4P1PaT-319uEG7IQWe03iRm_Nj}{Q=+mu$0k(Vp8)vds0)dn}
z@S7xK<fLp^Ym#J)oFrr9BpD+o$rw3F#>h!JMh=_=(m?hM@P@*H#{2LaJ{f&}pvl=t
zVo>M>xCJVZ^B^grfu_IWH<@GPKrWM@NS^2gn*A;5u$L01h)7rb$$;ck8fUz~Ux-v7
z?@fTTXdvDNCFvY92Z|)gF>|1p^l)3o%%NDI;B4S9&&dlE(lu)004Gp_XAVGNyfB>W
z1xgb@aDVc}_)Yo-VKzx4%Rt}--b61LT-6)Afzi0_2CrZ;8cqq{LIEae0xB-h1Amg*
zK8T!5xBc-#7@Nh}E4Dw<5ope`+aGTvXGu8AZhur5&9d7c6~?mYC$>K-jAz;Hj|wZZ
z?Dj{6)me7?qr#djyZupNBC8J+V*8`QfmwF@qr$o@zU>Va+tN{4cKhSwu-{iQCTj_K
z%gxgQCuG^}kLuBkEW7<t;p{BC{gF}hmCVmtPu_M|kct+D?T=Y@`(rD?OHG#D{<sga
zIeX2DlfK5hD|ord;_Nll3%i3@zS?9hV>kz!>jkefS$6xQ;*BQjDwYqi<y%aa-TtWM
z+f3HYEI+}VE&6wuEW7=Y*7GEuEW7>jBhmkq@v{9$g|;^eqIzSYT?|RMsuEedH9B5+
z3nf0L!3l@|ZUnSfgAqk5UJizoFq=h$t%ZI`TV^iXhva_ea<h^9GeBd~Hj)WkIH?RF
z2y+4#4l&90%L!aK+*MElR|yhqIwILk;8McO3I@!WI{YTRSqfG!$Gp$qxU@&VIUgl4
z?g;b6*%X>iMHqZ>nv?4_dlHm54#4#^FW4UECv;(Nf-esPnq-nr!nY#w<WX}n{eA#2
zze^c;NtV$W@I-;{0geKMlXu8pUYX54p_)wN#D8toTmeG1@H~txG8v9{C`jaHQf_9A
zlbcDo0|32d{ivs@aWZl$dchzJx>0x@Wnm=Kls57_HI>zrvQ8ot8=F$rrR+?aJz5G`
zjg6Br(8}74!e=N8?l-3U$+b>aW6EktD6$$;Rz09sP(`~6jTwxdB&Msz=zG(B)KN%_
za6W-4B!6re667r8sEvmj8FI%lIxeERxQx7tnJnr-u_cm=D3wx9T!z7Aqrq2P6k&NK
zvu#78IB6sqUSrxKt#7)^EcBZFMT6>%bN2MM8o+h%Vmf;Bygn#p;-6hHZ^5Lto^IeJ
zQU0evGE!ARHw1u-q7|M4m<Q+T>D&eaI9N{y{|TVW^2X9!9(hnkpO-;CMs-V`Q{Ck=
zFfhnPzgvOn%ekzYNO%0HWF>rCsWjU_VwOa}SjBUrhJ&E$b0p?5@c|OoBhmbIBrwNX
z)ZzfhTP8#2Ze+L2LSkqSBzU~k93)z`6?0ZEZp9CL;T46oq-8$xzXCz)y;Z9Bp%(hv
zvO7vLdSZ&nYptctJ<<M}VIRQ!Dt?NsJ!q=NA~6~XubR}eEY&TJdZbV;bCmay693vh
z)>4(3*81BT?&7p@vq~yB0jk#BY*EP8TRTR>+(Cj85VZczmcLr9BFKIxOD`llFU&vC
zuB2747Nn`9dX48G-QGM<3R!!NYZFgc9q)tn4G^$7>^-VENH;jN7it;J=1EHSufe%g
z9ZYT+Bt36P?4-DH%yN)(1Vm}iA0_R1+F90HrM;li4lUvik{6XO;dSIdD(MdP#m01$
zdEA`}yjPpC`#Yf+y{JC-zN5kpr0f9d&#4-c2U~(rdR~9hNNDu4=k<q}M9&*w&+8Ar
zDk$LvnHZ1%N&FMS&?i&^<zYTSi(`!}i<4zw`KP2IAq5Nn|1v+K0QdjoHn5@rrY7HT
zB#fra8wc+kaibK3<Zm+)R|r4l774SnPF+<F0s9V8yN>BnIhYH)L3`441Q-cZTS&)&
z`1uKqE~LZ3kPZh!I&ci>z%e}>!C85vk&z92Du7Rs@BrjxL~x8920v0B2)v7m#Bi?y
ztt>NaTH>Qp81djTZD~$rY6w%z^MY^T4{zcUDBM;@u;?sgG+M;QZ~#+J#Et2e=Aby4
zGHymSo|4#5d4PC><zOH=g^oKIPQIRzb1*gK>?2sC$&HUJY?Q)P>y9)AbOdc)a^E9q
z<H=VYsirjfcN*(>E7h&>s1b1s&d8%vpR6fp>~?Hp+K6*9HiN3kDvVWqZJE(TcWk4z
zdrfr5_UDL@m*b<pjXv>ujBT0^*<U<P{1H-OxSDSEF=a;JK_Ai#?rFF(a?!SK^|7`W
z0int`%*uI^Hb15!ov7mWy-);W=7oo$aw+n0D>8<ijgR}7Ylc(c6C&_CisuzB$`)`q
z83|Kwv$0b#G2i7Ei=EiB4~zGqwKawK-F{m94j7x_P3CSt^Zz8m3qeI4`%(o8ANN!H
zD21pT#kUFuwZdl<HWYtOjP7iYpZ=%!1HubfMYDlmE-R|poGCE3LqHm+Gjr)-b0@<r
zMx$du0~~|T9RtiY!}HLdI|nE}b9UhB0B$0O7U$w`!k@Pxe~xEr0&L+>#Giutc4%g&
zsv@W0@eaK}fcJYas8dh_bDC)S1UU@MX#oZ%+#l#{qTfM13`hcVMu34?p%9)cF2jYH
zJCBI<F^~vVsAw_~zW%1@T_RNJnc~D>M6hwRm_2A9o}p#1@vjbCWzF<*Zh?E|>Y!Av
zGyYFoineo?_2HTzqcsI0VzUt5Yl18=!(&+IeoYX$o;iunwATh1yepAGy^5YDLN~Wg
z=zb@0B+S3@5xf*02#Ic|v$&%M@YF%Z<9(Yg>wyrJZ$b{+(gPs|@Oh#cc+ZVOsQd~r
z_gp+@eMn&OV9KAz>tdJ6cXBs&Qu+Nr@vD`;TjVc2PUY_w`L`2cAfxDAAU>vlT%?x|
z0jfv4*%M-QouLr5srW_WnMACv+T(#{H4v{;*g*UdaM5%IVs8jzFfV}Kx9A%hu6Q;u
zYg^I31R<CTb5Eq3wdC#?mIm+K`_sBv2a1^?4Pz(iTy8`TJC#mhw)w}2>QQr@!X*0%
zP#U_la0zIaFnjtIbua@LU#;9~P5?qBUPtYlXluI9$mMRePUzeVo}(dy?oF#bU3#B?
zBBv=DC=kkjp;Xus6*L@A7(`{JkHY2wdIjU!p~`Ozh<GRVt{N48Hz=;dz=Un&Cb`Id
zLrzn)yqn~Lt{w`6NZ%wE*#e;AAY-NYUf^5^-yj#{Cq&~wyiqQl*24f{r=oF0u=8fQ
zJYOI}mE0_sW7FY4xBwNMM1(lqDpFPedGTqCP$CT{O?jR({VnUl>!1kYeohw>X>8_&
zBVaTn03kxXf!NLU7IZcdtWtC%5neX+PGcYPI*=EiN?moT%jwALqTz~+G~N=ct4?%n
zMov?-rn)p<k1r6NI~OsiOCw$7$-rpzpoRQ1f%15T4NapXrY;xPzNRlk5t;+D<JZxE
z|7de?ic4yHK>*%*fQ|<;(%GM-Is7;ZD$ptZEH$2U3J_{UQ9TgnhQCS~^uh7pq@k=s
zN$xzbDSSmB_!K6gz2?pXqr&clsJq|gj(4LVuqymSAzW76>@?_{4^axuDY^6O8wz`%
zFn2x#YvEZ6(Mv0SjTp`154nNnpYE>XzkIa_%m`pM6Gbb5yn=~r+h1s`T#UNeSlvSk
zJe*~$zLZ$~h8#8wAjC5N3|I>GuWfX^_-}05@8EcQTsuz6iCs1F=YaYrEA3smPY*j&
zBmb`4r&ka`nxfx;*qgsEWg|xeLGK50-@TlOu~+y{f#6gaAA{2QDE(0G@O>2`f{M=(
z3~Gg!DQqadTQC%B@qR$<8b9(ggv~ITWPlaT=h(6&pZBw3pK*>}U>&{(rR{NRWB5um
ze8}M&#}Wxxbv?M_8yPZeKxfDtXTNS5vhkq!!b%t{67EM1gEUwq{F?}eH=+#Haq?Io
z_^s$XAcky+l-)!mBYnkB5Tiw&AT4sxIM+~4l!h_|m|iNng{U6m;*p~CX+ST24X?4Y
zw5FZ8UUxP7cTilOrjFN3O@DT_nq4oonLi!~R}#u#_T@k#ew-A3ML44)me~m`K1U$5
zD_%kjx6T&c7l86+RD*iF|3+xUGVy(CgD0Z^=E<np=S68z{70I7v6}77^?E2vc!Kd}
zr>oh^#O!_()$C<r%K1bv8)Y#2J|G%$si4eBKs<9s;pv3vwiIm=)KK_5A>+AR#I~Lc
zh^km2&2^q26e_%4AX=xw<SC%V6}-aF+j>hNuhiU4pMpN){1|Bc!O&?N+~GhoD2)f}
z0$^~GG>Ez6Ei*mY`a1ZG<GIuF)=o8E2h1bbb~_03o5*4J*HPG0r{U%5sg`)6{mll0
zR9$Cn-=Og-7TCgN_BR*pzq^zVW4Tv3i#-r_Q1JpVk3vKhbS@U1Rk$xK_VK<@B@-y*
zf&*zGU~)khCK-(8GFMZId`P@dba2u0QsK&n?KXvAU!-|x<C^kXEMpW4f--_J#Zfh*
zP==gUxTp$)w66++HI+XOnMJ`XVO#z<<k}>Z6ids?pNw*sM7butmfthr1H#5M$HOan
zI#5PLRlKVWl;Kd-EOh4sWprA_QPDsd715=^VcL)n?`^6cW6$GcG}P*P%GGrKxQ6Wf
zaUgcN6S3ITQM1dk`G}BB;T~^OjBrB|=GZjHx-N-pPLr)R9v0R*%=DGvHnOqvg>dV0
zh`$ZDZcp=m47Zt1g96Do7HuEnot-T4cCGG(Q+uH%v2hwL<B2BP`Whv3MDpBpTzj*s
zVM?Q9wug&m5aYUNl+0m5-<iCm7>*{%Y$6vZhK-7!RSbH?P0l4f<D~dJ#SQdN0vBCJ
zo3*@b7U^d-(61my-Dv5TL=CdPo=t=+SPOri15w*3Do0FPGZ)2(xuWNY5O+n><^!P#
zDY|<B5NkqV@_7Og0>$z3iN`zmo<Q^sTKdKXEIqG*`oKcLFiXqlE`nL|BuMdVi_w$f
za*IiL{cE-?&Sg7PxNHfSXMtDYV;6$=WxCWf`BYR!-=)AMtZBt<F9JEHvAN>#RX{~m
zENzy|%f-7GrDu(U(~3)gWl*P(PwxPs+v0i8$-O8qnOFI_WQLQ9mS4gF2<jm}`8r7E
z!(FrjT*k?~P+qzewDs(06=$s^Mm!Y`RtQCk`(Mstgh1hofJL`)zntQeuR!q-?h=WM
zB@5t7(FF{GV*hI3Z-~pq?eV~c$J6Z-lKb@R1=}&MzJ&PG<gI-ax0TDJOWGZ$*z!&+
zUz7Y|!s0!YcT4j1y)1r{7tOeo4gD;hL;A%j4>|k*@pCEd2io!~^8Xe2=kXTbNq_L^
zkYS43v5PMlq@dGa{WZU*^afe`3sB};gCWdJB*rr_9*L)z;OCID|A9mu5`&oNkHkJC
zDvp)bVL3`Jxe9lae;{$y)kxfk#CJ?=LZb2-B(@=O91?iJ#2bLKB#Jw>IV1HBTJsU|
zmx84ITS)9<;w2;+U5iH?36OR866g$|4*x-72@^c=_f{q%NW8}c&+<*IrJBy{;M)&Z
zhflQ8HyLT|>yUpNNZR*9;s6u1NW|75QH{iKBr1;O>u?%M{y<3wo+|S`T4IOkNDRFm
ziSv-Sk%>!?XnX?_YmgYj#EmSv5s58G6x@WwgGgM<#A8UjxgLq<khpXM60b9di4Tz|
z+la&$NIb&?Kko855;X>Ql)@3}Q%y2J-Y5$)0nT=yDZqUW6an<K{v$4BCdw95pJrTF
z{MD%{WAx3&<Cm>CAgGs#+g9Xo;#Mznv6q23lO31FOE2jbgBK5GJcV7ZGeIY4<zyAu
z10>V2vzh`|iNMvjLLl!CtI|#d`+orz^Sd1^hHYbR1KvW3iq{cOXM<lQlh2adfu%=N
zd>XJ$C0EH*@?qdEa+|zQ<oVa^Se(mShQe=AoLi4OfWpf+v1>u6?ud6S&K<`)sN%0t
z%wAm4e>UUVf1ai(9&jh{>xc0p#1|gM^>+bZdKhm7=3U@^F>LhRMCi5@cDff3Hw8s0
z+lbI<DeQJXB(*>oE#69eIwfoQufVxe;iSUr9w3C13Qv0wkasnOcM5DM9rzGrtz?h$
zfY@~h@fi%b;`nxOqnm$FO8)^=w3wya1;6qzN-@%UIF0>w+Z{k?9*;=#7%m7ND!k|s
zuu4~}_)*~8sZ+4=Sn=GQ#1jy1#kW5SJj|g%yMcHs-<ihSOU7e>XU{;xRNN0ZZ;nG;
z{g}%a9*;^J^BxB=&@O4idj%o33jclrZ|Qo{qsK*Zp=`7IG5vyiZNY`BS+*u)`gn`C
zGw!Q0Mml^pV^^LrX{;?@N&0rt&n79>-oHikdW#F+CjVy{uTHS^9}~ZyakImJ6E}-a
zvh=vXKB9(+QF*N6E-d$s>DRr+8;ciGyuc<#If%OBNn8=Ago#l;Ci$KS6*Mu*t8Mwy
zhy)@$Im&BoD-qh9qTFXRN>hYyK2VWdcT<J7^jVam@hX}Q)J3jB#lAJC=hh>n(}Xwl
z93?ftv4D9T#c8Q;O<mz!`gmt_$5b1Gr-<*4?y=Yl(%4yWOQv;Aye>C01bu@1EI_h<
z%nQmErQ<@n-jU+N!|O?ULhwN$jqkIhR{(Yy&Z;>v_=*&bIkL!m1^t=NTMl0PQqNTC
zOFeIzwQ+|2Ca~^MHnaHt_nTS#t0tlvWHXCjH?xG3!dD>6o`oK&MSZ><$i&H_u#3xo
z0u7s2!d(6n$T7<)p(GsU@}EG=!l*3R2sE`Y7UuGwK(2-HFqi)Xnps#G=HiGzo`uz6
zF8>MSTUZn3@}EF~g^6$<0~oh(V3^B)0!0?qh1XC~v4x|;YiMLC-a^sHG2tcTEjOD4
zP6%`PPoQD*N|?)k0u7s2!d(6nXxO|G#+}j&9NxSV=JKDw;ms>yF8>L1Fn2*Vm;Z$0
zq_44?S(ckHm;VF~Z(a#=`A=Z5xrE`y3jXlr#K&2@(S*7DCosg~Ehc<D@$nXKGhr_O
z!87z$!oS0Wx%?+^c=Jk_%YOnx@s^A7pE78-jK%g8S^g8)#gIg}{3ozmqvJ)m{3r03
z1}7Zh@}EG%=9Q%IL@*?UuYtN$HW6;pNz*m3Nny4R$>mlV$;}4s+W_gL%`in!WRhej
zjcd>k+lGw?2-9I%lxuU7$Ztku%EAx<cj4mA`m2Q8q%tRE%Q}EaPl!E;vTRu!En6#+
zo;O~j85pKDMh}x!4}vP@Y-A2s%4Rd`EM(yyOvc|P<^Zoq{pPx}=TB?bT2MX%m6<dw
zpN2(VFrJzw@I1gAG0lE;eF_|XgaXTC{iYLCJiQlHdT{g?$Ww31s2?W+H8K0ip{>qQ
z7TRll8#IhYHO53sOS1ey8)Wfv%jJOW_Mv;_N|Wgz!%CBlFRQL>Ic2OhNhZGtkEL=*
zBbAfkrBiGwgLtva{M*Y(M=b??*C7XzUQ|ixvjKAs!N_3t16uOZ5hc00PJxZam|R__
zpuoEU&lG*$x9D1JmsSh$r{KzuTlWT>r-J5p0inL@XM^(V$^*Z?*Z1ptefPx&eZBvG
z{&0jYZfxk%g8!ZUc|Kk2xD9%Bs~*1fun^A3Ry{0sWX!qL!7g@OCor7C-VWb-P#8_I
ziyallQrO#tj^3(=Z#`&fWeR&ceCt7Bb&6f=sIVr*E_PIyNMUamI(n;K=;*C_p`*9z
z;ad-n!hT<gZq>tL$0r0%NU@6@)uS0HcCn+v*(vPpLJhrL3VS;&cI*#NxY#kpE_NI)
zc&SOTiyfbZ?1rs+SnT+gV7pZhiyhAw`qd`IE_S?D@H&&i-VWb-P`uHk*u{>Dx0n?6
zcKFtV;%z2{y&V=iy53H<>fu`tw4RF{Q|w~L_eDQ?JK3st_*)DNiTxIXM#q!S4u&4n
z;J9xwP#jOQ4~H)XLpaQ4A$ttym#pq)F58FX^6R{k%dL7p0LWIoj6ibR;keMF{i`rZ
z^hGa3vtJU3rV@pt&k#kUm+>baeT6@Jyy#c_U1Fks5`m`%zb1MQa(&T{@i!1HM-IMW
za4V)#;dZQ+jDSC79o77g_5k{`M}s#r>~Fjizp@9=fAkky{W-UiBI<AYZ~V$0Kz}Zi
zxE!zt(0{}pK#Gt(fc`wLQOb_`<1sWR*#qb=k|ftN`-{IpDXwq32hd;87rC+r&|gSb
zD4FY-{UyH&(mjCw(n65I-N{^S7M1nPQC-iR5y0&XEhD-ga=j+<8Q18&Ns!b;KI0lq
zLo*IUzYe3qqUR$&DcX(=J9-N$E6l^Ez2qoH_FhVK1xh1PE^JGUu0}d7+8=_`qX}4&
z5xo>N(dbOb$&5BZepYlH(%DVqGp^BDplKZaM+hcF>+m-x8i$0K=ldM9=9FZbEgxTv
zgk#_hhq>7<$F#xUSi>J=Ga9M#@zqGm6cozGS0fSKQm7wajij>8VZ0?DUyY>Ec{bQo
z`S@xi^BS@phdXy9i%A4jKE4`}dmq@Kr6clF+c)vNx=4OG9i4(E6)9kn<lhk$)*~|1
zl0#IaC^d~A4388mil$vnR7#`&AL`x&KFaFcAAjdPI2=}klK`UDup>wk7L`f@vZ-Oh
zVhA$BHil%fKuBU{CIMv8OmJ(f32OH;sNJq5XzixNw%+!(C1~wVu*<I-V3*rg1>635
zf4%*GpL5Rho;R6j?eE^+|K}HR<~h$f=Q+=L&a<8Ko|&N!JZ?dl9Wj-DklCGFG-@N&
zO`oeu3r0n$G(-2hVblt2@JGyCpz3Z0Lu4yb(uAcXtdt)D-2VfwW8}!8x1&z|s^>@*
zyh&LoPvFuJ$K8PMgcv!j4DIwMMn?rdMt$ho+o+)gQXjhZHcIxW(hbf<1bhzvD?1+Q
zTv~<3_{1ooE*>&E@5gw5(@%_!9+JUot51xMzDO^O{>13$APey6$xxzxpBNo&xYwT;
z9X*^hfIl%hy5A>8N2|2Povc4GI(n2Awf@BD=zgCV9o_E}qoezMVsvz9FXrG*R-YIh
zed)iVpgu8*4~Wis5$xxzgntR-wBgmw`2b#r<P_pn=6nIKIXMx$<~tJtKOTnq+qA<C
z{0aT&Cz*gz;7$dS1TM$&eGH`ufuB%^TGQbQi4Lk&t!_0Ta2kZ&H&hrDfpXNV-}7+a
zpvb3w&%=F#gs6vkgNAY5aRr=UV2Yy2Nkp?rCLTbV^CGBRNxy0pm_noc5U4AcV3@!Z
z`aIWPsrYeKq}u#%2Aup2ruPo>K5-9JC@`JE%*1baATA*PmHLh5!A9P`1T7qA8E9OJ
zc}^xlK4@sTrZSK-<u^bN7pGs+tus@9O0#gLRo7!TI*y5KFzxREG5R=`B9>#2tC-k$
zL+q(<^(XcY`V6g@tz^QK?l+x21B&#`{nK}$h0>lboQ1BXsazM}MkNVN@NZ~LACI|8
zeZ=TG(|qPqvWIt4iO$UP?`_eozhmBK#fjP?TB#4e6u|4%g;xQQulNbjNAoUI3zAPF
zcV-8cP;IHI<$*a3{2uz#FBDw)Fp(@Jk~!bTlKn4Lq?&ms&Z6_dKpBy%N3r1B@H^kY
zFoj6^S5cp@16xEB`JkED*Ufui^%1n2GZZhsK^raSXOen8KQZrt+vd=s#lC~jR_WC$
zqO~29(#;CZd!Y6;qD4*L<u%QJ(A2)MTeqH>N3(6!!u$4?S!(NoOBc8xf=)BlXS;Tj
zhrxl-=KN<(@3iSXSKWW#J0259eXNLVh}(RZ`PkQv%MMd-MAe*ycnN$r;LM?~pP3H8
znfH6ste{OZ^a(UBRG)7+KwPY%M)_RH<IYqH@Gi~ut6TDaw@Y_k$9$;|k3FL6JGUxz
zooMP7oA<zbm25tR0gM<i99#n#w@RI^!mQ>mK<RH6I}_<w@<xuB57cOK@-rJ}U?wWk
z4HKu;P7cU72sxkF9wvTfkaOv=%rz7=hKXMpoVhtoiJf<I+7y0)<qCdE7aV+0W9sP8
z2r>Gy(PQwz;2aQf$2wy4^&=LJD23^ZDfrFxMW}~IG$7=9Q6Nwn3ZObT(J2iTLY_k}
zMmx-n-l*TOP(X|xF#=>RqISbaX_^<6h893&MtHR&sCJ~OMNg_7#SB0a(?FkMP(aaA
zt#f98*5y$6F(DuJ63~#EYoZYv=c~)L^pT=~x@m|^1+*m5!nc--(Z!Jc_#w==8tl?>
z{fZOpD6nb6Cng1#?=@5tzQPQt>fTWhSUgh8bo$8BP(Bu!rhVl_K0)V?$C^$oz-TlH
zYDVjELy#IyLPNu{iv^l&`%!Vqe2^&(%^&Gv-c$V)^3@ck+1{`SZhSdbbOsf8rLVF*
z?Z`823!*;DSH#Fyj|i++49*7L$6&z~fjNr($cU(70nvR<hzJxZ0A1%0fSvmYDBvYz
zr1Pl-D&{KyO|S72!GkKp-bK?#TK29pl7N({?*d;D6y9kkPGev1V-m%MmLM$&$+_6}
zcbpQ_T&>_De`7WNaO$vlxE3J3*~W2h&~qXD65E&fTI!n$@|<N^#FP-1qZ6%$nam1b
z5$xVbvc|`v{HkOHakC%oSDjL?0)q2btYp^lIMB}?v0tXF8l0{&Jiss)k0k5(|I1%k
zk1(>o>lkHCo6Mg5h2JuB{LW(xJC95J&Ld>anyBRZokyM>0sg}8Jl@o2uv3}f`2?k2
zm)TL^FT90O#?C(B3ZsI`iN1q;!j)b_wSwF*-><6^jixJIos^|sN>|xyka}T`%4=9{
zo9fe8)J|i&oNkF(wVyEnsnqu>%LD2BOv@h?XZdvuo`W62Z0!dMe8Z!4p?}VH+#)~P
zD6^W|9Djwiin)HYU-{u}JX6DL=bQNqaJ$$e`n?+N_p`U88C_>>gNh5N$X@uJeuCP!
zTyKfN_t?JhIw*JniM);?L;ks+*U@Aao1SW=Z!kSoVabR9+3wO2a7D|kaW7|(T+|A7
z*f-L0l*6OIL#udo6FcUcwVx?vf4tIqHRUI`6TF0vhSG0%3+?4s8z!N|q-twy@h!ZF
z-%15r=@2%hi`WBDti{LJO>&{e9ct~0tXEotrQ$G7NpNY6I*+g!%}ATkjPg{)DuGh1
z(RSTvE*Ep=lf#+M7&|*^@c)X3^o#qSlTqabrmHjur#&S1OS5faf|V_@ss1a#e(rK>
zb=VP;L+qDLS!1Vc%9n$%e<U4*c}_H@Vv3V|?nvnnyrb6LDO&%hTD7;n(6`bcIfG5+
zDnBuJKHKaq)ZMSoZ<1uQ;s&+i4rSGota?hdkzD)Nas->sNH(2O{jFtme`~q8zqR07
z)NH0b#vcbM!S<3x{2&So8{v{yI!~|kSZ_e(TE>}<@KR)t<9X&vB?iljNiDpQE~6z!
zu+$ixK9irLK<Rl+sD!Pz@xreX7&+gk11NH`Js>gSWZT5a$)*z(vFK0_qCX(fwp!>*
zwy8NjNXb*7qDr_qNc^3EX|%|Ud$paR9Sp(KqmBtt5H$%TeQys6G!zArB2%NXiaEAG
z4r{Kj2o~pYh(IFF0w&h`rQ@^!2#4BYkc8{h9qBja^zY=*frMMPSlHh{DBy9T3kFK8
zsV(v~RJyZRTjLG=eS=-$CAPw!4=lCl{#h?lZ>w=ukjt%fb(p2(+tV(8uvE^%CgB5g
z=Vr4YMt2ZI6%|ul=?#u<cJO}bH^Qos4%X_w=04b6{NL`;t)0HToO>D!^`Dn(vo{;h
z&gN3>Y$ou={j&ba_CJzeYa{YBMa6xJ9~@46&H~wiT{(6YCa93B@KV4jKHG%(P=0NE
z8d=jct8o6jly>JlC|b>6XXD$O^InzmYfnSfzMPHyYM&9|NJeGYG$!1GHb><ec-v2|
z!J`A$piLS3a=o*MJ3xNyn+s%tyjT;$p4?iKe;$+@^E}XD!65CFkdY@_0#>fqTeP1l
zcI@2Rw#A;EoQ}$y^_<A5E%Il*a3a*6oEBxw?0O)Qf%|mBwz1b`zQ&-rT>GLG9vA(r
z7|+Snl#RbeKJ5*JzIK0(qXItG!QPxTPkSBY+QekoKZ0KX{)}6>$5p<iR*2Pp#2}gX
zS~Df(T>dNR>VGje@n;zWx9|h<6MqhZTgq%jIR5kJAeXRz2(f?2)&3#ROGcFI9y<+Q
zYMh5tLL1*dLAlgAKI>cz4y%i7B+s0FayrVZXqVP^v`3~lF!QjsOSO~O%sJOE{)D&a
zriheO+awZFItt>gx!tg+eK>E<6<X^RXBr^XFFhp%@NdlFE$qg;z*As7EjSQ^0vSeO
zqt27pL*anWu8=R&P)B{F+_d%f{LOswF4w%7y3>Z6ni_Ld8*WaX)OOp}A?NU#LNt8T
zXL|B>+t_9?842%WiKi0IU>33e^Sg}xCPgm8IC34Hm--R^Ehfc*dno7m>Qo&&*=f+-
z;r(@YM1S4=JCWLI_QiTn@z0Cb#5<CGW9Z7x*szolO)#4lRr9v?e%5Hz9+34;siKM|
z1Jix0n?_+(tL(I2p*fZtm6>ch4@mGRs<TQ$&p4_Z#hTV%3#YSP_cKZBBz$H`Zb0oD
zS-%IKv>UTB1I_kxrwtGHshBe)|NV8=p1Rw9mJQkf@SNZf2A+-C;7R9Uz8vOS(~sN}
z`g!I_8xAs0LlYYUKR0A=dSieo!!UIwQSA8u>&?`%lnhd#+}xr9hm!$bU7W}JSOWPQ
zvf2QNEd#3#=Tc<C#I5p=c8f4z?U#GhunOz|X`^5g3Y^h%V&sedi2byKE!95Tw*_Dt
zZx->@^vitf4jHeqyz5n8?TM#fGP1_Dv+KN;ob4@E12lzlGXXXCb#^wFLsS*E?*FZ=
zi2p$3zx8m7Hyh*p`M`K9ZB|8ERBTXKtH?ekK$u3!$l5Q{3eoRm!>*O@bb}i6`NjZ^
zWQS+GLcZn0Qlf(|Z&NbKE+~=p=NsTq9eok!gC2f)n$~X%1lMNFu%7~wYxCvVGp*LK
z&CN2>0q@8<3}31+TW7((M*?tYq`Nr&A85IFjL1SYCmFm8>Yr!WdB0V@VYy(3#(ojP
zTHwzb)Wb!+RT{*Z`CF1au{ohV3bG5oP}o_~>OuOvHGv_%g|XSgYd$o@<M<&Q*GZQ6
zf=GLUhaXqb&&r4TGwy*W<oz@5;hfuJ9rRQFk(`K(@+aeTkZ8gI&c(rk=R$Lcf_gsh
zzXQMrh?p;(1JV(q>W%|MFQ-vCdY;Zr#(Ku)>6poB_2YA#E88K-*gR$?kjF(%p)vj)
zJDn!`jL`SA&2MHHMmxtVX~kHhd`Y}MPxi(`0<WLSGifp=boCWgroh2nCGeye1NZwr
z#Zi)g8EGZMZeIt=S=w#DU~~nZyz7brPB#3pUlA$tg<q`792?LF9{u^{Y&{5`j&Y>*
zj!0ApzQ*YDTWf6pwG~!rNC}4YSG_^*l~{$B9wn7C4l|UDI?)XilD8?2U?m>OYDTs(
z%0BQJt#uT6Fix$s!trspBG30pKu_zcAr5Ud6je=Lf8p>`3*3&i>Nw8t{ghl)Y-jxi
z9kPE87gU71;c#J!q|J&0ZwVBQ%Z-*98dun&4jTQts8zete>B1&V?bb0LBs5>zzgNZ
zr0j+lUv6x*WQr#U4g`up+(#KKKA2}J$_7|*DNFYF)%M33G6wGVL>b#wzf5&wJ|f5X
z8bP;G4BObe^0X050IGphNU`ksGqO3{h8~;F^;wWoj(KdC`nC#0q>jh^d&+CIp<d_j
ziXbu^=1L@K!^$GX;{V@1HPlKRWMzk!_j_FS^AH~y+b}i-|1MIw2;N1)lBwZHcKoB*
z@$<b3Z#4&`={Y{X3Ibz%MF{5-YYn97Av1T3Mw*_hC6#A%*I>sEGL+KaalYOlMpk4T
zF%i3zYT3_{4Vk*P2&pU;(lHLI*uwmGUU%amAX;yQl;8)ReQ8JZKXBcRPst!Yn)js~
zYbW#<JNvWCtdw#7Md8(#q1yb^YK3++wim4ptdji2z~E^td4%;PlYK^mh=onJj&V~7
z(1+(_zrG&yoK2y$FZFG>Emh7*Nx`5vzQ?pw9Jt|TuE^gSchX-pmM}uEKA59}b>;%|
z?H72-)u~HwBnjSf8&+`0PSmK$d}VRCdX*hqX-DQdmqLDlz<(h53gC}C2mTeN5-o-G
zja3b)>UiO<1=q%|oj<#wzA?3Hc5P#-a9e#c;ix7J_1g+-tE#e_%rCf>`|Fm57`_9t
zsj8;FAzo02p`1jry1r>HU<}$^*^-F26x7BW3#zEjly?)nz13@99j^h5YpBWH&GCfp
zs>lGuM;^dYeUk=(t!$~)jf=OX>Kl@?>l+slxu)i-rfS1NRnyL9kDrG4F2jOi4=&Dq
zYV-}%#SwD@VaFX32u6Z3-M7)5eu)_EUKbF_!$Vy0b;q3^5Zhz~mpwPjOMsbD18}80
zQzvhg9lat~o(co|4%7uil{^FZ3Tja;Uk7;kVSqLAlIx==T&CJ=$Ey$rN636Ja^;XA
z;`t<gWJ!pVBjgE`KA()B@I77VR)rty!pBtM%!uP?_2FazTK!JJ4=MPM3cg>#e^c;X
z3chzFwf}R1+IK1V4+{REg3l@VaRvWG!ABMReFYy^@Ds_1Ou2hQq7CnW3PbM9+~3G!
zZgpNt{gLciMXPL2i4hUmLk;k6Rj!;byEE?0P}sdWSC*Uw17~GT=p}c?rH@5x%V$Qn
zrp0R6F6PVP5;3|!c8lrq@F6)d`pD_77eu&ITvaUAMa1>(vgG7@Wntz4(ON8WkBXiH
z@{(pTtXMqnv@aEVlFM3CDUnJpkI9Y=4<FjKeq;9?>DofIpeuvNWbJmfxT0;P7<pKP
zlj7QlSbGLCIh8t<Dv_y8?$q4#DRHrTbwDHvR5zJF<RS%#rS6o#5PVPui?~P@q}|ma
zcREeYy*k&O6q0@J%yF3310!XzJNXjvPFZkXj5_|{H@@-NyXwVDPP<qdxpq~Vm?#TQ
z%J)5cL_|8p%){=DA$LVcmZk1F-}8vLT_!*B5izb<j6Qt!y>0HSygSs$XM*1mBTm#R
z_;~PKciExZ`C`~%jQ-k&>+gy6iQ(;H_zCx#Jk=tCS69{qk6~KxZIKaK7L{e2<e{iL
zBX^Tqkh@WK$y)aV_+8~mxf|WNxlwmvNFLgVwUJTx`Vi`_4?zqY(cJ!jUjPO4^^gSr
zga6Bpjj{ubY;t2Eca0wY4`5?`$elr@O>Q}uxjk2WXTLlpo(i~61OgauGx12hz>n<M
zOcU9Gb{`^+t^%+I|6fZjqVjZ9k=Umu0dy)PFGStP0_yGKV!Z6eF!)@%_Yd4eWIBTJ
z@wQ3Poq>Mea`Or?9GS__b7Z?ad8~U?NKSiBYS+*n>^&_;ysp;<uOjG9$`d1w%CjQ0
z(w#m59wNEpm<&f{c;k67?6^B~v^;xI_I>8q?zS(3S1}Em)V;Ap5l9A4r`JAIw$Lri
z?O7ylKP<-7xHHC!I(P)A_>6WjHsVeViSO@f7mp8(h~4e?iP1IqSvR<-GivM}g59~7
zzETQP{QSpy56bXnajQ&<ndCxxcgmWV&&rZCRz2LCN%hFQlQNwO%djk2?B*dF{2xRO
z7hg^DKN=t2I`SlTC*a~eC#~XyKZf9!6Y3jl=jo`R+cl8$Mw_=EH#o51!#Nyx`US0i
z5yKy)d=bnGA4jggff#VaSB3}1Es~4W`kYYf(|x*RdnQVVPr6gai<VR3k`v;wKtV2+
zU}C0L{BTJA_%!}fa9#JM?-M`YSA+0yuq6pU^Vd=Gu-I|9toP)3@xcB_?xsDdj*e8T
zqTU(Ih_#2^X`v^Nh4(1TDH^Xm7)`aQ;$bSv8hQ;9Ln165bLH{e!fAQo4XOpXia;<;
zuNyX%%zqPfZg?8~E18~~nx0!YeYNV;8SFh$67#`gSR^+*nf{gF-_+dHWd0{U7|0Jt
z#k&tgUhar?KYAhB4ZG@SreK)PaT^0i(jt5~j2byfReh|PrvCGbQI!^_?kJFNoR6N|
zEkn_htuKrBUnGx~N5#M25qbFipIQ|KrS~OHp!x4cCe!Ina_S;Edv){$pzlny1AW&h
zP$?51J&=6vp@W9;Co{4HKWIl&?+kXQznD&mllzljQDO)h8E#V5k)Ucjx#zx=I2TCD
zHx#xenA#1Fuwtna#JtvHqOm}PWC8rkQ8_);O^r4^fminhdim6<=lY`GY!i{AM`Vxq
z>b{6%M!M5If724wqoTD4Qg@LSKXhfmvAb*Qx?Vn)dI4T51zUc;CAr9*l9xh@K&#xB
z+R}j;zA<E_7$J*WTkH1Jwx*7yj!~_eSkK>X5YLNt@wL4*t9D+$)USt=#-A;FB~w=R
zMfoc^r8ZnL2h@-6cIV<d<mcx6cm4m0JNFWI=2*On>)=GM%KO!Z$7F|Ca>AV(au*Z6
z_i<`672udOz%jDd{TGT$Arx}lYeJ6!r<xQ~69lU<;B5>h{nF4AGOr%<URj$F!({<z
zTo4bq?W<0gltEZe$ltsye!s7?^`N-lZ5MyuS0KLYM0RCfs6&R9f28Z#dO1bTec^6d
zFDJFOhA-@rH<z~@6b&cDxWh-pZE~f!3Tc=t?%U;lKM=rpe;TTbz*6CiTug*SQ%zml
zvoSea41>?kO~J($zL1eoO!B$?vPSL_qmswuL@_GzTt_&yS+?SJt4JR>A?^x9An~uX
z$>JUa@_WRy2Pma{0y^|m;JA2ds9PL>#r%9vL@w5v2y<(#eXd)ab<ULO1tv8Kl7b0R
zTyeguL*t>*t)fp9kYWi*e#bN*=m1_^D95+D5BA)B@JV+l{Qu2xTdp$;uUY#8&Y+b8
z_Gi<SF&~NCfIe_}69Qw`N5AB{=>MOHBChibV6$kwwa5Q2?KQUTPR3QHpA{(lJikeB
z=)aS|FQw^S1&0KWw%y3+1|)*#Sp-u8XQ3`%b&g{dzkEQF1OHb?7NE35CVOsLoPpc}
zePY*PF|1Rx9T&rkYrD{9K`~mCxibT`D9j_>S}u!`nbIDjkoFDbvK?SSJHU#=?ygX{
z1jVbUVMG>Fr|AT5#)br25dvfAzwX3^ILhC2NT)u3KpsWmq$6ppXAT?|b;akOgMXYz
zwaNCGTgA?!=h5P{(+R|<4#>mZ$A-A1CuB220tz~I0AE4`l)U<GG3RJFoi6H1<5wSm
zA$R4z){*M!N-J%mUlVejy#Lv3!r@r06rf)e_ooeSLmR01+g5@8s`DnBP-e|b72d!3
z1~MB5Tb97$GL;y71VRi@Iw)$zU)+Lo3!~A#?w{X_CHVE;PMveA?I;%LE)gLI;0AT<
z?xLR0%7Zr(j%c|H39}0>==lDKJNXiwWOiaROZcEHW+=%(C-nmPj&PR>UBSb_)^DsT
z>%b=NxER$ACZ5=T)V~iFzJ0K(_Q8Vo!S29)uu%J8SM7rZ?Soyl4;Hi!cFjImsC}?2
zXdfI9cM6&BUOhII`a(Q@uj036$dI7;;a+z#dErlp_HekYrz<79l~+_dqSB3rln~(6
zWcsAuBn<$2-K#^QYUOw1VrqLz7N$>UdeULB8{5s{hdaW3Wpa`l>nOT~(nor`wag%r
zJ69QztOV_cO2iiqM8r3o*W*Vh1iMsJ@4b#*j8kYu2A32sI1vg1val;G?>;Z*oJUL(
z4e}B(o^p09!zF0i<u-+|#|cGc`mVBGY!_73anvY)R{U(2n%ikY$U9|6pUmK^v-Z}C
z8)f@-Kgfu$IPLC~&=IjqM#Lj~WqYsgS`)0h>At!=vEu0Y-m@jCbXrb4E#}F5l{o~D
z65)Car(`BwXSOy}=Z&5Ur(1o^(&<`d^ORkfRy1R;dAL>U57B^xTMfxGD0Y_(Ugr&W
zg8ImbJ?S=@;-YhJK}k$a_D037PT42VmNYIpv{9xq7sTo_;=KnTh2J{GiXp`W^1KWV
zk%j~yVwvg1f|L}=5_f(c;lzLJPi|bYE}AY8?Ex}^K(Gc}ps8p&Dz26_XVa+t+da2$
z7UPq$M>U|uAr*7Up}X$9F$X1a+(Vn^5^TTD;ZUT9{_DliB^b0scDy1($ZK#Cxh3Sb
z2Xas1)MS3hT@<2M1LV3(&|e;M7v{-HXioIpooL$Q77<}=$cu7mZw@dQEskK(-P=O$
zy@A{}2wWbb*XyX`{1CotY)T%Lt5n7ETvTIIj~C+Xi?UUoRdlIoiCiRe6**alE@<|v
zK(70jKptArAX!*!MM0#*eF04-sRee=k|=uVMbbfw2Hn!p9~1aqwgQ-5Z@N#0x*-{@
z;D;f@aQet9dG3POT>Rh;S~j<<?_{4mEgm1zzF9?+VtnS@bqfB6qe)Fu%Z|!z4e?ka
zSy{CM;U0fAEtNatv4+as`1&x7!S=K&m5l3C%zisk&K>-*XJAlz`}<UXNb*Op{+UTu
zn7Qrl8;Ea5Obdj1#Nzx=4?I@Sf&5Sysy{McM-|VI+p#Fv2h|m5JQ)JkBM>xE!VTgF
zWQX8q3l-W|+A2%BOG--8IN&-XOQI#Ui&eKsa1pGCFtyqvw+AV6dHTQ^r6Yl$p%e&`
z;hzUb`DZLgU?i^~98E_>eL;^pCUJwbjSYA)3wC(-`tX-PvOL+9K2P4l4a$|&1_X5`
z48L>mNcem-EJIs+-;E)DpqwT896Qi?w}`Y4#!3$|qi<s>2fKT;0A2@w=$m&G6+7K&
z6ozu?P_`jiB(eP>W6)~tiIV(wNo^YAM9ye`tbE5^b>vEo<Crn#ZlZc4j*JxRDt?gA
zOQM;L;od&l?WHIm8;OXwNDn}huZ@;;z|PLe`^3$~V(#(obV(|#=qeGwAw725olLIa
zJjsF%u@B;Sa>zwug?xP_#qGktAywlRToNSrgLAlP@J}WLYHTjP3&@9c3qsVzoi!#3
zcLWdM&I-v%?vX&Ag7d`q!?Gj{B#z@mjr&!6_gpuTM*A+Ap$O-d((cpnFJC}UwATNM
za>Z~Qhe4!&*ncLir|N|TlI0<slaK^mS`gPQ9`lqtFXYY+MGvJBRdK2rdblJCPG)EY
za;H&jJqzcx5fP=Y&n?MS**DJUP|+bqbxxEM`}&F|_TnX4q-HiJhe)e@_9G31`LHdo
z&TLqPrkRamOuK&sI{Td-LUvN_P9pA$<O#5|Np7b8K?;n$M-(XYp{zL6jh57voyT%)
zSJDi+g<$8dGWXMg&}KQ&y&(iqEeMGwcR@g0QVbN3DA!VXLh)v?%`FLtD~q?dOGEmf
zz&U6@%%G+kfzS8R&~6b4zz4b?!vW}7>@z^=n&K_tF4^_G+lOHZIxDB)<a!G6fd9JG
zqU5RyFiJ=FSLG6}aJ(L6Z^+$<QZ5uBCEj&Fo)Ld>ir1sXZC#s@WdKOGg6+-jomk_g
zAvwjJpL^cj8cItFXwU=2R}E&5kVdPR#x~!*UIk<oe#J2N$v}Wafu{_;N2pP3Osn|X
ze&YU%f#NNF=XynE|6%b;pgq%@32*7zjB$G1*<%%D7|B7ffv7oA2hXb2?t*c|;8uUV
zmLX`PVJf?6ms>GbOH<xS-5#Qs1YTU_TU_u=g`4l`-Q1fIj~s}AzWD6^h&b+^lJ)7c
zXV1CoLcOxKS0^7TeN!qybov9C3~7nhJ-2AglRe#;y61)r74O?CYocL@^tFR<u^Vf<
zZ(j=~`>{CDg&dU<M+D-Mb7AP;%X^E_{zg2qK!da5FbWUsJ#*F_fj#)Y3yPn=L>L%+
zKmHFt*vozdXm{@3vp@9^uHHP~<6t;=07PWxb67m<d-L$-+iLZTbSlK!4f!)YH&D!T
z#P0(5BF9y5Y~sdb4|&A0knc6u-JdH@imn66vv7SGN!bgM@}ohxI`<$v)br5ZN%Ry%
zR39GL1gY6Re~YW&{j#axiN;i|?Bv_sGr`(84U(z-uw3;aKtqD<>eZck@om20MjsDn
z#GXjMmw2QH31nqR{M1PzLxbNbMPepjQ;Dcbx!iSQh<MPQ0;hge9vWR060H=nU7V3A
z2HeUqo6_#&T=)I}O}$d)zv12-!oxWChB2A*hmi7;nDEVw%W_3U@+`sK<lkIz{{gpL
zoq^#%BaDfjg|fSCxuAu@D~jF=@ZE<g&4mw}qGwIQL=1Qr9!@LHW~p!^Cw9BH<!0R1
z@J0B9E)KdoCWw?fi;fv6D-fgHtpO4}45|rXL4+di*VSU6RZ#%dpAQ5?__$h>0b@br
zv&JA%wgbYz8-3#sQp`2f-C4Ofu{o?{(CvO0DzJ^7Y`QzBy9wHL3P#>dD0zh%1{0_m
z=T0FXDIN(NPPt!o$BI;Y$~_v$6RiW@ceRIc^eGlaWTYOp`qO>xRRP#|?=M%$lriyu
zc-TEbIe|`*(CYX5a4d^V;N9*i92L^gIN(%og=6YLt`}`i?>nLG{aTeT{~8uBxV^uP
zXZ>u&Z~wtRJw7ofZ@$Me{^Zw7VPWHdb?yt-#HJ4~zy_{c=(7~G=>I^UtsRZnt<W)C
z&M$7jjA8Yc1VX7vp;WJU!^sb{iDCJn5^-sMs8&24AaF{4C@LnSj6GK7zV!2QKLrJs
zqPj~DNOXpwwsz#WU1eLUDB6-DCn9VAW%Ivn$;h@vnc7rsYkHMP2hM~_riGCH?#=ho
z$u1pyDWyLBocO%poR{oSP>$+Sjw&DAh~FbQbMhO}!i)+sForGSxBE|oQ#de2`jrm%
zMN`pmcNre$osm(>^0bAcZxJ@BE$#T`sk7qacfc%Fo!at>ui$7<A7Bszs)B$_CX9#b
z9}Jwyyz<)jZxff|L3*?=8s8|szVA%9E8S6q=YeVQ?Lg!)Vlb#uX{59rvh*P%0p&)-
z2uj4Ypj6)J7LI;8e0qaAlcKW<Jnl$~zwJ9!(w$l)diEET$ift$bAbX1_Q!De3F}^t
zUpEzx?K=v!{;7Mo=b^6dbPAXc>^lR@uiWE+-@lKZ5B=Ib+|?m-MS34jfO0p6UsiVv
zT16Y(FBl%#S|WQUdH<`qD)}PSLqSM7Y!N}sdqn=~BRJ-esf}rPB{8A%hVDrwnVYV%
z!n*@U#fJ~96u*LtO>KnxEs98!HqN{xi1T^bE_*X@h|x?G=e+HGG9^A0kTv4<{qjtP
zlKmI<(Nn9>yGO-?fg0@mkA;zQ<wSg=r2FuUES!;DV4@^+$eno!w)AzUVZR^Wi+d&L
z{SzTykM`atXQs=<8-d8dj0}r~ouRJjCY>W*HHgIco@YzSdLGy;n#>6yj_6Pe7R989
zZ6B>IJAyBAzr8a}hhT}$G-bJJW6+U~;$R4mtUJT#)Dy*j;@i7dQZgt$9Xu@V*%Rqf
z$6xx4*DV}#utWSwB)c#4c17iP6`A7Tzg`e|oo8R5c#-MuJCD3hd}3cG_<q?v92R@r
z#hzy$E?0KrM>Iv>9$NQLU33&Vp&~+uD&qIf37z}vY4pI!iA1{&%o?TIYEXRoz=_NS
z*(OWG`wv8Vqfn_R&ZEUShc0gHDSj1)-<?3pjA%ZE4TA1EATRC^j~{rwR~E|XM(i=7
zQLz%6BRa^T6ONE9JlPBHdL9|XE*$8MID;w8l%28=CpkFU>qT(DDc?!}NG>3;G4Rs*
zjL6HsUG&Guu6xQvJ4*T8YsOLhM2|Hm>?)a6)w7dzQ3ThM6a^uKzI~lty*M+%Y`R3#
zVZV@Y4ub~C_H5k8_qR*E@g{D>2S|O-Ug(DYNkre7W7_)8%W(+TWhr;t7`Zr#z<Ds-
zo9<3Sw@>Lg&7cFzeA-sR>nPQF&ajm$8vC)K)@povhx>3KbZCGK(04xBqKiF{lEo8&
zG3$xuCU=Y41VRvx?mv-+Kroj>m?zRJq_(pk70(1E;^oxwNQXA>+IrHBgf?_U-8({Z
z@~v{S7;#FZBI3zCr)2kr4n*%;<vqW|rIs;r_lL!c7e&M;_D0U1he~|Xm8ULjz*D&1
z-b3!=fsoj}QVf&HueOS(1C+L-tDA#p`CbGY*LeX^WbnxO&&iaxx5m_M0v$g&rg<T<
ze|F3v5}cx6b+V~aA4GXX27N>|a*2+OkKo#0cw?(t&vyOHKWN|UO2n>$JzHR&_aDfo
z2T6Ni3~87SPFdmcUJZ20rR!8*^8d({|3q)=!fL@bi~IMR;~RCjmy&AV1M=`ka0sWI
z0uvlnb>@O$0$wtNCsSwAf5MSuug=2di{bDF(Q*`5pyZXC+^h3aUAP6dLG_3PH)1=P
z63HYYq-d@YpTvnlx)0tf-Iqzpa93TI@1c}CdrU`HSC@FgO=>5sA{Th-C@D#mY}EEq
zPlUgQGkURdrPy-H-7`*1tU*41L~OveUd*cbljzughSFrD-8YQoR~*>p;)ySrXd#ff
z$J}c}$Q5Z<i;e5L+`HVn1G!<ha00bMPgLQO*!FSQYR?;cgfI(oea&*IxIGW*`b@wr
z2*~HeEBocjvetJmNv98`<*NPnyz5@Er}I9syYqgWe2Zc2qOB9pW^iGmW6=e7T5h+T
zoLZO=yGSs<73<p<io#B8f5a<JG9wRlpM6f`9>+}a)F}AFF05+QT^8blImCGV{DVZ(
zh1+PoROzlzXUH={;(Z6)8G+A0)<-}6^f9^dGsncpqfg727<Tl@&mI$39~BoLee!Af
zhPdDy#S#2b@dvzLb5xeeMF?NLbdEI9ork>w8QY4GyN$pZd32z?ek{Nna%lq$KY?=_
zH%jMDZYw-P-Z{ii_aa#1tFQvs>3vhnd>c9KKWx0p!kUrICONaU7g#;(^kt#GM3!?@
zSm~P?Eaj}XP1ANcAsuy>=gK0eZg^{^_O(r7S0n`ws2(A`E{kw{B@dq8NdG~AJH8-S
zzm~y1Zrpis<N)ra(sKpuS*!6JV0!MMo(nQ{L2f)RSNZ<kvPs?zyIxDjiSv*~z48&1
z!W4rSz{c^6t^fz3#kitzN=!jD#<?|w;d;)~vWT5BU%g*i^Sx;5{Dn6}oBIIn57UZa
zw>ARbQJp$}?))ZfmsB4)*)15e<C9UemAQX(Zx5XpN%!^uPIcy}PNJ;__i3-CPH&Jx
z%*<`g;L${;?sVoX9)e_WXhS!Y@5S|P*LmolzUH1Its*Bm;1J*EV*P8bR&TEHs*mDx
z9UD6q&PkUn(*Mfh-<+3Qv~k16D9&x`q8k^^370I2s(+hqUQ&3)X3-ZY7+bQeEPP>O
z?_Fh^v8gW@i`$#xl9k<4A<r53$<FBAsUuOT6Mow9i6BLI(W4G4gBsJ9LgJy8;izg6
zmIrIagyUV}uK`Mx7pXh1Jt}<P^mM9fvp6&)A5VL_O6Cb%P+hv=Q26XdoDCeuZ_?0O
zQgR;%s@zbGs}e8OTjV8Ge$j#F!s&%*M)yZHZaVwuLgkcc2Nh5cDOEq!MJ3K6uSVZ+
zO!w~?{*7Fs6Be9z*QL9o;+u&xf7VO{d!B>0FIjY2{B6h?q*Migm(G8t>!A$NvDBlx
z<l^34sdtKbk*(cd?vOjhCv$KfKjkBv7tUU|I#pOU_lv1GZG2pcI}@XeL}o`)jF!b6
zC5yw+jeRtxt9C|i{7^U@J$UP4xrMeZf$Ql-@0rvb>Y^e=7mD>W!Plu@B$!zw9z1Yn
zai*kI{5nt|M#+L`xEFVghv7<QO>0TX_U>>vj7R7y)NHa8l`L9sy?#lwD^n$IiHJg4
zuYi~m!EtA}^iY{Nf5*{q^zKKyR*4A_oNr7Hl$0H$Cc$F$st72)#Kp;Q6wj|=zW;iM
zx`Y1wkVyBUKZ;)k<e5LEWJl{EB*eoz#qQ!L9=I(kgDewUzbqRzmyj*HYJ0Y@uA5lY
zg-?mbl_Ix2dZe~XCkA>*ee`)Os<x3Lhi-lZdZMXg;>Eo(KhIs9n-*8)A3BseKot*&
z;mOqcZxC4fwD{hrq?n9raD_S##7fkC@IF~7LdV690x|9cH4~#x$nHD0U<aJ3t<BUn
z1Lp>1G7`L3M#bugm|N3bs&J8@SbZE1+-thdr&X@3W<UaQ7a~S(=@gS|GG})!jN!qP
z_)nY(r?HFs>;7WAudGc+D}Y-m?g>Qt+GGoEg|}ZV60%c#4iE8XDSa2SYeds2x_ku$
zj(=)4)ONkxAwQB{c(6{YW2By_Ol%Z6#Yi@~aD_IL(7YZGZj?7{|FPK8E~eIWAM8e&
zg2(yz*WJAZ54%6TCH><6K6Li{7I$*qXP!)n5lMM=^Dpt_L6(Zq?Q+p(+-C@F!Np*N
z&U8xlc8Q*SN5#(qr^J!{HF$?7Cg2Z4abe)x9$C|kh}+fM-P`@Yv6~J*Bj<J_TYB_h
z_Zu=VU5NhO4=JtdhDYv0^<*#^P;Md+R7Xh*pNt;rj-HgO#HdrEZ?7C=EN{?Hi8DQ7
zOyu;zr=mFFc#ue?YLAu7nk&@-`yqAd*i{b6l~*F4um>k{As!d55%)J??;%^eOK?r$
z&QYDXh$#!YvG=aM`$4(@H5@n6KO*kG2xnj7huBt;I)83EKJE|@FXrLKN(hgGCI=3_
zCknBp5+x;xoA0_Ooi2?25!*prbdTcVU8JOJk+}7gn7uMwSW-vl_l4aX!{-4&@2ME-
zN}Wb(`3L7Poo1-}3T<$EI(4lHehj;~nPWS^Q>N{g=jBcJ$=2wXk9BOq1<quqM@Byl
z>)9%Edp_-6Hz6hG$V)f6*Ieo@94BkLyJKGzy|+go|C3^jJPfZZ4~oO1u`!$^7aqf@
zEK=HTBw;^zxlcZ<+$o-L;$DB}55$$H<k;SBkOzZxvaGv%lN>8E=TjNI$;FvaYgA%q
zP4$n<&`U6e`7*y%=6-PN##)o2;qit(+o6X_FUV=#_>;Y)8c&HYx4xbxqPZ82iQz{-
zweP-<;yK~!9x>r4wyrBy(kCSP<P_XVkIKT1JGb6dkA%6eM@~hyoBC6?_?d(IFh_7(
zjG&d`u>;uK%Exfb(e}EE6BFGjW01*r(iO2Y5?5K}YN|X%;Uw-Z&g&LeoItLg8$IS0
z)5|sEWKSw8C(Ff0#Jl9{J^Eg%I#&vcJ?a`vgUG3Q6zkcUR=GxyT&)Q9h@-o3w{i__
z<zE`=HU(&U;$`Rcve(L@VtRz0Vona!cBG!%_2*-V45#IfVRKlGQ}SU9pAwhLnuf<u
zZ!p(SRtC?Wm$fAaktyl0b2!)=#!Z%zu$*+T^sY6v9h)|6cs$zGfeZYpC_X}RTl%ED
z0%}@(P_8+6zDTsz$j{E%_!&8Fd-QD8=CTs)9gARW(QwHZc8f#%Ul%_Ow8Lo9ILD|z
zEXGHoC0}?+DIShCQcs5akh|Z8jZ{xr-ve^e5&8I2?rhw;$jI}uF#60JUHE)KrZ0o1
z4M)W1_H~MH;>zlt_9I6Qg+=Sia9;+&rd=G}hf|0@29o0EPVobHuz4;MmB)-S6dw+X
zwsvvx>sxoqjXl4G{>;dT+p&L9JkWE7K=3Yl#a+}qS^U2|qxe!d6%JRZ`r?{kgZSy*
zPTW6h7bDv7^f}x^WTwmGrCn`k;s%cg-&YHv_4O8J%2KV+)57jOQ2U7~x#Zb&>Af=d
zu@V?<y9}4rhWl`wm?9acy5+Cb0PQ-vpsewa``vi~@gDrjUm6}Pd|Jd$iObu=a=Hxl
z!5chOsl37O-w_eNxdW>B!6A4M097nBD@q9vcAzTzIp$6s_vDXKuP77_#TMa;Stp3$
ztwu~}-=Xj|c&t#9I{!yippOAf=|1=C*7UivzwS9EQ$5%}$!>Y<S0>|12F1JYI4b@!
zBvJ+iuRo4wk6_}**Z~(Zg%`uoaCoL7R~)?eUIT~+_rqbo5$Np2y`Nt3v3+N7e%am~
z?n!sh<*a;hRlA74o_<OE$vGiT1kM~gAijivHTt;3?v-djnHMWsm`H6`ZTf8K%VphN
z2UXMy%EQ5v-L<9RW6^cp8L<JMh<g2=BPpEOu4)%^DOJ%&*a@*JBIXqk85NV^WK?hn
zo>4wKfG|jP%jxA$Vi^@&u}Hlo#IlGeDL%RQZc%wy7Jg{+HuVf~zS@6%<xO+(e|U5C
zww@v4P$Sh?-|tqhery14c(;WOSpO|nDp|82mZYmY3H1TP!45>6MxDBk3q2e*rxM45
z-L-Z2d_njJUA?t*u7D3{>^Vbc{+C3G5PL{g3AyU)o9aTD%(<e8RHh`eBifTbi^s8W
zFu7;XpFgMYxOURv4#6JgLtxK!=tJ9spD6uv_N_ZB`N6B&h?);wW}Pg7H<lt89DL78
zSiTEeMXmL7*0*>_>;KH>TO3i*4l2J{FN2sINU0PT3VKZKDD+jM;1@`mh1*4(?lynl
zp);wc576H8QIv7=it;lDa3=!C=b^(?8jjs;Eqzu@EyIZ*Z7=T&<i(HlqQeZjq@j19
zw;aYc>z(wFG1DrGjS48E2tN95xrIJvScKR^RAkGeh}Yh~E{O{*`0VCmxC}FOjA%F|
z#_2smBzQy(ihHfW8`15hN9DwyWRMjqEbcl@{xCi9=)kT20FqLvM~eiZJ>6-wd4gNS
z<%{<RRMr`MJ(zY^jCEJ!Ms;q0%89s9p(@>3qudn}=<(zvdOBN%&nMzqhdd!C7OBzP
zS#;hS2#U&xm?DcaxPpTdo*g|=d<aIad{F$vIqr^wO77l`AB#)Ho1GZ0xwXVAcRJNg
zvBst(mFk;gx2Kwt@dSU2H-=9I<Mvy;u{K%ftXUhodC9ui($dw-OIP1yn>1BbCgWVY
zF1l*znlfki?nM2bIL4^inZ)CL(jsT&t+6or#?~xdxnfxbny4dCCsw*9mZ)rv$LM#-
z@bTbSePeZe7pi0R3BbvCOJ!BEzBLXE{f5r&-7WFzR8`zrx1wTs>8(!LnkCD_ibz{a
zeKH=~R+)%9H?AoUQ-f8dtJkkX7aBj70<i_m=hCt@%fhPjtsY~m*O!$!F<e;KL0wuZ
z8xsvQvuNpxvgN=u#@p!bUBYs##)87{0LxBUX~l~2C1p;1V<L&x)o}<kRYhQYS6yW)
zk&IV2RBm%(Rdp~`XW5dnve?q~rDYYRt7CIwbDYxUD^^#aHq{cVYHCRBY(z)2jnVHJ
z5w#jf!CAR})mm6>WlNG4MoFu>zAD*VS>NJpzg?dxW6id;RJQD<{*5$ROTvjpG1iSY
zt|*VKt5{O8Ld{@jWy_9u3tCmx#jAES)bC``+`6Q^bji}P6|u4vt8c2fIku$yrn1s?
z;0+6PV`<q6bV)Yth&N(&*W#!ADx$F)*RNhyQMzVzEas#d6ZN%?@#=gU7%dYmRi1p;
zRg{zB?B0!wmOCp+GRa2Vu53~55_3={p*bs-EV~)B@lo`uSZgJwqvV;`-I%Q06+`Q$
z7P_E`O#+dxs%(rUl^{~h)wEi`B`Vcxv$L(Kn#7=1UoE~;el-zVWpv!VyMcZ?arf?R
zxbc~4hEg}y=BpQPBIxK;+`M8n(M+~DOV+I`y=k?g0qd!bH3N6cEqZDs-SP^jra9JB
zQ<I1%m4n4vm#ta1zI;V&?UM2(tB4FtqsY9^abkKQpjJFvgtA&ovvf7|YONu?d-pCf
z6JkYAwsKn&lmU9Rdv|43RlM22u#{$?=vS+t2HO(KkQ<xm+>7qf;IotZbC!f?iPuzN
zj>f!~(PBEWnuf|+{QNu_DfEt(Ud>i%d@NSkOwCKz#grPaUAJQW@-=D^%*rB$rxJ1e
z^83;y%fc1qc=42A_4-vySCoS=RuX*Es<$R$l?_-BfV@<5u0?_P_G}@MY_4kF?ZlcI
zs#&^<MiXfdSxHQJ91YjReLB)W?u?g}R#WveDg+~MgBA2M$9XWv>ZTOZ2{m!;SG3q;
zmC4w)rUs{U^|}>U=~{24+4_hX_^l?GF?a$WiUhHzMAt}mOH18cS&gNqx4HUlo_?FJ
z->z|D32pf?e4RoA(^5`IFMU&Myrrh0sV#;(6Zk)_bUvQcm3sNWOA7|8sc(S=#dhL5
z5rAog+{tp3OD1D6vR_fQZbhv0Mo(Fnm9K!Oh%Hk@lBpI_BoMFKVZ_`*E7vlY)n;k=
zlGQL<qeSbK62SqlErb6>3;>e}2yOX_h;qy8%PN#Fi{0ofS-W<{YI3hoS*r%*UlfPy
zHY{0-N^SOV$+%9{60g+(!_1m2Fh)87dxjR#*H55_@@jbZ`wc46+_kPLm7^%K;>Oa|
zE0(V**Gr`wfnKdxq7K$Y>tN`{YU4>|N+7apTfCMWxiM}nFU`oc^ObACjPx2du#i1R
zp{J};R*ypYiW@yEsVHBsy)<bKsa{R0v5K4}2Buh$YEW~nOx8CwCakZhSP`iprvq_0
ziuZidci1>o5`M0pJV$H78>MvhtxL*EN%+mRP01!+Jq`fCBLFw2lB9#Mg;vF{wLS<%
zF+iTCswst$qS18~(X}g3Zct9RA<^95wC2LJhy~KtR#d9lsIip=QXnKXYtlhhxg2A7
z5CmJbiv4R#G0sh^*XJ+G$G4Fb%(Fr;4wFQ@u3}C3id*5$z(2enX$7JZ+2Bs?!YH9x
zwq`Z_HiEB~SU<-PS<>%@`#$<jUP`+zpK~A;EUatV881YbZ?20s7Gej3kE$1Lza7nC
zgtT6i+ia_EY@%7Kz=wC(1zwf=YR04il6gUU)~^n)UbA6!3~9;|3at);Tcx*fOUlb}
zm~PC1ygym5(^{h*UDd$Q)Vju&-HeE{4B^A;c;gak*iZ?F0FMPx8+}&7p<oL4;54Ro
zZi53&Ho<2g?@|qw;_FbUZNtNod^}n(2+V<GguX2*b@X5gDGrh-cGUHaG3C3f>ULNH
zCLH4v7l~v{M>NP$1$-YT@m)yIbf=g~0d!)9Q3v#^BB^?;QX;E3(8^>hs^i;IwGMJG
zcuI<^+cX07U~Kr5A?0I8k{viD$j77S1t<91_%5^s70gN1#}aMzN#t*kq8Ux+8kD3V
z>4xiv&Hx2nY;4kksH50s@}^j_Wp@k-Dc%vH;PaAXz)k{z1-b8T`Zx-Yq+_QUl=30U
z<S|ijuVxc7u3kB>Mu^Tbq)^Q*@z(mLRKf@u-Kw-gf<kR7nSeHWGuG@n#9Vw=J%!TP
z&NviP%^$vI&b7+(k!w|RQVYe5#v2nU=!CUoB-+@8&_+QGKv@Y9tc2VMFl?~HK@v*}
zjV`(xlWU=E3mmo)d3C%YPFnyScs-_*-~#kK9ifayRVwWVt29^*?5jbimsIo-$GSFS
z`@<~4C1T<pag(?xY^=7SX<H@o4ONSs1oA^WTj-U-!>g%Iw1kvV8og-ogg9?5i@Z6N
zP&)wY`3A5?N>tl|EI>&ShD-Y9QwXh=7^O+=2evgE)@Tk{a)R-K9=w7#4}i^0%|68-
z-$lV>J5*SivPnaI)1<r_KCYj*pe$st=&STksU?-HaIl6u<2xy51{%3z3t1j)qgoT9
zl`__5WT+O18prkWVG9O-LGjS`(4)rTA@E&N)K+&=6lh*{cwU>DmN)_(?RcH))Xtr|
zAq+AB>Z_fRC9Yir8AMDwOf(_~qx4=GfVOmOul;-(e`Rt*%o45`)Rj`<-LeEZ?yOV>
z(Wulnrj$X84$JC&msS&^k#gU(cWi-&@|KJA9^7C~l@$16)%8{#wR37}jK!O3?3~D#
z8zoYml%!%+fUQ}<ZIjmOs+tC?p$>$lY)pxdB({^10+_Eh>3DTaS)w^esxsI9Nd#3m
zdeEs%eWS`#V!DyP&cV(hwr1_JHOp75qdhR>1BKN9@!hY-wzw%f2_%;Ef~;L15js_5
zAI;pJmJHV2NXZN=7hj6jL|!W4&{XIgGNyFGD>XIaK!SMXV-adYW(eoDjj}X74`@#_
zG!`khf~xBim5D@r=eCC3{g~0jtB}McD;uF_HAIOHDwHFwVtOiAG<wB^ChD=`@rqk3
zbb5kJ%xjD2MQ*WC9~Nkv!k&qe5paaPy0Z;ahs{>*h^w=U7}**n?65`pM5Ke91qmfm
zU<i%6k>RK=uux4FnAS>cc(B~n4#Ek2ubd%U+1yMCobEuBsJ_*q=K7<R_0_xduu9DQ
zArH)>CRU^9>1p%GiF(?-8hUU<2}C-S6<;j|ZHRCeC0z#-QYQ(-gWBA3wbl)&gT~VS
zs0lkHowU)sRKrS|1o0Ewwp$@UwHoIvjfh1wIH`|vK2)GOXFD{2W`VOcJrRVuIm$GQ
z5RHsYiL}yzDb(Y5OXmm)Ef*y^tfKlJyJ}Fxu@d>H#9T!TBUB<u0Ll;|(WV;pS{Rg(
zz7nThi5L`C6Q^d4w7jf{dgSd*Ffc{G2Br~*HqiV@A}ZUDc{-NR5+Tu2;-QC7>)EI_
ze*M@Wt-)bJ74xfG`#FZAZ-^sC*VpKAla=)iY_2VFwH-HOC=NA&x=QT28ynz3mAb-`
z;aMqlY>2nU8$1g^JWF`fL;-twcv+fLd{?tx>TON%2bC=?mAlnkw~<?gK$4VynVION
zqtijEL8gjWsOlh6&~eBWG%D+<^gd4veQ(+sBXw`COxD5AXV)Y4sQ3tjMNWmqpc5qJ
z=+KM8tumQ`{pj%2d`=mLzB8*@xq3~ArqKUW&avire20q4iY*f%wP|uZVc!Q4@kgKg
z6HzqLb%(c4R^hB^+xAw96Ks#fXf+NRkv<{T>%B#yi5$LRp9e&?TUlMLVvHixf3#S9
zCk~XInjNt^1U6&}4)SL5aFCEn_gi6&O>~;KBOY&#)k2Gr+mkCrz`$<S45l)s=9Z>f
zO2-kT=>!l-3K9`Y!?mPorPR(#O-@UNc0!2k<Yd)^Vr01_H}r%<^2itxx()5#Oq-o>
zv@sK91}=u0ZA-klp|UEzlSUXYb0l}9KzcF=dNiBF9-aJ=y5KuJwHH$CK(H`0Ma=Qo
zB4G@mN{NMX%X)3FV##=AOLbElR9Jodoq`gHLZ3wR`;<Hez;?X_sVxo}8j-glfrz(l
zM<natjMA+(I>}OQK@ro#f~=Ynj7-@kg$G(iJA<aCEIE+UY9mwf0LNrE!~;&b>T94J
zns2x?G6|xW%@3_JF`^VfcOVtkkWocbQoCQ}N8sn_FhNhFKGB$h*Va8K0yHR(0V<RM
z8<O#c8YMi^P<U;ehno>}qCw|(1DV6zk&x1Y;!y#)m?W9Co|0ZGxFfSyF`Bg_rfuJA
zWEF8Bb!|0jw~MnZvPP0kGt4AQ&iW8-J2pq;|Cg;=iv$dh1=g)waf`o%#}>$TD1Mla
zfI{3bH@w38;=~Q><5fTml{kBD+{OfMQU{IYo`<F!6<_8GWkPqj0XSIoMYSk3BinR#
z);E$UHR<^6j%kh5r*TIdUm(cd%A<p(Y6n~st5u0?3p%L-ooZ(XsUFf(9M9A@BQ^8#
zEtM*4M`BOQi~Wq*QX2^vmLUWj&fT7(eYx6llNf+9!#GVX<efCGy1um@NfFU9yM^sK
zYGV-SH|9x-KvTy2Fw2^ln#^|N>{ui!x<St&?QPo;BN6EnIMSlH(UxccA!UXze5CsD
z`*ksTWJb*mgDp7tf|H>W6&&m<t2H$`QKNQ#@_H9QrmbmGlx32JgO)gubq>93OI7W_
z5i~KOBu4}5K&pc_85OOak0Ip_)P|L^8Op>-kKy`=N;8j36g8i8lBJ&0sWH?!6*xoo
zgR))<0GcyG86FL35^4YWVT)NEGlFAY6*tsbYdvM-dPi=>K>mQl0J?MNWiB-*q<Rua
zjO&Lg*uPX!l@<aTP=VUS)LAYyG#pZAj}L=Wy9zol(+kV|@tT-ccz}jOam93E59oU&
zwah7P(Cb2?Q|HPaLnb-*_0ijN8jt$v5fn{510zT3z-pt8GC+~bD&MDVtm<aOV6+rT
zvDc7S&7-7NFGgxan|`kyJwOKSZG<8rnWt4KX_nw6k$F?Ck%vA60>YzAIu^r;gvBV0
zRnLRzq{ZR~6G)qnwpl?lS5F$qaPVk~=olWzoV`^uIMz;&EsbbtN;b@!>tNTxcBSXV
z%~`M%rARK`7|L=mZFVP~01z!&ym)8^r-K#aB2>gASP|2Mk*2Xk2{7jFAI?mc!n4|q
zLYeeovicM-9XsmhWX*JNOItp>B8nm9Ka^Hkv8gHOqFs1zg4UaOBJ=YJ0oV8QV4fy$
z^Fdfpj)DzI4NuEN=F7t>7L`;SdZ3Rd-m6R3-MnJCYGTwG5y{sBryB{JK(-ox-ftZo
zmOq=YDJ#EY%#y~|%YaoOI;M>h8(fy+$O;47Y;0QU>1+sXbw^eXQ}iUvlQM^_-X!6d
z=%my?31uWoXB*Xq3V}Ahlb*O*_O!t9$mHhOx)qQJ<;j*Wmb%&tQK$Y^qMkzPw8>XV
zhGR^VLyXaDBNMWHob-DWg&xze#<+M4WzVgNM)Ujwx`}7)ctVS(=IY7;PIQpyQ&OdF
zE<ip+QY8W86;0#SYsy#Q0tY=%(CxGr)9vWI0{gQKH$yAdtzEKgg`<+ASalOFV(6W*
zp0HDeXAlWWLUn@%T1TV^YGk$hq*NEA=^Pa-B<oSh+~Bb_d|bbAb)rV?y|kG4r&y{Q
zTK>%?gca+SEy1%fxD(vRsH#)!;9f>ueAj&BlsK$XnVua{Z92H9G^JWIOUai?!&Ux_
z*{iGw9zZ?Lx@G;EiWMH?NWU<EcIr#(@nAIR&?gn?C`29lA<>2y8u3J~eEqTt+=lRa
z8ehfp;WU64G9SbONQY<+J&A;j)jNr(GEr4uuQvVa(emmFCt(zTTB-*rBphf!g}JFh
zgR1j5@Ujy!Q5Owk`heK0Gs{R?s@j?|))>cXkO#IniW8MUp_1_4I7`+oD=kG%ihLLw
z(8d-hu8NSjSB2cmS-Pygv8KsUCy3xSUWMHwGVA81wreN}#aUZz5|2rorJRI-2cH<>
zn31kGG!?0DUom!+Y^rveT5FJ~;(>z>XQ~fH&MNqa-A+TI4#!4Ls-}USwbj+@?$tO*
z)43RFHg$1o$a&Y`xCNo6x&>P{wF$&_ysmx@_FD})i1y=1Sw*!TpdpUKsruSF%LLBM
zV0mrWUpL~)OIZT<J?gRNC{nL;ob_e6m_Y_dM|#`Tq(}^;csNR`r5~cei5Si(@rcZn
z@uqFAKHi*gDl4nED_Rbg0cq7cN$UEfo;u(Z4_lA=S~`JnuraLB&2U!$`6{lQ)vE_<
zw8e<;qNhSj)oh6997TFA9S*fsCv<Bfh(YIQBD9g-hFomNTnC#K92R5Q=(*VKsd}6Q
zKxVj{fqNwJs^%ot8y6R7!-jGrE<aIq5xvZDAQ(M0r&`UFltSqQsVaTew+ecS6HBNk
zREjRT#v93st)28k+h({QLQY6^K?lnDjn?>X*!pXIQA45Cmb!e&hS-|*6>Ha5KoshV
zsd`F|D}Bzovi0R_ac<C5MSDD@_}rB222B!FTdPuCqEot>$l%%#B!gWofL&@)>1?*j
zSzEs5R$PM9**#s@p)t?~cavHgoMmfP!Rc1;0Kn_60Q63#2DusZp{2H!IyKWlyaLFF
z;P6nN%BK>Q$dyr#L!ah40xBDt>nfc@L#m}2I$xjAEp-htD}%xQ25q-BR5s!<6<yy$
zDTPe8g+4y0{_t(`>d$rBB*XJ9E{EZ3EKV9Q>+K4I2{`K~8IZdHmDSuJ=vQ{=FW^*U
z_o~o!_LT`<XHdj9!|$}X9EKNK+<1mdEH0m6^#d%xgWe2=7u$A44Bu#R3mBe&+sX7N
zoVHGv3zr!r2rgjwa*Hcs_#GBEgW-IO%V&6!#f@ipipAwHJk{c|7K(-U1I;f)zMerI
zCg5x_mEIfo`k>dVg29g%)J4uiLt+mN;o?gM9ds%b-XmoIruecc2b^05HfhB*Z~D92
zybpDnow-wPcP23+Wab%gw(6Gl^(E8iw0RFWn;EpdZnf<-^lt|77EICQc>1$cHfw}^
z&2Ew<&vAyzZ1e6qMVV3quQTrfXPu>~p?gdf4~}1MOW(0X)nx{@{X}-#``)ZAE6i0s
z#bNjwd@7v&pu|NCUu$t$3dXcHd5g2Y(t!Ids>6VfTGS^D_=H7$&VbKY)K?Aob&L9r
z0l#liKQ-VlEb4a#eAS}<!+`&3QNzs4Mw)k+$2bE{u&Aj9oMBN~NcNS*aJ5Iff<cyy
zaFRnZ17)L-1Er&oET3bBqC&ESp7SGFMkoD9meOfIlI3*Hk7P+*@FQ7Pu9>nLou!rI
zN3y)$;YYH>uJ$9Xv^2yrV*$Y@3=|Jg1BC+=i{@#=F;Fa+=PioG@{&cdP=0JtERx??
z6bt0f7RBNSn)zTv7Dlc`u_z{46bqurqW-=Z%Cp5#o-Ky*Y%!E)i=jMQ4CUEkD9;u{
zdA1nJv&B%JEr#-JF_dSEq5SWQA(AbINVXUv*<y%fiy@LNhDf#;BH3byWQ!q^Erv+8
z7$VtXh-8Z)^7q9M%@#v6TMW@`F+{V)5X}}tG+PYOY%xT$#SqOFLo{0q(QGk9v&9e{
zC<YEW*BiT`q>tg33=YZHodGU<%hzxqF|PZbuMNXBCIwc+xKL}5H0nTNTvz97!*G+u
z<uE)JKQ}>t7~n{N3*!tD1LQC~-s0YL&?5X27X1aB$Q%RSXi>V(zNQU3uXt<~Wf=aw
z!6B#k66Xnwd&Aa!p6eL*e{9{8T*o+JSOLv{;W`gz>yB{UaDy9T>)y|GjKj}(sz1<t
z57#lS#MDtb#V|{AkaUU#e5p^+3}0b!ISl{E;FM}`;m5v)4FAO9vQ~}<y~(t}$}z~@
z2Vs>dF2=WI(jW2?25<6EYa<4{-9xR{&Fw1_TI)5*+F$*~aCV*7WUcM5A#Rdmnh2*Q
zkm155UcYh%FSqU73>RkGb`0{6ir&CMd3Kv@KL)Ek)LI6cJXBU>VM4Y^mJC>e2}6Yp
zpW&3n<uKf4apM`@ZE^Vw@3FWU4BugKMGPOXxCIQ~K1@pl>i1`d3oQl-1{W}#u(%?I
zQx-Ra;WmrQXLz^8jc51{i_2knuf<7*?>9Kb;K0>mi5@XCg9bCmbHN<Ec`;4lblrP^
z3p@Zd9QeodKjhJ`V350kR_B2?>-SNw-z^M&*+XsaFn0VN^N#)G-zQYggudqyTE~PQ
z^ay3`@;+%=f8Oi0mO++&z=;i%2~Yz$dJ96sz2RdFMm*HkN&_;p*kChg`HnI8itWhY
zWTOd4i{A#H>kR?sAc&3rerHmK%ghegc-b`d4Nzys+Ubp%bsE5eIAnTLd|>zk28Vd^
z3da-1ec0EY;m2+J3*4S@PuM#7Ub8P}+^22b0<L4+Gq$do>lpXEsUw~l{*J*RP_Q6a
z3P3T)0->G*SAlSErY<Lp-ccKdSxH=H4!)IF_vB>}PHP~;1=f>*b1Q?aCq$27mOh#d
z6gE&SPo6JO11F^h&7ReqtXX~4%;q&~O+1+fPmG%fk{`sre`*MD??Iw8H{r2{I>WCL
z&CcZ+M!exMv4zPn6RPcAv>nKbS21wCm>A0$=XTlR-I6WdE!pDTGH}pA&H#D1c28>S
zvWHujJ={7T?vu9T69#<JqSzKbZ&3qHU=ZCNWDzbiet<1w2zmV=mw2L3se$qw*pc)#
zyIa;-9!Hl4%(#>)F#MFo<uLqdi!)QTj4-XoOdAAATd5&#lJS~kB`@6M!(NlDvsG^L
zKCekRgP-tFYZ?5Mhk8?XY?G`VERSWIWbN))CZ90_kqjCBoW<oZ`~`~}&+xMrm(TEV
zi<`l4kHr-+{1uB^!0=1>LPz>THuGwL3*RzGFt~u>Z(Cdu!{4>I84Q2l;_?|jWpU#f
zK5cP148Lq~SxUpgJ7p#TrD2eV8N{5kdsT2Rp4cG9mEG$W?!_!3%X((N7M*>~?pMzJ
zc#4B0FxkB#+>3=Z$k~5(uPFE8r5MD$pEJ^X)sx~{26<88GZ^H_2Ar(D5m)`lw`2_e
z#Nu)o{;9={XZYt9m(TDoEN%wFzqGg_hJRym3mATJrd|r@@{vVc_@+UUE;Ia+#T7C9
zZHt@1@OLdPpW*LY+<1mhSzHdoeHNFc%PhRsk(y!XGK1WWviPM|vow_5uVRpX?|&Qp
zZW*NCC*MZDa_+~|97LaInOSjD;SBrF3>Q8-n%Ai7#8NIe7c&wqxv*~rBhiuz4|+(n
z<ievKl3HG+yM5WbLy#wye$5no(mjzi+kt!!mOT#EX5iG|h6YZI49LuJvUx|V#5B!n
zmwCrNg2DHCs4WaW>Y;97@P_G{0BA9|!b9D{;CqaC(27Bp97bgDeYO>YAMjAOFvy|?
zEe8K+TTM1%o@d@cey0I>Ss)1pKk2pF@`M3DXHj1;;1?~5my}l%<UeDq>{;^;zO+c}
z>su|^LBl(g<i(|2V2QZSyunoL#lckU#ih*2mkcM0q~$_G19?H#_G;3zjX!(tU@L=X
zM(K{Ac4R3RSXzh*46?LTJ1($$8YFtWH6uUt7+H73Fu<;JkZ3s=t)<?iitP-ZU&;lZ
z3D|umYg#})zjTm^J+qW2#tNWX4kGyH|E_J5;4P28@#eevs9~2a7%`N=S3TFYcYKBm
zLp`h9JludBJq8KCgNW*>I!{!0Sy7!{$_1aOo*zt9rw0?&^Mi@%^k6!A`t69y$Kzi;
zQQi7E!|soaT#z_0_*+j@tun)fah|AdWpKHNx`jcG$AfHL78u{gj%}FpknHN*|Im<!
zM$R^dTx;HaRgBtesw8@~;2Ot6BN@Y<Om%u@DOEA*7pButblO4{j0hRGMATXpHO6c*
zHC`7+G@FW%hL-Gl7`!u<y&}5hs)~W$&Z9R_;i;mWc>8<aMmX|>r)(cJ&0#}NE#<;9
z-s-Mp@PvoDg+X5weJV?R{%W*ho~IRS8Eo>j0?v#Jk9h5FVeq3KYAu7GG^imsG`ljx
zC61{GDx*zU9qWbHwG3`BN`{#pS;~d22AKzf;`u}R7;DnQ0l8p`Trf4m)s>!tu4VA!
z9=YZ@87{nN+Z{D3!}<W`W|)=dH3n+n>H;-z`5rU9*cH0Y+zflZADKGDyMgLJhgSnh
z4fH#d+SD77vedyrpP2>osU$X#Q-yrRj6dFsyA=cZQ0)dXvcoJ-i+R7uSqse_!o{RP
z4<&RfD(*0d1Lj>igr)x(!z(bHLdiozy1tE<ffgqn*zTa##=XcA2lC27<BUz6lo&q7
zc<a4|eHmNDU}<BQF(MAE!<_`qelMSU+2lahTCw4=<M&1RC%skAI{bafjPNJVT-P!<
z-G-GTOS!PnAhGHUa&X4NJ(FeD0~3;A<TiqHrc54}Vg2Oj?5i3mQXYcmrkmdU4p14`
zbYT3`P3OJ&fU0UBm0y^33YyU2KmTUj)uxUVc0b3KKM&G@abt~z2b`=U9@lhZ+7K^;
zOquk9;g8#)pIOR<ZyO}pJHxN~8*+j9!5|DyGOP`{hOD748>6N3Cx(A$aXAeC$l}H`
z{8Nj|XSjWq7CZLc_%3r(NSk*IlFx95#f@k9Zi~xd_#TUs16PzM@dv{Q_Rb74$w5*F
z?)4k5R|SL2+#s2)G<@WlcL<t6W_6GxkGcP#Zx#&y*5dLR{&$PZnl01%sK>#224C?|
zSr6&5dsT3+pLo5pp2&T|RP}gG)-u@Vp|Z}C&E*njoLMO0q+aw2j~XNdH*g(?8-%al
zodGV`epwb)X!_mnk<L2yofpt`*O_<HbB1FUmt!b+Z`?0z+Ca4!tng4-&)K=xa<56&
zQ8f=*We1lGcUfEx!-p&`OCy-pE^oN?4DR(%75faxlrR-<ng(D7xHp<G_>U3dF<$nD
z&l-!H{KRXLC8M92s=u0dS~P|qb~Vqy6*2sX#bwEeX$?1RFf|76@=#ftoZYK}d)@8z
z%CfcWUbk?sy<V>@TN`7lE;H{g(olvwy>3}ip1ZvTWxk&FH;;0gWO$mr36{g~bc@T9
zBh&I-3ck`b=Wc^27Wd+-vG}}0cCW1UXCD8tUd+ZU-z*p|x40aJ*I8WFY?;=LrVXYR
zHXwH!WVYOErPr$>yI0n1na6*u*FiJJede8PgyBOLm&5Qw7MC?!ru81vW{|06H_4g@
zkMOW>B!(ZcxEzK*Y;ofmPMXY{(uV*SQU-}Bj%T>l;&K>nv$(7&GIO7_Q)H0450WZy
zuaA1YDi~x&21yl|k6k`~7{124u-BHu@U<3~#W&Ns)6l}wFv#5p;eaWw_EBc|dlpy3
z@b@h)ivy+=Gi|^DgWvK{StqUBYophsg29s>D$9X#uPU#}Eew9mLuEPZT2r;lYqFNX
z=RMRq26?W7<RM&j+VmouV)*A4m&5QcEG|oIOzX!U2U(FYyGfQ!WjD#naF~f-`j}z(
zjK$?J{40wa&+zYpUQo?v`1ck!p5Z@OTn@vpT3nV8n72PzAzW^nGs!`;_kw9X$D=$a
zv&_H|^FGu`<Uc%QGJgMgz~668XWx(vzQvGC{@31+3$iHlL|^mTv`L0vx40aJ|7daJ
z8GiRrD`<w_V{zjde!${#7=F;=vINb%Nz(>K${=?i#JzE^i@aVHI}ON;46;1`$IQ#u
zi@~?(#oTxLX2Ecm#pN*kh{cU(_zE*`*kwM$@36S>3}0z+ISl7poPn(3FmH#=n2;WW
z+<g$~aj(a`UKP(8kQo_7dVEFG*Nefo=*8SG@XdnZKUiE5!>?Lg)@+&97E^=SGI-8I
zWw~bVb(7bmg26jH)H(+L)u4ova5G%^zHMh^uOX(+m+J61kHO!1y|RK#+*GxCP1Z8V
zV-B)zESuL&FY@vXU$D3whTpKb@eKdb;_?~(i^a`gxNVqc??nvnvbY%x^TlJ*Y=-Z!
z?Zz{_&*E|z-fwY+11nvg>&2!G)|x>cdJrAuUL(C;6$~<SkSl}Chj8}o&vu%IrI1JJ
z76y4vgB+V|G_7}dz1B7ukY_tc_|7#=ifper28>#i6^@36nJS*fAdihNHBF|N_rZ>J
znXh)QO`Bx+Uo0+%;U_FEYt@+6drcdx+CZ+k$w#~<6%2mVLuKU(Jm?pFgEPF)oWhU_
zGF)tNSxhpmA9};BXK=3RHi+?YuNS>u6@3Pr?e)sqB7fC1@%3WxEqXEcCB9iOyvX8m
z7+z{|;~D;n#pN^nRf`+X@V{AH4#QuwxGd>0Z!yybOUz)8hsw%yxz`%6Nd<$<$ROr?
zlWEOOu?c7JEqZM-y>@tGt!**jUW*#2mptdMn<nI38J;;pw+1eU;aL`!B_pQwO>emM
z403nOmO-X8h+|+v!^~h1K*)fTEb7gsGQ?|g3-_94Q3HFOFwFkDCxD_1!{<HRybQyC
z@o@7q3}0!;lb>PO4w>Z(c;>UcZf%m`LW|2`c#g%5XLz2)<ug3r;$|>>jl~r)Tx@X*
z7{20iEf{R%e-_}vI}8#Euz=w!Ev|^+i5545;mH=4&+t@>8_)1`i_2knhQ&#SA2B$^
z;J`&>i9Tj#2J2+-;|7K6_?_l>()Q+l+z5(hD>cMT-tUpVg~85T-2`rPXr2ah4VOR-
zWPA|k`U^wztmW}VhYL;iX<(ZH)8-v>`IYk(Q}{PO@-}k{f5E)NxW00kX6?J?9jMn0
z=z83)U1h+iMd@z#m2WUIgW%$Mk6UID2F{?5+gBYfeA#e|b`1I^@T$WFJAthX{)acG
zbqs#po6}YXd76qlF8tB9W02>r+HrxE63=b3moMu?m+!(3Dv&cCx0@Mct}*1D0WN&g
zV{J2o%(ZIAg}>T%3^LcM9T(XCkfreyD!et_%pfnb>dFN+u|X0%R>nKL<y*@u`m9Cq
z;(gbm9P_Mtw0&mH50Y0})Gh<wZBd^!;8!f_RRjK~MO|$!LR@dJozxky)uQ+&%F`D0
zGXwtKqAoZ017`kz)V&Fq6xH?jUo#BYAZm%I?cOZnxHm2lHSW7fw1?>#L5D$c-@y$v
zIFPvSAgCCZCjR2C5ska3XreJjqj8C3d6l?D4KWxsuF>~Y_xYStsar$H@BcjS^Zb1t
zsn7k^x#ymH?yXx(SNG^v4wNy9hq*LM@p_kDP<+j$f%*Z}>bezQdn$Iibe7^}F3nf`
zjZ0rC4p^~qEQ+sDio3gXn&P=Gy`uQ0OBWAn__$iP;_GY0fh(E&Jrp}!x=!(Sm)=lZ
z>=Mi1%DNni`%@Lqap@k#CtMo3N~7_zZl&T_#lu~?T=9QgdRg&Rmu}G`<)?PUR5&=6
zw<Dplf}*e3l|~5u?+&^wv);>1F8Kd>>3>_}eb3_t30B?%SkS||%&}P)J;VmFmQYhp
zHQ_Pc*;}om{<xKNZ#BhTUCP#K)?L)9uOMN);G@=U1J@N=Ia>!x`u1!OqsF>d7qh*o
zi`mGsE#%$xU9fti*44UAUbuqqF>SLNOlWeGnGG!GzVkfo<19;GWyjST4Yui4CU%G7
zIG4c58iMq1eos!P=LcU~xk;Pa)0_oQT^>}Ef9ke>a^CKDMxo!DH6&`wD^)M_^pmz_
zUpBqJ$hcW1I-@wNW#sU{@Nf;~Jl)ExiyPD^{M6#C+^_hIOLVzM56<RjoB!xO8RnbR
zg?k@|*H_K^xYN`t$5PG+uCD`7vAMtlDo;m??mN_M!k6~`r27`?HjYl&LXtINVl=c+
z8eS-ksIljxjKv9N;Vm|ZYdem1Im%fb$Xm`eCbh1%>yZlhlu4ssR&?KOq3^bAMA=%)
zN0TDyUOY|yn>%3rTGmB&f7ah2nJ8p!nIC1H<lHc4>m^5Zwp!k+m5X(O|46q<e47pL
zv*Xn})gv2<eyCl~1k2irdiLbRDkH#U7ZKzP3bm$c?E%p#&qgvo<gLQmG}X?{*_U;l
zu9r<_wvFYItImG<mh6b2nf}SxB`?s9sAXG8?dq+Oy)@Y5V1&o0CddC7H42BjxPFZS
zT~2DlbYB)s;@RF-g>nt{BnPMOrHZ2^8n8x_HR_|-P6OZ3Msube>&R6W*W?0xy=yW2
zKduGOPVjZDHP?~Nb!ZaYtkS|=sg~fDwHgkS=Y?=z*Mf-fHP0ggzci^m8zi;fF_S77
zX=6FZ!~JTFsoaNyOQ=Qk{ZhSvk8v%Ak995RExra>kR2e^b7nw)wZ>GQJAg~5MI6Va
z;(`C=S`2^fS`atBPFEX=0Q}UXcF;YAKdvxI&8eR9L?AgCVEpxsrQ}B#3$VTdk!Ufj
zpG77bzcUo+hj58jg6XJet+1}biCr09MH`dHLerZltm^MimEodmtuQ}>nlucr>2^h!
zpF9=27+%Nih>u*@wpB?|3DR`VK|r-(Rx3EZ^+Gw?%uL3Cr>i8N>NM3T++=p`;9Rpi
zv8hJkF?}*70}Otll6)fARHHCRJDoETc2mD&tjP*^wMkvet5<i_r8{jiS!t?n3(>@A
z<nU9XenV04x4d+<aW&Q0kM7QcM>glFQ%v*j5y;f77QiG80EJ%UJSe$CE8P=RMtNTM
zEFYaXH68tns{dKH%cb_qWh3(2y;N7(HV-P{R^Fc9{g$2TVsJ@~%{y90Y}<OXU8FWG
zI+9}B)tl`gwHfKQ2li&myn9M*rTfXXq+BYGOny-pnHN<hd$v278yb~uaL3G*Fc0gk
zX<h?O+4kBcY?x!>_vqgIvP29?Efw%E*J60MYekq}98H!em><3strfn_>z3i$U2BE!
zaIFO2=~@xK%e5H3+qGcHqp#bjjVyT})pKsQsI{fls)7WZv(#*=)-;eD#Mi6FZ%XE@
zub5*ZL)Yu?4Nnf-1?$vIHMvH&%SKb8S<Qv=@Irar;0Pmi_o%T9T>-w&wHUtNwIck0
zYbAJ|Ypw7O{+?zT-qE#Icqi9N@Gh<u;oV$|VcxS%`eDbM0)73H#wJq%eA}cpkXCZm
zQXIW%wW=WT<_z<%)tX-nmSH}=w<GjJJX;sbHGao)Th($VV3Y2`M4Fh^TN7kz4{Ks_
z0Y1RB818Z{$Sl6Tr#6yVkm@<n;&EKcGu-W33{P;a2*0da@}6%*;gysj{5#iT_*K_}
zE)m=jY9n0&ahcPli`4o`^IWdos(hz;3Z8fl(HS~ax5?~<hq)HR>$z5hPjsyepX6E*
zKH0SxKE<^l5oO)Co!OLY-%&nRw>h(Y^Gr3#A0CJ#Cw~OObz+hTn2Q|IV)!--Dm>ir
zHPeFZn5{@P2}%{)Q0o$_RSj!Z&0GP8cWOC_8|Gpoi5p%?FD4SZ-hBNZ-627~q1a!m
ziNvKIo^rZEPz%ga6-Qho$^C5TDCiwMp>}d!gFjH`eWHm?wNJFLoW@xfRkIBdubj#O
z%&+?=xq^#sSA<t{tpu;-S}VMLbE8>V9$ttj?4Y7F(hBeBS_$6SwIaN$Ycaf=Yr$Y{
ztwC+4+rCl9%)-n9#aB&kPh^UC?knFh7MUUq^^0cgnCO;L1u~0w`GH*UPuft<kxHYO
zNLnJ8^yD0>e^HO`>sG#P6vJH6<g`W~_DCfS-pjQZ{*G%!_<OFE;C)<ch4*!>40pOV
z3f@2;0wnk9%@j6NQPMFA-pI8wyoqbAaM`sIyqRl7cnjBJcuUuU0Va8GYbWHO2Wckf
zVwPIBTCFO`mA3u~5{j>>Wp96i1ds2T$KVnCIeNCcLbvuONDzi;KXZOa<~6PJu5RTL
z4D?!^+1dZH2D5~qhNwgL5?nopCgZXV@$Ibb)LXI~j#WO`LT=Ai<C=iR<>IW@KS6ST
zCQz~M^_GAMvsG&1z+1Z(!`r%6gtv381aI$JE4+hiWq5bjM#0Z5+vvR<QFEIq@JoQn
z5e4&ud7_o!-)d#iTH%*mE5Wb0R)k-5Eru7kR)9ZLtsY=@q{!%{+A}%KK(9CByx=p>
zuwIpV^i5X8YzR4v<U!gnwfjbG$$C%m_k3|88lT7%iEWwW!_vI-L)L9Far^7nT$<FU
ze8M}chr$XfCWh-PpOrSeNDDMwuboY2UbDX-wdz2Yt-MCB*WGk638c?5jRq#@wola4
zRHJZ#i_J9(d=*625%3DNlhucxp8dk4(aY<~J4Cll(P)tGDu^#|KeqypGN}tZ-K5cA
z>RS?Ex4xiU?-Yf?fJTocSa5_&bvp_>xY%5yQ1!~-oo?4uqi~PgfurmokqlGVMnwq*
zJSlBQ;fHPq&Qd8E#q3c~@5s{3oFSPBD{<t_oUE(sbSB+t6RrZXp2!@`MwN3my(cpz
z<(CM*sbxDY$HDDA*>2Y@$pJ0ZEwjNMpE>^J4H%An`YKmsAV+D=&n7NVN8ji+xk!Vl
zp7Vg?0X2Wjs+|~TV|+x%;UnGljZP`|8>W-ojafGM4xR)FvXbOnT<)bwKG{dhT{h^k
z%s7Z+RtXX>jxW+FN7^ObFZ7UmR;`=>{;b}I*`iPxuDGR39JSxrv0dQ+E!p8z;jkO$
z5=YqME{)bmC)#mSnWV_<l8>CTS@=xj{L&KD22xA9JUi%eUCcV`r#++7$!ww5qpa6$
z^m={!>P1`F>o$6QymhgyNAY5pu2HPHL~fpU=`F<%Tq0c)EM09N8BD?tQy5&Sep`FC
zxAzdFr;@FkgR_11l#{G#oN+k4NX7GdcGKCx`9g;A4wX_3gqIUb(}2u+e*PO@Im^H%
znFyMr6GvqSe-q6u<JMPf`VA{)%|>ayS^JaMSF*=bl8J1+U#okDGO_uWYRjt6MC08?
z#<!lqth2ARLO*-|r3$WXQZUe)>aOi{E7z9=_(s=C@J+61{yYwR?W#6%i3nbAQgDm%
zUEOuMnN+}QO=<^eKj*M#*Uefh=?Z+iYcc$`Yi0Ny*JAiDt_5AD&AZh`x(rf1XCcMo
zyD87`BG+PgM}3DnxgmgeaxI2;b}fjMHvi#~f>h6mbT#$JPnYGSokn*_H4g9US`6>$
zS`nVBTK$m}g}YLQ@ZGM(@XuTedQET#sEv#dNcEgsjs4UbQ+X0lkedyP1e3_}h>9X{
z^b>i;p5c=ye&O{tizPU7;ez++lPL^8;N6Vj&s{6SU$_>-U%D2gh&CTp8%YsJ^_+?E
zwpxE|wSvyj=vS%6VSc<)IvB%E`gXr)MfiNxWMa&ZC|r;-gfDb0hA(n0==JKlZ*AS`
zGf0ZK?HkpfK~lt{JZ!Aw-AsmFlV1!i;FZ9ViPJf=K+(PCPaO7NoazsJiEA-@nQKM(
z|EN|^B!$;fhVbjI#W3H$NT#DN_YESrtF@j?AMi<&g6BSAttz!>H0QX);j`wr0up}C
zR3-X9d(R5+8?MFhJFXSs@(PXKO8OQ?6h^9;Ojvj`*J5~c*MjsB+-KIM4v^|OiTFgV
zztnAC`LoFK(1Rku=<KCP9P%t=?$o^Li@_GDfZ;7&i{Y(ZE5c`~R-b4T&Q2M^=eQQb
z=eibTir{uu8<}X}F(w5QEv!|g7LDfQ7l$XB;|fUlITMZO&r9_JKHs$%zSy-Q%y*C^
zeJ?~5)`%OkFPUiYny$t0TCN4@Be*%%r4DehNkRI;T2*S%XioZY_=!2LfP|luKB6Cz
z>IHm+YW1{GI5K6JU6ydRsoKbF`OhZ7hkUefRH`NTXxC!+c-M;XL#ove2nr9U4B>gM
z#qcAp1tUsur>c!~5xm}{U_`@ORcg^_&WPgh7IRzy2|s5<iT=@4FW|>qi{YQUR)m*Z
zF}3niSYE~CfPhzUErw&)g7gvGE7qkBkm@;!cu}nv=vG%=iUgx8FGb?$b>+oia4KN<
zOxH^AS*`^g!`E(VBlBW!#Y0^>N)b<a2Z);Ns9WtTMPlhEpN%GG6Uum$i=+ed&N3Tj
z+{)+exI9sJ$+%{Z)`)6!t2sKk0Pm&s<o1NF9_bQY#e2?83^AYQ0Tke0s3r&S!id6?
zDZ^~2?E7WP2L6?6G5m~cMflgQmEh-HYlV+l$qtV>O%#q*QPS87ALm*Lp6FT;KEbsZ
zKGC%Te1U3`l{xxpx95QjyrB`x<N|je)G*6Awq8?fOm)6dq^2HQR@6ZHMsi6#v(Q(I
zLrtz<!BgB&<$m%?YGO{AZuOJLEs0K<ZmM_hVuJ>1Z}|R>Of8V)$>Z{@vz#aB+o~ga
zl|1%=85(&g9eN5rtj+V34I9rSOV;iInivuyQrK8~))DEsP;1MKE5H}I7Q@qBE5fh3
zR)!b2R)l}=S`7cewO}12wjZmFd|&`lJ!caBM6G{nwK_lo$vM*z#~)Miz<+Wrh8Mb4
zgwGn>$gUhwiz5nWtC*bW;B#Dy;d5OJ5<zfZTbIUwRL@Dodg^f_-O5A9xl<_+N=_<>
z<ib=$aO=vcE>c)u#boYe=NJ1nPT9aiRxxMOnkewy^gL(mTVE?CHt@yz&C?|L%@i(C
zG0z$ME>GFOzgWW}Tiit9Nfq;)vG3WG4SaaXoXzh;;RqG;oU!l7lns28YcYJBYejg6
zAyNH5Nyqdi3OlMOjTYgZT#MnIT?+=3eS4*B;Ae+fqYIlUJf~t_Pucf!$_CzVM9LY3
zF)HRcW8e6c4Sd0R=4^fwg$q^8bH=`lQ#SA=uEp@Bt`*^#u9e{JS}l-;5ryqllt4=G
z4z3m9om`9Ion0$5T>HOt;!X`j&f*}|b3P}Xqt=)vXR=mpWmDbeEI0GC+GEyO1@v0&
z9$bS6e|)MN@K)<LY-A44k0^{%F>latHrb+V1N{%J1>aH%YmKJXCfZoe`TqOb#zodv
z1zg8!1>L<~t#9;N;QCf8xFYzYTEFhKz~NS_6C^`9SIO+!T5Baqgtu`mhPQXE2tTBn
zjLHiUg@;py@I2RIn7>h%H+rMhzC*V%$HpigXs%9-;QQPxJE^{-yYMLU9!xn0k2go{
zQxxxV30y*Rq3?DA_gcYJSVyBS={89Te2Qx^%nemu>hPt9UL+j`sh)G9$K&_CwF2C)
zsUb>hF}#dx1+8Kmd|j@JMDQcUdtG`+@%JvhruZ+HnzbF;6JNU1HtgaR>m(`gZXRX{
z-rcnzbbPI?HqspUZIgoGqt;L}se(J1)M)`L5C?xHBZ(V6U#p2$f-i6_h#Ozs)?5cT
z&7>giuvV2?XIrfx?g_f<blu8l?fNmK_weY@MxU{`4gHyIekK>-r(G+-zj7_;KfbP4
z8yPo{?<3|+`mk1&TE8$yLH~(^*UFP|gSXRHbdzy|c`HA$^WHZIUmsg@9pKjX>T$0T
zEVNoxa0{yyj5cxb%6k$Ie3Hi<!za5I#Eq}rt+@`6>N)ww<0&c6@I|i0@WrkL5#Z|#
zj{u~4P6Yf(lJl%qB|9WEdP%Br_)^zmm~SIWI*V{$eY-iC25>*uitsY7#c;v3pwq;5
zt%ctK;xebxVXZ2)Xf)><?mBH_2_`>Qlc#hme`ijf#LQ}0v-V3>7U;I0>^UJ?vqt%^
zL5)SK&>S_g!$W%dr_uxua4m+HcdZCt=UNG_xmJYdxE8}db}bklVp~~lWEBFpFsbu+
zMP8TB$^B|-GR$gKKw^_|1_>$WB9CVIzNEY{7Qw`k(>@+=(Dsw10)Ei77=FmLASw8|
z#rhJQ!Kwae$_@OIYcb5%Ad|4N^8;T`^xhoR`Icnj27Wcw9K67_BFq<Nk|P}E3p1h>
zVZJaUS`2S$FP(<r6WePZK8VYl@uJrIR;vnrU{c3WZI||QuBAdpZ8#$OoV&z7Ya5s*
zcZoE%o;I4ZE@7SuF*}-=xR>B$_z!J-WoxLiilWyFR(Wc<N#K|?@pX}8n!q(}AsK#n
zj%&fJ#Mk~7WCwV)NxeqEmrmrv74QnH6`bdZ<7cUO;FI-T=K5_kg;P{aI+z^*oXxlP
zIzaxIOwP!LwW@p{;&pRW0awuWWoGTDxQ9s<aI8teJu%HaXujLPc`EgZCbiTkylCPn
zEj60Nzx?!BOYm}M)?ITnDZ(51XqIza_P?BZ%{le-+~>7<t)1X<j`@L_kHNZKR+`^@
zxcpv8@`(rHFx{!&uh~qCxK-KPZ4j<g1Jj!co^mEZ)=NQtrlE0lkaflcJWIn%CL;WS
zYbBUJQ<FDg@pXyTlSK}E-=yG33u{%W^|sXtjx^%<&|@sXd}}~rjA8y<k7z~s6R%r>
zKX<JaKDu8cYxPGh6pm3*9Ja#8x>kaZcdZCdaxI2Wa4lE~=xn4m$=O4Z>N$_bTGV7&
zt5pFBE@y79tJa(9RxVox!sE?TunvUP%C-H~+^Yq{NUtxo)+QI=BbRBUT{2vTk8&-@
z627jqC_BJ5t(J4BQ0sQ9RlQH~5tp)u&4Zx{)(2QyL6V-<T3eY(a5N0oU7MRpWedf<
zT*`*Cjqd6+lTMI~<y@iuR>OH$xAHWh0Iy)4f(Nx9skxg3-(scFW7LZbVF5nQwHQ9$
zwIV#xwGw=iYprm9od|MtE{rG)P%$|=;bmPb!OOW;gjaAahGW;1d<f|5RT^B*wcR<o
z>wMknC-M}ZG`ap6J4FKO8+9co7K+5u+c)*Yct#T%o^y`-Yc+<S=vL+nND^d?0f`}J
zR^6Zuysh90@S%)Ja?$#wYR#J8oDj2FlxwnV2IT;!UD73&HXu<q%WoX`_%(=q8>dDZ
zeoM9b34p@eDZ}2JZDpP50Qr7qPX7o2Q|TYL&>RJa;{@Gxm~Q*YeWpy8B4xfK8rSuS
zh2+oIPmGfZ#U6g`cW}mHVllC0?`-wIT=FWn{CWDB1G|#l$j|ET71`a=J+m;fmYA^X
zcWN@I{-RUj!fn|1N3~i0-)v?U&`HFy`m&TXGP8il(CC{~Mam2nuZ;y?JYrC;)YfHM
zgTFPY6U1H4<Y(7=S}R%j;8puKrb%)>gNv?d4WCNvTP<Y+ukKn5ukBh9UR%F2ATxJy
zL}4BOB0&)@xfa7iT<bNs-K^1*BN(4@K8axWHPL&h#J*vv_Tb^J#qheW72%CsE5W?R
zl^nKxDDWPaj6w<KJucCTFfR*<7Q>TPvJngtLMOJ?K;+;BkF?i!gX<q^9c;DQKpM@t
z>F2fTW$hiXz%iln?vZrE-o-k}yAi`DyH<oxbFBpb%-&*=vn_>t{1ufFe6MRo_<q-7
z_yN~~oc>A!*xPJo1c&aI8JnC-JeqjW+)OUOkGK}YtE}7@=K69^VO15A`2ZJP3u510
z_wAjsf#<tch97q=@Ws9-Qa12YuEp^AtE4(W;Q|$t4!{?>7Bu>jI{rYnIjbFU{l;QA
zIf7{-Sp;BjE?flIcTp-N_+i&#c%ExP=-27K+jJ|TgH+F%CU|@#<r)5qYcc$;Ye59h
z=)Tln=m4pn69FFIOL>O>=2{HjyJ~8jDcq-GGS2Y*t_7i<rTb>+R+0tYX;OQmA^#VT
z52rlCKh=Y@e*93lQ^jN<ayJb+O84=nB;*%qZoO-#`o7?C5Pt4T`GbGvS`6RoS`ohA
zwG#Y*YppPUL_%UN!}Hy46nxRhMn9y(b628pv5Hc86nu$mWq7)4t?*^8mEc*f72zvf
zi{UF>3ljY~!Q0Dr6QgG3U34q+5}asK7dUivx_V+ujlu#Ir7F03sbME)uVISo4nb-M
z*EgwaGsSyNY6m|usjG8n!^hRb%olj(x=3B%MJn})rZm?m%rLul@G6tKz@a1X)(*bB
zAyU`Zipy-&kdn`K;8-<D2Dqh3UEnq*wS&8;RF9Uzo^A)eWl~pp<3{_-ZPM6E)qXV!
z8>=Wou-m4M{X@$sI|>`BD0bjflRCklS=AE@H3~18C=YH2>cktYTk$tUafHpui4nZH
zn}Od>nZY}oSvz=wNnPMHlY*6M6P?80vdKJdYsDROo7{iG1<UR@kYP-IjsT`%xhDpR
zA@K%ZW^s)J{rC)j$Y5k9*5u?#+#G>&;|QK+U8;n~T_=a&My1A}%fcQWcby!9+uA`^
z;kf&r9&FMg2ifIzq;!HenpELP`PO>0*tvFV1JBm2_&QhdewPkdzhSlh23B!d9S0Jg
zqylD|iZgIio3Rxp7}G_pPS#;ySQ2O1|47$5rN*9Sd1el?gh{<-n6!#E1t!1JWY&F-
ztCk#BJ)x`MG2(U_;hwt9xiZ^Jca7`agn?(_P5K5i8Ir!i2iOD&`nHMgqPkRTfvGN9
z56lFU6(Y*~_g!_hpS4!WSVRPJgqwiwIEayx2s62VG_yG4-4m0C5ZMNp_nd5!%)sOI
zm`E}MPgN~v)JN+sswbI&sh(s8COY}ysccje)z$Z{wIDMD@;`0@y5k@-M-Oi_b)s%%
zI)VGxvE2@~tCaj~%}EqE;pSY^vWs(Va#&^mV=1{+eJ3{X+ZI9)`0sSr@6DtF{!OLa
zABlZS&+VJoGSv-kqmuk$*wh*Y)-V}g(3i7rkY!EM2l@)v4L)XzUIk?F6ZfF6gWaHC
zeFS-!twGP#?LfI2k-s8vO7hQ!wYRjzkG<vLy3FD`Ib&tVgsT#+I`YPi%a2hTH);=x
zrnK;D@O!R3vD~lU&>H)yYO~_M*-VnZVh}XV)yntuswK}Y`;JtbrEt5Ro+7r;ZPFun
zJJU{VhObghjzy4DOYRTKaiw&j)vJKi%lY}F8EQSpYk|~~Lv7Bn+3~qm?H|%@GKMSY
zY0j^}f~z5}K4z<FaytfJ<5~<?H)}L3w>AqS3LPp+<rwaCt&okCMsLvu<P#E*>aucx
z?rFw>Sx@ZSFVz}+fNL>))aDHj$sHVgv}-YZjB7#kU#Z^#W>c<hr@WhPa~3{a9&6Pm
z7vSSui{X=9E5ciE*$7{<Kc|VpHY!S=itx6s#qhUXE5My;huP#3@j2G1j;u*(i-v+f
z`6Ojb)@G#I?5tZ^5Wzp2)DHgLqzXu<a*}$fhIY4wI2xqevWyblZrWS<iA|6M<eaPV
zP5jb4j=WZTwzqF-Bp>KDxk+f&J`J$Gjc(IW@RawL`R1q#dXyZ}*$DEM>M(?IEo?7b
z;y=~!hG}f_*k#b&JJmZFtjX9APfIjoaZg}Ha+(y9)y26XCW}V1?$=L}lRs`{e;A9e
zKGatn3S2WJhVU8QNDTM5797XAE7E(7<l7k_E^}sFSgT4c8qJwY#4$A$4?NAa7(UCj
zB0O2MB#D^TMB!8wlSII$xfa8xyA~vZ;BL}JB@rMla}p8Os#1$aa}q%u-%rH@PjM}V
z&vdN_Khn|&R1)z*6NN`rOcDV<=2{H<D`MeuM}oUi8<j+Wy!n}vh_F_bS~QxI2;z9$
zV=TZ=xE8~|a;*q|s>e$`5fu29&Lk1==V~Zg41eKTFe3<Vkv1xc068vm5)sy_Qj11&
z5<wharQ(7A<ys7X?OGA;yG&z7NdHRk<^5B$gu)dnCWi2pt`*^{T#Ml!xfUdhPHd=w
zNW#GT)Ho+$VXZ2)2xJKf!&JV14-#t5jr6M;8ShmzMF)ZBYJ_rKxqzcumx3tzO6&3Z
zfYh^n3MA&bRD$5!U5nv6TniG3ubb3H64_gGZc@#f(867*mf*)+i{bgM1rg!vq2413
zO@fGM;TNfv;1^ws;g?(sBEr{my+;(91QF4~tEraYw_S_jcU%i1!q>vyBMMD|h-l$2
zsg~e(U5nvGt`*^v^=DpXNn9LJI7P)|NrWf67Q?5y7Icx|R!|$6m>@25j_|Nnm0C2K
zbA%Je>8W_&DXzsZzjd7S51!_BCHM!fwZcDitqh;<+9-I+a*cyb61%X8!Wk+`!=vCH
z*UIoT*IMBpx>kbEa;*rT<5~=#>sl~SB=2_ZgbWl&h&cll)~ZsAPUH;KH?*;ABRO(w
z)1>&^K=L)?<zP`=MU7VTdLZ?3Uf`t`KU<t!`@>#se0DM1N*lpcf&}lg_PfCcO{##K
zX;*R{Law8`zOCE5+Ytuq{M4Yq7rGY17r9o1FLtd2&v303=BGMkmQHV?aH;;9qs-D)
zc)DvPnBVkF4kLJ$+r{wZt_8D?&fcrR$?OAZCTAW|>p`nk1^3j(a^~!nYE1)6*A}&C
zKweA&m(bSh+SVHuVFf(PBJ9dez4dh024+$LNoLMG&(=!bLmVW}E~iAR43^EttxeG?
zE7fpB^Mj)^a;&luF?LsIL^9R|_)6Dem|ss#<^()k-``4>!id7UDkg^T2-jkGJ=cQC
zLvW8;x;j8y=1haIR+U;bnlt5yqcs%|yuNEO%#X7s{ewSQku^@v2^9XRVqyq?>RJqc
z=30;lf@{}6WM+f7%t=I8t4b{z%}E4te36O={?fG={>rr?+-FcD5z^-p+^z3c$Sj%G
zLSZ~FT!<ljpld~Vf@?8+uxmlW=)?#OL=px*vQi^9Nf@twJ-UiX4e)<MM^zjVTTTw|
z);4G>ISs%xD)%Hm)|Z3!)1KtqrmQu%5zD<RH@3-hv23-xXJypm*R_%eV0=jivaWJw
z5otaom2UV@*JAh>*NX6}Yc-;;Uo255s+b%Y@M^Bb@anDw<4kauS_V77&DLzRxr8oZ
zDoZ{{qd9|09BZWFf!A~`hKIRUgs(1HBIfp?aE*#dBH(LXi{a~B3lc$a2WX=*;TtXa
zzoAJLYg)+Z^=E50JT$MP+vNGJ@{y&6mXl&)y+KW+Zw2`8LmJiUvw^~56%)h8ZvU5k
zpQdc!TZfvnIZYI9Q!&pO`|eKJz=!H<Qxe&nCJKkCnCFar$EIxH((qJd6o#mn=Zt;p
zrflE?+}ZqyLRZSrv(+H>b*F6L16_;Z39c34gIz1Zhq%@XAK_XV-h71her^+mEmV}=
zm*Fj4YlXLRtpsoFS`psXwHW@kYX!JdH5u2rP1#JHpwXXgy%<@`+H9tum-8vV+%xQ}
z(y{*OdbZY&)#F>bmCso~dMZa8LGGqOCZEPA5_isViSJ9b`GN9jZJ)wJJJn+tic0e8
zdt>&}qPuU;hQ3%s{vwr><+Z6*tjD9<GJ)ouitbhykC`j^*e0kKe*6-KARpT-MZF(r
zc(jrKQOtd6^{{U9?$jE|jG|pMJIO%{@8((z@8Mbz-pjQTytiwu@ONA*!~4263LdZX
zSElm(h{Ay?N`Rx_gIp`a2fNk^AL?2OKHRk;e57kJe3Wa!qP>#_e}r!3j0Dn5&b`hd
znOc3KlLyzRcYrq6Cpu$raEKnGHK$s86>t-+mvh5@s#?#sTJ7MERBDlz;noS7qas%Q
zqJg{2-e8y7{aS0jIqY~`@oAGP;BzK*%3WOjzdbG3PLO`fs-yO{Aq-6VMc1{oZG7Fc
zW}pz-4V<~<xoZU7nxXdi%ef>a=A|(Cn|ezQF8J@N$$S7mPMN_?mWB?npGt{0cpWz@
zDUQ%>f4NPrcXI6-5;@LEBpqk;8>3E%@scYY@Yfo2pXkJ<8U@cuu%ce8_BZIZ@ke>5
zL_-mNsyiexcPh@;ZK^A(*k-c!mS06n)+qR0-6vWJe$TanIZ?pZWojdlfNz-;yk14E
zOU$GS@{?tfw%_R9KbTdJp_=Y`%uFit6`yq}8#EpIR85iuz+?1-%OnBtSl5CC;H$sd
zNCLpBNkIar)nq1BaBq`>-V(<FYLdhak8>@CyIm{7<6SGk2fNk^|H!p6e6?$>@HMWL
z;Okr~!gE}UVSaHd=|^^q=<88hPx1=lGH0PVOs)AqIXUiOqLV8lkN|QH?j?Dm?>RRy
zXK4WZo?4D)8oj|YQh?{W7Q=VB7Gw!ux2cU}DVs=4ZZebLQzKgVO{yh$i#`p9GDc;1
zOV@&k@byP)t^@qgq+n);wW`!AYhyWQ;;>d5wT4)&;MjXz!}yzpQvpX<t*&eu-^|pK
z@23=~wxLxUm#s#hKl8@GHLX@VNMdtl4ZHT#TFEg3^P^;<mEh}BcG;lt)oBrQfHO@B
z#%Q$ey4FmBB+=--YLWyA|HZWu{H|-kM8el&)?5eplu1F5VXZ2)-n3dl+&|Y{OK?o6
zi_|pf8oYLk9V0Qkj%z{J@U^Vk$Wa?BQZ45|X4l3k&+z@Om0<oVa1v>D2H=Z7C@;-{
zKeeEO<Wg&IGpU07Bv;ODCviOFF&5y5U5jCUQA*-2!k@Wa3I5!*BK)OmG5nQlK^}<h
zX|<6&fVf;jkN6cZc^C-NXwJDQY^yChEYE5ff3k2Y;NMMZ2R}Bc0+Jg!Gl6tJXH8+(
zfW9_=3-C^^mEfIS3o?nX!D=I!1h+FOSc}72Rcej0TERSAS$7RJli((Yp9<T^O~6f5
zk}onGQKPWA+hqrZUhkqN$?*gq=voXP<XVs=eC=(`b%0dQxv1Drt-GyO&|exoG}SnK
zwreH$9M^&%@ioPo>j0;DwQQOqT%PAP1^9f|V)z2ritr__mEcqQHJYkFzMwE!MH!3|
ze5z|j_;lA|`1`H}eWw$%G!U7_;O<&Y1_-1TStCFik?)N*)hN)S+`tuPwG3+t?xA;8
z-~1u<zES;;cvAeH?k*&9NAd+L6g>CWJ=O5LSAW#5ylJ^D*EUdxv?~t~v*Sq%oobr*
zw2RiKn9bw@Jj=BhzTCAS^Z1&kHj;Ue>XLcTJxz?Wk+biLRBP}fuEp@9t_4xy>qd_X
zq`E`}x~GZyHiyT?zJ;mQ;E(kUL7Cz&L=-+zG4K41v%h;-Aa5z=tRrEqDz#`#USNEH
zXJ8h4Sg(zGf7Kv!uFm;Uvo9>h3b@#6jkiV=zE*4AL6y@M_+6_tu3PaUm%tZQlC))g
zM+0;p)pNc)w2_)@s@vqZpU#lqdZxUm>V;@(JgX(ylWpa2wKzq$GLgX^m5TD@edO>$
zDfxHcH}c==`)()?n&g!XEUs3|<i(9bNuEmmn-zP1_8<LagF9Vo(2k@RByl+xJdbNF
zOqNalpqczNvX<okY!hFo@z=Ud<}W;64=~YU_(0c!!w+A3>mJGFzKT>6DI3B1`c~rx
z{&r&lKH0SxKE<^lf{k_GR=QnYo+!uyJdoa_pQQU&Z0v85g&Grf(cB<4IZ=LR3mf(k
z3O4fNVrG-=X0~Y=%WPBfMc6{tb#mvLbw#t2Q<;Fj?^+B$s9Jr&qQL9D$>72dd*z_f
zXLR3hQZ{f=UkempWq38$0$=P~J!J#$=voZ#<XW%3hN+EQ-e>c*mhKv^+kVlvl36jB
z@(!x6*wE9nfn7v0NKMkSfqg`Y&5~vVAuS>5Y;?;e7Y)q7Y+M6n>iFJlMDm5$)ZT1*
zh<j&EL$U<G?XJae)wN(W*mro!1|GX?qh*<fiz5pAtC%#J4Gd>9)tL+}*rC;O?%cv!
zZPZ%HY6bT;cWWC<VX}m_|DawXYslV@?e9{ypZ#=KtlI(d`-L;&nJqI0&ul?kS@+4;
z_6wE9E~K*VDl~R=%0jP7B~>YLD7%ozd%CS`T-cnTZjv#A7r0i2fA3l_miU^cHZqpr
z%O(X6<ic8Q)Oylt1$UgM>#m>ZwqLYm{dlMRyy`19^cMMbQI0Ei(Un1JvZUjO=7>zb
zp8_sLkeDuALeA3A&(*D*ML<HALjt51c_$I}{Xsn?g9|s=+s%_>W7mSg#n%TGRj>v(
zYxRC9H}DwO%J5j%g67z_f64|v+qD=z$F*L49i}!prw^KQli*PhEu5Qb3BJ&^7=F>U
zGW?QjG5oS?LFBYqQ=6Q~ss6i^8+d_hG5iPDitry@E5UzqtrdRLwKDv`a<<}6Yo@@<
z*D~SC@Iz`SS}Q!ywG#ZOYejgzYcc$|YX$g4)#UUuO`q@kf=8ydS0hO#NIUW}L)KN!
z`wgSi0kvDA0Z~hh68(^4H1rib=>D$yI>dsifFwyS|3gQ?$?ZgS@ZWWXTC=SAV5P<6
zzY8auZ21e^5gB3xo1>lxriaO|jKPd%Vwe4oeJ^R?$<hYD>RJp({vLc8ZgMR)b}cv>
z2kO4%Qa14NuEp>m*NX5Bs>uwUA5pk5WeDHoS`6RpTCc%vsWx&K2G&dp26u+;`jMFg
z4>D==b~Q;d4X?UFV_cHs94@*R1j)YDQa12fuEp>VTx*4Y=voY)=~~bx`_4+)z~{LZ
z!;iXFh97e+hUdH1Yn!vwCTHEI`r|1#@RP2^@F;z%R=>fcu(gVk{}|rJwID7U{cZ1Y
z{Z4m%WG0o56^E;5xgY_(vG6xC*tdNuAox|+%J2f$g21oTeb?w#o{AM}6y~TXQyzRN
zZI@j;Xz2H9l+0-O53a@VYpxaHT~=&(tsln}c2!Xv7UA7oi{af}3wla$Z)>B{DKOG%
zIS&#)QENA;fIC>N;GB`Il{``2OwG5lYQdsG_<O2Jl0SGa*J5~Y*NX5yu9e_NRjcQe
z!ec2zc)n{z_zBly_~)(#d8QK`Y9o0Dsh)G=d5~H^WVM2%9;ds$ZzdJ+I+KE&66%v`
zlH?TrrE4+#E7ywfGp?23U%S={Kkr%@K5QkM&vTk69Im1SQ-+Ultrb4XwGzy4ktfFj
z%<qni7Q@GT-C&GJ%I`E_86%MDIghzp)Z=oxmE{VYU{Ww_%j>RTW>U$n8*Awoky`DW
zQS#TSmECi2iT5ov*;%&|5BQcz?b*h5*Ij#=Nd@#;K`(mL`WoFPj~n5I<|()bXAt;3
z_GI?K{CavaXz;t5B+<(7d#=Us`>q9pJ74!bsar`4NOf80Ks<?6HdE|clxhtAz_l3u
zyK6;wv1=vxW7k^YhxIF5^|LUAc`8aaTH!}rE5VPsR)qO^@g%$O6K)q|?X1C#?q951
z$p?tboMr1ewZ6q`f%lmdOr|B&`jgi>K%?!}t=z7F$C=a)PBtlM?hf_&xcRPtJ6WxE
zn!};Y5zu`HbL4sTnR1k!Mwrk*{SqT<M89A67(wdgd|JbR{zbbXgI$1c)!(<3871F+
z(!y=JO$@Uk@PqNQS842#830~rzm*#-Lbt26e@(IiUZ~$-lsnxY6dOKg>Q;P%Pn*=9
zjpzyW{Tq)6e95GCaDhtl&h-&B3h$d;1^mFIcJN;&RX`8Eoe1ByNGsrAOH2^_Q0;xJ
zCb`2tPK^$=R8_!Ky^Dg+X-`*sqD(HZw$Si)urPz=_&Tk2k2eQ;t)M3lsP(VC7Ff2n
zy0e4#g<7v_CY7S1*9wj&Cg|;{i3;E0S`6RgS`mJ7jYcdo^XE2EcuGZ?`9=7buEp@v
zt_4TP#;Z3RZ>C$B#o$(2O;!zX2a_rw4d+~F)9$ZQ?ZeNx7Q=s8vk{B*rwqUAS`5GE
zTF{@vb>B4IN`Ed@ywauYz!K?)7S+iSOsjHv5Wyb7#H_1`eeY{?$+`sp)wLM@yK6;w
z|Fs%!>sR*_`0{Ep+;Eo~iWbA;Tnp0kjW*U#Z6rM))pOQlJa(r%!xLPK;n!R%!>_v*
z!wX#tBE3)dJ*-=a6r{RLIS@}`l^qav{W;Yb{I+W`d=Os%mRSf-a4m)pb}a~gYu&fK
zZY3;`>JmJNr<~x~b!e(F_;A-^_(<1^@X@Z7;A32Cg^zWu3{P@x6dVt+$vM4=!ip-&
zL>vVVa;*#xcC8g&#kCS#bgc-l?ph45;aV^XB=0BM33;*vQccca*92#xkJNsJbs8O&
zaRCV>=T_=#t#z8!Y6p8%lD}s=wMOASx64l1YjoEfGpT@cO2jliTk9^he!y#iUTfTc
zs+F8}!)n0^w2wAIZ}MKSE2_=fx|L_s1$bW%G8++Nvu0{&;k8_g;UTUS;TKe^FQ62D
zn=*u7bS;KoaxIus1h<FU$eaSHp0j|Spw<^!t;&xSuXm}pM9@I;xd2T3$yo{ZxWls&
z`(D=OlCu)Lz_l3u?$AawVpoRw9sJ~E1MlN@L9T}DzV&r0#}P<%Sp`8n<*b72+Bel0
z-0oTof2f*_{=$gDKT?M9N3I3Yv+v`S4g85~G5nQlMfjWHjV#tL+bBfqT55}MlWVcD
zYe8_A4{P|?RU42z?xkohqu`)zR*!vBp5bL&i{brTE5l=4i{Y`Z1(DL`#%6PJ1XDkm
z#IXAcCo%gbnXkzO_!HG6)r%tv|4bP+66XKT*L^SQcDee?io@e+@?X434f#XceTKZt
zXuI7{gJ|iCREzKyBN{ex+?3!gT?<mizO7O=@Yb%y@HVa$;cZ<j!8^Ow3g56nBeo=M
zO%!faQ37s-Z*r{!-{M*kzRk55zTLH;vqRTw1hAfNW%b-$&1ps?5KlRa#L4R5;Z}My
zqf~34|C?h}2#o%c@gxVAduR}iyp(Q?!mBFEBUo^?^&9o%dLs-9XFqpmg&Kulx-&54
zEDZkFYER3ODUf<OAJhL)YrSEuRY0%RmCXXXhNOE(VO<p^3*doiI|_%m9moX8%@&RB
z;?4>+3VXOSu%xr8{;+}qfAK<s15=HLSzTZKZf*W6AoX&xnyr;wB!$(2v@WUI7TOy*
zCbm)B!KIxPJ*Lj=n0-fkK(1wefJJlEj&FAq90G@`qaS)os6`k#M=9a-S4dK_lk(oW
zUCL^>VyiFQM6n9V<q}+RZ7TL`^}0POsUYvGZK7CqX?sNvvP~7+&`4DkSw0K!4_zz6
zXS!A}CkpI4D`f+p=UNPZ?phiC!nGLw(zRaOyhUx~-~g$fvlQa7e^aAc(rfrC)#?{w
z6n>O4)Rt_6v(?o`LI9_m6ih{GjWUxec)3Zzkw6?*t4R_#yhXEhCWg0kEl3@{Znow+
zK&t1Y4v)K}Jj1_otpq>gS`Y!gMyriv4xDdNkU467$4si=lO}b7wBI*6A(|8owNX=G
z_ph~Pl2G`0*J60*mPW<;B^!lZRFujwysK*kxIJCDw@BWwK6HTil;Oy_${8VQHQN`b
z%Qd*9n*5oJzdo>2J%k$C_P%d1`_Q_4-#hF>dr<euSK1y|+|W8NClBTAbt`6JCq`$p
zkqx*x+9C+FSzheT2AJ3p*klW=BW$rF+ak4kv{v5JfroS-{mfbQf2$^RTmHJt5p<m>
z5-r<2UzU$7O$TL7M(8fGo6|Zotg5ETbcV;c7Q=sbtqi~6S`5GGT5uH8=1FQJM=?nC
zoLP#;w^E+rw_S_j_gpK&NA+!_NDjvN5rv~wl&%-yV_b{jV_gfnL~sMtM!E!2J?DwZ
zvTD7Gc`ny>SN@K93f40MnPk=E4pI4b*JAh%*Mh+DHB)UQ@Y#w~6Dd2fsKpn6<pEJx
zi>m^wOf9}%EY~1mt>A)#T4z~=qr+OkazOBRruq)w<ys8?%(WtXuWKdvKG#~|`&}!;
zkGeJr-bO#|mDx9~g~GP}5%4JZ+pd-2?OkhycXX`;@9bI;-qp1j-p#dOQjol7v=cJC
zAR*=)pqRXBT`$+})faW{*KM*!!t+#<dy0?rO_XI;YD^YcsJ2xc?b11l7r3;c_M)s?
zIZfU6b3IMjyi@o><GQL}L+B?DWctY&p7KP!T$ckCyw%=$>;fM#sq^ei=cHoTx2~@=
z+9&J{fzA~)+SPTN^MXc;2Dyu7Mt<*b+8H%`(cOlc?I?BW*#ECODibT)%bdAJ7a!L&
zCG!e?Q#F}a;Cm@E{z}hDHjv|HC^CA9H-Z?X!<J}p(S~vyKgm4IrB=mFT-sc5YnQfH
z+|{MM6!&$hs<^*P;}s8e=_tjCE}g9SeV3*wp5xMmiZfigLh%}xeyn(tOSdcD?b7{<
zkGRB?XTB#nWX>~%6D>P|2kCJA7ZaEvltYP8^!4R`c?@2wVccsIssb|Ca-N42mT7c{
zHAGg0rU4Dfr(73Pi4^5r9pK1owTHFZv$?xb=Q4|v96YqaFo={Lg`7hyyWq*|IrAe{
zKVCwYu)#mr@znO3;&J+9LarcASA1W$@}O$L6bhf4T_@OLCx<q0Ig>i+(Q`J}+Q0=S
zb-bxazw2$%^L1_Q?Z~EZi9Pqcb`b^sW$xjf*`2ep-=)dn<zksaIC|P*A4hjya*3Y3
z<`O-8&!rC(KX&PJ#cy0{(cTZREQ}-cl1tgd@O1=+x;Z)}f_<#p!ZEDSL%Jm=c#v+%
z)gU4G*tBIsI9{j9B{pR$;5{aFfJD+a>X|mTPmQKXn?wPU5SgkV!>X0DkualaOKO6A
zCqQdb<h6aV1UUlKlH!NnmH&N!52}-gb({R&sC>9nD2=EgJ#Ot(K)!s@H<~!@fj+e`
z8Fe|E3?}pGc8pd)KVZf&u3WX{te#w!?xC|VxgUl1bS;MWa;*qgTr0r`>-%QOL%Kc`
z4)K@JO7Nks72(5Oi{T?&3$CB(!~_jQuAf0%=B)Q&tu|`WXwGs%Encxr9tgwqDf#FT
z_P8fz2Qgybk*U7H(_M?<8LkC6z}FdSBRL4#Q$ZgmM#)&idaa&lF?@vD%NV{8Q8-e?
z#1KBpwID9t6_pj_U<9`?smi)@ut^<M%x*U{lPc(r+Hf@9tw8sUQPy?TYPHPK{w{&;
zD7X#AqenCvBw0D9e)4ymR!;^7zR0x_e6edmzVUUY+DN`ZuQuZt-D?}F^;oqkc&<r7
z-l%n&n}A*`ND^^es<o2t!qZ)g;Tf(K;h(uyg70yy2;b*g4BziskUnC&Qf(xC;I%5r
zuc=QBE}^N1ksN*?&E_m7VXZc5(Se+Wi})W-^#lHkYcc$;Ye9eU^{m=Rf0b;5$sf(6
z3cg`dFg2+4dp7~SRxmXP^?j|CObvLEYcc$RYejgmYbE$Y*IMC!xK@TgcWo5>;edu%
zKb2AVhl&#5DEK4S%J3(ywZfmeR)Rlwtq6bVS`2^XS}>L*Z+BhPWh}vc`!xC>uNd-F
z?k4q=^VVVLsEVTx?8A?7p`&q{J==ti+Hgci<R;<iDON!ttT&o^BsS-`2y2a@7DJS?
z`2I<=^)JiXL4CB7YglIwT1(MCcsnQ?^rdP-UUJ$BO@a>)Lle$l)*fT<PYbUCPOxzv
z2cBnA1stPicv+Fa<4hU{US(1R^sWW(7w}uiZqjW5D~!`f?$fOd{h}UzVECW<@j+eu
zS_>;!2xCC}*X@|YsmZj6)0VYPBB+^j6@0!%L^kpslJHBk{MM{I`uzDXcdEA%oDH(J
z^4xHGc+Q}g`~<3ae55yz*pAYSG(1w;$@0_z;xxbMWAqWrpO$H)Dd*fYqtMv(if)s?
zN&^qFN4Mj_ZEayH*I<Sx=SKw}Q?I|$t=t-dTiU|Z1>!JyPOW?0cQ6&14ga!`CKq7-
zlB%rRF+5&>Q78GFpozkPDkg^TL9S`oHpwCyEvStwz97|e76d#_NO^`2b}fdFa;*q|
zp_+t0w~4}+DMR=x*JAizt_58pxKq_eu4zE3=d8k{WOs!n+=wivCduIj4>E1X8oZ;q
zs(^c`BtKc)RHMMdIhiK9+csw?aao!)316i9nxh?S@Lj5jEARo8>P=GMx=ZZ9`Dr_4
z+w7-wfo_|llOmXg<jD-krEOn%HDcttHHuGYZLu`Z3hd$%E$4y`lef)F73`xY!9LNc
zM+B={STAUOp}NGMyh{Lnt-Ja}CrqhX!A`oPb+>I^z}`&8*ggeZ6Ln5H7G_PONyVUJ
zPpZ+=x|Km04AaH{(Pp(wlK<DNq5V_sW$<~Isjo#FOu?+j=4jGjbzqyJT76gDCfC0(
zf3HN2^QR*U{K1mM(7Y(%>;#J`xVFdSI5Vk&J2f}l$f^bIuTr0AYB)P^#h=rX!2mnV
zRd7vkh&FtL1<(fm#H4ZeD?a5C_>4;Zq8U5(+hWZc<rZsm99XdM&zMphqJ_=fE}Or7
z)HU7CIgQ<-CbwB&)vT9ebQh!0EI*zL&$Viubn#7>h<AAlaety-&!pf2@_BXO9Se@q
z6V(J$nZMv)b(bu1C)X&rt6&1H6QnUXN|~aESj>T!qjlF*GpSsu$RDPW7_*thq1Wp8
zq1L+A90hGn&|TC{R$%xNt2P=W4q3LQ)+o69VA*09f08FTFyY75eR53!KjB(%0OO0l
zdy})4V{*Gi9!x+?+)Eos5II*S_ozdE&o9V7q5mS)1^6k~V)$v-iZHMDNlHpEulI@8
z3P0<0%kT@Xje@td+la~YBMRU0SCdA;Te((-{gtrEt?;&PSAw^5tqAYnS`6>#S}?XG
z@27Tq7R*#k_=`DmB?S^)&UHJr2AShF(AydfK4bS{@?!wm1MK&jU~V{*GZswFa;^Zs
z(Q4aT1l`~dOsYJhNCfg60{p_QK>n;t&eIB-!?&ENTQ-xw>ppZ?p@#Mo_xLZx0XjGX
zqDf|s=B)*jeod{ufqMk$k<8l&p6_PhNShTicFkt|uR-eCNu7704d)&vSH9-&3w1<e
zIXAsHKF~rOdxWC5HI}v*o8-b7=CAh1#QeL~^pJvei1xl~?d@L)+S`9g?fuSbcKjh|
zFF1V01<nt6Tcv-Qqu|`Qo9^1rOvXH~__|5Ks?U+WkB#l*0(^~YCHPv`f|UVZyaJlD
z>W3y(tY@m{oFzT1)kdw^Rx7xk7^}N3F_VLAmMNT|yG}Ec3itz+`bCAKC*}NU01|PV
z+R3p~fS2jp@SmI;;DT#G;_$W5!U*OBCU=`j75s%s?I5qa%KQfZ>Q>n-yrjF_B*^81
zYVwSEsqp$N9m~1SVb=z!zQf<q2RU+6@Ipl4yDBEh%tnc`9n_i3E^s@oma|q+Yg?;T
z1?QX8{<Pv>UHZ?>x6%C0)_ic6K=YW&Z6&ye)f%5|i$6)Uw}n#yH@8}yAW6#^fC=j0
zGjr6nj5-)$j)KQf=c+YX5y!8nG|*~QK;FS>i6-7%s8L!=4GU3EB!4DH_WY+#%7uHe
zmhGneMnJKa?P%RH>+TedkiYsPL4zbnp1g*C5M^JjH&M4z4@}jYH#OVdQ)=%?YUi)=
zFpH80kMIynTyVyt8U9L7GWp?Cw3=u!%-=}LJ4o<#oHZA$B$ym!Ccz1h*1N3rEouiT
zA7RykD~zyOxi&ti7WDskH96TmgLG9!d`d8Z*vX%3O7a1proNKA!DqNugdcRR1V7|j
z5q{XU7@p@^uvih>`D&AMD#YY$GpT~pP3i=%R!I(srW%Di+%7vk@$Lb%f%GZoL>tx$
zE*LJ*Hi<!w7m$SHJk4Ske|{(#D|o(oOvVa+!nGp&3)f2UldiSGPq|ixpK)yz{D6Lh
zAZMWY5rqd;lwd}|54l!`=egDjKk8Zup6^-_e!{gF{<&+xWFmR|J*Aw<gvo2#PdV{}
zyQpWm-vMc?PxSrp-YIm|7P<<~8JK)wi9V$Of9*kKr|BEI3ln)!a4@`y1s;4n`<I~F
z6sxwaRSV9>i?rJHX3`Gcppv}2I<-cD2_Q!bNb2O*#s_CR(?@-*WbQ|ULrrQMr+B_e
z!7;Y1?iyhx`-8OK6djOlo_sO&a;}ER4Kp$4rj+mww6?3@4@_zUy%W{Tbng{rwLeIb
z`$VUQ%Q!LZV)aIYxRi$lApOt12H0I)?5*48=(GsNfoM~*nWN8#S_mEASM&}BC(?;(
zLN4T(%Q`07Usyns3-BLZi(x+1OqR#qd_AxAa#jJF`?Z-=L0XWh40>Y|i`mB5_nHS;
zfET(J!+&<I2*2T434X`5R`^}*s&u*xzvo&j{Jv`?c#&&G_ygBs`0uVMd5`JqM;e<X
z7Q|)F)2gsmm0GRZgyb3=X;K9oXHq+Om`Z)3N#VL2HrPgk8=9+5kX9rHkeuZ_`0A?;
zisq>DZACIC=Xp<AgZS%)EnW);>$*hqZ<!P<=ez1I@*uCF4u;8zJi?m-yQ|=teMMbi
zlAKVoaqp=%^DUy_VM^9b&T?DT+E<&GV1=L$1S5lyjpZP%%{v5gg9yH)yXv1iQdnrM
z1!oOhk)`B;7kq|QtDdEJlS@BU^f-f+>;yHLX|=}AQ6%1+1&PV?k(ws!8oY+SiXmDI
zuj!iB@O<H`kJ?Cc0~A+v$?Y3Nt!2!l8rBMWOB`Ektt4*vE!WEM+pYz1<LfMopacA)
zNx>mOt=-L}+NOB7NnPN*CUt|qGpP$C%A7-)=FYQP!6AVOVaQC)CYxX}NoHWyW@l{y
z+vFo_nAV%4DTCohETT?uzDo6bAqr2LDDPEJ_^nsY#zC9JnsfHvOKW$Vm-Y#Y&$^U#
ze1Ptv137uRNKGy`FBOpC%egXR`2M1`l1T}_=UNQ^)wLqL$h8vuH`iL>+5QGn8NSN3
zR`_byO7OL=72%p|F+9h$;Gm(eE2@ng>>w_4E^otHRcak(j=I1jP3i{ef}HO`qRcsH
zXznXbpxpNs)F%#Q#RrepU47*{79&U0D3aZrbHf2z<4_B<0^&4hnv~Rfq;C5}XUvZ%
z@Lrl+18lAP`D2dKLGUtbFnAD*$!=y+nWT88Zj&#2ou@p@&9cYICz>@<mb@vn`RX-_
z{H4$&T_R^|Gc4Czqmv8pPh5-P8(k~HH@jAXZ*i>^zSXrd{8QIP!I$gnX7xwf6t3|1
z)JDNqx>km-a;+7<+O-mVt!qWN=2{HTaV<EyNZwo82|2nzs^`2iLaoQFRuv@Roa<z2
zy=%4Fz;!f4nZ)2QmE>z~(Y~wKDALiK>Hf0%U7%YzcMODSNT&8;-OVfNd8a0NLv?Xg
zfZbJf6OHj`3x8~OcFxn*mNk>$!tZ%CInqozK^zyN8S|#r|HeGZR5u2hKlPJgHjYKw
z2)$1wg83xND9Dt_S?c&}q8D2L!Sw-ckYVw%rCN`&T4TVyO{#!&vMCw^PI0Sj*O)Qq
zn@Mo_%|H=GGUo8ER;}8mNTWGd0%YbUHBCIhcbYb`2H$VmW;OUR(>AZczcg)&8qA;P
zOn!q1e%0*0RfAtQZL1pmu4$u!6_b7Mna$(^{Jv{3%%AI&%Zwtt$H2xgh*pC4bgc;Q
z<ys8y?OL!P5gRW7%Yp>rGUxm_NIkA*p2N#c+!WL%XK<-L+)RR*MC{+SmL?bAeO!y-
zifcu9v}+}}-L+P@>RK5-z_n5ES?e{%Le4hRnkk&Eq72X|_#D^D@OiGa!WXz!f-iEd
z2w&n_3}5P60Y0iV6=3%8C8HN>&t$~G4~934WyHbOb&)#3?M!M1C!5p>-fmJmIM1X`
zkW5L7+2C`g9ihK#p;y5}^eg*vo&x#0yL|X~^Hd7|7({=%!Pb=;Qr+%4Eu6lx*?}*q
zRJVIe3!klGc68t=9g&<<CLJK*a@`90n9aDkr{UB8JxCuDo~~O7VQvqF=G6$H0={HY
za2ZK&cko`%?ZN+E8hYJ7{YXVNH;4>(<SnT=l}wSOy7>00jW9`5UCe7^s`tA=M0cF_
zUe0e|KkH}*_^L_4tv$h}`aa$Ieu8@kQ|XxAlN0LnrAfy<dFi-kYEC-tnVQqaJwZBh
zdNHS`N24EMy{~|&Ud+ks#hjoQ8|pVJO3T~KDk~oE5_p12^1(o*M&S#$8=!~gXgfqJ
zCoA5f+vSo&wBM|z!l>beQ6p-|Pk4<N71xd}q)il`b!pWV8+$j@t<01I70+~u8A!Hs
zuDZ6-=0>aU<gx?qw)Vz=2ddN}-|SzfMu{~isSJCtW5Qs^5bVJg?3g1IhuFe32Ha1j
z<)az%duFxFm@WSd-C@ldIuk`M>%i1pn4dQn<_B|u_Am4H!DmdWfX}JaPkzXv|Kina
zl>6vvBdKPkSVo@?i^Q)fz2nk_y1ve}b-2<PTK|`IezuNPl4h86H${8{-|9`)nR$_J
zlXpe>YuIG25baRU=9;w|bPpYo-`t3HSiLq@BmIGHRqm^2gI3)(M?2TxgX~Pv2A*tY
z<=Umn_nBGcGCigr(XD*LW@?SX2ew>|20vA4nP}NQU!5v%&h^*DU{&1?mhTY^lHV6O
zC0b>$Y&LFfidI>v#@;P$>1g{<asAaBX_GO!TJcGj#;wuVd$?}JYK65L(h%K>bo`Kp
zG)uQ4ap1jbXUbr3f2<Sc9^EE``%C3lZ8Ej-yH`KcaY)RbQhr6Za+3W_aRZx8qd|VW
zPoDLcY83W%J0>9KG<m4VD6eY6=cD``A3l&#mJ478`AW5tbKu846nx}IpRFT#m2L+n
zXH_}EXURWn)=-!80c)h#|2<DvjrVLJsW8X+i<mMFO!o<XAfKaniA(OaK_m3+P|<CY
z^GV9T*R4FnI3{zPNndC8aM0ajr-zPtiZ7cq8XTxccD?GFTG${hvQB?T`&qYS6>ak@
z&+eh%S#ASUi{k8_?8%`%qja98u7qX>3*}{D3Qp6gKC@(wXCYk6=J0qH#A!C^#<Tj}
z;1cuj8JD=cI#RE!B<Uw8{?Mho4)r#qhv*n2orW1lnfM^%(iDva8J(mi%t(nD$ap1Y
zu%8mghNr}_3?^qVaYn-YkQ_@YKDNVe?9%l6G`*2nIo0o?GJlC(`khTh5<R)#DoD&g
zCb`^MEmmj$(5*-ynUjhjiOWyo=p`lb`*u+>nv7jw$NuR5CKqd`4r};H^Im0$hMV^)
z4f+sO!y&3NM4S(k<xr0+&IdV<2pFM9Q&Byk{E}|v*(b>QlOCbxE%#l&Q~Z-lj1XfW
z&KL&rEfRB;bw;GH*Igtab$_v_Crm{bskqFJ(k^hGN#j876r@cswPGz=+7&DOl>>77
z6MM!{uE9SwZDb9;&$Mz4eoi%6c;D@z@Mg*oCUbSecAY%rFc~g5waC63EV7(?IQqof
z%~L7(5RL;G%DNo|AJ=gp<6F0*K*;i-mf#p+k-*eoFU%S2aSZmwKC<9rCUt|1urvUs
z276&J*kZ@glS<seAaOVAv2uqUGowKct@_s$DR4l^y#vUxB@5QadJg7Jr=GU!gQGdP
z0Wa%WFO{=7J^cB>DQh=QOX6%!&jnhj>9#342)xVfruRIjg<r3es!U;_ic%R|>~_<8
zDEzsUs!XB9u2(03+naRI0DZ)^fo`RVh7bQYr?b<0PS<$pY*RFWF5q4IKfNdGzb?A(
z1})NI7-Y+H$0~{)E?uaX=X3osoxgOt`kD<#gQEJSr5v`4r>-vl#yMZR`Ajo6u+*p{
z*N+YGfB8duLoCS$%`9x7_M7XrPbA`nT9}m<qs)IC?CA^5Zk@je+C1(&R?+8YCo96W
zw$69f6rXbGSBfka^3iO#M0AF$K_{!hn|58-$#q@9uIoBkAeaY|Fp&8#M=z&`qwTt`
zldHe!E^+mDuS={e+)PUJAa@+evU;Xo5nXLpMx8e+u4l_nC%CCf@+T6DTuV-IGw`gG
z*{6C#*lg2l^lLiFnbFeCFGn;6cU`~b%bxv{XtUE^YGx)yls7BFDbU6gxW&f1?KZ`~
zy7WOX1=_+X(8d&a#15)9E`!#z%b+%9#eA2T6-))W6<tAZMS12S(mi^(upG%m`AMnK
zZ89h~fIpFYzs3PtTbj)MdyQ-o57RR=fhD<znWXh4hl0=8ZjhN<x1+!{dEyXerq&H9
zaCS=!x7XX;y>%-I01vWz+-~qNmBihG9tv03V~K8%Cl>W)DLm|UAdfNXb`*YWv$-2&
z(X881SXoz4dDsuKsMhT$tnYRp&r0fc6js$kNBn`KRI1xi*iR>j*nuajRJWtBo}IF~
z!Hra^+fg{r?ZDJ^$MoR3BN;X>JYKP5x*O!lPQ48Z@3<ZKu1a+~3ZJ?i_<7onLcz|x
z-5~2n-5-V3+zwnrrMex34crbqDs7iNh&pv59%ys40x~Vd|AL-uy}W~u<Ba1-?&U!a
zqr5{(%<>MX&vbq6>jxD0*|0`9QWHF1KlYPg=l4*UVV?z#zg9oD<8!>aUEUhRgdl6u
zMz-%Pj`TO_RCYm;IlXj!@22luJty9Nt}~f4O`>I^$Qyy2<!^2eVG^R;gMox7*_az#
z_vejO-H?dW%ilgaN@IMqz+G%=b%7O=D&V8GsC9v?WA#QUY-Ed27s$F(x1(^TEe2g+
zYB89*#KnLkM=}L69qMf?%}|haQY@D?;F1r9&b;*UVd!E{95~4m*9rERQ~|%RL#7kt
zD3LC`kaNg%<{UCFEHQ25NV=NM5EGM$S8tQg`(D&JlYEK+zijhp4ERmT3{DN{3wfUf
zy$~#1IgvbVpFH9=nfh?5iKp|LcsgieX^zaKuS^k=lC+vPN0<<t)Dk<`SBQ~zNyRuM
zc1tl3(|aD(i)o%b%IJL7Lm}1wrThRHcU+Lmd;tF!*XB#ngW1-DRIs!21}l8zO|VOT
z0G$njS}WRp#W;{I%0)4FkXd!o3^yi{8;~0lxnBTTVVB~Fl2=U#iuYdr-@O7u+NH(t
z{MnvOUd|!-Ko2jWtYf*VfTU5*so-92wYTD7E`elLDuR>U3cSFiZt!-KDt9PydY0>Y
z&_|~mBoT51J&-s59takTX7x|cnxn02;UuvSMf|RH>l#esIhQK0=#l-FZj&Y9J>|dY
zHs^^o)mQ^$E@uZ36Zbr__D<kAc)XHb^W+rE8Jqh=kp}1`>jri;+m&rUbkrF->I@xq
z{%1$+p`-TDQ82A1>gUBh_PKFz-+zwoy2?y~1RbWkjy03EGZm@bBJaAd)9cF486=s4
zd9Up}koVfo19`9Qgg<w|k(+8`US1pX^4ge}*GBl$7_`9v%P;vZ?5Vw!xgu_;*|E&l
zm8CRWQPL7VS<cpL{CaS<YW{BuXY0xuNX7s63o(}i62yPbP1mYJ8%CpbD{I>cig&v7
zGsT~~1m0>_m0jS2CRM;g>^7_mJkg{I*kNy0c7YR2s({|XU`5CdgpBm;p4T<#4?TGB
zQ<ds=6h3!5kS6PP*{qJx?rx#mWPyeEu~c+}T_yz!YEJm`rgCZcpAWd98aQJq(axKC
zk&4{t*2QcWHpz5B&X)Ax2;C+1=JZfF^*{Gv6MKT(&9U&3)=Cltb0;FF7qE{`jKmD?
zuUbD@_a-K<1ZjCon?!BjRqS->B*lAmn|Op5yBYXZ$_(zS^N)rp?_u+@?O;W2mXcOr
zUJ#b<f$R8Vq3keRq6xau(pz~*@eP;A(+bvu3LV|dqN;4C*ya*}5{Vq^*$8rG;DVk%
z>cYE{A1z<?P#ERnf*uOYz$6uL>KF>2C2gFUx=F>Es{L5El0)zYYjl$Q*oGE-y=nvZ
z(yY~wTMB*vRzR{Wb`SJWV2UQOz~nx;cY~Rua)r(~oNGhV38rqf9|&%>lO`_LI?P7-
z^3DVDCgiZD+O7Jb!&ADIPcF0Lc2$sr(fDJ+OW!{3p^$3i<3=MW!)(6TYw;(z#Iv*e
zU8-qR&slVBuPDCmQa0e6iS~5QJK;n-Zz>ZlHGjhU?HqUWdp-=^U6ki8d|Ncf-2-_G
zaW7X_*~1{2R#Q2xPP4fy;<;LQPPa0&U~0h*ufqPRU0cnTh3=)u@WLMIal9oH59UBk
z<~ID8#+BH?seuSDqmI(c_2YD#e8(8R(6t!8$hAVY2lzTiZRD+^-b{XICRLDHedI?`
zgDYi1!dQ%^)F@Ch=dOrwFG+<BPj@YbFLSL3&vLB<U+!8fe1&Ue_(!gdf*%~!$clWA
zXKoXPhg3|y#{)m?S{Z)CwO05s*Gll?t`*^*yB5R0aIFAuxOFPP><E(4!Rt5n$RLBn
zBX@&YS0eT1sA!H38lt$BOFJs=>JoUmN^-Q$oqDDgE=!9Pu2M1i0qyL6^k+r2kx2x4
z9^@sX-s%msdTrp)a>G~xTi7#I6MU|2>muoSHZ4;4+J>ZDgO{@*$+;Dx3(Ht2qrp@c
zrcdpy3qAs4!Vwt52#{`hHHT!ASCRg+@3AzKifLL9(<d7=JpD_za?JxS7-?x;)I*`~
z<_%F!=HO~3wY{bIPu)uL7v+t}q8>&hmFV!zwdM^Qjjf{FWR)GRype9@st3H=NB8Eb
zG?423%|Y+~x<#XbFLW!t2RHpzs`nIjQc<ow7AKblBWoy=(&p!BVb`rvKE`X|a@|T>
zS1aC?wxjTKw*x;-+pVR&-N<{rsE5KfDoP_{IF*Pn(>Ll=zFoJ=$dNnXn`Kt7A-rvK
zz51Tw?mA^!qLbv;M=9N4<5Imzah^+$DgNH2Hx=JDsU7^#q-wv78mZh@x5-pERQX8V
z%2fD);(aNz=agSHv+8D>G`#Jm+r-;g<->F<3)5waZ>G%Pew#L2Bv%8+DW9Lx+I3O-
zAKfN)zgK=ErR||d*@3!E>|RuUSGO{X{Wohgx0-H6YSM$ukG~4YaVW>%oT=;U<bFZ7
zb&;vLk58#NQ&~ID(%F-wh2x0TQqlslSSDY8X+-D$4%B4tY6G!Z4c^_f&1*0NCl`32
zkKtyuN3}}F#*HR&F7fx($-)%t6ZQY5M&Xw}lR)NO-Hrk?PaY0|?|W6SpGDCQ4pB*x
zJ9{dH5pD<m-DX#%Q)f$;Ze>V8CX)P4SyPSE8?#1YW76zx6QunX#fi2Ww_llAjin-U
z;Z9rd+L;L~Mq(8%LG9tf(w?0y5`T7P)N|{TqCrdz`XvqGij%fTOfHr$k+P1Ka>Of3
z9C5}}q6Z1AK9<?g>SAs`vk})VvoXJ}i{^)Zz6D3<9G7|vdMHd#QNjZcS1I{2n*7cU
zMGhOW1n)?Dr0|S+Yy+P+kMg&qM${<!g4y<Mowl7eeMf@_sMI$)A*oD}wNsANuXVDm
zuw^3~5+T@aQa5<9N$uc$CUw7{_=-yh=-Kut-O9tc8#5<hk(k~$*lD%<9Ys#75*Mo-
zV_6>yrXXif@s=IdJN3SU%qJ@+Od4CF9{Egy5|d1><u=j2jIusez)q9Km$Xk@aY(e;
zxhcM~9Y_M9GxS5uK)RHib+UarOQ-1bHdVX9S52yb18lA923ZE>mIY)PloW!Vhz@X7
zTh_Y45hitjo0`-OZf{Zt$fc;X__eNwE7;=K4X$BQ2gvDCDuOJPGAn*El>%o_u>+ZF
z_1Qy#MYUd;0#|l*%N9ND4zP>2?(DK#x8vfD;g^;{UqCy+AGtTsFO++x+6kUnk|av2
zFiT_rK_*PS7ugxZ%HFKkH{xm;MTRyN>kmD!vlNLrH-_M#tLZFc3MP{n_Abg$aZoHV
zc+Mu5>G?kK26H7Vy*_U$g*#J*Fx{*hW(TD%W=|bSGueFC4YSGR1i!Lg0gBP09twV0
z*amWYR=1<T1!DiC@~oDL(a;(a*NpN;ak5J;9OY}~H7*#KbN{|KJ1hQuZ*M)IC5h~2
zyE>(Tx|sD_7qjlNx30-j$Gz*adZ<gq1w9mKSMFUwR)@MBeci|wgU*~GT#$F~8a}bl
z-n+__&fdBv0q5Mi&dHmvbAo%<AL~4LOSg$Pc#&x%YcO4|=aR1e_gUXcXZ<dz*$?k+
zTDb;uSS9luzQ?X2I=Kiw)h>cNv*Ub?THj%{+Q5%hlI!G3jXSc{)K&e5D%RD)x6FS9
zr0KfdOx=H<+ksE0RJUV2TT|Dyx_GD-xYv_YGq-x2zeM7qodY>_0%!fJ_k#k9VZ8~K
zh$ek7C6z%AmbzUwd9Uit`k!^1%o1+Z_tEt;85%gXZr+|Z4{s0V;hO3N4{{ft4dPmD
z{KvYL;K2iQrpjvw-~^RqqJGvx;TS!j#SXmKqzV|@CEz%49g`~HD<+Kt|6o!Dyvi;V
z$AO&6C4TUCZUw$=QUxTd5`FeuBvLkA6-~hYmYWJlI_kN})>}z07B{eq#tJyrB)h2o
zwM$%7zwZ(k)jZdd+pp|XEs@9qmop+U8&~y-3Ud0*xs~IXV3A6uDQk0wF2{)mb44b3
zSlmP5Upj~)F6dcCM`4(5>mr4%eTYCV=jwJ8=wH$_OkeAU6u6E{3}LR_>V_0pa1%qA
zlT6)^{E@7>m>ucE^kVxS-6q~xd{}uBjkJEC*TsnjZ|8^E;vNcn`;-G``l)nr4+S1A
z$dLdtbQ1959tw<M(lC6Ij%VGF!Vm16TLEu3sS|wMqzafC^o2I)JNTe4?4iJ*O3WZ*
zS`UQ+V=Cgp9tx>3THKQ}M&T!YOFKsAXv(kl)Pv7?>ObqD@CRS^K(Z|nf40Qbr+V>O
zUN1fiK6bfJm+as8(!HrJ_&e%W@|m5Vd+NMgWH*IlIotX(&9ThHt*qx`S>GnQbdusU
zm*_87G4f*(980^~O~qKwpEF$IEXn{%#cb$PwO0>X?+z;I<B?&yT|Sx^Z9crufzRwz
zuRIi;8-Dqc@UD7Au%~XbRnUK?`{nz=9JhYOFd@8Rm_XM#n51I12cPIw*kF6mQvv<L
zYdpxf$VD;8(?@w(7W{`@7IlK3m{b8jH>nfkdPyb;$fc9C2>!s*Fdk$%6DyDmNnD^O
zs}tN=*E;#V)~PiLEQI0>T-DZ+@u1JAPLOkpv<dp-qE4`&Q>@-51;35&1lLI0QQ(6d
zi482-l&yfnP3i<Wr$}x=ztHIXlU88PixtSZMOyqXCJ+5jrGj--7M|HT4@5e%4@9JD
z&MG^5DyuA~PO+m$9M~eUdU0Tjw1iIjF+Luo-}P{_J!j`edf}41nE`L?S`3eLtq32!
zZNsb7EyG8+R)mjqErySBtpH!^njRq@HSvztIOHJ>h)WsYtf!nI$I(9KsCu~KsU}q}
zQoO?@@G+I-2BfJ*;VrWp3w~yHr#00mMB6mFlq|)H{dL<X5<3bzyB*k(wxe*l*^Q|w
z-eOV(yvwRe$P}J*J8+>%ZU0pK!lVkgnhui;0r)+WDh$E7CXEFd-<-dG!l*E&Ilnyd
zZH;6Hj|d!NQrl6A$C^|DNs!#KouR>bM8RDgBQaDRHAmaj;Nj+cbgLo*A|C*dfy=a!
zq^3{g26gJ>7;E#U0{SehhO@BBEPTpl*GWw^3cqo&x%Q$K7J3t8;BAY)$~bRf!xdzL
z!()HT#EdcHlzsknfaJ6}nlUEZ?J%jE<s@|sN!{Jz90Piu_aCo&XPDJkQqPQQjy9{o
zJ{;l0|E)AfsYL-~5tG|EkXGaz1Jdc7o4q9r^>|BqHFQ+{zr~#im{irZ?{_l@qCf*G
zh=?tNqJ~b>a~s5JrT`)kY{VG#bamC~?xJg=2I$5_agI{}m0S!esEH4wNzg<gYGRug
z<8(DR4^hL#A;zl-USrf4@vXJjf7NihPSkh5cVB%UwfFv=|6Y6T;q1N7uCBt{c$(HH
zX!>k=JJ=3{gjA*BP()PPkABV5`>FtFMOfnVX0_V|37?`|iTDo+7^1mAoz;BgVG<Xw
zM_9sXt<O$Kcy-eFeR)={@lW!sLgW9;vvQ4pnrDL%%>`QKBOo-rX>?Z(Ez#)9Ikapy
zqVML=5{+tkWD6H_LEqw9v^e#)#9*3GCI%)V<c87s_<nMYSh>cJ$g@5bR$C{+7CAW^
z(SPJo&S69}*YP<?i{@IAM;cw0L#JponnNubJsXJr?y_u)Cccx?oubiea;Qb4KP=3u
ziJ#|Tzb%@$E0_5cjs7-=S~U7hK5N+)O}w6m{kCZ0{XFcyMH7F|Sv<wtaI<kK-?n;B
zd6i}W2=}hW7w1{I#+T$-pWaoYV-YDa1XVI4C-L=YW=_&)c~B=bFFURAcaV*Tq?V?k
zUfY}34Ayu9+NxAOz4o=dX0XO1c~+(I6?xXDk@Q+ufkxvxIN1k{C-b^78XwzVD!@OS
zU#5w}04ehrjgQN-a*ZFJXMLRO#J$^{yN9c`X#5ti61}P>k0>y$@gwuBT;mh-Y>dVy
z=UIiukIJ(t8b3PEsx)4iXN?*kHze0aTPJDaa6oFKMvafpvnq{O<k=LBPsp<hjZez6
zF&aNA&&oA^be{ETb8WmfRN`N>Z#E}s(WrV-;*|STs8z~Ggb(4~ei0%48S`t1ezLzb
z7@-5<u2#LoA3OIo-gk?$1`b?>a1i}$@+vc7;$Q`NFHTV}P8z6QoRUEFnmke;)xi?W
z)h1L&YdXaA|Jkl)YqZan_&sP3MG2&x;-|d`nrjjAZbakHqEpG88noi-Tx<53l{Hrg
zk^yFjDevQ3U)6@~P9N3V@MhG0+H6Y?MRaN&-GS&Y@<^kv0MU;Ymi4h-1`oAT)IPuS
zYoDvd0i#>2Cope~!nA?Qx!{gL5{;tmI#E^(VNQt1lV4J=|7GBz7|VwteDDCTWl1Lv
zlrV#E1H#v_oBi=Ia(xFvuN80poyh+@!v8?H9`?NX^*_pa7XCeRh$#AvlkjAO8xek9
z{!d1WB6gUB-~1oWfA$zDcQtkcpI3gzp`zc7@bmQglj>7pe<s3j=<Y+z<=*F^J+xi4
zJ++*i5Rr<J61fuL6tv$-KJEWy^%0a4LzqN3(&v7;8T=;*U&W+45px)_=YsojW1o-l
zbOpj|5Wax$J%qW8h`fmWYjEFPhA{I5^G}1`oBz!|3!oI(=A*yQNB=9_&r83cKaWAL
z|4rPdp8VeW|6zoXR}l^zCF$c3{&)3rF|O2Z8g?)9v3~*D=VFBSAnfPUJ~tgD9zJuN
zgnCe)n&$Of()vNkJynu^8sR}c`gJv;)1&?A_-I@Ipwe5)m(?GFe%1dNtRC~{bc9~}
zM}T{EH~HwdqMa|qJbNSNhvk^Jy!P*ee$*G#{|fp$4i-zFXTN)r=&qeC;dJ!hsR+IP
zsD9lS)ZYmE`t{n+v;SrFGqA4x6yXC1A4ll*f8#_Uv*Fi#gts8{>YK3cPCZtx9FI`{
z*2YhN@E6o;{sD;Wk5C_c^}09o>SsZ);B)eyf%$ti!gCOAMA!twGqeCt!F#du+kyG%
zpBQgd7;hfA8G!lx|CN3u>~9z@C96NbIY`pO;n!Fn|1|$qu=5(iKO<CoBVo^5zrmOf
zGbmqmTK@mE{ucNVME|HC-gcPm(;ol7^ZyF|5BR_I|9#~DxLjKPanCsL_Qz$=y@Bwx
z&(Yt3=ZksR4=uy}aGHh~H)kRAmbcC)-w%-gzpH-^>&Y7k_4l0aKHO_r(qC5J0y7&C
z{s7^2gx=tr0ABsAULn%@fWHFsk)9$vgZaq&DBj0RWx6Mp3AUNabS5QXr^X`jjGIcD
z%6KB<RyNO^KQ$BVK&m62t!&FiqT#8Lu&Lx!XE5DqD#JZ-vL|6CC0ACtsdOX}FG@Ic
zE#*dooB^?9G-E0w@d&+V+-`brrvzO~goBx&sdPJ?_Ea$DI-Oz4t0_|%$|O>0Do}zI
zA-YI5gRw}63QUk0daJay#ZFtA)S*Ny=Emt_*lo*pIKfmf-r=$pn~cQU6B-Y;wWZuu
znu<o^uEwdAG#X7%VUib?`ZV*G1^hV3w+@ECY3vuEl%dcD#`}1K+e|Lf`$YQ3Q?2H2
z=@+1sF)aWUHkE(#E?>NzEX<$j7qH?C@=vm<{F^ubY`XOK&pu0N`J4I$tauYZl}#C=
zx3PD7yoj#z)>897+%G^WV;%-*#dzmwgX^yObz8`P(7_VTKV`oFrHq+^d1jrb!8}R(
z&8E)^{NFi9^6$j@HP2eh`>*9_*hSa(734RACBHh_iu_*xfz29<aGR>VR^)F*MOz{C
zwx8DjLQno)<nKlPw_up_^VZwje%~X;ZKBiiwgUo`GG-h0`&y2L^v1pxzAmLiVg6p^
z??wJx#gGZh3H?_L^18;Ge`vs7=*2#@GgjPVnon{Y!}Dxm`BTnrwwI>hL!@CUMCkQ@
zD{;=R?H@q?0P_FaGGs(hQJgf}C|#KU1suq|u#2fN(fw_Zd-IlmH(e>rKkubxtDX0f
z<X?DPE~|}b|0(UI2rF@$m?^{B?4>Egq(<KM^5%cYlfM!98^2)wCp`J*A^$w&_m<~P
zKTY|0?5Y1tkbepCua{=XjZe+5^?KP;{_f#Y|J}o-{;DULeQ8?5{~%h}es3ZFTgYFI
z@{v7v|7iZVJ^9TDDc_8c^0#^NSEwO`dnsgFTL0}MCI2=YJZ<;rwcd(9pa>UHr2wJk
zKi0$59S!%<b&VHFpF;UbsYdRSS38t|m$7)}!IJT)e#KXdQ^p+XlfQGcw8(A8<chWt
zZ~miw@{ekk{G+G;>-;sy?`^+hza#k<`;@PK%<w6{=N8HT{8OqFKZ;Yv%=gK^q(^4_
za?b?j&CibmQc`g}TQ8CP%RL!9N!xdxF1Cg~+93I-REyn76wIZ}I_`B{;OVVY`4zvF
z{BL^p*WU8Qdg=H6<XvOGK%a~KX|~pVPT|G=<caQIiunMusb8QF*?522l{{RM???NG
zQu;wg_XmZ>`g5yb-7V((8(q(f`4FS)bTL1G*4;oMvhn`3a_hQUc(K13YI?C=7V}|7
z*TG^w-01pN%*&0gTg7~Y(e<d9kIbzz#e9^}^`n>{WOQ99<_8;{?~C~%M(6QjKHBK~
zT+C@S>bzTUp}#rQ=zLm$X_S=yP@=!Vhcks@iudoc3l~9u;~Ct@*WZlySWx{DKD@$*
zAK8cV{nL;7{T)xg^E@!Xy!V+m13y2MnZEtS>q437+h2{A_wBDa#JSw^VF8NeU*Do=
z8MX7nShw{4UID%fT<48$;%sNF$Bv)>7g{?bO%?V9l(er6^j>C0nDql^f=Iw0nwFWq
z{@+HN%iX)Cxk&#2rAoCM?`v4U9e&m!*B%PX%y6^ze6e#7_$Sc60sUSy#1INu-wHj~
zlVAKNTWtT?@_<c`fW8v^%@M+{wO8qR5d7Sc!Z(4>0Utd|xSqo-CeGzPeRZ={4uQTC
z`iBn^{e$3X@GB1%&iitH@gH8XpGO`Nu<1jwSX@Dz?eB(ttuOyo7W1vB?@^TI*Jf~Y
zQL{}i#RJF9;H{Sz^V`68Um*N&O7m+6c<%<`R|_`1;H_5)=kdy~2UYLkkAe?`{|AcP
z@N&)mSAf&ZVqY(V2f(%5*T8peY_>Wb=YJz!YFtrc+V<Rfe8B2&wC~0oLY&JDY!*BE
zpfyhU7UA2VKMLGz6}}UEDtIrr>g&MQ-dL<ZLG9lp{H!uDG#h;D&BgpA;yfOjzZS5<
zMwA-@?*Ts@JPrOd_*cNs2mcJb27Dd(+UWsH?gGCN{QQ9MVes=F@Rw%`zZ7~tKVU!I
zIl|k)pCHcdJm^PKFAPKTC-8kg6wdn^`=ZTFseas_xE&|AioOE!N#N!daBPkmeeBHg
z;U^Pk|2Lfxu$FNgVNL_z0<J4rC-^VH^|4jwv0-P59q&9=zFqv(d8`L^W<lSHdR;=C
z>pKa0-Ii{J{x;~V%Ot}upl|(Iv3;E<UpY(s(RoAX$-U6)Joz~6Ki(?(`_K^2!u}rU
z^}hQH^bd84zFXWeA40$Nr{a(LUrrC?T(6&k>&IiqfZyxU&jjBEJ_`1~1-=(tpVKnn
z27apkO7IF#eQyDu2CjbI4;}!=$JOQq@U`Fv!yo=zDz4X7a4mNTZOfV853cLNMDU-3
z>wGvJ{1I?H*5UJgw(|_Q`WYu)>VD}a&f~fDV(Axc=PSWu9{ywSHQ<!Aue-p{1wRe^
z5#sDm#m?gKwg>v>p<fUEhtTi7TlCs)<uoC%pB<M3tnx(YCxPDrJ{$aa@V7nsMc~JL
zSL|e=*Zx|vL(0{0!k>$9xi>)H0DX!$*ULb!_vz)(KMVaB=x+dj7yNAS9k5dcJBNbr
zg1+<8fF;+0zY6_9&};vG2z}XQqE|b^=)PqC$Aas;Gzq*GocD|TswK|#S`Yi`|H;s=
zgMOvRjRXBI=ym*eLvJn*SmkrjUj+Rg=yT(3fRwuz{1E7GfSu=Hrw9Bl*lC3xA0L?~
zpkI7Nz$!0*{sr)-z&`?i2X=Zf-n1VF4wiO%^h&XF3-smS$?pk&7JM>sZny35N5}09
z=;y2xy{@MVz`Mcsr~31&1^m3L12(;c`jua2!TvV*IYco1MYoiDC%Dc7>%l+p=x+sI
z4L@~0`3?95;FPqlKY;It`&adUBVKAg*+-nm+s=CfHvc(d#tfu|n|b|x!v9$&7lwgX
z|62H5TJQNa8oawVVAIEgPXNF3H^R4qe+7K$gTi%QZ3K5cyjksg_(|ZGd-ziD8^Eu!
zUKw*bc-8Nu+~KsI@hb>^;v)f@)_oD5J99gn{HSoX!+!|N{Ey&IqF(2NZ+~3$T^J9S
zfgkpa@EsUG8^E7>LHLF6=ik6jeOdTYwEy+s+g=fVuaVae!9%YW^V`73|FM|=9Q;M_
zuffi}#O*wJPw~9^5O_Jb&SSg5E5N6~&ij^+F%>vZ(E0gO@BlbJNAc?bx<N{f&vN42
z&gFXoEX$pn9RWUOPk^z}`?nH&>Yf1OoW2IUZcl(Ql_jrc@TNTh3kC@`OTh!+st<zC
z21oarH24B=wX+8N8{o&FzL$Zoc`ac0rS`7{KL?ze%f4;}zXUu5zLPlj*9pIFwuDwV
z`+5@kkD*V3zXAP{`$ezw=RW8ouLrDh9`xljL2>)v0j~Wx8T<k83!!fUpYw*;iGl0B
zs0!uk{k{<TJE5NoeF*#`a9zh&6X*ISQD60cJ@j9FQ_9u#SJ(X{%GLFeKbPZrJq-P9
zl>0021OFs;)St(}mx3Pw{VU)r!6$?N75w|)AAs*8&i)?&f3&|w(?rewT>h4ntLy$0
z@E?I613Qi2Pk=X+$%O^P+5TR%&tcGqzzz6N@Na{cgKPh81m6m-e*P4EyGQ>J_-+s1
z4ZgOwc)WcKo&;C>BgrxLe=E3-ljDeU`@HpE0qc1j{vQv1>ifdK1HJ(KY4F?8K4-#y
zuV);t0uP|v5wNok+<5pl@CtC9fB5eM+5hjtzRr^`f$s(%3H$GZZw1$K52TE2rxo_K
zUnYZ(_1K>Q{-meBmV@_#tNkSSLU3}!zAgoC_4MOS;8h;|z2Frd{WIX}J^WqbrRMpM
zh;#q;9w_5v3H;IhSou)lx*z)t`dQ%J&<~`6#CGll-vV9^e)=%6vl;wg;@r-cJS2P|
zcqQ~7K)(^Z0s1ST*ZFw~^p_16JC~M8hO?k=g<ku8HFye~lJ>P8{5<gez;7j9s@;A;
zoa@_ql$5&y`uo5i1)m81Ao#oB$AbSJeDu*`XBznP;Pb!_8X^~7C(iA*_F>WM`1urk
zJ-CkBLnu<p{|e&P|7x+b4CPJ%zY9DDUIjj(M)b45Yr$P`{Y0S={Cw~e$|S>d@cV1U
z&J5U@3H~X#&gb*NC)A1l9N1X`zO`QXnXt1=?SOZIp8?+4Ao|&`(+YljqwwRPkAOc9
zJ_kGvKCVghgJ7o{eB$xK^||uf;M2iJL4O|j;;)H*D(qhZ{%!C_z}JD#nJ#+We{Ldf
z=e@^-)AVj%H$rbt5Kbcd+6KM;7}8F`<|p74u%r9QyHxMtzb0O4Ts;Q;)_*T9_f_SO
z7xTX=e?mAV?Q1Yin5FCwC(h%xA}RVM(2oI6f?o$do;ZKL^MdDdoTH&XaHZHe33{FP
zmV@iOcO3MWf&aWrGStBSTORxM;Jd*GsD0vwKF^xu`8;T`)%X28@iZTOm(}<EJn=l@
zBdL9MuaSD;@yKidfAZRZ_2ldDe>3>r&xBuKuNrf^<wz6+zxLrz!;blm*m((g_W0=c
zLBH!F(O(4p{xngKp#IwHX}6KYbq<Hr2364O=cI#iakkYDH6QN_Sdsx>M!dq%Zq)O6
zYb*5coG$IQ1p_exUbkHA(DG+rY4CB^3;zoETJS4Q5U&0HJ@Ajfb-mjRerc!Zb-Zl@
zf2>P*3+&$wp8A&XYrr3}9EpP95757aez_b2;x+Ki@JIcB-^b2=v>~KReO_ZNA8IDg
z2-s`dK9ha)jnI!iQS|r2;#}~jJ{11v{&Jy(IFE;&p8Kl<`ZMFAe-PuDzxTxBf7}_u
z&lWT0Jn+#s2>%HDO4$F%V}B#`mv_l{NTJ<s0^jwX*jWQRcM&hA&#$+^4zRfo`s2rl
z{%BnIE%?L>h3^1=5_}5w3Hsde68O}S;*aDq<{j`$#|qguUJU&W++8bN`~4H}A7MOq
zirkE#2Rd%IOhEM7kK@5NVVs~_%vA8+(?qX7(=i=<<X?m@hy8_?_x-z$rO*#~TlDSF
zJK*=Eghx?um*o%@1eZX+zFG8JaP0>0`*45JW1xNgFYxiR12(PW|Ciu@JYD$J_Np=e
z8~lB=gWkWt2Oo&>uk+6<;0?!%9T#@~0>1Zr;WZeyAA;}stMDr5%MO-)Ip0(6Q1E|z
zAo>?zXT0UeTo5!tKXR|=v7I!Fz{i1KhdgcI2Yc$31phwzcM<d#fiL(kv3~>jm1-aN
zsf=D@Hi18fc|i5IgTL^p*f|pQx(9q9#)-E7?}(4+H_8M&>*>>04<`zOH(}=zPkX)(
zZf1yw^N?qMI$$p~?;T<JQ1fHxE5=ENV}11Vp^pp_``5$%89w?X^e3$dSf%=N0eJ6B
z;k)crV>bHO*#><Q?RF&e+rfu#5j$^<kqbMCmzP){AM~;RBJ8Z6C3e0C`)`Ba6&1b^
z+>Dm_+>C0o1jU;DiSzt(F2=LY+hf5`jEEh1r@xN}KeJoN%~)vbEw`qN-uV046-7i6
z%VFo{5z;T0LDLSNN(L<X3HVClBl?XogFX9)bC}aQbsFlW>;A>o4l)-6*ZJ_DSw7S}
zgz>5K(*4$c{_o$^{u9ujH9-9T5z2TK{A!G!4d8zP@7^4+q!Rp}mLpLRlv4+By(&EY
zHI_K{*AnbAFGZeXEiW*D=nNm;0y}3+6aRIdJOey}c}Aa)R)TNvjOR7PdHrpLpX$N6
z(Dx1vD6-+j;AJu4Ex5WF{0NNO?}PsYe9mC;b2U2PZt%lB^W<;AzdBRwYy1BJ{Ob3F
zp8)%N!DlTOE_Vk#1JQ$Isrlzf%ZHk@5r1~}6GN5YAMOx4_rrcY_(8jc|D#MU%m%NX
zE_@O6%fXL%NB9)*cFU0{2+oH7CETYgaqUv#rS?S|p`U>JYYFtXgP)L=dJP#Q7w)jU
zpg=?)gZ`*h0ZSUt4$pxP#r{Ow|4-nL%@O^I5n^aBco6%vDX{Z*@Nb|UX!~SepMl@|
zNx-HLhkp22xi9K)|LT5eyycR&@Vy55{sX1H!(nF@cp1i(-tSAn|NO3$tNX(<z#mvC
z{9_d2f*%2X6L=DQM_kIC3%(XS_L<nZ0DK+zqj)}=0Dc|#OaCeQ#o)JtH-VoF-V1)G
z=l*>d{J8$&&rax{1%CkZ!*$@VgU7HR-ZWe;ybnIqb3c|HCjAmdKkip1`f}nGuvr*P
zg8p^PKl^a88vK^c0ZYyXKLLCc){*t#3&9^lJHSnID)^^p|H;tv@2l{<x^r*9k|g-I
ziSs-h@XW&(K|gSUw445Z$2H(vPZK*dz1Y_e!E4YyuY>OdpNIWS8~798Q!rn3fj<ZS
zDaN^u&o{s)B*dRjq5r^gBnpB-<D|Y%V?5~of4JoZLPRI}@ENf4pVtMfavJpW!42AZ
z2l#UE1=#;z1s(=p77JK%3ixX9?yh3~UGPhqgl~s_1Nb)B$$;Mgelf<w9PnGg&&B-t
zE%3X+C!t(jryc=sMEmRbc@g|bw8NvY^BVZwI|G&+g7N=X@PGfM@VCML0lpvByAxq&
z@Zr*5Be9QN4t|*BegFRdNa$a>Q0)I5`mciTcZP7<F4|W!_`K_d{~mlX_-mLS&IWhD
z&-AoI!g7cTg6~4V9{Rz!_I=`ffAxCK0e%eq7~Joz(BJE0|2gPayc@8}bD=k(U^MD<
z#1e5Qoe8EgCX~vgGuig`%8+rKSuKl~It%BY(&9Ljnq8DyFstBFIN@|e6K%n$W4}o3
z1hd_Sz9gKCx*0cISzlK(&F}>$67J?yjgjvnhqJL*kCroM(QI4H+@;MY&v7)x#b`WV
ziv8BIEhQODrQK9zhZ`r4>5Ihek*MqN_l%vW8}G<;lJzA^=d`qZ)0w+$(X5vFix)Xg
zWlddOZC;!R1v9RXuC~tf^n_jdvT`<*F;t2ZiHF^88w*E5nPf1MvWd1xJdrGEq_)1P
z$x5<G`U<s6_A>PSYB!alSh^>k33fY_NO00#pfDMv!g_i_oo=X$aj-3F^U=4X(^0Vz
zcH2diswM^f+zsWTuWBbKq)UjUGl{fWw&<iqi<d8Q7A~IE%=I@>w>#HjJv~l`n{kr#
zCGAKeo901aU3A<KS#pA*keg&z95Tv5%*_NjYzwB@BPZ0!4mxrA!ug7o4#lF0VAyG+
z0pzCg#`tUL7$9kux6@bBqq$l;$wU%bv0>$6L#(>-bT;J{n6=H~B(v#GWTbDSyQz}R
zUsu)8;B%qA&LondMA)UF6N#@1Mk8TI097{~N=1?x{^EUKls0WW85cQuoYSDQHqsfV
zjRs+tvF}cV8Z;8`pw0^=vhj=)YR|?)Y%^`*G^XehjnY+aw4{GEP1OysLxU^qq_b^e
zyX1&&tZuS*9C_knt+tUWNe;%{)uj~;Rn>kMO1EH5!?YTo9Mc+oE>ze0U1;*TP~&H+
z*3T5(+$Gznp~27HMxUBDR@M8MYV`4{v9@$QYOBZ;-FTra{TM{Zv?o$sd{^`E4Rtwg
zESc%?LcT3lM`(I(Pq{8;%(NSA_v-BBk`=CRq?xw3B$-o6tLZ;b@u=<ZNqAU#btDt&
z^eWTARq7+%0Cab+3Z}f8r0aH-ZqE9q#y(=2PCX@aej2_s*Oc_Xp{fq86w0Pj{QDH8
zW%Qfmviv~i=*{fGDVpoT^lKR+=4tX@+^h|?x~PSs2|HT_Qyo4I)Hj+~u*-FzEUjv)
zs`b`CMRP_X<#T^G)KtM!8aLjYJX4k~rk)0}RM2YjQJUgIU6~ZUmCo2Wt=_Cy#Z#P}
zI5{3oB)YOmOXIXC`?P-}t*IqDrjgpE^o0hW8@j2g^vzb&G_7<QwN*4@@ei-i+{<^N
zlj%v)u+_anyAzJAiiDZOvZP5ydrTq~rll+tqc(LqQZ6lzDR-sKl1|$QAP@!a%4{%7
zVVB#JHnel#X<qWva%_`yF_VaAV{No%QBje2HceqNY6BW`W`#pP8pH3|Xp{oleYg~~
z2cxv=uE1<TYb9!u_Gvb19Ua=dCfi!4O(+-B)rj^>X)0|MwaAK9NhjsDhiI{i#EX()
z+7U!z!EP%Frc%KkCrLly!Wkrm{T2gMTCXDsK`N1n)>PY!xL|+#hVv!bR=6SBjleFF
z>Bt(Yb*>!hgK+5z*VQyw9rE!Vn~qXDmK;<K^gp&0lv&_CvhzeE`3q#!Iel1LHq_;2
z(uLOOw|BV3nOlq|&BoK6!IbOcer@eED@Lo>VdQYzP=*2*tZiGb0%#kB)5vVs1W(%G
zTQk?l{@Z~1nnE||`G9_&hciky=hG-Em`u8HpDNYY`Rp8O>wFg0TG}j^?5}#iEkzwI
zTP1TeRQr_CR9AX-sA;OJDs8HXwu<>C$TcoTiZ_jJE^VrjOqF!Ei6-#U7yRnc=(m|_
zs`fF}SnJbPjed>TRO8o((|k-dR8K2ij|N&XN>;FrR{zo${M@Z;@~L25qt8-NU)4xG
z=-9_an&-0dPPe<((9%UStKAbh;RO9SmH$FnM@vd3(dEW@elG1T&1zyQ8lhE!)_{_-
z`Wl}BP+#LS^y{j5^wC2a{h}E8p3KryMz-CCA(~HYBu&qZ>^@CdcJ_4W**fWv8?lmJ
zR5#J{LMivEo2sg~FnU}MQdymms<sHtZPA2;ypCm~Nz+yxracVr1H<XgNPEVt%+k&z
zX3~6drpyuH>Nb;F<wzo)i}A{8B6KYrX>T_(?ajlC+clY3U1zT+tLiFi8tK2UkBa#W
zJp!7xNQVt+@utTw0_0~l9>H^1Hq+kdP+Xp>?6ZF%vehVA<7(Rd$AWf45J@NGnJ=3T
zc2IMs5*_@kPOjQS$faLDYYWj6p*+Mnv`EsEtxSw|5}f_bMa?JApG8eua79j5oUboj
zJhOSBvv}^@Q|7cdEzL6*&f#N~XrwLVgwk2Z{$N`&nCY|+wp=;PuvnY8r2>JkFPuMf
zmQ!6>U0KK7%>$qq@*zbi5f8V~X#w?*<E(18Bd47o*7MSu%33^K+8*F??LzDDb9p>L
zn>jibp-0tx4lXgB2`94j#~6iP<Q=7ADU;z}iX-3oIEg1s9!l~YZ%dLV9y~?Z2Y%UF
z$2&xnre&MTutz59giY`%K~JnL5jA#fha>4AZNXw~v`M4W20B40c8l8~NDGrKf{pU2
zP&{E)rV}Yo4aia^(^H(?W|Of?ZU@69uF^q@?Pl&O-K)@oPi++OG#mRu?(<<=Zc8SQ
zb+&786vBPLH?}sK(;nj%RNFkM@TSr@uKg{(o*p?jvK`Jx1T^wlZs)jMgpOgT?rfIN
zmFTcc+LCr|d|t!Pm~zs>9Y#k#mQsCX)n^H3r>#&bD9xTo($r?pMe_YF)2Iw!qFucE
zvG<LP#b}gvbu<vA=V=tuPBs$FH)t(<;p3blXE=L2L60-mD<>Ta@-ZcEsKpn)^W_>l
z8Hr2W4kvPnQ?|x@i=~389$Rz1HS&#`&%wEKO&xam<dR(G5thn${N)=VueIHhdj`Td
zu+ToLTGy>hvX4Rq9N9K;if!3DLk^8rB(x$<h&m#p=UxRxk~vPXRc>qY)1J-BIcYo3
z3i-yh&T>Dpn(wRJ=%SY3Uy76=%)OHeXOo_cvZKr-xC}c{+1uLT>C&qtJGK>g%j(3^
z9VX_+Xt^ks;YOgjf!yJvOpHV6Tj_k$PS?`K`KY$?5VTSc0174<^1M$$1tW%^fzmpI
zNE_2>W}KdLLONA-6*MkpTX>p|@F}*<O_^v03DZe!yPIe)_RlFeL#I=0a@UT$RAI;R
zElSN8PA8~|;$c3hBe!W@FrlbRj|C~u1jg-`ESQz1;XdK99!f;BvAA*OFQ$H@8{f&M
z?Nfqo(q&I>&-+*|?M*WiJ<d}nIjICa7V%MeJW*T^dHzpl_@O_yFxgX}n4J=e)m%LF
zm3Oq!?twNR+z4{B>R9JVh@d>iI(EIZ!>PD$vhg-LEDaY!?l8_P&(^kcxnB8M%8><y
zo~tp1u)6SOq-yg+v^}Jj+gpXSLZ;(>OC(v5<(-P-+_o+B3EHt;DmL5c>0PHUE*rV%
z*)?o1pB6V>(XBwuO~0&4?Zu0xj8VRg67eXVwbQtv-+;Ay6w>*5%JyiwigaKa<kiW3
za*^nfY7?L}fZx@<f;OTLBxu89tHKk7O!zbcV~JIsO^0UYO$M*_HV=1({RLMxDZOqx
zuq{C!!LVm^dhK@01E}4V(XZM@+Q~6h+Xr1rChZ*~TZUD1{=sJ?e8R+iN2g7gV(196
z)6Ox(<cvfcoSbK&-66maO5$eBPsn!gkXhEEr=k(sKsyUoIZNFRIuCJEv!Xov+g&Ec
zF|Wt=9?I>|VAzfdGKDi8u7<6p8|NiTkC#YLFe2?49krF6dt{yB4OqDN^M*EbitaVg
zGkqp;yMRyup+pkh&E2S7QsfRDLq|LtAj;U5pp8}g>J+V9#pBd*eD{yi7WU{jSLJ*g
z^Km5)XAE>1)kXI<oe@*He6!OavQ2=ok23{w3q7tzXw1=36)bXgoh@=B7rQ)klk6Qb
zG`)rstL=?}k88N&xrO9prf_UA<>d>vI<4AW)T;I~9wYltnojxXzF;@2C$nT!Mw1>V
z>B6h?wG-kKN2iUq*ZF3q0~ZzA-)^QUz0Yc3D`e+xHyPz;JzBB-rUG&UBUVP#{{eIN
Biktud

diff --git a/docs/content/2.download/osx_64/jq b/docs/content/2.download/osx_64/jq
deleted file mode 100755
index c7b521ec27e91c90f110f32dc4b835b45d6cbc57..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 190556
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
E7nNM@YXATM

diff --git a/docs/templates/index.liquid b/docs/templates/index.liquid
index aaff1c9f..7785526c 100644
--- a/docs/templates/index.liquid
+++ b/docs/templates/index.liquid
@@ -16,8 +16,8 @@
                 <span class="caret"></span>
               </a>
               <ul class="dropdown-menu">
-                <li><a href="{{root}}/download/linux_x86_64/jq">Linux (x86_64)</a></li>
-                <li><a href="{{root}}/download/osx_64/jq">OS X (64-bit)</a></li>
+                <li><a href="{{root}}/download/linux64/jq">Linux (64-bit)</a></li>
+                <li><a href="{{root}}/download/osx64/jq">OS X (64-bit)</a></li>
                 <li><a href="{{root}}/download">Other platforms and source</a></li>
               </ul>
             </div>

From c181a9185ae14971ea78393a3552baadb56f1669 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 20 Dec 2012 12:25:50 +0000
Subject: [PATCH 193/284] Add a few lines to the bottom of the manpage.

---
 docs/Rakefile                    |  1 +
 docs/content/3.manual/manual.yml | 11 +++++++++++
 2 files changed, 12 insertions(+)

diff --git a/docs/Rakefile b/docs/Rakefile
index 375ce408..a95c97fa 100644
--- a/docs/Rakefile
+++ b/docs/Rakefile
@@ -90,6 +90,7 @@ task :manpage do
       end
       f.puts ""
     end
+    f.puts manual['manpage_epilogue']
     f.close
     puts Ronn::Document.new(f.path).convert('roff').gsub(/<\/?code>/,"")
   end  
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 5acb212c..cf5de527 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -50,6 +50,17 @@ manpage_intro: |
   document.
 
   ## FILTERS
+
+manpage_epilogue: |
+  ## BUGS
+
+  Presumably. Report them or discuss them at:
+
+      https://github.com/stedolan/jq/issues
+
+  ## AUTHOR
+
+  Stephen Dolan `<mu@netsoc.tcd.ie>`
   
 sections:
   - title: Invoking jq

From a05904b2267d53f9a305d010facd6f307a9d5373 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 20 Dec 2012 12:26:15 +0000
Subject: [PATCH 194/284] Version 1.2!

---
 VERSION       | 2 +-
 docs/site.yml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/VERSION b/VERSION
index 9459d4ba..5625e59d 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-1.1
+1.2
diff --git a/docs/site.yml b/docs/site.yml
index df758cef..863d578d 100644
--- a/docs/site.yml
+++ b/docs/site.yml
@@ -1,7 +1,7 @@
 # The key value pairs found below are available within the templates.
 
 
-jq_version: 1.1
+jq_version: 1.2
 root: '/jq'
 footer: |
   

From 5578ec0f6981e9c01d92f0cda65dfc02605a030c Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 20 Dec 2012 15:12:14 +0000
Subject: [PATCH 195/284] Give Windows builds a proper .exe suffix.

---
 Makefile                            | 15 +++++++++++----
 docs/content/2.download/default.yml |  2 +-
 2 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/Makefile b/Makefile
index 30e6d42d..69e97c71 100644
--- a/Makefile
+++ b/Makefile
@@ -53,12 +53,19 @@ build/osx64%:   CC='i686-apple-darwin10-gcc -m64'
 build/win32%:   CC='i686-w64-mingw32-gcc -m32'   EXTRA_CFLAGS=-DJQ_DEFAULT_ENABLE_COLOR=0
 build/win64%:   CC='x86_64-w64-mingw32-gcc -m64' EXTRA_CFLAGS=-DJQ_DEFAULT_ENABLE_COLOR=0
 
-ALL_BINARIES=$(foreach platform, $(PLATFORMS), $(foreach binary, $(BINARIES), build/$(platform)/$(binary)))
+BIN_SUFFIX_win32 = .exe
+BIN_SUFFIX_win64 = .exe
+
+ALL_BINARIES=\
+  $(foreach platform, $(PLATFORMS), \
+    $(foreach binary, $(BINARIES), \
+      build/$(platform)/$(binary)$(BIN_SUFFIX_$(platform))))
 
 $(ALL_BINARIES): build/%:
 	mkdir -p $(@D)
+	echo $(dir $*)
 	make -B $(BINARIES) CC=$(CC)
-	cp $(BINARIES) $(@D)
+	$(foreach binary, $(BINARIES), cp $(binary) $(@D)/$(binary)$(suffix $*);)
 
 binaries: $(ALL_BINARIES)
 
@@ -97,6 +104,6 @@ docs/output:
 	cd docs; rake build
 
 www_binaries: docs/output binaries
-	$(foreach platform, $(PLATFORMS), $(foreach binary, $(BINARIES), \
+	$(foreach platform, $(PLATFORMS), \
 	  mkdir -p docs/output/download/$(platform); \
-	  cp build/$(platform)/$(binary) docs/output/download/$(platform)/$(binary); ))
+	  cp build/$(platform)/* docs/output/download/$(platform)/; )
diff --git a/docs/content/2.download/default.yml b/docs/content/2.download/default.yml
index f364277b..502ef0b4 100644
--- a/docs/content/2.download/default.yml
+++ b/docs/content/2.download/default.yml
@@ -38,7 +38,7 @@ body:
 
       ### Windows
 
-       * Executables for [64-bit](win64/jq) or [32-bit](win32/jq)
+       * Executables for [64-bit](win64/jq.exe) or [32-bit](win32/jq.exe)
 
       ### From source on Linux or OS X
 

From 0fed03f35a63c01e89c0ba91cfe92dfc226d1e86 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 23 Dec 2012 15:41:20 +0000
Subject: [PATCH 196/284] Fix a bad memory leak when using --raw-output

---
 main.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/main.c b/main.c
index 0ab0f3ca..fd482122 100644
--- a/main.c
+++ b/main.c
@@ -68,6 +68,7 @@ static void process(jv value) {
   while (jv_is_valid(result = jq_next())) {
     if ((options & RAW_OUTPUT) && jv_get_kind(result) == JV_KIND_STRING) {
       fwrite(jv_string_value(result), 1, jv_string_length(jv_copy(result)), stdout);
+      jv_free(result);
     } else {
       int dumpopts;
 #ifdef JQ_DEFAULT_ENABLE_COLOR

From cedda2084d2f6b331ba0a73e05f0b77ee7995c86 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 24 Dec 2012 17:11:18 +0000
Subject: [PATCH 197/284] Sneaky valgrind trick to detect stack memory issues.

After something is popped from a stack, we overwrite the memory
with uninitialised data (if JQ_DEBUG is on). This means that
valgrind reports use-after-pop as an uninitialised memory error.
---
 forkable_stack.h | 13 +++++++++++--
 jv_alloc.c       |  9 +++++++++
 jv_alloc.h       | 11 +++++++++++
 3 files changed, 31 insertions(+), 2 deletions(-)

diff --git a/forkable_stack.h b/forkable_stack.h
index c96c132e..74fcf433 100644
--- a/forkable_stack.h
+++ b/forkable_stack.h
@@ -100,13 +100,22 @@ static void* forkable_stack_peek_next(struct forkable_stack* s, void* top) {
 // Returns 1 if the next forkable_stack_pop will permanently remove an
 // object from the stack (i.e. the top object was not saved with a fork)
 static int forkable_stack_pop_will_free(struct forkable_stack* s) {
-  return s->pos < s->savedlimit ? 1 : 0;
+  return s->pos < s->savedlimit;
 }
 
 static void forkable_stack_pop(struct forkable_stack* s) {
   forkable_stack_check(s);
   struct forkable_stack_header* elem = forkable_stack_peek(s);
-  s->pos += elem->next_delta;
+  int reclaim_upto = s->pos + elem->next_delta < s->savedlimit ? 
+    s->pos + elem->next_delta : s->savedlimit;
+  assert(reclaim_upto <= s->length);
+  int reclaimed = reclaim_upto > s->pos ? reclaim_upto - s->pos : 0;
+  assert(0 <= reclaimed && s->pos + reclaimed <= s->length);
+  // s->pos <= i < reclaim_upto means that position i is to be freed
+  assert((reclaimed > 0) == forkable_stack_pop_will_free(s));
+  int new_pos = s->pos + elem->next_delta;
+  jv_mem_invalidate(elem, reclaimed);
+  s->pos = new_pos;
 }
 
 
diff --git a/jv_alloc.c b/jv_alloc.c
index 320f16e1..e127029d 100644
--- a/jv_alloc.c
+++ b/jv_alloc.c
@@ -26,3 +26,12 @@ void* jv_mem_realloc(void* p, size_t sz) {
   }
   return p;
 }
+
+#if JQ_DEBUG
+volatile char jv_mem_uninitialised;
+__attribute__((constructor)) void jv_mem_uninit_setup(){
+  char* p = malloc(1);
+  jv_mem_uninitialised = *p;
+  free(p);
+}
+#endif
diff --git a/jv_alloc.h b/jv_alloc.h
index 0613d587..b4e72c0d 100644
--- a/jv_alloc.h
+++ b/jv_alloc.h
@@ -3,6 +3,17 @@
 
 #include <stddef.h>
 
+#if JQ_DEBUG
+extern volatile char jv_mem_uninitialised;
+#endif
+
+static void jv_mem_invalidate(void* mem, size_t n) {
+#if JQ_DEBUG
+  char* m = mem;
+  while (n--) *m++ ^= jv_mem_uninitialised ^ jv_mem_uninitialised;
+#endif
+}
+
 void* jv_mem_alloc(size_t);
 void jv_mem_free(void*);
 __attribute__((warn_unused_result)) void* jv_mem_realloc(void*, size_t);

From d327772dfc78ad49f46fbf583418e33abc0b59d2 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 27 Dec 2012 01:56:23 +0000
Subject: [PATCH 198/284] JSON parsing error messages now specify a location of
 the error.

Should help with #53.
---
 jv_parse.c | 9 ++++++++-
 jv_parse.h | 2 ++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/jv_parse.c b/jv_parse.c
index 0d4f1549..f55c17e5 100644
--- a/jv_parse.c
+++ b/jv_parse.c
@@ -26,6 +26,8 @@ void jv_parser_init(struct jv_parser* p) {
   p->curr_buf = 0;
   p->curr_buf_length = p->curr_buf_pos = p->curr_buf_is_partial = 0;
   p->bom_strip_position = 0;
+  p->line = 1;
+  p->column = 0;
   jvp_dtoa_context_init(&p->dtoa);
 }
 
@@ -294,6 +296,11 @@ static int check_done(struct jv_parser* p, jv* out) {
 }
 
 static pfunc scan(struct jv_parser* p, char ch, jv* out) {
+  p->column++;
+  if (ch == '\n') {
+    p->line++;
+    p->column = 0;
+  }
   presult answer = 0;
   if (p->st == JV_PARSER_NORMAL) {
     chclass cls = classify(ch);
@@ -373,7 +380,7 @@ jv jv_parser_next(struct jv_parser* p) {
   if (msg == OK) {
     return value;
   } else if (msg) {
-    return jv_invalid_with_msg(jv_string(msg));
+    return jv_invalid_with_msg(jv_string_fmt("%s at line %d, column %d", msg, p->line, p->column));
   } else if (p->curr_buf_is_partial) {
     assert(p->curr_buf_pos == p->curr_buf_length);
     // need another buffer
diff --git a/jv_parse.h b/jv_parse.h
index 5958316a..1d538c12 100644
--- a/jv_parse.h
+++ b/jv_parse.h
@@ -16,6 +16,8 @@ struct jv_parser {
   char* tokenbuf;
   int tokenpos;
   int tokenlen;
+
+  int line, column;
   
   struct dtoa_context dtoa;
 

From 52db8000c6e0564e92fdba72687e338dc603e02d Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 27 Dec 2012 01:57:09 +0000
Subject: [PATCH 199/284] Fix an embarassing I/O bug.

Pulling some I/O out to a function meant that buf changed from
"char buf[4096]" to "char* buf", and "sizeof(buf)" got a lot
less interesting. The upshot of this is that jq read input eight
bytes at a time, which is not the fastest.
---
 main.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/main.c b/main.c
index fd482122..e18f6fdd 100644
--- a/main.c
+++ b/main.c
@@ -135,7 +135,7 @@ static int read_more(char* buf, size_t size) {
     next_input_idx++;
   }
 
-  if (!fgets(buf, sizeof(buf), current_input)) buf[0] = 0;
+  if (!fgets(buf, size, current_input)) buf[0] = 0;
   return 1;
 }
 

From 89e26969ae5bc7a259c1bd150f4d58c67800424b Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 27 Dec 2012 20:49:34 +0000
Subject: [PATCH 200/284] @foo syntax for encoding of strings into various
 formats.

Fixes part of #47 and #48.
---
 builtin.c                        | 171 +++++++++++++++++++++++++++++++
 docs/content/3.manual/manual.yml | 141 ++++++++++++++++++-------
 lexer.l                          |   3 +
 parser.y                         |  20 +++-
 testdata                         |  14 +++
 5 files changed, 307 insertions(+), 42 deletions(-)

diff --git a/builtin.c b/builtin.c
index 4f9fab59..c431be07 100644
--- a/builtin.c
+++ b/builtin.c
@@ -5,6 +5,8 @@
 #include "parser.h"
 #include "locfile.h"
 #include "jv_aux.h"
+#include "jv_unicode.h"
+
 
 
 typedef jv (*func_1)(jv);
@@ -207,6 +209,174 @@ static jv f_tostring(jv input) {
   }
 }
 
+#define CHARS_ALPHANUM "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
+
+static jv escape_string(jv input, const char* escapings) {
+
+  assert(jv_get_kind(input) == JV_KIND_STRING);
+  const char* lookup[128] = {0};
+  const char* p = escapings;
+  while (*p) {
+    lookup[(int)*p] = p+1;
+    p++;
+    p += strlen(p);
+    p++;
+  }
+
+  jv ret = jv_string("");
+  const char* i = jv_string_value(input);
+  const char* end = i + jv_string_length(jv_copy(input));
+  const char* cstart;
+  int c = 0;
+  while ((i = jvp_utf8_next((cstart = i), end, &c))) {
+    assert(c != -1);
+    if (c < 128 && lookup[c]) {
+      ret = jv_string_append_str(ret, lookup[c]);
+    } else {
+      ret = jv_string_append_buf(ret, cstart, i - cstart);
+    }
+  }
+  jv_free(input);
+  return ret;
+
+}
+
+static jv f_format(jv input, jv fmt) {
+  if (jv_get_kind(fmt) != JV_KIND_STRING) {
+    jv_free(input);
+    return type_error(fmt, "is not a valid format");
+  }
+  const char* fmt_s = jv_string_value(fmt);
+  if (!strcmp(fmt_s, "json")) {
+    jv_free(fmt);
+    return jv_dump_string(input, 0);
+  } else if (!strcmp(fmt_s, "text")) {
+    jv_free(fmt);
+    return f_tostring(input);
+  } else if (!strcmp(fmt_s, "csv")) {
+    jv_free(fmt);
+    if (jv_get_kind(input) != JV_KIND_ARRAY)
+      return type_error(input, "cannot be csv-formatted, only array");
+    jv line = jv_string("");
+    for (int i=0; i<jv_array_length(jv_copy(input)); i++) {
+      if (i) line = jv_string_append_str(line, ",");
+      jv x = jv_array_get(jv_copy(input), i);
+      switch (jv_get_kind(x)) {
+      case JV_KIND_NULL:
+        /* null rendered as empty string */
+        jv_free(x);
+        break;
+      case JV_KIND_TRUE:
+      case JV_KIND_FALSE:
+        line = jv_string_concat(line, jv_dump_string(x, 0));
+        break;
+      case JV_KIND_NUMBER:
+        if (jv_number_value(x) != jv_number_value(x)) {
+          /* NaN, render as empty string */
+          jv_free(x);
+        } else {
+          line = jv_string_concat(line, jv_dump_string(x, 0));
+        }
+        break;
+      case JV_KIND_STRING: {
+        line = jv_string_append_str(line, "\"");
+        line = jv_string_concat(line, escape_string(x, "\"\"\"\0"));
+        line = jv_string_append_str(line, "\"");
+        break;
+      }
+      default:
+        jv_free(input);
+        jv_free(line);
+        return type_error(x, "is not valid in a csv row");
+      }
+    }
+    jv_free(input);
+    return line;
+  } else if (!strcmp(fmt_s, "html")) {
+    jv_free(fmt);
+    return escape_string(f_tostring(input), "&&amp;\0<&lt;\0>&gt;\0'&apos;\0\"&quot;\0");
+  } else if (!strcmp(fmt_s, "uri")) {
+    jv_free(fmt);
+    input = f_tostring(input);
+
+    int unreserved[128] = {0};
+    const char* p = CHARS_ALPHANUM "-_.!~*'()";
+    while (*p) unreserved[(int)*p++] = 1;
+
+    jv line = jv_string("");
+    const char* s = jv_string_value(input);
+    for (int i=0; i<jv_string_length(jv_copy(input)); i++) {
+      unsigned ch = (unsigned)*s;
+      if (ch < 128 && unreserved[ch]) {
+        line = jv_string_append_buf(line, s, 1);
+      } else {
+        line = jv_string_concat(line, jv_string_fmt("%%%02x", ch));
+      }
+      s++;
+    }
+    jv_free(input);
+    return line;
+  } else if (!strcmp(fmt_s, "sh")) {
+    jv_free(fmt);
+    if (jv_get_kind(input) != JV_KIND_ARRAY)
+      input = jv_array_set(jv_array(), 0, input);
+    jv line = jv_string("");
+    for (int i=0; i<jv_array_length(jv_copy(input)); i++) {
+      if (i) line = jv_string_append_str(line, " ");
+      jv x = jv_array_get(jv_copy(input), i);
+      switch (jv_get_kind(x)) {
+      case JV_KIND_NULL:
+      case JV_KIND_TRUE:
+      case JV_KIND_FALSE:
+      case JV_KIND_NUMBER:
+        line = jv_string_concat(line, jv_dump_string(x, 0));
+        break;
+
+      case JV_KIND_STRING: {
+        line = jv_string_append_str(line, "'");
+        line = jv_string_concat(line, escape_string(x, "''\\''\0"));
+        line = jv_string_append_str(line, "'");
+        break;
+      }
+
+      default:
+        jv_free(input);
+        jv_free(line);
+        return type_error(x, "can not be escaped for shell");
+      }
+    }
+    jv_free(input);
+    return line;
+  } else if (!strcmp(fmt_s, "base64")) {
+    jv_free(fmt);
+    input = f_tostring(input);
+    jv line = jv_string("");
+    const char b64[64 + 1] = CHARS_ALPHANUM "+/";
+    const char* data = jv_string_value(input);
+    int len = jv_string_length(jv_copy(input));
+    for (int i=0; i<len; i+=3) {
+      uint32_t code = 0;
+      int n = len - i >= 3 ? 3 : len-i;
+      for (int j=0; j<3; j++) {
+        code <<= 8;
+        code |= j < n ? (unsigned)data[i+j] : 0;
+      }
+      char buf[4];
+      for (int j=0; j<4; j++) {
+        buf[j] = b64[(code >> (18 - j*6)) & 0x3f];
+      }
+      if (n < 3) buf[3] = '=';
+      if (n < 2) buf[2] = '=';
+      line = jv_string_append_buf(line, buf, sizeof(buf));
+    }
+    jv_free(input);
+    return line;
+  } else {
+    jv_free(input);
+    return jv_invalid_with_msg(jv_string_concat(fmt, jv_string(" is not a valid format")));
+  }
+}
+
 static jv f_keys(jv input) {
   if (jv_get_kind(input) == JV_KIND_OBJECT || jv_get_kind(input) == JV_KIND_ARRAY) {
     return jv_keys(input);
@@ -332,6 +502,7 @@ static struct cfunction function_list[] = {
   {(cfunction_ptr)f_min_by_impl, "_min_by_impl", 2},
   {(cfunction_ptr)f_max_by_impl, "_max_by_impl", 2},
   {(cfunction_ptr)f_error, "error", 2},
+  {(cfunction_ptr)f_format, "format", 2},
 };
 
 static struct symbol_table cbuiltins = 
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index cf5de527..55f43a00 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -75,51 +75,51 @@ sections:
       You can affect how jq reads and writes its input and output
       using some command-line options:
 
-        * `--slurp`/`-s`:
+      * `--slurp`/`-s`:
   
-          Instead of running the filter for each JSON object in the
-          input, read the entire input stream into a large array and run
-          the filter just once.
-        
-        * `--raw-input`/`-R`:
-        
-          Don't parse the input as JSON. Instead, each line of text is
-          passed to the filter as a string. If combined with `--slurp`,
-          then the entire input is passed to the filter as a single long
-          string.
+        Instead of running the filter for each JSON object in the
+        input, read the entire input stream into a large array and run
+        the filter just once.
+      
+      * `--raw-input`/`-R`:
+      
+        Don't parse the input as JSON. Instead, each line of text is
+        passed to the filter as a string. If combined with `--slurp`,
+        then the entire input is passed to the filter as a single long
+        string.
   
-        * `--null-input`/`-n`:
+      * `--null-input`/`-n`:
   
-          Don't read any input at all! Instead, the filter is run once
-          using `null` as the input. This is useful when using jq as a
-          simple calculator or to construct JSON data from scratch.
+        Don't read any input at all! Instead, the filter is run once
+        using `null` as the input. This is useful when using jq as a
+        simple calculator or to construct JSON data from scratch.
   
-        * `--compact-output` / `-c`:
+      * `--compact-output` / `-c`:
   
-          By default, jq pretty-prints JSON output. Using this option
-          will result in more compact output by instead putting each
-          JSON object on a single line.
+        By default, jq pretty-prints JSON output. Using this option
+        will result in more compact output by instead putting each
+        JSON object on a single line.
   
-        * `--colour-output` / `-C` and `--monochrome-output` / `-M`:
-        
-          By default, jq outputs colored JSON if writing to a
-          terminal. You can force it to produce color even if writing to
-          a pipe or a file using `-C`, and disable color with `-M`.
+      * `--colour-output` / `-C` and `--monochrome-output` / `-M`:
+      
+        By default, jq outputs colored JSON if writing to a
+        terminal. You can force it to produce color even if writing to
+        a pipe or a file using `-C`, and disable color with `-M`.
   
-        * `--ascii-output` / `-a`:
+      * `--ascii-output` / `-a`:
   
-          jq usually outputs non-ASCII Unicode codepoints as UTF-8, even
-          if the input specified them as escape sequences (like
-          "\u03bc"). Using this option, you can force jq to produce pure
-          ASCII output with every non-ASCII character replaced with the
-          equivalent escape sequence.
+        jq usually outputs non-ASCII Unicode codepoints as UTF-8, even
+        if the input specified them as escape sequences (like
+        "\u03bc"). Using this option, you can force jq to produce pure
+        ASCII output with every non-ASCII character replaced with the
+        equivalent escape sequence.
   
-        * `--raw-output` / `-r`:
+      * `--raw-output` / `-r`:
   
-          With this option, if the filter's result is a string then it
-          will be written directly to standard output rather than being
-          formatted as a JSON string with quotes. This can be useful for
-          making jq filters talk to non-JSON-based systems.
+        With this option, if the filter's result is a string then it
+        will be written directly to standard output rather than being
+        formatted as a JSON string with quotes. This can be useful for
+        making jq filters talk to non-JSON-based systems.
 
   - title: Basic filters
     entries:
@@ -646,10 +646,77 @@ sections:
             input: '42'
             output: ['"The input was 42, which is one less than 43"']
           
-              
+      - title: "Format strings and escaping"
+        body: |
 
-              
+          The `@foo` syntax is used to format and escape strings,
+          which is useful for building URLs, documents in a language
+          like HTML or XML, and so forth. `@foo` can be used as a
+          filter on its own, the possible escapings are:
 
+          * `@text`:
+
+            Calls `tostring`, see that function for details.
+
+          * `@json`:
+
+            Serialises the input as JSON.
+
+          * `@html`:
+
+            Applies HTML/XML escaping, by mapping the characters
+            `<>&'"` to their entity equivalents `&lt;`, `&gt;`,
+            `&amp;`, `&apos;`, `&quot;`.
+
+          * `@uri`:
+
+            Applies percent-encoding, by mapping all reserved URI
+            characters to a `%xx` sequence.
+
+          * `@csv`:
+            
+            The input must be an array, and it is rendered as CSV
+            with double quotes for strings, and quotes escaped by
+            repetition.
+
+          * `@sh`:
+            
+            The input is escaped suitable for use in a command-line
+            for a POSIX shell. If the input is an array, the output
+            will be a series of space-separated strings.
+            
+          * `@base64`:
+
+            The input is converted to base64 as specified by RFC 4648.
+
+          This syntax can be combined with string interpolation in a
+          useful way. You can follow a `@foo` token with a string
+          literal. The contents of the string literal will *not* be
+          escaped. However, all interpolations made inside that string
+          literal will be escaped. For instance,
+
+              @uri "http://www.google.com/search?q=\(.search)"
+
+          will produce the following output for the input
+          `{"search":"jq!"}`:
+
+              http://www.google.com/search?q=jq%21
+
+          Note that the slashes, question mark, etc. in the URL are
+          not escaped, as they were part of the string literal.
+
+        examples:
+          - program: '@html'
+            input: '"This works if x < y"'
+            output: ['"This works if x &lt; y"']
+
+#          - program: '@html "<span>Anonymous said: \(.)</span>"'
+#            input: '"<script>alert(\"lol hax\");</script>"'
+#            output: ["<span>Anonymous said: &lt;script&gt;alert(&quot;lol hax&quot;);&lt;/script&gt;</span>"]
+
+          - program: '@sh "echo \(.)"'
+            input: "\"O'Hara's Ale\""
+            output: ["\"echo 'O'\\''Hara'\\''s Ale\""]
         
   - title: Conditionals and Comparisons
     entries:
diff --git a/lexer.l b/lexer.l
index 7090de31..12851de8 100644
--- a/lexer.l
+++ b/lexer.l
@@ -68,6 +68,9 @@ struct lexer_param;
   return try_exit(yytext[0], YY_START, yyscanner);
 }
 
+"@"[a-zA-Z0-9_]+ {
+  yylval->literal = jv_string_sized(yytext + 1, yyleng - 1); return FORMAT;
+}
 
 -?[0-9.]+([eE][+-]?[0-9]+)? { 
    yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; 
diff --git a/parser.y b/parser.y
index 807db704..397982d6 100644
--- a/parser.y
+++ b/parser.y
@@ -48,6 +48,7 @@ struct lexer_param;
 %token INVALID_CHARACTER
 %token <literal> IDENT
 %token <literal> LITERAL
+%token <literal> FORMAT
 %token EQ "=="
 %token NEQ "!="
 %token DEFINEDOR "//"
@@ -158,8 +159,8 @@ static block gen_binop(block a, block b, int op) {
   return gen_call(funcname, BLOCK(gen_lambda(a), gen_lambda(b)));
 }
 
-static block gen_format(block a) {
-  return BLOCK(a, gen_call("tostring", gen_noop()));
+static block gen_format(block a, jv fmt) {
+  return BLOCK(a, gen_call("format", BLOCK(gen_lambda(gen_const(fmt)))));
 }
  
 static block gen_update(block a, block op, int optype) {
@@ -316,10 +317,16 @@ FuncDef:
 
 
 String:
-QQSTRING_START QQString QQSTRING_END {
-  $$ = $2;
+QQSTRING_START { $<literal>$ = jv_string("text"); } QQString QQSTRING_END {
+  $$ = $3;
+  jv_free($<literal>2);
+} |
+FORMAT QQSTRING_START { $<literal>$ = $1; } QQString QQSTRING_END {
+  $$ = $4;
+  jv_free($<literal>3);
 }
 
+
 QQString:
 /* empty */ {
   $$ = gen_const(jv_string(""));
@@ -328,7 +335,7 @@ QQString QQSTRING_TEXT {
   $$ = gen_binop($1, gen_const($2), '+');
 } |
 QQString QQSTRING_INTERP_START Exp QQSTRING_INTERP_END {
-  $$ = gen_binop($1, gen_format($3), '+');
+  $$ = gen_binop($1, gen_format($3, jv_copy($<literal>0)), '+');
 }
 
 
@@ -373,6 +380,9 @@ LITERAL {
 String {
   $$ = $1;
 } |
+FORMAT {
+  $$ = gen_format(gen_noop(), $1);
+} |
 '(' Exp ')' { 
   $$ = $2; 
 } | 
diff --git a/testdata b/testdata
index a1c72f0d..c3352af4 100644
--- a/testdata
+++ b/testdata
@@ -52,6 +52,20 @@ null
 null
 "interpolation"
 
+@text,@json,([1,.] | @csv),@html,@uri,@sh,@base64
+"<>&'\""
+"<>&'\""
+"\"<>&'\\\"\""
+"1,\"<>&'\"\"\""
+"&lt;&gt;&amp;&apos;&quot;"
+"%3c%3e%26'%22"
+"'<>&'\\''\"'"
+"PD4mJyI="
+
+@html "<b>\(.)</b>"
+"<script>hax</script>"
+"<b>&lt;script&gt;hax&lt;/script&gt;</b>"
+
 #
 # Dictionary construction syntax
 #

From 9302b16247eb124c23cc7cf091822afc503105d3 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Fri, 28 Dec 2012 14:21:28 +0000
Subject: [PATCH 201/284] Docs typos.

---
 docs/content/3.manual/manual.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 55f43a00..fd91ef13 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -748,8 +748,8 @@ sections:
           means that you'll sometimes have to be more explicit about
           the condition you want: you can't test whether, e.g. a
           string is empty using `if .name then A else B end`, you'll
-          need something more like 'if (.name | count) > 0 then A else
-          B end' instead.
+          need something more like `if (.name | count) > 0 then A else
+          B end` instead.
           
           If the condition A produces multiple results, it is
           considered "true" if any of those results is not false or
@@ -872,8 +872,8 @@ sections:
           For instance, calculating the average value of an array of numbers
           requires a few variables in most languages - at least one to hold the
           array, perhaps one for each element or for a loop counter. In jq, it's
-          simply `add / length` - the `sum` expression is given the array and
-          produces its sum, and the `count` expression is given the array and
+          simply `add / length` - the `add` expression is given the array and
+          produces its sum, and the `length` expression is given the array and
           produces its length.
           
           So, there's generally a cleaner way to solve most problems in jq that

From 417899f9a02f8957e30fc6252cf0e02b713c4c4a Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Fri, 28 Dec 2012 15:04:16 +0000
Subject: [PATCH 202/284] Fold operation (code/docs/test)

---
 compile.c                        | 11 +++++++++
 compile.h                        |  1 +
 docs/content/3.manual/manual.yml | 39 +++++++++++++++++++++++++++++++-
 lexer.l                          |  1 +
 parser.y                         |  6 +++++
 testdata                         |  4 ++++
 6 files changed, 61 insertions(+), 1 deletion(-)

diff --git a/compile.c b/compile.c
index 139b64bc..178b0463 100644
--- a/compile.c
+++ b/compile.c
@@ -306,6 +306,17 @@ block gen_collect(block expr) {
                gen_op_var_bound(LOADV, array_var));
 }
 
+block gen_fold(const char* varname, block init, block fold) {
+  block loop = BLOCK(fold, gen_op_var_unbound(STOREV, varname), gen_op_simple(BACKTRACK));
+  return BLOCK(gen_op_simple(DUP),
+               init,
+               block_bind(gen_op_var_unbound(STOREV, varname),
+                          BLOCK(gen_op_target(FORK, loop),
+                                loop,
+                                gen_op_var_unbound(LOADV, varname)),
+                          OP_HAS_VARIABLE));
+}
+
 block gen_assign(block expr) {
   block result_var = block_bind(gen_op_var_unbound(STOREV, "result"),
                                 gen_noop(), OP_HAS_VARIABLE);
diff --git a/compile.h b/compile.h
index e74afce4..ce1b3089 100644
--- a/compile.h
+++ b/compile.h
@@ -33,6 +33,7 @@ block gen_call(const char* name, block body);
 block gen_subexp(block a);
 block gen_both(block a, block b);
 block gen_collect(block expr);
+block gen_fold(const char* varname, block init, block body);
 block gen_assign(block expr);
 block gen_definedor(block a, block b);
 block gen_condbranch(block iftrue, block iffalse);
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index fd91ef13..1de1a387 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -841,7 +841,7 @@ sections:
             input: '{}'
             output: [42]
           
-  - title: Variables and Functions
+  - title: Advanced features
     body: |
       Variables are an absolute necessity in most programming languages, but
       they're relegated to an "advanced feature" in jq.
@@ -858,6 +858,10 @@ sections:
       (many jq functions such as `map` and `find` are in fact written
       in jq).
 
+      Finally, jq has a `fold` operation, which is very powerful but a
+      bit tricky. Again, it's mostly used internally, to define some
+      useful bits of jq's standard library.
+
     entries:
       - title: Variables
         body: |
@@ -962,6 +966,39 @@ sections:
           - program: 'def addvalue(f): f as $x | map(. + $x); addvalue(.[0])'
             input: '[[1,2],[10,20]]'
             output: ['[[1,2,1,2], [10,20,1,2]]']
+
+      - title: Fold
+        body: |
+        
+          The `fold` syntax in jq allows you to combine all of the
+          results of an expression by accumulating them into a single
+          answer. As an example, we'll pass `[3,2,1]` to this expression:
+
+              fold 0 as $sum (.[] | $sum + .)
+          
+          The variable `$sum` is first given the value `0`. The body
+          of the fold (i.e. `.[] | $sum + .`) is evaluated. `.[]`
+          produces three results, `3`, `2`, and `1`. For the first
+          one, `$sum + .` gives `3`.
+
+          Having produced this answer, jq backtracks to find the next
+          result as per usual. However, this time, `$sum` is set to
+          the previous value of the body, so `$sum + .` gives
+          `5`. After the final backtracking, `$sum + .` gives
+          `6`. This final value is used as the value of the entire
+          `fold` expression, so the above filter returns `6`.
+
+          More formally, in order to evaluate `fold INIT as $VAR
+          (BODY)`, jq first sets `$VAR` to the value of `INIT`. It
+          then runs through `BODY`. Each time `BODY` produces a value,
+          `$VAR` is set to that value and jq backtracks to find the
+          next one. When `BODY` stops producing values, the final
+          value of `$VAR` is the result of the entire expression.
+
+        examples:
+          - program: 'fold 0 as $sum (.[] | $sum + .)'
+            input: '[10,2,5,3]'
+            output: ['20']
       
 
   - title: Assignment
diff --git a/lexer.l b/lexer.l
index 12851de8..fd0e120e 100644
--- a/lexer.l
+++ b/lexer.l
@@ -49,6 +49,7 @@ struct lexer_param;
 "and" { return AND; }
 "or" { return OR; }
 "end" { return END; }
+"fold" { return FOLD; }
 "//" { return DEFINEDOR; }
 "|=" { return SETPIPE; }
 "+=" { return SETPLUS; }
diff --git a/parser.y b/parser.y
index 397982d6..5cc2640f 100644
--- a/parser.y
+++ b/parser.y
@@ -58,6 +58,7 @@ struct lexer_param;
 %token THEN "then"
 %token ELSE "else"
 %token ELSE_IF "elif"
+%token FOLD "fold"
 %token END "end"
 %token AND "and"
 %token OR "or"
@@ -201,6 +202,11 @@ Term "as" '$' IDENT '|' Exp {
   jv_free($4);
 } |
 
+"fold" Term "as" '$' IDENT '(' Exp ')' {
+  $$ = gen_fold(jv_string_value($5), $2, $7);
+  jv_free($5);
+} |
+
 "if" Exp "then" Exp ElseBody {
   $$ = gen_cond($2, $4, $5);
 } |
diff --git a/testdata b/testdata
index c3352af4..bb8e677a 100644
--- a/testdata
+++ b/testdata
@@ -331,6 +331,10 @@ def fac: if . == 1 then 1 else . * (. - 1 | fac) end; [.[] | fac]
 # []
 # 1001
 
+fold 0 as $s (.[] | $s + .)
+[1,2,4]
+7
+
 #
 # Assignment
 #

From f1e23448e789983f8581f291e56a37c3c63e7dbf Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Fri, 28 Dec 2012 15:07:27 +0000
Subject: [PATCH 203/284] Support for two-argument functions.

Should probably support n args instead. This is a quick hack.
Also, ';' is a slightly ugly argument separator.
---
 parser.y | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/parser.y b/parser.y
index 5cc2640f..2b9732c0 100644
--- a/parser.y
+++ b/parser.y
@@ -319,9 +319,20 @@ FuncDef:
                     $7);
   jv_free($2);
   jv_free($4);
+} |
+
+"def" IDENT '(' IDENT ';' IDENT ')' ':' Exp ';' {
+  $$ = gen_function(jv_string_value($2), 
+                    BLOCK(gen_op_block_unbound(CLOSURE_PARAM, jv_string_value($4)), 
+                          gen_op_block_unbound(CLOSURE_PARAM, jv_string_value($6))),
+                    $9);
+  jv_free($2);
+  jv_free($4);
+  jv_free($6);
 }
 
 
+
 String:
 QQSTRING_START { $<literal>$ = jv_string("text"); } QQString QQSTRING_END {
   $$ = $3;
@@ -414,6 +425,11 @@ IDENT '(' Exp ')' {
   $$ = gen_location(@1, $$);
   jv_free($1);
 } |
+IDENT '(' Exp ';' Exp ')' {
+  $$ = gen_call(jv_string_value($1), BLOCK(gen_lambda($3), gen_lambda($5)));
+  $$ = gen_location(@1, $$);
+  jv_free($1);
+} |
 '(' error ')' { $$ = gen_noop(); } |
 '[' error ']' { $$ = gen_noop(); } |
 Term '[' error ']' { $$ = $1; } |

From 79c9c418c6c6312c550b9253b62701f3f788dfa2 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Fri, 28 Dec 2012 16:08:29 +0000
Subject: [PATCH 204/284] Path manipulation (path/getpath/setpath/delpath) and
 docs.

del function should fix #37.
---
 builtin.c     |  42 +++++++++++++++------
 execute.c     |  23 +++++++++++-
 jv.c          |   3 +-
 jv_aux.c      | 102 +++++++++++++++++++++++++++++++++++++++++++++++---
 jv_aux.h      |   8 ++--
 opcode_list.h |   1 +
 testdata      |  44 ++++++++++++++++++++++
 7 files changed, 198 insertions(+), 25 deletions(-)

diff --git a/builtin.c b/builtin.c
index c431be07..de40be7e 100644
--- a/builtin.c
+++ b/builtin.c
@@ -484,6 +484,9 @@ static struct cfunction function_list[] = {
   {(cfunction_ptr)f_tonumber, "tonumber", 1},
   {(cfunction_ptr)f_tostring, "tostring", 1},
   {(cfunction_ptr)f_keys, "keys", 1},
+  {(cfunction_ptr)jv_setpath, "setpath", 3}, // FIXME typechecking
+  {(cfunction_ptr)jv_getpath, "getpath", 2},
+  {(cfunction_ptr)jv_delpath, "delpath", 2},
   {(cfunction_ptr)f_equal, "_equal", 3},
   {(cfunction_ptr)f_notequal, "_notequal", 3},
   {(cfunction_ptr)f_less, "_less", 3},
@@ -508,22 +511,36 @@ static struct cfunction function_list[] = {
 static struct symbol_table cbuiltins = 
   {function_list, sizeof(function_list)/sizeof(function_list[0])};
 
-typedef block (*bytecoded_builtin)();
 struct bytecoded_builtin { const char* name; block code; };
 static block bind_bytecoded_builtins(block b) {
-  struct bytecoded_builtin builtin_defs[] = {
-    {"empty", gen_op_simple(BACKTRACK)},
-    {"false", gen_const(jv_false())},
-    {"true", gen_const(jv_true())},
-    {"null", gen_const(jv_null())},
-    {"not", gen_condbranch(gen_const(jv_false()),
-                           gen_const(jv_true()))}
-  };
   block builtins = gen_noop();
-  for (unsigned i=0; i<sizeof(builtin_defs)/sizeof(builtin_defs[0]); i++) {
-    builtins = BLOCK(builtins, gen_function(builtin_defs[i].name, gen_noop(),
-                                            builtin_defs[i].code));
+  {
+    struct bytecoded_builtin builtin_defs[] = {
+      {"empty", gen_op_simple(BACKTRACK)},
+      {"false", gen_const(jv_false())},
+      {"true", gen_const(jv_true())},
+      {"null", gen_const(jv_null())},
+      {"not", gen_condbranch(gen_const(jv_false()),
+                             gen_const(jv_true()))}
+    };
+    for (unsigned i=0; i<sizeof(builtin_defs)/sizeof(builtin_defs[0]); i++) {
+      builtins = BLOCK(builtins, gen_function(builtin_defs[i].name, gen_noop(),
+                                              builtin_defs[i].code));
+    }
   }
+  {
+    struct bytecoded_builtin builtin_def_1arg[] = {
+      {"path", BLOCK(gen_op_simple(DUP), 
+                     gen_call("arg", gen_noop()),
+                     gen_op_simple(GETPATH))},
+    };
+    for (unsigned i=0; i<sizeof(builtin_def_1arg)/sizeof(builtin_def_1arg[0]); i++) {
+      builtins = BLOCK(builtins, gen_function(builtin_def_1arg[i].name,
+                                              gen_op_block_unbound(CLOSURE_PARAM, "arg"),
+                                              builtin_def_1arg[i].code));
+    }
+  }
+  
   return block_bind(builtins, b, OP_IS_CALL_PSEUDO);
 }
 
@@ -535,6 +552,7 @@ static const char* jq_builtins[] = {
   "def unique: group_by(.) | map(.[0]);",
   "def max_by(f): _max_by_impl(map([f]));",
   "def min_by(f): _min_by_impl(map([f]));",
+  "def del(f): delpath(path(f));",
 };
 
 
diff --git a/execute.c b/execute.c
index 6d0bf727..ed251d18 100644
--- a/execute.c
+++ b/execute.c
@@ -286,6 +286,18 @@ jv jq_next() {
       break;
     }
 
+    case GETPATH: {
+      stackval path_end = stack_pop();
+      stackval path_start = stack_pop();
+      jv_free(path_end.value);
+      jv path = jv_array();
+      for (int i=path_start.pathidx; i<path_end.pathidx; i++) {
+        path = jv_array_set(path, i, jv_copy(pathbuf[i]));
+      }
+      stack_push(stackval_replace(path_start, path));
+      break;
+    }
+
     case ASSIGN: {
       stackval replacement = stack_pop();
       stackval path_end = stack_pop();
@@ -293,11 +305,18 @@ jv jq_next() {
       jv_free(path_end.value);
       jv_free(path_start.value);
 
+      jv path = jv_array();
+      for (int i=path_start.pathidx; i<path_end.pathidx; i++) {
+        path = jv_array_set(path, i, jv_copy(pathbuf[i]));
+      }
+
+
+
       uint16_t level = *pc++;
       uint16_t v = *pc++;
       frame_ptr fp = frame_get_level(&frame_stk, frame_current(&frame_stk), level);
       jv* var = frame_local_var(fp, v);
-      jv result = jv_insert(*var, replacement.value, pathbuf + path_start.pathidx, path_end.pathidx - path_start.pathidx);
+      jv result = jv_setpath(*var, path, replacement.value);
       if (jv_is_valid(result)) {
         *var = result;
       } else {
@@ -311,7 +330,7 @@ jv jq_next() {
       stackval t = stack_pop();
       jv k = stack_pop().value;
       int pathidx = path_push(t, jv_copy(k));
-      jv v = jv_lookup(t.value, k);
+      jv v = jv_get(t.value, k);
       if (jv_is_valid(v)) {
         stackval sv;
         sv.value = v;
diff --git a/jv.c b/jv.c
index abbeb6d4..9a362a6c 100644
--- a/jv.c
+++ b/jv.c
@@ -254,8 +254,7 @@ static int jvp_array_equal(jv_complex* a, jv_complex* b) {
 static jv_complex jvp_array_slice(jv_complex* a, int start, int end) {
   // FIXME: maybe slice should reallocate if the slice is small enough
   assert(start <= end);
-  jvp_array* array = jvp_array_ptr(a);
-  assert(a->i[1] + end < array->length);
+  assert(a->i[0] + end <= a->i[1]);
   jv_complex slice = *a;
   slice.i[0] += start;
   slice.i[1] = slice.i[0] + (end - start);
diff --git a/jv_aux.c b/jv_aux.c
index a4bfddd2..83695f96 100644
--- a/jv_aux.c
+++ b/jv_aux.c
@@ -3,7 +3,7 @@
 #include <stdlib.h>
 #include "jv_alloc.h"
 
-jv jv_lookup(jv t, jv k) {
+jv jv_get(jv t, jv k) {
   jv v;
   if (jv_get_kind(t) == JV_KIND_OBJECT && jv_get_kind(k) == JV_KIND_STRING) {
     v = jv_object_get(t, k);
@@ -33,7 +33,12 @@ jv jv_lookup(jv t, jv k) {
   return v;
 }
 
-jv jv_modify(jv t, jv k, jv v) {
+jv jv_set(jv t, jv k, jv v) {
+  if (!jv_is_valid(v)) {
+    jv_free(t);
+    jv_free(k);
+    return v;
+  }
   int isnull = jv_get_kind(t) == JV_KIND_NULL;
   if (jv_get_kind(k) == JV_KIND_STRING && 
       (jv_get_kind(t) == JV_KIND_OBJECT || isnull)) {
@@ -55,15 +60,100 @@ jv jv_modify(jv t, jv k, jv v) {
   return t;
 }
 
-jv jv_insert(jv root, jv value, jv* path, int pathlen) {
-  if (pathlen == 0) {
+jv jv_del(jv t, jv k) {
+  if (jv_get_kind(t) == JV_KIND_NULL) {
+    jv_free(k);
+  } else if (jv_get_kind(t) == JV_KIND_ARRAY && 
+             jv_get_kind(k) == JV_KIND_NUMBER) {
+    int idx = (int)jv_number_value(k);
+    jv_free(k);
+    int len = jv_array_length(jv_copy(t));
+    if (idx >= 0 && idx < len) {
+      for (int i = idx+1; i < len; i++) {
+        t = jv_array_set(t, i-1, jv_array_get(jv_copy(t), i));
+      }
+      t = jv_array_slice(t, 0, len-1);
+    }
+  } else if (jv_get_kind(t) == JV_KIND_OBJECT &&
+             jv_get_kind(k) == JV_KIND_STRING) {
+    t = jv_object_delete(t, k);
+  } else {
+    jv err = jv_invalid_with_msg(jv_string_fmt("Cannot delete field at %s index of %s",
+                                               jv_kind_name(jv_get_kind(k)),
+                                               jv_kind_name(jv_get_kind(t))));
+    jv_free(t);
+    jv_free(k);
+    t = err;
+  }
+  return t;
+}
+
+jv jv_setpath(jv root, jv path, jv value) {
+  if (jv_get_kind(path) != JV_KIND_ARRAY) {
+    jv_free(value);
+    jv_free(root);
+    jv_free(path);
+    return jv_invalid_with_msg(jv_string("Path must be specified as an array"));
+  }
+  if (!jv_is_valid(root)){
+    jv_free(value);
+    jv_free(path);
+    return root;
+  }
+  if (jv_array_length(jv_copy(path)) == 0) {
+    jv_free(path);
     jv_free(root);
     return value;
   }
-  return jv_modify(root, jv_copy(*path), 
-                   jv_insert(jv_lookup(jv_copy(root), jv_copy(*path)), value, path+1, pathlen-1));
+  jv pathcurr = jv_array_get(jv_copy(path), 0);
+  jv pathrest = jv_array_slice(path, 1, jv_array_length(jv_copy(path)));
+  return jv_set(root, pathcurr, 
+                jv_setpath(jv_get(jv_copy(root), jv_copy(pathcurr)), pathrest, value));
 }
 
+jv jv_getpath(jv root, jv path) {
+  if (jv_get_kind(path) != JV_KIND_ARRAY) {
+    jv_free(root);
+    jv_free(path);
+    return jv_invalid_with_msg(jv_string("Path must be specified as an array"));
+  }
+  if (!jv_is_valid(root)) {
+    jv_free(path);
+    return root;
+  }
+  if (jv_array_length(jv_copy(path)) == 0) {
+    jv_free(path);
+    return root;
+  }
+  jv pathcurr = jv_array_get(jv_copy(path), 0);
+  jv pathrest = jv_array_slice(path, 1, jv_array_length(jv_copy(path)));
+  return jv_getpath(jv_get(root, pathcurr), pathrest);
+}
+
+jv jv_delpath(jv root, jv path) {
+  if (jv_get_kind(path) != JV_KIND_ARRAY) {
+    jv_free(root);
+    jv_free(path);
+    return jv_invalid_with_msg(jv_string("Path must be specified as an array"));
+  }
+  if (!jv_is_valid(root)) {
+    jv_free(path);
+    return root;
+  }
+  if (jv_array_length(jv_copy(path)) == 1) {
+    return jv_del(root, jv_array_get(path, 0));
+  }
+  jv pathcurr = jv_array_get(jv_copy(path), 0);
+  jv pathrest = jv_array_slice(path, 1, jv_array_length(jv_copy(path)));
+  jv new_obj = jv_delpath(jv_get(jv_copy(root), jv_copy(pathcurr)), pathrest);
+  if (jv_get_kind(new_obj) == JV_KIND_NULL) {
+    jv_free(pathcurr);
+    jv_free(new_obj);
+    return root;
+  } else {
+    return jv_set(root, pathcurr, new_obj);
+  }
+}
 
 static int string_cmp(const void* pa, const void* pb){
   const jv* a = pa;
diff --git a/jv_aux.h b/jv_aux.h
index 36b0e5e4..0b827d2e 100644
--- a/jv_aux.h
+++ b/jv_aux.h
@@ -3,9 +3,11 @@
 
 #include "jv.h"
 
-jv jv_lookup(jv t, jv k);
-jv jv_modify(jv t, jv k, jv v);
-jv jv_insert(jv root, jv value, jv* path, int pathlen);
+jv jv_get(jv t, jv k);
+jv jv_set(jv t, jv k, jv v);
+jv jv_setpath(jv root, jv path, jv value);
+jv jv_getpath(jv root, jv path);
+jv jv_delpath(jv root, jv path);
 
 jv jv_keys(jv /*object or array*/);
 int jv_cmp(jv, jv);
diff --git a/opcode_list.h b/opcode_list.h
index e6dece6e..e460ffe9 100644
--- a/opcode_list.h
+++ b/opcode_list.h
@@ -15,6 +15,7 @@ OP(BACKTRACK, NONE, 0, 0)
 OP(APPEND, NONE,    2, 1)
 OP(INSERT, NONE,    4, 2)
 
+OP(GETPATH, NONE,   2, 1)
 OP(ASSIGN, VARIABLE, 3, 0)
 
 OP(CALL_BUILTIN, CFUNC, -1, 1)
diff --git a/testdata b/testdata
index bb8e677a..36429f59 100644
--- a/testdata
+++ b/testdata
@@ -335,6 +335,50 @@ fold 0 as $s (.[] | $s + .)
 [1,2,4]
 7
 
+#
+# Paths
+#
+
+path(.foo[0,1])
+null
+["foo", 0]
+["foo", 1]
+
+path(.[] | select(.>3))
+[1,5,3]
+[1]
+
+path(.)
+42
+[]
+
+["foo",1] as $p | getpath($p), setpath($p; 20), delpath($p)
+{"bar": 42, "foo": ["a", "b", "c", "d"]}
+"b"
+{"bar": 42, "foo": ["a", 20, "c", "d"]}
+{"bar": 42, "foo": ["a", "c", "d"]}
+
+map(getpath([2])), map(setpath([2]; 42)), map(delpath([2]))
+[[0], [0,1], [0,1,2]]
+[null, null, 2]
+[[0,null,42], [0,1,42], [0,1,42]]
+[[0], [0,1], [0,1]]
+
+map(delpath([0,"foo"]))
+[[{"foo":2, "x":1}], [{"bar":2}]]
+[[{"x":1}], [{"bar":2}]]
+
+["foo",1] as $p | getpath($p), setpath($p; 20), delpath($p)
+{"bar":false}
+null
+{"bar":false, "foo": [null, 20]}
+{"bar":false}
+
+delpath([-200])
+[1,2,3]
+[1,2,3]
+
+
 #
 # Assignment
 #

From 3a5377e183976cc6dafa16a17f608e091dfa96b9 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sat, 29 Dec 2012 01:37:22 +0000
Subject: [PATCH 205/284] Fix a bug in URI-encoding of certain non-ASCII
 characters.

Oh how I hate C casting rules.
---
 builtin.c | 2 +-
 testdata  | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/builtin.c b/builtin.c
index de40be7e..bb704bb8 100644
--- a/builtin.c
+++ b/builtin.c
@@ -306,7 +306,7 @@ static jv f_format(jv input, jv fmt) {
     jv line = jv_string("");
     const char* s = jv_string_value(input);
     for (int i=0; i<jv_string_length(jv_copy(input)); i++) {
-      unsigned ch = (unsigned)*s;
+      unsigned ch = (unsigned)(unsigned char)*s;
       if (ch < 128 && unreserved[ch]) {
         line = jv_string_append_buf(line, s, 1);
       } else {
diff --git a/testdata b/testdata
index 36429f59..50e73203 100644
--- a/testdata
+++ b/testdata
@@ -62,6 +62,10 @@ null
 "'<>&'\\''\"'"
 "PD4mJyI="
 
+@uri
+"\u03bc"
+"%ce%bc"
+
 @html "<b>\(.)</b>"
 "<script>hax</script>"
 "<b>&lt;script&gt;hax&lt;/script&gt;</b>"

From 465a4ec565a106e0e4cc1d64214fb2d6d791c8dc Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sat, 29 Dec 2012 16:13:06 +0000
Subject: [PATCH 206/284] Improvements to del(foo).

del(foo,bar) is now very different from del(foo),del(bar).
See #37.
---
 builtin.c |   5 +-
 jv_aux.c  | 164 +++++++++++++++++++++++++++++++++++++++++-------------
 jv_aux.h  |   2 +-
 testdata  |  16 ++++--
 4 files changed, 138 insertions(+), 49 deletions(-)

diff --git a/builtin.c b/builtin.c
index bb704bb8..dca3d6ff 100644
--- a/builtin.c
+++ b/builtin.c
@@ -475,7 +475,6 @@ static jv f_error(jv input, jv msg) {
   return jv_invalid_with_msg(msg);
 }
 
-
 static struct cfunction function_list[] = {
   {(cfunction_ptr)f_plus, "_plus", 3},
   {(cfunction_ptr)f_minus, "_minus", 3},
@@ -486,7 +485,7 @@ static struct cfunction function_list[] = {
   {(cfunction_ptr)f_keys, "keys", 1},
   {(cfunction_ptr)jv_setpath, "setpath", 3}, // FIXME typechecking
   {(cfunction_ptr)jv_getpath, "getpath", 2},
-  {(cfunction_ptr)jv_delpath, "delpath", 2},
+  {(cfunction_ptr)jv_delpaths, "delpaths", 2},
   {(cfunction_ptr)f_equal, "_equal", 3},
   {(cfunction_ptr)f_notequal, "_notequal", 3},
   {(cfunction_ptr)f_less, "_less", 3},
@@ -552,7 +551,7 @@ static const char* jq_builtins[] = {
   "def unique: group_by(.) | map(.[0]);",
   "def max_by(f): _max_by_impl(map([f]));",
   "def min_by(f): _min_by_impl(map([f]));",
-  "def del(f): delpath(path(f));",
+  "def del(f): delpaths([path(f)]);",
 };
 
 
diff --git a/jv_aux.c b/jv_aux.c
index 83695f96..f0e15b50 100644
--- a/jv_aux.c
+++ b/jv_aux.c
@@ -60,31 +60,63 @@ jv jv_set(jv t, jv k, jv v) {
   return t;
 }
 
-jv jv_del(jv t, jv k) {
-  if (jv_get_kind(t) == JV_KIND_NULL) {
-    jv_free(k);
-  } else if (jv_get_kind(t) == JV_KIND_ARRAY && 
-             jv_get_kind(k) == JV_KIND_NUMBER) {
-    int idx = (int)jv_number_value(k);
-    jv_free(k);
-    int len = jv_array_length(jv_copy(t));
-    if (idx >= 0 && idx < len) {
-      for (int i = idx+1; i < len; i++) {
-        t = jv_array_set(t, i-1, jv_array_get(jv_copy(t), i));
+// assumes keys is a sorted array
+jv jv_dels(jv t, jv keys) {
+  assert(jv_get_kind(keys) == JV_KIND_ARRAY);
+  assert(jv_is_valid(t));
+  
+  if (jv_get_kind(t) == JV_KIND_NULL || jv_array_length(jv_copy(keys)) == 0) {
+    // no change
+  } else if (jv_get_kind(t) == JV_KIND_ARRAY) {
+    jv new_array = jv_array();
+    int kidx = 0;
+    for (int i=0; i<jv_array_length(jv_copy(t)); i++) {
+      int del = 0;
+      while (kidx < jv_array_length(jv_copy(keys))) {
+        jv nextdel = jv_array_get(jv_copy(keys), kidx);
+        if (jv_get_kind(nextdel) != JV_KIND_NUMBER) {
+          jv err = jv_invalid_with_msg(jv_string_fmt("Cannot delete %s element of array",
+                                                     jv_kind_name(jv_get_kind(nextdel))));
+          jv_free(nextdel);
+          jv_free(new_array);
+          new_array = err;
+          goto arr_out; // break twice
+        }
+        int delidx = (int)jv_number_value(nextdel);
+        jv_free(nextdel);
+        if (i == delidx) {
+          del = 1;
+        }
+        if (i < delidx) {
+          break;
+        }
+        kidx++;
       }
-      t = jv_array_slice(t, 0, len-1);
+      if (!del)
+        new_array = jv_array_append(new_array, jv_array_get(jv_copy(t), i));
+    }
+  arr_out:
+    jv_free(t);
+    t = new_array;
+  } else if (jv_get_kind(t) == JV_KIND_OBJECT) {
+    for (int i=0; i<jv_array_length(jv_copy(keys)); i++) {
+      jv k = jv_array_get(jv_copy(keys), i);
+      if (jv_get_kind(k) != JV_KIND_STRING) {
+        jv_free(t);
+        t = jv_invalid_with_msg(jv_string_fmt("Cannot delete %s field of object",
+                                              jv_kind_name(jv_get_kind(k))));
+        jv_free(k);
+        break;
+      }
+      t = jv_object_delete(t, k);      
     }
-  } else if (jv_get_kind(t) == JV_KIND_OBJECT &&
-             jv_get_kind(k) == JV_KIND_STRING) {
-    t = jv_object_delete(t, k);
   } else {
-    jv err = jv_invalid_with_msg(jv_string_fmt("Cannot delete field at %s index of %s",
-                                               jv_kind_name(jv_get_kind(k)),
+    jv err = jv_invalid_with_msg(jv_string_fmt("Cannot delete fields from %s",
                                                jv_kind_name(jv_get_kind(t))));
     jv_free(t);
-    jv_free(k);
     t = err;
   }
+  jv_free(keys);
   return t;
 }
 
@@ -130,31 +162,83 @@ jv jv_getpath(jv root, jv path) {
   return jv_getpath(jv_get(root, pathcurr), pathrest);
 }
 
-jv jv_delpath(jv root, jv path) {
-  if (jv_get_kind(path) != JV_KIND_ARRAY) {
-    jv_free(root);
-    jv_free(path);
-    return jv_invalid_with_msg(jv_string("Path must be specified as an array"));
-  }
-  if (!jv_is_valid(root)) {
-    jv_free(path);
-    return root;
-  }
-  if (jv_array_length(jv_copy(path)) == 1) {
-    return jv_del(root, jv_array_get(path, 0));
-  }
-  jv pathcurr = jv_array_get(jv_copy(path), 0);
-  jv pathrest = jv_array_slice(path, 1, jv_array_length(jv_copy(path)));
-  jv new_obj = jv_delpath(jv_get(jv_copy(root), jv_copy(pathcurr)), pathrest);
-  if (jv_get_kind(new_obj) == JV_KIND_NULL) {
-    jv_free(pathcurr);
-    jv_free(new_obj);
-    return root;
-  } else {
-    return jv_set(root, pathcurr, new_obj);
+// assumes paths is a sorted array of arrays
+static jv delpaths_sorted(jv object, jv paths, int start) {
+  jv delkeys = jv_array();
+  for (int i=0; i<jv_array_length(jv_copy(paths));) {
+    int j = i;
+    assert(jv_array_length(jv_array_get(jv_copy(paths), i)) > start);
+    int delkey = jv_array_length(jv_array_get(jv_copy(paths), i)) == start + 1;
+    jv key = jv_array_get(jv_array_get(jv_copy(paths), i), start);
+    while (j < jv_array_length(jv_copy(paths)) &&
+           jv_equal(jv_copy(key), jv_array_get(jv_array_get(jv_copy(paths), j), start)))
+      j++;
+    // if i <= entry < j, then entry starts with key
+    if (delkey) {
+      // deleting this entire key, we don't care about any more specific deletions
+      delkeys = jv_array_append(delkeys, key);
+    } else {
+      // deleting certain sub-parts of this key
+      jv subobject = jv_get(jv_copy(object), jv_copy(key));
+      if (!jv_is_valid(subobject)) {
+        jv_free(key);
+        jv_free(object);
+        object = subobject;
+        break;
+      } else if (jv_get_kind(subobject) == JV_KIND_NULL) {
+        jv_free(key);
+        jv_free(subobject);
+      } else {
+        jv newsubobject = delpaths_sorted(subobject, jv_array_slice(jv_copy(paths), i, j), start+1);
+        if (!jv_is_valid(newsubobject)) {
+          jv_free(key);
+          jv_free(object);
+          object = newsubobject;
+          break;
+        }
+        object = jv_set(object, key, newsubobject);
+      }
+      if (!jv_is_valid(object)) break;
+    }
+    i = j;
   }
+  jv_free(paths);
+  if (jv_is_valid(object))
+    object = jv_dels(object, delkeys);
+  else 
+    jv_free(delkeys);
+  return object;
 }
 
+jv jv_delpaths(jv object, jv paths) {
+  paths = jv_sort(paths, jv_copy(paths));
+  for (int i=0; i<jv_array_length(jv_copy(paths)); i++) {
+    jv elem = jv_array_get(jv_copy(paths), i);
+    if (jv_get_kind(elem) != JV_KIND_ARRAY) {
+      jv_free(object);
+      jv_free(paths);
+      jv err = jv_invalid_with_msg(jv_string_fmt("Path must be specified as array, not %s",
+                                                 jv_kind_name(jv_get_kind(elem))));
+      jv_free(elem);
+      return err;
+    }
+    jv_free(elem);
+  }
+  if (jv_array_length(jv_copy(paths)) == 0) {
+    // nothing is being deleted
+    jv_free(paths);
+    return object;
+  }
+  if (jv_array_length(jv_array_get(jv_copy(paths), 0)) == 0) {
+    // everything is being deleted
+    jv_free(paths);
+    jv_free(object);
+    return jv_null();
+  }
+  return delpaths_sorted(object, paths, 0);
+}
+
+
 static int string_cmp(const void* pa, const void* pb){
   const jv* a = pa;
   const jv* b = pb;
diff --git a/jv_aux.h b/jv_aux.h
index 0b827d2e..561f1083 100644
--- a/jv_aux.h
+++ b/jv_aux.h
@@ -7,7 +7,7 @@ jv jv_get(jv t, jv k);
 jv jv_set(jv t, jv k, jv v);
 jv jv_setpath(jv root, jv path, jv value);
 jv jv_getpath(jv root, jv path);
-jv jv_delpath(jv root, jv path);
+jv jv_delpaths(jv root, jv paths);
 
 jv jv_keys(jv /*object or array*/);
 int jv_cmp(jv, jv);
diff --git a/testdata b/testdata
index 50e73203..576c02d6 100644
--- a/testdata
+++ b/testdata
@@ -356,32 +356,38 @@ path(.)
 42
 []
 
-["foo",1] as $p | getpath($p), setpath($p; 20), delpath($p)
+["foo",1] as $p | getpath($p), setpath($p; 20), delpaths([$p])
 {"bar": 42, "foo": ["a", "b", "c", "d"]}
 "b"
 {"bar": 42, "foo": ["a", 20, "c", "d"]}
 {"bar": 42, "foo": ["a", "c", "d"]}
 
-map(getpath([2])), map(setpath([2]; 42)), map(delpath([2]))
+map(getpath([2])), map(setpath([2]; 42)), map(delpaths([[2]]))
 [[0], [0,1], [0,1,2]]
 [null, null, 2]
 [[0,null,42], [0,1,42], [0,1,42]]
 [[0], [0,1], [0,1]]
 
-map(delpath([0,"foo"]))
+map(delpaths([[0,"foo"]]))
 [[{"foo":2, "x":1}], [{"bar":2}]]
 [[{"x":1}], [{"bar":2}]]
 
-["foo",1] as $p | getpath($p), setpath($p; 20), delpath($p)
+["foo",1] as $p | getpath($p), setpath($p; 20), delpaths([$p])
 {"bar":false}
 null
 {"bar":false, "foo": [null, 20]}
 {"bar":false}
 
-delpath([-200])
+delpaths([[-200]])
 [1,2,3]
 [1,2,3]
 
+del(.), del(empty), del((.foo,.bar,.baz) | .[2,3,0]), del(.foo[0], .bar[0], .foo, .baz.bar[0].x)
+{"foo": [0,1,2,3,4], "bar": [0,1]}
+null
+{"foo": [0,1,2,3,4], "bar": [0,1]}
+{"foo": [1,4], "bar": [1]}
+{"bar": [1]}
 
 #
 # Assignment

From d5fdf70434a243e6f3bd6967dbc2d28c9144cb29 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sat, 29 Dec 2012 16:43:36 +0000
Subject: [PATCH 207/284] Refactor assignment.

New version is much more elegant and probably slower. Uses
library functions implemented in jq rather than dedicated opcodes.
---
 builtin.c     |  3 +++
 compile.c     | 16 ----------------
 compile.h     |  1 -
 execute.c     | 28 ----------------------------
 opcode_list.h |  1 -
 parser.y      | 19 ++++++++++++-------
 testdata      |  4 ++++
 7 files changed, 19 insertions(+), 53 deletions(-)

diff --git a/builtin.c b/builtin.c
index dca3d6ff..f5917cbe 100644
--- a/builtin.c
+++ b/builtin.c
@@ -552,6 +552,9 @@ static const char* jq_builtins[] = {
   "def max_by(f): _max_by_impl(map([f]));",
   "def min_by(f): _min_by_impl(map([f]));",
   "def del(f): delpaths([path(f)]);",
+  "def _assign(paths; value): value as $v | fold . as $obj (path(paths) as $p | $obj | setpath($p; $v));",
+  "def _modify(paths; update): fold . as $obj (path(paths) as $p | $obj | setpath($p; getpath($p) | update));",
+  
 };
 
 
diff --git a/compile.c b/compile.c
index 178b0463..08187836 100644
--- a/compile.c
+++ b/compile.c
@@ -317,22 +317,6 @@ block gen_fold(const char* varname, block init, block fold) {
                           OP_HAS_VARIABLE));
 }
 
-block gen_assign(block expr) {
-  block result_var = block_bind(gen_op_var_unbound(STOREV, "result"),
-                                gen_noop(), OP_HAS_VARIABLE);
-
-  block loop = BLOCK(gen_op_simple(DUP),
-                     expr,
-                     gen_op_var_bound(ASSIGN, result_var),
-                     gen_op_simple(BACKTRACK));
-
-  return BLOCK(gen_op_simple(DUP),
-               result_var,
-               gen_op_target(FORK, loop),
-               loop,
-               gen_op_var_bound(LOADV, result_var));
-}
-
 block gen_definedor(block a, block b) {
   // var found := false
   block found_var = block_bind(gen_op_var_unbound(STOREV, "found"),
diff --git a/compile.h b/compile.h
index ce1b3089..150eef28 100644
--- a/compile.h
+++ b/compile.h
@@ -34,7 +34,6 @@ block gen_subexp(block a);
 block gen_both(block a, block b);
 block gen_collect(block expr);
 block gen_fold(const char* varname, block init, block body);
-block gen_assign(block expr);
 block gen_definedor(block a, block b);
 block gen_condbranch(block iftrue, block iffalse);
 block gen_and(block a, block b);
diff --git a/execute.c b/execute.c
index ed251d18..94f6cd43 100644
--- a/execute.c
+++ b/execute.c
@@ -298,34 +298,6 @@ jv jq_next() {
       break;
     }
 
-    case ASSIGN: {
-      stackval replacement = stack_pop();
-      stackval path_end = stack_pop();
-      stackval path_start = stack_pop();
-      jv_free(path_end.value);
-      jv_free(path_start.value);
-
-      jv path = jv_array();
-      for (int i=path_start.pathidx; i<path_end.pathidx; i++) {
-        path = jv_array_set(path, i, jv_copy(pathbuf[i]));
-      }
-
-
-
-      uint16_t level = *pc++;
-      uint16_t v = *pc++;
-      frame_ptr fp = frame_get_level(&frame_stk, frame_current(&frame_stk), level);
-      jv* var = frame_local_var(fp, v);
-      jv result = jv_setpath(*var, path, replacement.value);
-      if (jv_is_valid(result)) {
-        *var = result;
-      } else {
-        print_error(result);
-        *var = jv_null();
-      }
-      break;
-    }
-
     case INDEX: {
       stackval t = stack_pop();
       jv k = stack_pop().value;
diff --git a/opcode_list.h b/opcode_list.h
index e460ffe9..0185b5a6 100644
--- a/opcode_list.h
+++ b/opcode_list.h
@@ -16,7 +16,6 @@ OP(APPEND, NONE,    2, 1)
 OP(INSERT, NONE,    4, 2)
 
 OP(GETPATH, NONE,   2, 1)
-OP(ASSIGN, VARIABLE, 3, 0)
 
 OP(CALL_BUILTIN, CFUNC, -1, 1)
 
diff --git a/parser.y b/parser.y
index 2b9732c0..a1be0b7f 100644
--- a/parser.y
+++ b/parser.y
@@ -164,11 +164,16 @@ static block gen_format(block a, jv fmt) {
   return BLOCK(a, gen_call("format", BLOCK(gen_lambda(gen_const(fmt)))));
 }
  
-static block gen_update(block a, block op, int optype) {
-  if (optype) {
-    op = gen_binop(gen_noop(), op, optype);
-  }
-  return gen_assign(BLOCK(a, gen_op_simple(DUP), op));
+static block gen_update(block object, block val, int optype) {
+  block tmp = block_bind(gen_op_var_unbound(STOREV, "tmp"),
+                         gen_noop(), OP_HAS_VARIABLE);
+  return BLOCK(gen_op_simple(DUP),
+               val,
+               tmp,
+               gen_call("_modify", BLOCK(gen_lambda(object), 
+                                         gen_lambda(gen_binop(gen_noop(),
+                                                              gen_op_var_bound(LOADV, tmp),
+                                                              optype)))));
 }
 
 %}
@@ -216,7 +221,7 @@ Term "as" '$' IDENT '|' Exp {
 } |
 
 Exp '=' Exp {
-  $$ = gen_assign(BLOCK(gen_op_simple(DUP), $3, gen_op_simple(SWAP), $1, gen_op_simple(SWAP)));
+  $$ = gen_call("_assign", BLOCK(gen_lambda($1), gen_lambda($3)));
 } |
 
 Exp "or" Exp {
@@ -236,7 +241,7 @@ Exp "//=" Exp {
 } |
 
 Exp "|=" Exp {
-  $$ = gen_update($1, $3, 0);
+  $$ = gen_call("_modify", BLOCK(gen_lambda($1), gen_lambda($3)));
 } |
 
 Exp '|' Exp { 
diff --git a/testdata b/testdata
index 576c02d6..224f0651 100644
--- a/testdata
+++ b/testdata
@@ -411,6 +411,10 @@ null
 [-1,1,3]
 [0.5, 1.5, 2.5]
 
+.foo += .foo
+{"foo":2}
+{"foo":4}
+
 .[0].a |= {"old":., "new":(.+1)}
 [{"a":1,"b":2}]
 [{"a":{"old":1, "new":2},"b":2}]

From e0cda536f331b0fc53b493069dce70bb32de9a8b Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sat, 29 Dec 2012 16:50:58 +0000
Subject: [PATCH 208/284] Make null + foo return foo, rather than an error.

This also allows 'add' to be implemented in jq rather than C.
---
 builtin.c                        | 26 ++++++++------------------
 docs/content/3.manual/manual.yml |  9 +++++++++
 testdata                         | 12 ++++++++++++
 3 files changed, 29 insertions(+), 18 deletions(-)

diff --git a/builtin.c b/builtin.c
index f5917cbe..b0c6c34c 100644
--- a/builtin.c
+++ b/builtin.c
@@ -45,7 +45,13 @@ static jv type_error2(jv bad1, jv bad2, const char* msg) {
 
 static jv f_plus(jv input, jv a, jv b) {
   jv_free(input);
-  if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
+  if (jv_get_kind(a) == JV_KIND_NULL) {
+    jv_free(a);
+    return b;
+  } else if (jv_get_kind(b) == JV_KIND_NULL) {
+    jv_free(b);
+    return a;
+  } else if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
     return jv_number(jv_number_value(a) + 
                      jv_number_value(b));
   } else if (jv_get_kind(a) == JV_KIND_STRING && jv_get_kind(b) == JV_KIND_STRING) {
@@ -104,22 +110,6 @@ static jv f_divide(jv input, jv a, jv b) {
   }  
 }
 
-static jv f_add(jv array) {
-  if (jv_get_kind(array) != JV_KIND_ARRAY) {
-    return type_error(array, "cannot have its elements added");
-  } else if (jv_array_length(jv_copy(array)) == 0) {
-    jv_free(array);
-    return jv_null();
-  } else {
-    jv sum = jv_array_get(jv_copy(array), 0);
-    for (int i = 1; i < jv_array_length(jv_copy(array)); i++) {
-      sum = f_plus(jv_null(), sum, jv_array_get(jv_copy(array), i));
-    }
-    jv_free(array);
-    return sum;
-  }
-}
-
 static jv f_equal(jv input, jv a, jv b) {
   jv_free(input);
   return jv_bool(jv_equal(a, b));
@@ -495,7 +485,6 @@ static struct cfunction function_list[] = {
   {(cfunction_ptr)f_contains, "contains", 2},
   {(cfunction_ptr)f_length, "length", 1},
   {(cfunction_ptr)f_type, "type", 1},
-  {(cfunction_ptr)f_add, "add", 1},
   {(cfunction_ptr)f_sort, "sort", 1},
   {(cfunction_ptr)f_sort_by_impl, "_sort_by_impl", 2},
   {(cfunction_ptr)f_group_by_impl, "_group_by_impl", 2},
@@ -551,6 +540,7 @@ static const char* jq_builtins[] = {
   "def unique: group_by(.) | map(.[0]);",
   "def max_by(f): _max_by_impl(map([f]));",
   "def min_by(f): _min_by_impl(map([f]));",
+  "def add: fold null as $sum (.[] | $sum + .);",
   "def del(f): delpaths([path(f)]);",
   "def _assign(paths; value): value as $v | fold . as $obj (path(paths) as $p | $obj | setpath($p; $v));",
   "def _modify(paths; update): fold . as $obj (path(paths) as $p | $obj | setpath($p; getpath($p) | update));",
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 1de1a387..fba7e4a7 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -356,6 +356,9 @@ sections:
               the key-value pairs from both objects into a single
               combined object. If both objects contain a value for the
               same key, the object on the right of the `+` wins.
+          
+          `null` can be added to any value, and returns the other
+          value unchanged.
 
         examples:
           - program: '.a + 1'
@@ -364,6 +367,12 @@ sections:
           - program: '.a + .b'
             input: '{"a": [1,2], "b": [3,4]}'
             output: ['[1,2,3,4]']
+          - program: '.a + null'
+            input: '{"a": 1}'
+            output: ['1']
+          - program: '.a + 1'
+            input: '{}'
+            output: ['1']
           - program: '{a: 1} + {b: 2} + {c: 3} + {a: 42}'
             input: 'null'
             output: ['{"a": 42, "b": 2, "c": 3}']
diff --git a/testdata b/testdata
index 224f0651..4a998d8e 100644
--- a/testdata
+++ b/testdata
@@ -205,6 +205,18 @@ null
 15
 19.0
 
+.+null
+{"a":42}
+{"a":42}
+
+null+.
+null
+null
+
+.a+.b
+{"a":42}
+42
+
 [1,2,3] + [.]
 null
 [1,2,3,null]

From b3bad59dd7d9fcea575ef2de2843b9515b0630b4 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sat, 29 Dec 2012 22:59:07 +0000
Subject: [PATCH 209/284] Add the `recurse` function. See #37.

---
 builtin.c                        |  2 +-
 docs/content/3.manual/manual.yml | 32 ++++++++++++++++++++++++++++++++
 2 files changed, 33 insertions(+), 1 deletion(-)

diff --git a/builtin.c b/builtin.c
index b0c6c34c..5818a6a4 100644
--- a/builtin.c
+++ b/builtin.c
@@ -544,7 +544,7 @@ static const char* jq_builtins[] = {
   "def del(f): delpaths([path(f)]);",
   "def _assign(paths; value): value as $v | fold . as $obj (path(paths) as $p | $obj | setpath($p; $v));",
   "def _modify(paths; update): fold . as $obj (path(paths) as $p | $obj | setpath($p; getpath($p) | update));",
-  
+  "def recurse(f): ., (f | select(. != null) | recurse(f));",
 };
 
 
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index fba7e4a7..de608210 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -643,6 +643,38 @@ sections:
             input: '{"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]}'
             output: ['false']
 
+      - title: `recurse`
+        body: |
+          
+          The `recurse` function allows you to search through a
+          recursive structure, and extract interesting data from all
+          levels. Suppose your input represents a filesystem:
+
+              {"name": "/", "children": [
+                {"name": "/bin", "children": [
+                  {"name": "/bin/ls", "children": []},
+                  {"name": "/bin/sh", "children": []}]},
+                {"name": "/home", "children": [
+                  {"name": "/home/stephen", "children": [
+                    {"name": "/home/stephen/jq", "children": []}]}]}]}
+          
+          Now suppose you want to extract all of the filenames
+          present. You need to retrieve `.name`, `.children[].name`,
+          `.children[].children[].name`, and so on. You can do this
+          with:
+
+              recurse(.children[]) | .name
+
+        examples:
+          - program: 'recurse(.foo[])'
+            input: '{"foo":[{"foo": []}, {"foo":[{"foo":[]}]}]}'
+            output: 
+              - '{"foo":[{"foo":[]},{"foo":[{"foo":[]}]}]}'
+              - '{"foo":[]}'
+              - '{"foo":[{"foo":[]}]}'
+              - '{"foo":[]}'
+
+
       - title: "String interpolation - `\(foo)`"
         body: |
 

From 38fe6fc0cbf23c3bb97b10529cda119cb4418245 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 31 Dec 2012 23:25:12 +0000
Subject: [PATCH 210/284] Ignore some more stuff.

---
 .gitignore | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/.gitignore b/.gitignore
index 6caf43c4..5e0bf5a7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,12 +4,10 @@
 # Autogenerated
 *.gen.*
 
-# Test binaries
-jv_test
-jv_parse
-parsertest*~
-
+jq_test
 build
+jq
+jq.1
 
 # Something delightfully recursive happens otherwise
 docs/content/2.download/source/*
\ No newline at end of file

From fb84541e1124565ee7af32cd842771cf81326dc7 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 31 Dec 2012 23:27:00 +0000
Subject: [PATCH 211/284] Clean up jv_object_foreach and add jv_array_foreach

---
 builtin.c  | 17 ++++++-----------
 jv.c       | 23 +++++++++--------------
 jv.h       | 21 ++++++++++++++++-----
 jv_aux.c   | 21 +++++++++++----------
 jv_print.c |  9 ++++-----
 5 files changed, 46 insertions(+), 45 deletions(-)

diff --git a/builtin.c b/builtin.c
index 5818a6a4..32b67ccc 100644
--- a/builtin.c
+++ b/builtin.c
@@ -71,11 +71,10 @@ static jv f_minus(jv input, jv a, jv b) {
     return jv_number(jv_number_value(a) - jv_number_value(b));
   } else if (jv_get_kind(a) == JV_KIND_ARRAY && jv_get_kind(b) == JV_KIND_ARRAY) {
     jv out = jv_array();
-    for (int i=0; i<jv_array_length(jv_copy(a)); i++) {
-      jv x = jv_array_get(jv_copy(a), i);
+    jv_array_foreach(a, i, x) {
       int include = 1;
-      for (int j=0; j<jv_array_length(jv_copy(b)); j++) {
-        if (jv_equal(jv_copy(x), jv_array_get(jv_copy(b), j))) {
+      jv_array_foreach(b, j, y) {
+        if (jv_equal(jv_copy(x), y)) {
           include = 0;
           break;
         }
@@ -153,9 +152,7 @@ static jv f_greatereq(jv input, jv a, jv b) {
 }
 
 static jv f_contains(jv a, jv b) {
-  jv_kind akind = jv_get_kind(a);
-
-  if (akind == jv_get_kind(b)) {
+  if (jv_get_kind(a) == jv_get_kind(b)) {
     return jv_bool(jv_contains(a, b));
   } else {
     return type_error2(a, b, "cannot have their containment checked");
@@ -248,9 +245,8 @@ static jv f_format(jv input, jv fmt) {
     if (jv_get_kind(input) != JV_KIND_ARRAY)
       return type_error(input, "cannot be csv-formatted, only array");
     jv line = jv_string("");
-    for (int i=0; i<jv_array_length(jv_copy(input)); i++) {
+    jv_array_foreach(input, i, x) {
       if (i) line = jv_string_append_str(line, ",");
-      jv x = jv_array_get(jv_copy(input), i);
       switch (jv_get_kind(x)) {
       case JV_KIND_NULL:
         /* null rendered as empty string */
@@ -311,9 +307,8 @@ static jv f_format(jv input, jv fmt) {
     if (jv_get_kind(input) != JV_KIND_ARRAY)
       input = jv_array_set(jv_array(), 0, input);
     jv line = jv_string("");
-    for (int i=0; i<jv_array_length(jv_copy(input)); i++) {
+    jv_array_foreach(input, i, x) {
       if (i) line = jv_string_append_str(line, " ");
-      jv x = jv_array_get(jv_copy(input), i);
       switch (jv_get_kind(x)) {
       case JV_KIND_NULL:
       case JV_KIND_TRUE:
diff --git a/jv.c b/jv.c
index 9a362a6c..fb4d2103 100644
--- a/jv.c
+++ b/jv.c
@@ -315,8 +315,8 @@ jv jv_array_concat(jv a, jv b) {
   assert(jv_get_kind(b) == JV_KIND_ARRAY);
 
   // FIXME: could be much faster
-  for (int i=0; i<jv_array_length(jv_copy(b)); i++) {
-    a = jv_array_append(a, jv_array_get(jv_copy(b), i));
+  jv_array_foreach(b, i, elem) {
+    a = jv_array_append(a, elem);
   }
   jv_free(b);
   return a;
@@ -331,16 +331,15 @@ jv jv_array_slice(jv a, int start, int end) {
 
 int jv_array_contains(jv a, jv b) {
   int r = 1;
-  int a_length = jv_array_length(jv_copy(a));
-  int b_length = jv_array_length(jv_copy(b));
-  for (int bi = 0; bi < b_length; bi++) {
+  jv_array_foreach(b, bi, belem) {
     int ri = 0;
-    for (int ai = 0; ai < a_length; ai++) {
-      if (jv_contains(jv_array_get(jv_copy(a), ai), jv_array_get(jv_copy(b), bi))) {
+    jv_array_foreach(a, ai, aelem) {
+      if (jv_contains(aelem, jv_copy(belem))) {
         ri = 1;
         break;
       }
     }
+    jv_free(belem);
     if (!ri) {
       r = 0;
       break;
@@ -876,10 +875,8 @@ int jv_object_length(jv object) {
 
 jv jv_object_merge(jv a, jv b) {
   assert(jv_get_kind(a) == JV_KIND_OBJECT);
-  jv_object_foreach(i, b) {
-    a = jv_object_set(a, 
-                      jv_object_iter_key(b, i),
-                      jv_object_iter_value(b, i));
+  jv_object_foreach(b, k, v) {
+    a = jv_object_set(a, k, v);
   }
   jv_free(b);
   return a;
@@ -890,10 +887,8 @@ int jv_object_contains(jv a, jv b) {
   assert(jv_get_kind(b) == JV_KIND_OBJECT);
   int r = 1;
 
-  jv_object_foreach(i, b) {
-    jv key = jv_object_iter_key(b, i);
+  jv_object_foreach(b, key, b_val) {
     jv a_val = jv_object_get(jv_copy(a), jv_copy(key));
-    jv b_val = jv_object_get(jv_copy(b), jv_copy(key));
 
     r = jv_contains(a_val, b_val);
     jv_free(key);
diff --git a/jv.h b/jv.h
index 12e7c790..c3bff367 100644
--- a/jv.h
+++ b/jv.h
@@ -72,7 +72,13 @@ jv jv_array_set(jv, int, jv);
 jv jv_array_append(jv, jv);
 jv jv_array_concat(jv, jv);
 jv jv_array_slice(jv, int, int);
-
+#define jv_array_foreach(a, i, x) \
+  for (int jv_len__ = jv_array_length(jv_copy(a)), i=0, jv_j__ = 1;     \
+       jv_j__; jv_j__ = 0)                                              \
+    for (jv x;                                                          \
+         i < jv_len__ ?                                                 \
+           (x = jv_array_get(jv_copy(a), i), 1) : 0;                    \
+         i++)
 
 jv jv_string(const char*);
 jv jv_string_sized(const char*, int);
@@ -96,10 +102,15 @@ int jv_object_iter_next(jv, int);
 int jv_object_iter_valid(jv, int);
 jv jv_object_iter_key(jv, int);
 jv jv_object_iter_value(jv, int);
-#define jv_object_foreach(i,t) \
-  for (int i = jv_object_iter(t);               \
-       jv_object_iter_valid(t, i);              \
-       i = jv_object_iter_next(t, i))           \
+#define jv_object_foreach(t, k, v)                                      \
+  for (int jv_i__ = jv_object_iter(t), jv_j__ = 1; jv_j__; jv_j__ = 0)  \
+    for (jv k, v;                                                       \
+         jv_object_iter_valid((t), jv_i__) ?                            \
+           (k = jv_object_iter_key(t, jv_i__),                          \
+            v = jv_object_iter_value(t, jv_i__),                        \
+            1)                                                          \
+           : 0;                                                         \
+         jv_i__ = jv_object_iter_next(t, jv_i__))                       \
  
 
 
diff --git a/jv_aux.c b/jv_aux.c
index f0e15b50..2c33491d 100644
--- a/jv_aux.c
+++ b/jv_aux.c
@@ -70,7 +70,7 @@ jv jv_dels(jv t, jv keys) {
   } else if (jv_get_kind(t) == JV_KIND_ARRAY) {
     jv new_array = jv_array();
     int kidx = 0;
-    for (int i=0; i<jv_array_length(jv_copy(t)); i++) {
+    jv_array_foreach(t, i, elem) {
       int del = 0;
       while (kidx < jv_array_length(jv_copy(keys))) {
         jv nextdel = jv_array_get(jv_copy(keys), kidx);
@@ -79,6 +79,7 @@ jv jv_dels(jv t, jv keys) {
                                                      jv_kind_name(jv_get_kind(nextdel))));
           jv_free(nextdel);
           jv_free(new_array);
+          jv_free(elem);
           new_array = err;
           goto arr_out; // break twice
         }
@@ -93,14 +94,15 @@ jv jv_dels(jv t, jv keys) {
         kidx++;
       }
       if (!del)
-        new_array = jv_array_append(new_array, jv_array_get(jv_copy(t), i));
+        new_array = jv_array_append(new_array, elem);
+      else
+        jv_free(elem);
     }
   arr_out:
     jv_free(t);
     t = new_array;
   } else if (jv_get_kind(t) == JV_KIND_OBJECT) {
-    for (int i=0; i<jv_array_length(jv_copy(keys)); i++) {
-      jv k = jv_array_get(jv_copy(keys), i);
+    jv_array_foreach(keys, i, k) {
       if (jv_get_kind(k) != JV_KIND_STRING) {
         jv_free(t);
         t = jv_invalid_with_msg(jv_string_fmt("Cannot delete %s field of object",
@@ -212,8 +214,7 @@ static jv delpaths_sorted(jv object, jv paths, int start) {
 
 jv jv_delpaths(jv object, jv paths) {
   paths = jv_sort(paths, jv_copy(paths));
-  for (int i=0; i<jv_array_length(jv_copy(paths)); i++) {
-    jv elem = jv_array_get(jv_copy(paths), i);
+  jv_array_foreach(paths, i, elem) {
     if (jv_get_kind(elem) != JV_KIND_ARRAY) {
       jv_free(object);
       jv_free(paths);
@@ -255,8 +256,9 @@ jv jv_keys(jv x) {
     int nkeys = jv_object_length(jv_copy(x));
     jv* keys = jv_mem_alloc(sizeof(jv) * nkeys);
     int kidx = 0;
-    jv_object_foreach(i, x) {
-      keys[kidx++] = jv_object_iter_key(x, i);
+    jv_object_foreach(x, key, value) {
+      keys[kidx++] = key;
+      jv_free(value);
     }
     qsort(keys, nkeys, sizeof(jv), string_cmp);
     jv answer = jv_array_sized(nkeys);
@@ -337,8 +339,7 @@ int jv_cmp(jv a, jv b) {
     jv keys_b = jv_keys(jv_copy(b));
     r = jv_cmp(jv_copy(keys_a), keys_b);
     if (r == 0) {
-      for (int i=0; i<jv_array_length(jv_copy(keys_a)); i++) {
-        jv key = jv_array_get(jv_copy(keys_a), i);
+      jv_array_foreach(keys_a, i, key) {
         jv xa = jv_object_get(jv_copy(a), jv_copy(key));
         jv xb = jv_object_get(jv_copy(b), key);
         r = jv_cmp(xa, xb);
diff --git a/jv_print.c b/jv_print.c
index acade6cd..388bf663 100644
--- a/jv_print.c
+++ b/jv_print.c
@@ -162,7 +162,7 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
       put_char('\n', F, S);
       put_space(indent+INDENT, F, S);
     }
-    for (int i=0; i<jv_array_length(jv_copy(x)); i++) {
+    jv_array_foreach(x, i, elem) {
       if (i!=0) {
         if (flags & JV_PRINT_PRETTY) {
           put_str(",\n", F, S);
@@ -171,7 +171,7 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
           put_str(",", F, S);
         }
       }
-      jv_dump_term(C, jv_array_get(jv_copy(x), i), flags, indent + INDENT, F, S);
+      jv_dump_term(C, elem, flags, indent + INDENT, F, S);
       if (colour) put_str(colour, F, S);
     }
     if (flags & JV_PRINT_PRETTY) {
@@ -193,7 +193,7 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
       put_space(indent+INDENT, F, S);
     }
     int first = 1;
-    jv_object_foreach(i, x) {
+    jv_object_foreach(x, key, value) {
       if (!first) {
         if (flags & JV_PRINT_PRETTY){
           put_str(",\n", F, S);
@@ -205,7 +205,6 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
       if (colour) put_str(COLRESET, F, S);
 
       first = 0;
-      jv key = jv_object_iter_key(x, i);
       if (colour) put_str(FIELD_COLOUR, F, S);
       jvp_dump_string(key, flags & JV_PRINT_ASCII, F, S);
       jv_free(key);
@@ -215,7 +214,7 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
       put_str((flags & JV_PRINT_PRETTY) ? ": " : ":", F, S);
       if (colour) put_str(COLRESET, F, S);
       
-      jv_dump_term(C, jv_object_iter_value(x, i), flags, indent + INDENT, F, S);
+      jv_dump_term(C, value, flags, indent + INDENT, F, S);
       if (colour) put_str(colour, F, S);
     }
     if (flags & JV_PRINT_PRETTY) {

From c013b557a2bc72dff8795d89d4529e17946a5f3a Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 3 Jan 2013 12:51:33 +0000
Subject: [PATCH 212/284] Change APPEND opcode to directly modify a variable.

Avoids a big O(n^2) loop in constructing arrays. Fixes #61.
---
 compile.c     | 6 +-----
 execute.c     | 9 ++++++---
 opcode_list.h | 2 +-
 3 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/compile.c b/compile.c
index 08187836..b06e4f75 100644
--- a/compile.c
+++ b/compile.c
@@ -292,11 +292,7 @@ block gen_collect(block expr) {
                                gen_noop(), OP_HAS_VARIABLE);
   block c = BLOCK(gen_op_simple(DUP), gen_const(jv_array()), array_var);
 
-  block tail = BLOCK(gen_op_simple(DUP),
-                     gen_op_var_bound(LOADV, array_var),
-                     gen_op_simple(SWAP),
-                     gen_op_simple(APPEND),
-                     gen_op_var_bound(STOREV, array_var),
+  block tail = BLOCK(gen_op_var_bound(APPEND, array_var),
                      gen_op_simple(BACKTRACK));
 
   return BLOCK(c,
diff --git a/execute.c b/execute.c
index 94f6cd43..fb4a3895 100644
--- a/execute.c
+++ b/execute.c
@@ -236,9 +236,12 @@ jv jq_next() {
     case APPEND: {
       // FIXME paths
       jv v = stack_pop().value;
-      jv array = stack_pop().value;
-      array = jv_array_append(array, v);
-      stack_push(stackval_root(array));
+      uint16_t level = *pc++;
+      uint16_t vidx = *pc++;
+      frame_ptr fp = frame_get_level(&frame_stk, frame_current(&frame_stk), level);
+      jv* var = frame_local_var(fp, vidx);
+      assert(jv_get_kind(*var) == JV_KIND_ARRAY);
+      *var = jv_array_append(*var, v);
       break;
     }
 
diff --git a/opcode_list.h b/opcode_list.h
index 0185b5a6..f384d715 100644
--- a/opcode_list.h
+++ b/opcode_list.h
@@ -12,7 +12,7 @@ OP(FORK,  BRANCH,   0, 0)
 OP(JUMP,  BRANCH,   0, 0)
 OP(JUMP_F,BRANCH,   1, 0)
 OP(BACKTRACK, NONE, 0, 0)
-OP(APPEND, NONE,    2, 1)
+OP(APPEND, VARIABLE,1, 0)
 OP(INSERT, NONE,    4, 2)
 
 OP(GETPATH, NONE,   2, 1)

From 925ec3751f3b407c17412b0fa04a84fe39c1e0b7 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 3 Jan 2013 12:53:06 +0000
Subject: [PATCH 213/284] Fix negative number syntax. Add a unary '-' operator.

Closes #63.
---
 builtin.c | 10 ++++++++++
 lexer.l   |  2 +-
 parser.y  |  4 ++++
 testdata  | 13 +++++++++++++
 4 files changed, 28 insertions(+), 1 deletion(-)

diff --git a/builtin.c b/builtin.c
index 32b67ccc..76e559ea 100644
--- a/builtin.c
+++ b/builtin.c
@@ -65,6 +65,15 @@ static jv f_plus(jv input, jv a, jv b) {
   }
 }
 
+static jv f_negate(jv input) {
+  if (jv_get_kind(input) != JV_KIND_NUMBER) {
+    return type_error(input, "cannot be negated");
+  }
+  jv ret = jv_number(-jv_number_value(input));
+  jv_free(input);
+  return ret;
+}
+
 static jv f_minus(jv input, jv a, jv b) {
   jv_free(input);
   if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
@@ -462,6 +471,7 @@ static jv f_error(jv input, jv msg) {
 
 static struct cfunction function_list[] = {
   {(cfunction_ptr)f_plus, "_plus", 3},
+  {(cfunction_ptr)f_negate, "_negate", 1},
   {(cfunction_ptr)f_minus, "_minus", 3},
   {(cfunction_ptr)f_multiply, "_multiply", 3},
   {(cfunction_ptr)f_divide, "_divide", 3},
diff --git a/lexer.l b/lexer.l
index fd0e120e..9d826efa 100644
--- a/lexer.l
+++ b/lexer.l
@@ -73,7 +73,7 @@ struct lexer_param;
   yylval->literal = jv_string_sized(yytext + 1, yyleng - 1); return FORMAT;
 }
 
--?[0-9.]+([eE][+-]?[0-9]+)? { 
+[0-9.]+([eE][+-]?[0-9]+)? { 
    yylval->literal = jv_parse_sized(yytext, yyleng); return LITERAL; 
 }
 
diff --git a/parser.y b/parser.y
index a1be0b7f..92cd9db8 100644
--- a/parser.y
+++ b/parser.y
@@ -260,6 +260,10 @@ Exp "+=" Exp {
   $$ = gen_update($1, $3, '+');
 } |
 
+'-' Exp {
+  $$ = BLOCK($2, gen_call("_negate", gen_noop()));
+} |
+
 Exp '-' Exp {
   $$ = gen_binop($1, $3, '-');
 } |
diff --git a/testdata b/testdata
index 4a998d8e..83f91dae 100644
--- a/testdata
+++ b/testdata
@@ -21,6 +21,11 @@ null
 null
 1
 
+
+-1
+null
+-1
+
 # FIXME: much more number testing needed
 
 {}
@@ -197,6 +202,14 @@ null
 "wtasdf"
 2.0
 
+2-1
+null
+1
+
+2-(-1)
+null
+3
+
 1e+0+0.001e3
 "I wonder what this will be?"
 20e-1

From d0cd26cd8e110e9c2a68e56dac4c208851ec24e8 Mon Sep 17 00:00:00 2001
From: 13ren <melbourne.research@gmail.com>
Date: Sun, 13 Jan 2013 17:33:01 +1100
Subject: [PATCH 214/284] Update docs/content/3.manual/manual.yml

There's a , after map ; should be .
#65
---
 docs/content/3.manual/manual.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index de608210..3d856546 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -995,7 +995,7 @@ sections:
           If you want the value-argument behaviour for defining simple
           functions, you can just use a variable:
 
-              def addvalue(f): f as $value | map(, + $value);
+              def addvalue(f): f as $value | map(. + $value);
 
           With that definition, `addvalue(.foo)` will add the current
           input's `.foo` field to each element of the array.

From 115552f3a6d75da79e4aef544c2a76aaee2eb01d Mon Sep 17 00:00:00 2001
From: jkleint <jkleint@gmail.com>
Date: Fri, 25 Jan 2013 12:17:56 -0500
Subject: [PATCH 215/284] Clarify description of `as`

It's more of a foreach loop than an identity operation.

Addresses issue #72.
---
 docs/content/3.manual/manual.yml | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index de608210..d6732e68 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -953,10 +953,11 @@ sections:
           
               .realnames as $names | .posts[] | {title, author: $names[.author]}
           
-          The expression "foo as $x" runs foo, puts the result in $x,
-          and returns the original input. Apart from the side-effect
-          of binding the variable, it has the same effect as ".".
-          
+          The expression `exp as $x | ...` means: for each value of expression
+          `exp`, run the rest of the pipeline with the entire original input, and
+          with `$x` set to that value.  Thus `as` functions as something of a 
+          foreach loop.
+
           Variables are scoped over the rest of the expression that defines
           them, so 
           

From dd70eeb29d2a2a735a4be3a3d810f391a8ef4e7e Mon Sep 17 00:00:00 2001
From: Lee Thompson <stagr.lee@gmail.com>
Date: Tue, 29 Jan 2013 19:13:22 -0600
Subject: [PATCH 216/284] use built in macro to RPM

---
 jq.spec | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/jq.spec b/jq.spec
index ea7fe98a..4bdcac6f 100644
--- a/jq.spec
+++ b/jq.spec
@@ -31,11 +31,11 @@ echo "Building in: \"$(pwd)\""
 make
 
 %install
-echo "Installing to: \"${RPM_BUILD_ROOT}\""
-make install DESTDIR=${RPM_BUILD_ROOT}
+echo "Installing to: \"${_buildroot}\""
+make install DESTDIR=${_buildroot}
 
 %clean
-rm -rf ${RPM_BUILD_ROOT}
+rm -rf ${_buildroot}
 
 %files
 %defattr(-,root,root)

From 52f906ab43e342002d675c6041ee7d1bca142baf Mon Sep 17 00:00:00 2001
From: Lee Thompson <stagr.lee@gmail.com>
Date: Sat, 2 Feb 2013 23:05:00 -0600
Subject: [PATCH 217/284] fix jq_test so that it runs in the distcheck phase of
 autoconf

---
 jq_test.c | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/jq_test.c b/jq_test.c
index 77e2860f..9cdbdba4 100644
--- a/jq_test.c
+++ b/jq_test.c
@@ -8,12 +8,24 @@
 static void jv_test();
 static void run_jq_tests();
 
-FILE* testdata;
 
 int main(int argc, char* argv[]) {
+  FILE* testdata;
+
   jv_test();
   if (argc == 1) {
     testdata = fopen("testdata", "r");
+    if ( NULL == testdata )
+    {
+      /* in an autoconf distcheck, the binary file will be in a _build subdirectory */
+      testdata = fopen("../testdata", "r");
+      if ( NULL == testdata )
+      {
+        fprintf(stderr, "Could not find testdata file\n");
+        exit(1);
+      }
+    }
+
   } else if (argc == 2) {
     if (!strcmp(argv[1], "-")) {
       testdata = stdin;
@@ -24,7 +36,7 @@ int main(int argc, char* argv[]) {
     printf("usage: %s OR cat testdata | %s - OR %s testdata\n", argv[0], argv[0], argv[0]);
     return 127;
   }
-  run_jq_tests();
+  run_jq_tests(testdata);
   if (testdata != stdin) fclose(testdata);
 }
 
@@ -38,22 +50,10 @@ static int skipline(const char* buf) {
   return 0;
 }
 
-static void run_jq_tests() {
-  FILE* testdata = NULL;
+static void run_jq_tests(FILE *testdata) {
   char buf[4096];
   int tests = 0, passed = 0, invalid = 0;
 
-  testdata = fopen("testdata","r");
-  if ( NULL == testdata )
-  {
-    /* in an autoconf distcheck, the binary file will be in a _build subdirectory */
-    testdata = fopen("../testdata", "r");
-    if ( NULL == testdata )
-    {
-      fprintf(stderr, "Could not find testdata file\n");
-      exit(1);
-    }
-  }
   while (1) {
     if (!fgets(buf, sizeof(buf), testdata)) break;
     if (skipline(buf)) continue;

From 0370d5b526d58e811b967b170102e7bc2f6219d2 Mon Sep 17 00:00:00 2001
From: Lee Thompson <stagr.lee@gmail.com>
Date: Sat, 2 Feb 2013 23:50:43 -0600
Subject: [PATCH 218/284] fix RPM build process

---
 Makefile.am | 2 +-
 jq.spec     | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Makefile.am b/Makefile.am
index 7bdc53ef..bb5133bf 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -99,7 +99,7 @@ rpm: jq jq_test
 	@echo "Packaging jq as an RPM ..."
 	mkdir -p rpm/SOURCES rpm/BUILD rpm/BUILDROOT rpm/RPMS rpm/SPECS
 	cp jq-$$(cat VERSION).tar.gz rpm/SOURCES/
-	rpmbuild -tb --define "_topdir ${PWD}/rpm" --define "_prefix ${HOME}" --define "version $$(cat VERSION)" --define "release ${RELEASE}" rpm/SOURCES/jq-$$(cat VERSION).tar.gz
+	rpmbuild -tb --define "_topdir ${PWD}/rpm" --define "_prefix /usr" --define "version $$(cat VERSION)" --define "release ${RELEASE}" rpm/SOURCES/jq-$$(cat VERSION).tar.gz
 	find rpm/RPMS/ -name "*.rpm" -exec mv {} ./ \;
 	rm -rf rpm
 
diff --git a/jq.spec b/jq.spec
index 4bdcac6f..35db1ae1 100644
--- a/jq.spec
+++ b/jq.spec
@@ -31,11 +31,11 @@ echo "Building in: \"$(pwd)\""
 make
 
 %install
-echo "Installing to: \"${_buildroot}\""
-make install DESTDIR=${_buildroot}
+echo "Installing to: \"%{buildroot}\""
+make install DESTDIR=%{buildroot}
 
 %clean
-rm -rf ${_buildroot}
+rm -rf %{buildroot}
 
 %files
 %defattr(-,root,root)

From f62184855bb6d1708f3e99ae18f6e079e0466d6b Mon Sep 17 00:00:00 2001
From: Lee Thompson <stagr.lee@gmail.com>
Date: Sun, 3 Feb 2013 00:09:47 -0600
Subject: [PATCH 219/284] use AM_SILENT_RULES

---
 configure.ac | 1 +
 execute.c    | 1 +
 2 files changed, 2 insertions(+)

diff --git a/configure.ac b/configure.ac
index 52037ca8..8b00a2a7 100644
--- a/configure.ac
+++ b/configure.ac
@@ -5,6 +5,7 @@ dnl Created autoconf implementation thompson@dtosolutions, 26NOV12
 AC_PREREQ([2.61])
 AC_CONFIG_AUX_DIR([config])
 AM_INIT_AUTOMAKE([parallel-tests])
+AM_SILENT_RULES([yes])
 AC_PROG_CC
 AC_PROG_CC_STDC
 AC_PROG_CPP_WERROR
diff --git a/execute.c b/execute.c
index fb4a3895..ceaf9897 100644
--- a/execute.c
+++ b/execute.c
@@ -12,6 +12,7 @@
 #include "frame_layout.h"
 
 #include "jv_alloc.h"
+#include "jq_parser.h"
 #include "locfile.h"
 #include "jv.h"
 #include "jv_aux.h"

From d8a072ca011c525885b7f79cc888a64392644e09 Mon Sep 17 00:00:00 2001
From: Lee Thompson <stagr.lee@gmail.com>
Date: Sun, 3 Feb 2013 00:35:56 -0600
Subject: [PATCH 220/284] fix email addresses

---
 AUTHORS | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/AUTHORS b/AUTHORS
index 1cf1441b..98fdf672 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -1,6 +1,6 @@
 Created By:
-Stephen Dolan <mu@netsoc.tcd.ie>
+Stephen Dolan        <mu@netsoc.tcd.ie>
 
 Contributions by
-Anthony Shortland <anthony@dtosolutions.com> - rpmbuild target
-Lee Thompson <stagr.lee@gmail.com> - autoconf stuff
+Anthony Shortland    <anthony.shortland@me.com>      - rpmbuild target
+Lee Thompson         <stagr.lee@gmail.com>           - autoconf stuff

From 43fd939f1628ce88274b28aaa284946f00e8aadb Mon Sep 17 00:00:00 2001
From: Lee Thompson <stagr.lee@gmail.com>
Date: Sun, 3 Feb 2013 14:49:03 -0600
Subject: [PATCH 221/284] rework build to not distribute tests unless
 --enable-devel is specificied to autoconf

---
 Makefile.am  | 43 +++++++++++++++++++++++++++++++------------
 configure.ac | 20 ++++++++++----------
 jq.spec      | 31 ++++++++++++++++++++-----------
 setup.sh     |  9 ++++++++-
 4 files changed, 69 insertions(+), 34 deletions(-)

diff --git a/Makefile.am b/Makefile.am
index bb5133bf..3f65c660 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -44,10 +44,14 @@ JQ_SRC = \
   jv_aux.c \
   jv_alloc.c \
   lexer.c \
-  $(JQ_INCS)
+  ${JQ_INCS}
 
-if DEVCFLAGS_ENABLED
-DEVCFLAGS = -Wextra -Wall -Wno-missing-field-initializers -Wno-unused-parameter -std=gnu99 -ggdb -Wno-unused-function
+if DEVELOPMENT_ENABLED
+DEVCFLAGS = -Wextra -Wall -Wno-missing-field-initializers -Wno-unused-parameter -std=gnu99 -ggdb -Wno-unused-function -O0 -DJQ_DEBUG=1
+RPMBINS = jq jq_test
+else
+DEVCFLAGS = -DJQ_DEBUG=0
+RPMBINS = jq
 endif
 
 # Tell YACC (bison) autoconf macros that you want a header file created.
@@ -55,15 +59,31 @@ endif
 # OSX ships an old bison, so update with homebrew or macports
 AM_YFLAGS = --warnings=all -d
 
-bin_PROGRAMS = jq jq_test
+bin_PROGRAMS = jq
 BUILT_SOURCES = jv_utf8_tables.gen.h lexer.h lexer.c
-jq_SOURCES = $(JQ_SRC) main.c
-jq_CPPFLAGS = $(DEVCFLAGS) -O -DJQ_DEBUG=0
+jq_SOURCES = ${JQ_SRC} main.c
+jq_CPPFLAGS = ${DEVCFLAGS}
 
+# always test, but conditionally distribute to /usr/libexec/jq/jq_test
+if DEVELOPMENT_ENABLED
+  pkglibexec_PROGRAMS = jq_test
+  # automake doesn't like putting data in libexec (pkglibexec_DATA)
+  # so we'll create our own macro and distribute testdata
+  mydatadir = ${libexecdir}/${PACKAGE}
+  mydata_DATA = testdata
 
+  DEVBUILD=yes
+else
+  noinst_PROGRAMS = jq_test
+
+  DEVBUILD=no
+endif
+
+jq_test_SOURCES = ${JQ_SRC} jq_test.c
+jq_test_CPPFLAGS = ${DEVCFLAGS}
+
+# this is what gets "make check" to work
 TESTS = jq_test
-jq_test_SOURCES = $(JQ_SRC) jq_test.c
-jq_test_CPPFLAGS = $(DEVCFLAGS) -DJQ_DEBUG=1
 LOG_COMPILER = valgrind
 AM_LOG_FLAGS = --error-exitcode=1 -q --leak-check=full
 
@@ -93,15 +113,14 @@ main.c: config.h
 releasetag:
 	git tag -s "jq-$$(cat VERSION)" -m "jq release $$(cat VERSION)"
 
-# can probably delete and have RPM created off autoconf generated tarball releases
 RELEASE ?= 1
-rpm: jq jq_test
+rpm: ${RPMBINS}
 	@echo "Packaging jq as an RPM ..."
 	mkdir -p rpm/SOURCES rpm/BUILD rpm/BUILDROOT rpm/RPMS rpm/SPECS
 	cp jq-$$(cat VERSION).tar.gz rpm/SOURCES/
-	rpmbuild -tb --define "_topdir ${PWD}/rpm" --define "_prefix /usr" --define "version $$(cat VERSION)" --define "release ${RELEASE}" rpm/SOURCES/jq-$$(cat VERSION).tar.gz
+	rpmbuild -tb --define "_topdir ${PWD}/rpm" --define "_prefix /usr" --define "myver $$(cat VERSION)" --define "myrel ${RELEASE}" --define "devbuild ${DEVBUILD}" rpm/SOURCES/jq-$$(cat VERSION).tar.gz
 	find rpm/RPMS/ -name "*.rpm" -exec mv {} ./ \;
 	rm -rf rpm
 
 dist-clean-local:
-	rm -f $(BUILT_SOURCES)
+	rm -f ${BUILT_SOURCES}
diff --git a/configure.ac b/configure.ac
index 8b00a2a7..5f939493 100644
--- a/configure.ac
+++ b/configure.ac
@@ -22,16 +22,16 @@ dnl   developers like them by default but the packager can disable if so
 dnl   desired.  This is useful if something other than gcc is needed or
 dnl   for distros that need to heavily tweek the compiler (gentoo, ARM cpu
 dnl   linux's, etc)
-AC_ARG_ENABLE([devcflags],
-              [AC_HELP_STRING([--enable-devcflags=@<:@yes/no@:>@],
-                              [Enable the same CFLAGS used by jq developers @<:@default=yes@:>@])],
-              [enable_devcflags=$enableval],
-              [enable_devcflags=yes])
-AC_MSG_RESULT($enable_devcflags)
-dnl AM_CONDITIONAL(DEVCFLAGS, test x$enable_devcflags = xyes)
-if test "$enable_devcflags" = "yes"; then
-  AM_CONDITIONAL(DEVCFLAGS_ENABLED, true)
-fi
+AC_ARG_ENABLE(
+  [devel],
+  [AC_HELP_STRING(
+    [--enable-devel],
+    [Build the tests and enable the same CFLAGS used by jq developers @<:@default=no@:>@])],
+  [],
+  [enable_devel=no]
+)
+AC_MSG_RESULT($enable_devel)
+AM_CONDITIONAL([DEVELOPMENT_ENABLED], [test x$enable_devel = xyes])
 
 dnl
 dnl these program checks should probably be deleted
diff --git a/jq.spec b/jq.spec
index 35db1ae1..3697ed02 100644
--- a/jq.spec
+++ b/jq.spec
@@ -2,9 +2,9 @@
 # Your OS of choice will likely ignore this RPM spec file.
 Summary: Command-line JSON processor
 Name: jq
-Version: %{version}
-Release: %{release}
-Source0: jq-%{version}.tar.gz
+Version: %{myver}
+Release: %{myrel}%{?dist}
+Source0: jq-%{myver}.tar.gz
 URL: https://github.com/stedolan/jq
 License: BSD
 AutoReqProv: no
@@ -18,16 +18,22 @@ Group: Applications/System
 %global debug_package %{nil}
 %global __os_install_post %{nil}
 
+# Crank up the compression
+%define _binary_payload w7.lzdio
+
 %description
 jq is a command-line JSON processor
 
 %prep
-
 %setup
 
 %build
 echo "Building in: \"$(pwd)\""
+%if "%{devbuild}" == "yes"
+./configure --prefix=%{_prefix} --enable-devel
+%else
 ./configure --prefix=%{_prefix}
+%endif
 make
 
 %install
@@ -40,13 +46,16 @@ rm -rf %{buildroot}
 %files
 %defattr(-,root,root)
 %{_bindir}/jq
-%{_bindir}/jq_test
-%{_datadir}/doc/jq/AUTHORS
-%{_datadir}/doc/jq/COPYING
-%{_datadir}/doc/jq/INSTALL
-%{_datadir}/doc/jq/NEWS
-%{_datadir}/doc/jq/README
-%{_datadir}/doc/jq/README.md
+%if "%{devbuild}" == "yes"
+%{_libexecdir}/%{name}/jq_test
+%{_libexecdir}/%{name}/testdata
+%endif
+%{_datadir}/doc/%{name}/AUTHORS
+%{_datadir}/doc/%{name}/COPYING
+%{_datadir}/doc/%{name}/INSTALL
+%{_datadir}/doc/%{name}/NEWS
+%{_datadir}/doc/%{name}/README
+%{_datadir}/doc/%{name}/README.md
 
 %changelog
 
diff --git a/setup.sh b/setup.sh
index 763e78f4..ef92f88a 100755
--- a/setup.sh
+++ b/setup.sh
@@ -1,12 +1,19 @@
 #!/usr/bin/env bash
 
 # RUN ME after pulling the code from git!
+#
+# This script is handy after pulling the code out of git without having
+# to remember all the typing needed to build up and tear down all the
+# crap that autotools puts in your source repo.  The intent is to keep
+# all generated files out of git.
+
 if [ "clean" == "$1" ]; then
   make distclean || echo "continuing..."
   rm -rf tmp autom4te.cache config
   rm -f INSTALL Makefile.in aclocal.m4 configure config.h.in ChangeLog
   rm -f jv_utf8_tables.gen.h lexer.c lexer.h parser.c parser.h
 elif [ "superclean" == "$1" ]; then
+  # if autoconf errors during distcheck, it leaves files that need chmod'ing
   ver=$(tr -d '\n' <VERSION)
   if [ "x${ver}" != "x" ]; then
     if [ -d jq-${ver} ]; then
@@ -17,7 +24,7 @@ elif [ "superclean" == "$1" ]; then
   fi
 else
   autoreconf --install
-  ./configure --prefix=/opt/junk
+  ./configure --enable-devel --prefix=/opt/junk
   make check
   mkdir tmp
   make DESTDIR=./tmp install

From 1d3d2efc89746a6f702efeded7680c63fe91d87f Mon Sep 17 00:00:00 2001
From: Lee Thompson <stagr.lee@gmail.com>
Date: Mon, 4 Feb 2013 07:01:18 -0600
Subject: [PATCH 222/284] add man page to release

---
 Makefile.am | 42 +++++++++++++++++++++++++++++++++++++++++-
 jq.spec     |  1 +
 2 files changed, 42 insertions(+), 1 deletion(-)

diff --git a/Makefile.am b/Makefile.am
index 3f65c660..90c5f6d5 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -3,7 +3,42 @@
 # setup is only used by distribution developers, not package developers.
 # Still, as a matter of allowing patching, its not a bad idea to distribute 
 # the developer setup script in the tarball.
-EXTRA_DIST = setup.sh config.h.in ChangeLog VERSION lexer.l lexer.h gen_utf8_tables.py jq.spec testdata
+EXTRA_DIST = \
+  setup.sh \
+  config.h.in \
+  ChangeLog \
+  VERSION \
+  lexer.l \
+  lexer.h \
+  gen_utf8_tables.py \
+  jq.spec \
+  testdata \
+  docs/content/1.tutorial/default.yml \
+  docs/content/2.download/default.yml \
+  docs/content/3.manual/manual.yml \
+  docs/content/index/index.yml \
+  docs/Gemfile \
+  docs/Gemfile.lock \
+  docs/public/.htaccess \
+  docs/public/bootstrap/css/bootstrap-responsive.css \
+  docs/public/bootstrap/css/bootstrap-responsive.min.css \
+  docs/public/bootstrap/css/bootstrap.css \
+  docs/public/bootstrap/css/bootstrap.min.css \
+  docs/public/bootstrap/img/glyphicons-halflings-white.png \
+  docs/public/bootstrap/img/glyphicons-halflings.png \
+  docs/public/bootstrap/js/bootstrap.js \
+  docs/public/bootstrap/js/bootstrap.min.js \
+  docs/public/css/base.scss \
+  docs/public/jq.png \
+  docs/public/robots.txt \
+  docs/Rakefile \
+  docs/site.yml \
+  docs/templates/default.liquid \
+  docs/templates/index.liquid \
+  docs/templates/manual.liquid \
+  docs/templates/shared/_footer.liquid \
+  docs/templates/shared/_head.liquid \
+  docs/templates/shared/_header.liquid
 
 # README.md is expected in Github projects, good stuff in it, so we'll 
 # distribute it and install it with the package in the doc directory.
@@ -87,6 +122,11 @@ TESTS = jq_test
 LOG_COMPILER = valgrind
 AM_LOG_FLAGS = --error-exitcode=1 -q --leak-check=full
 
+man_MANS = jq.1
+
+jq.1 :
+	cd ${abs_srcdir}/docs; rake manpage > ${abs_builddir}/$@
+
 # nasty circular dependency on header files between the generated C files
 parser.o: lexer.c
 
diff --git a/jq.spec b/jq.spec
index 3697ed02..87dfc0de 100644
--- a/jq.spec
+++ b/jq.spec
@@ -56,6 +56,7 @@ rm -rf %{buildroot}
 %{_datadir}/doc/%{name}/NEWS
 %{_datadir}/doc/%{name}/README
 %{_datadir}/doc/%{name}/README.md
+%{_datadir}/man/man1/jq.1
 
 %changelog
 

From dc4d3d8cbee6659ac444cb4696edd9bd8157f6eb Mon Sep 17 00:00:00 2001
From: Lee Thompson <stagr.lee@gmail.com>
Date: Mon, 4 Feb 2013 13:35:42 -0600
Subject: [PATCH 223/284] get man pages working

---
 Makefile.am   | 5 +++++
 docs/Rakefile | 1 +
 2 files changed, 6 insertions(+)

diff --git a/Makefile.am b/Makefile.am
index 90c5f6d5..2aa2dda0 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -164,3 +164,8 @@ rpm: ${RPMBINS}
 
 dist-clean-local:
 	rm -f ${BUILT_SOURCES}
+
+# Not sure why this doesn't get cleaned up automatically, guess
+# automake used to man pages which are hand coded?
+clean-local:
+	rm -f jq.1
diff --git a/docs/Rakefile b/docs/Rakefile
index a95c97fa..5ca6e31f 100644
--- a/docs/Rakefile
+++ b/docs/Rakefile
@@ -1,3 +1,4 @@
+require 'yaml'
 require 'bonsai'
 require 'liquid'
 require 'maruku'

From e45f93f85f22c73025830a6bd0b2807263068996 Mon Sep 17 00:00:00 2001
From: Simon Elsbrock <simon@iodev.org>
Date: Wed, 20 Feb 2013 22:38:50 +0100
Subject: [PATCH 224/284] fix typo in manual

---
 docs/content/3.manual/manual.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index de608210..21907b95 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -178,7 +178,7 @@ sections:
           If you use the `.[foo]` syntax, but omit the index
           entirely, it will return *all* of the elements of an
           array. Running `.[]` with the input `[1,2,3]` will produce the
-          numbers as three seperate results, rather than as a single
+          numbers as three separate results, rather than as a single
           array.
 
         examples:

From 054e3f379572f7c3fd859d16b8f5014b65030ae5 Mon Sep 17 00:00:00 2001
From: Shay Elkin <shay@everything.me>
Date: Sun, 24 Mar 2013 14:01:19 +0200
Subject: [PATCH 225/284] Add missing require to Rakefile Use bundle exec to
 make manpage Don't set executable bit on manpage

---
 Makefile      | 4 ++--
 docs/Rakefile | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/Makefile b/Makefile
index 69e97c71..13e0762c 100644
--- a/Makefile
+++ b/Makefile
@@ -85,13 +85,13 @@ docs/content/2.download/source/jq.tgz: jq
 tarball: docs/content/2.download/source/jq.tgz
 
 jq.1: docs/content/3.manual/manual.yml
-	( cd docs; rake manpage; ) > $@
+	( cd docs; bundle exec rake manpage; ) > $@
 
 install: jq jq.1
 	install -d -m 0755 $(prefix)/bin
 	install -m 0755 jq $(prefix)/bin
 	install -d -m 0755 $(mandir)/man1
-	install -m 0755 jq.1 $(mandir)/man1
+	install -m 0644 jq.1 $(mandir)/man1
 
 uninstall:
 	rm -vf $(prefix)/bin/jq
diff --git a/docs/Rakefile b/docs/Rakefile
index a95c97fa..231f01b6 100644
--- a/docs/Rakefile
+++ b/docs/Rakefile
@@ -4,6 +4,7 @@ require 'maruku'
 require 'json'
 require 'ronn'
 require 'tempfile'
+require 'yaml'
 
 module ExtraFilters
   def markdownify(input)

From 87e9c64003fdb13c629a3e0fbd3c6691a1967d7f Mon Sep 17 00:00:00 2001
From: Nicolas Williams <nico@cryptonector.com>
Date: Sun, 28 Apr 2013 18:33:45 -0500
Subject: [PATCH 226/284] Remove globals/make jq_init/next/teardown() an API

---
 execute.c | 281 ++++++++++++++++++++++++++++--------------------------
 execute.h |   8 +-
 jq_test.c |   9 +-
 main.c    |   7 +-
 4 files changed, 159 insertions(+), 146 deletions(-)

diff --git a/execute.c b/execute.c
index fb4a3895..7f1dea9f 100644
--- a/execute.c
+++ b/execute.c
@@ -23,24 +23,28 @@ typedef struct {
   int pathidx;
 } stackval;
 
+struct jq_state {
+  struct forkable_stack data_stk;
+  struct forkable_stack frame_stk;
+  struct forkable_stack fork_stk;
+  jv* pathbuf;
+  int pathsize; // number of allocated elements
+};
 
-jv* pathbuf;
-int pathsize; // number of allocated elements
-
-int path_push(stackval sv, jv val) {
+int path_push(jq_state *jq, stackval sv, jv val) {
   int pos = sv.pathidx;
-  assert(pos <= pathsize);
+  assert(pos <= jq->pathsize);
   assert(pos >= 0);
-  if (pos == pathsize) {
-    int oldpathsize = pathsize;
-    pathsize = oldpathsize ? oldpathsize * 2 : 100;
-    pathbuf = jv_mem_realloc(pathbuf, sizeof(pathbuf[0]) * pathsize);
-    for (int i=oldpathsize; i<pathsize; i++) {
-      pathbuf[i] = jv_invalid();
+  if (pos == jq->pathsize) {
+    int oldpathsize = jq->pathsize;
+    jq->pathsize = oldpathsize ? oldpathsize * 2 : 100;
+    jq->pathbuf = jv_mem_realloc(jq->pathbuf, sizeof(jq->pathbuf[0]) * jq->pathsize);
+    for (int i=oldpathsize; i<jq->pathsize; i++) {
+      jq->pathbuf[i] = jv_invalid();
     }
   }
-  jv_free(pathbuf[pos]);
-  pathbuf[pos] = val;
+  jv_free(jq->pathbuf[pos]);
+  jq->pathbuf[pos] = val;
   return pos + 1;
 }
 
@@ -57,30 +61,28 @@ stackval stackval_root(jv v) {
   return s;
 }
 
-struct forkable_stack data_stk;
 typedef struct {
   FORKABLE_STACK_HEADER;
   stackval sv;
 } data_stk_elem;
 
-void stack_push(stackval val) {
+void stack_push(jq_state *jq, stackval val) {
   assert(jv_is_valid(val.value));
-  data_stk_elem* s = forkable_stack_push(&data_stk, sizeof(data_stk_elem));
+  data_stk_elem* s = forkable_stack_push(&jq->data_stk, sizeof(data_stk_elem));
   s->sv = val;
 }
 
-stackval stack_pop() {
-  data_stk_elem* s = forkable_stack_peek(&data_stk);
+stackval stack_pop(jq_state *jq) {
+  data_stk_elem* s = forkable_stack_peek(&jq->data_stk);
   stackval sv = s->sv;
-  if (!forkable_stack_pop_will_free(&data_stk)) {
+  if (!forkable_stack_pop_will_free(&jq->data_stk)) {
     sv.value = jv_copy(sv.value);
   }
-  forkable_stack_pop(&data_stk);
+  forkable_stack_pop(&jq->data_stk);
   assert(jv_is_valid(sv.value));
   return sv;
 }
 
-struct forkable_stack frame_stk;
 
 
 struct forkpoint {
@@ -89,36 +91,35 @@ struct forkpoint {
   struct forkable_stack_state saved_call_stack;
 };
 
-struct forkable_stack fork_stk;
 
-void stack_save(){
-  struct forkpoint* fork = forkable_stack_push(&fork_stk, sizeof(struct forkpoint));
-  forkable_stack_save(&data_stk, &fork->saved_data_stack);
-  forkable_stack_save(&frame_stk, &fork->saved_call_stack);
+void stack_save(jq_state *jq){
+  struct forkpoint* fork = forkable_stack_push(&jq->fork_stk, sizeof(struct forkpoint));
+  forkable_stack_save(&jq->data_stk, &fork->saved_data_stack);
+  forkable_stack_save(&jq->frame_stk, &fork->saved_call_stack);
 }
 
-void stack_switch() {
-  struct forkpoint* fork = forkable_stack_peek(&fork_stk);
-  forkable_stack_switch(&data_stk, &fork->saved_data_stack);
-  forkable_stack_switch(&frame_stk, &fork->saved_call_stack);
+void stack_switch(jq_state *jq) {
+  struct forkpoint* fork = forkable_stack_peek(&jq->fork_stk);
+  forkable_stack_switch(&jq->data_stk, &fork->saved_data_stack);
+  forkable_stack_switch(&jq->frame_stk, &fork->saved_call_stack);
 }
 
-int stack_restore(){
-  while (!forkable_stack_empty(&data_stk) && 
-         forkable_stack_pop_will_free(&data_stk)) {
-    jv_free(stack_pop().value);
+int stack_restore(jq_state *jq){
+  while (!forkable_stack_empty(&jq->data_stk) && 
+         forkable_stack_pop_will_free(&jq->data_stk)) {
+    jv_free(stack_pop(jq).value);
   }
-  while (!forkable_stack_empty(&frame_stk) && 
-         forkable_stack_pop_will_free(&frame_stk)) {
-    frame_pop(&frame_stk);
+  while (!forkable_stack_empty(&jq->frame_stk) && 
+         forkable_stack_pop_will_free(&jq->frame_stk)) {
+    frame_pop(&jq->frame_stk);
   }
-  if (forkable_stack_empty(&fork_stk)) {
+  if (forkable_stack_empty(&jq->fork_stk)) {
     return 0;
   } else {
-    struct forkpoint* fork = forkable_stack_peek(&fork_stk);
-    forkable_stack_restore(&data_stk, &fork->saved_data_stack);
-    forkable_stack_restore(&frame_stk, &fork->saved_call_stack);
-    forkable_stack_pop(&fork_stk);
+    struct forkpoint* fork = forkable_stack_peek(&jq->fork_stk);
+    forkable_stack_restore(&jq->data_stk, &fork->saved_data_stack);
+    forkable_stack_restore(&jq->frame_stk, &fork->saved_call_stack);
+    forkable_stack_pop(&jq->fork_stk);
     return 1;
   }
 }
@@ -148,21 +149,21 @@ void print_error(jv value) {
 }
 #define ON_BACKTRACK(op) ((op)+NUM_OPCODES)
 
-jv jq_next() {
+jv jq_next(jq_state *jq) {
   jv cfunc_input[MAX_CFUNCTION_ARGS];
 
-  assert(!forkable_stack_empty(&frame_stk));
-  uint16_t* pc = *frame_current_retaddr(&frame_stk);
-  frame_pop(&frame_stk);
+  assert(!forkable_stack_empty(&jq->frame_stk));
+  uint16_t* pc = *frame_current_retaddr(&jq->frame_stk);
+  frame_pop(&jq->frame_stk);
   
-  assert(!forkable_stack_empty(&frame_stk));
+  assert(!forkable_stack_empty(&jq->frame_stk));
 
   int backtracking = 0;
   while (1) {
     uint16_t opcode = *pc;
 
 #if JQ_DEBUG
-    dump_operation(frame_current_bytecode(&frame_stk), pc);
+    dump_operation(frame_current_bytecode(&jq->frame_stk), pc);
     printf("\t");
     const struct opcode_description* opdesc = opcode_describe(opcode);
     data_stk_elem* param;
@@ -170,10 +171,10 @@ jv jq_next() {
     if (stack_in == -1) stack_in = pc[1];
     for (int i=0; i<stack_in; i++) {
       if (i == 0) {
-        param = forkable_stack_peek(&data_stk);
+        param = forkable_stack_peek(&jq->data_stk);
       } else {
         printf(" | ");
-        param = forkable_stack_peek_next(&data_stk, param);
+        param = forkable_stack_peek_next(&jq->data_stk, param);
       }
       if (!param) break;
       jv_dump(jv_copy(param->sv.value), 0);
@@ -194,51 +195,51 @@ jv jq_next() {
     default: assert(0 && "invalid instruction");
 
     case LOADK: {
-      jv v = jv_array_get(jv_copy(frame_current_bytecode(&frame_stk)->constants), *pc++);
+      jv v = jv_array_get(jv_copy(frame_current_bytecode(&jq->frame_stk)->constants), *pc++);
       assert(jv_is_valid(v));
-      stack_push(stackval_replace(stack_pop(), v));
+      stack_push(jq, stackval_replace(stack_pop(jq), v));
       break;
     }
 
     case DUP: {
-      stackval v = stack_pop();
+      stackval v = stack_pop(jq);
       stackval v2 = v;
       v2.value = jv_copy(v.value);
-      stack_push(v);
-      stack_push(v2);
+      stack_push(jq, v);
+      stack_push(jq, v2);
       break;
     }
 
     case DUP2: {
-      stackval keep = stack_pop();
-      stackval v = stack_pop();
+      stackval keep = stack_pop(jq);
+      stackval v = stack_pop(jq);
       stackval v2 = v;
       v2.value = jv_copy(v.value);
-      stack_push(v);
-      stack_push(keep);
-      stack_push(v2);
+      stack_push(jq, v);
+      stack_push(jq, keep);
+      stack_push(jq, v2);
       break;
     }
 
     case SWAP: {
-      stackval a = stack_pop();
-      stackval b = stack_pop();
-      stack_push(a);
-      stack_push(b);
+      stackval a = stack_pop(jq);
+      stackval b = stack_pop(jq);
+      stack_push(jq, a);
+      stack_push(jq, b);
       break;
     }
       
     case POP: {
-      jv_free(stack_pop().value);
+      jv_free(stack_pop(jq).value);
       break;
     }
 
     case APPEND: {
       // FIXME paths
-      jv v = stack_pop().value;
+      jv v = stack_pop(jq).value;
       uint16_t level = *pc++;
       uint16_t vidx = *pc++;
-      frame_ptr fp = frame_get_level(&frame_stk, frame_current(&frame_stk), level);
+      frame_ptr fp = frame_get_level(&jq->frame_stk, frame_current(&jq->frame_stk), level);
       jv* var = frame_local_var(fp, vidx);
       assert(jv_get_kind(*var) == JV_KIND_ARRAY);
       *var = jv_array_append(*var, v);
@@ -246,15 +247,15 @@ jv jq_next() {
     }
 
     case INSERT: {
-      stackval stktop = stack_pop();
-      jv v = stack_pop().value;
-      jv k = stack_pop().value;
-      stackval objv = stack_pop();
+      stackval stktop = stack_pop(jq);
+      jv v = stack_pop(jq).value;
+      jv k = stack_pop(jq).value;
+      stackval objv = stack_pop(jq);
       assert(jv_get_kind(k) == JV_KIND_STRING);
       assert(jv_get_kind(objv.value) == JV_KIND_OBJECT);
       objv.value = jv_object_set(objv.value, k, v);
-      stack_push(objv);
-      stack_push(stktop);
+      stack_push(jq, objv);
+      stack_push(jq, stktop);
       break;
     }
 
@@ -262,23 +263,23 @@ jv jq_next() {
     case LOADV: {
       uint16_t level = *pc++;
       uint16_t v = *pc++;
-      frame_ptr fp = frame_get_level(&frame_stk, frame_current(&frame_stk), level);
+      frame_ptr fp = frame_get_level(&jq->frame_stk, frame_current(&jq->frame_stk), level);
       jv* var = frame_local_var(fp, v);
       #if JQ_DEBUG
       printf("V%d = ", v);
       jv_dump(jv_copy(*var), 0);
       printf("\n");
       #endif
-      stack_push(stackval_replace(stack_pop(), jv_copy(*var)));
+      stack_push(jq, stackval_replace(stack_pop(jq), jv_copy(*var)));
       break;
     }
 
     case STOREV: {
       uint16_t level = *pc++;
       uint16_t v = *pc++;
-      frame_ptr fp = frame_get_level(&frame_stk, frame_current(&frame_stk), level);
+      frame_ptr fp = frame_get_level(&jq->frame_stk, frame_current(&jq->frame_stk), level);
       jv* var = frame_local_var(fp, v);
-      stackval val = stack_pop();
+      stackval val = stack_pop(jq);
       #if JQ_DEBUG
       printf("V%d = ", v);
       jv_dump(jv_copy(val.value), 0);
@@ -290,27 +291,27 @@ jv jq_next() {
     }
 
     case GETPATH: {
-      stackval path_end = stack_pop();
-      stackval path_start = stack_pop();
+      stackval path_end = stack_pop(jq);
+      stackval path_start = stack_pop(jq);
       jv_free(path_end.value);
       jv path = jv_array();
       for (int i=path_start.pathidx; i<path_end.pathidx; i++) {
-        path = jv_array_set(path, i, jv_copy(pathbuf[i]));
+        path = jv_array_set(path, i, jv_copy(jq->pathbuf[i]));
       }
-      stack_push(stackval_replace(path_start, path));
+      stack_push(jq, stackval_replace(path_start, path));
       break;
     }
 
     case INDEX: {
-      stackval t = stack_pop();
-      jv k = stack_pop().value;
-      int pathidx = path_push(t, jv_copy(k));
+      stackval t = stack_pop(jq);
+      jv k = stack_pop(jq).value;
+      int pathidx = path_push(jq, t, jv_copy(k));
       jv v = jv_get(t.value, k);
       if (jv_is_valid(v)) {
         stackval sv;
         sv.value = v;
         sv.pathidx = pathidx;
-        stack_push(sv);
+        stack_push(jq, sv);
       } else {
         print_error(v);
         goto do_backtrack;
@@ -327,21 +328,21 @@ jv jq_next() {
 
     case JUMP_F: {
       uint16_t offset = *pc++;
-      stackval t = stack_pop();
+      stackval t = stack_pop(jq);
       jv_kind kind = jv_get_kind(t.value);
       if (kind == JV_KIND_FALSE || kind == JV_KIND_NULL) {
         pc += offset;
       }
-      stack_push(t); // FIXME do this better
+      stack_push(jq, t); // FIXME do this better
       break;
     }
 
     case EACH: 
-      stack_push(stackval_root(jv_number(-1)));
+      stack_push(jq, stackval_root(jv_number(-1)));
       // fallthrough
     case ON_BACKTRACK(EACH): {
-      int idx = jv_number_value(stack_pop().value);
-      stackval container = stack_pop();
+      int idx = jv_number_value(stack_pop(jq).value);
+      stackval container = stack_pop(jq);
 
       int keep_going;
       jv key, value;
@@ -372,34 +373,34 @@ jv jq_next() {
         jv_free(container.value);
         goto do_backtrack;
       } else {
-        stack_save();
-        stack_push(container);
-        stack_push(stackval_root(jv_number(idx)));
-        frame_push_backtrack(&frame_stk, pc - 1);
-        stack_switch();
+        stack_save(jq);
+        stack_push(jq, container);
+        stack_push(jq, stackval_root(jv_number(idx)));
+        frame_push_backtrack(&jq->frame_stk, pc - 1);
+        stack_switch(jq);
         
         stackval sv = {value,
-                       path_push(container, key)};
-        stack_push(sv);
+                       path_push(jq, container, key)};
+        stack_push(jq, sv);
       }
       break;
     }
 
     do_backtrack:
     case BACKTRACK: {
-      if (!stack_restore()) {
+      if (!stack_restore(jq)) {
         return jv_invalid();
       }
-      pc = *frame_current_retaddr(&frame_stk);
-      frame_pop(&frame_stk);
+      pc = *frame_current_retaddr(&jq->frame_stk);
+      frame_pop(&jq->frame_stk);
       backtracking = 1;
       break;
     }
 
     case FORK: {
-      stack_save();
-      frame_push_backtrack(&frame_stk, pc - 1);
-      stack_switch();
+      stack_save(jq);
+      frame_push_backtrack(&jq->frame_stk, pc - 1);
+      stack_switch(jq);
       pc++; // skip offset this time
       break;
     }
@@ -411,22 +412,22 @@ jv jq_next() {
     }
 
     case YIELD: {
-      jv value = stack_pop().value;
-      frame_push_backtrack(&frame_stk, pc);
+      jv value = stack_pop(jq).value;
+      frame_push_backtrack(&jq->frame_stk, pc);
       return value;
     }
       
     case CALL_BUILTIN: {
       int nargs = *pc++;
-      stackval top = stack_pop();
+      stackval top = stack_pop(jq);
       cfunc_input[0] = top.value;
       for (int i = 1; i < nargs; i++) {
-        cfunc_input[i] = stack_pop().value;
+        cfunc_input[i] = stack_pop(jq).value;
       }
-      struct cfunction* func = &frame_current_bytecode(&frame_stk)->globals->cfunctions[*pc++];
+      struct cfunction* func = &frame_current_bytecode(&jq->frame_stk)->globals->cfunctions[*pc++];
       top.value = cfunction_invoke(func, cfunc_input);
       if (jv_is_valid(top.value)) {
-        stack_push(top);
+        stack_push(jq, top);
       } else {
         print_error(top.value);
         goto do_backtrack;
@@ -437,24 +438,24 @@ jv jq_next() {
     case CALL_JQ: {
       uint16_t nclosures = *pc++;
       uint16_t* retaddr = pc + 2 + nclosures*2;
-      frame_ptr new_frame = frame_push(&frame_stk, 
-                                       make_closure(&frame_stk, frame_current(&frame_stk), pc),
+      frame_ptr new_frame = frame_push(&jq->frame_stk, 
+                                       make_closure(&jq->frame_stk, frame_current(&jq->frame_stk), pc),
                                        retaddr);
       pc += 2;
-      frame_ptr old_frame = forkable_stack_peek_next(&frame_stk, new_frame);
+      frame_ptr old_frame = forkable_stack_peek_next(&jq->frame_stk, new_frame);
       assert(nclosures == frame_self(new_frame)->bc->nclosures);
       for (int i=0; i<nclosures; i++) {
-        *frame_closure_arg(new_frame, i) = make_closure(&frame_stk, old_frame, pc);
+        *frame_closure_arg(new_frame, i) = make_closure(&jq->frame_stk, old_frame, pc);
         pc += 2;
       }
 
-      pc = frame_current_bytecode(&frame_stk)->code;
+      pc = frame_current_bytecode(&jq->frame_stk)->code;
       break;
     }
 
     case RET: {
-      pc = *frame_current_retaddr(&frame_stk);
-      frame_pop(&frame_stk);
+      pc = *frame_current_retaddr(&jq->frame_stk);
+      frame_pop(&jq->frame_stk);
       break;
     }
     }
@@ -462,33 +463,41 @@ jv jq_next() {
 }
 
 
-void jq_init(struct bytecode* bc, jv input) {
-  forkable_stack_init(&data_stk, sizeof(stackval) * 100);
-  forkable_stack_init(&frame_stk, 1024);
-  forkable_stack_init(&fork_stk, 1024);
+void jq_init(struct bytecode* bc, jv input, jq_state **jq) {
+  jq_state *new_jq;
+  new_jq = jv_mem_alloc(sizeof(*new_jq));
+  memset(new_jq, 0, sizeof(*new_jq));
+  forkable_stack_init(&new_jq->data_stk, sizeof(stackval) * 100);
+  forkable_stack_init(&new_jq->frame_stk, 1024);
+  forkable_stack_init(&new_jq->fork_stk, 1024);
   
-  stack_push(stackval_root(input));
+  stack_push(new_jq, stackval_root(input));
   struct closure top = {bc, -1};
-  frame_push(&frame_stk, top, 0);
-  frame_push_backtrack(&frame_stk, bc->code);
+  frame_push(&new_jq->frame_stk, top, 0);
+  frame_push_backtrack(&new_jq->frame_stk, bc->code);
+  *jq = new_jq;
 }
 
-void jq_teardown() {
-  while (stack_restore()) {}
+void jq_teardown(jq_state **jq) {
+  jq_state *old_jq = *jq;
+  if (old_jq == NULL)
+    return;
+  *jq = NULL;
 
-  assert(forkable_stack_empty(&fork_stk));
-  assert(forkable_stack_empty(&data_stk));
-  assert(forkable_stack_empty(&frame_stk));
-  forkable_stack_free(&fork_stk);
-  forkable_stack_free(&data_stk);
-  forkable_stack_free(&frame_stk);
+  while (stack_restore(old_jq)) {}
 
-  for (int i=0; i<pathsize; i++) {
-    jv_free(pathbuf[i]);
+  assert(forkable_stack_empty(&old_jq->fork_stk));
+  assert(forkable_stack_empty(&old_jq->data_stk));
+  assert(forkable_stack_empty(&old_jq->frame_stk));
+  forkable_stack_free(&old_jq->fork_stk);
+  forkable_stack_free(&old_jq->data_stk);
+  forkable_stack_free(&old_jq->frame_stk);
+
+  for (int i=0; i<old_jq->pathsize; i++) {
+    jv_free(old_jq->pathbuf[i]);
   }
-  jv_mem_free(pathbuf);
-  pathbuf = 0;
-  pathsize = 0;
+  jv_mem_free(old_jq->pathbuf);
+  jv_mem_free(old_jq);
 }
 
 struct bytecode* jq_compile(const char* str) {
diff --git a/execute.h b/execute.h
index bf31e5e8..77509f21 100644
--- a/execute.h
+++ b/execute.h
@@ -5,9 +5,11 @@
 
 struct bytecode* jq_compile(const char* str);
 
-void jq_init(struct bytecode* bc, jv value);
-jv jq_next();
-void jq_teardown();
+typedef struct jq_state jq_state;
+
+void jq_init(struct bytecode* bc, jv value, jq_state **);
+jv jq_next(jq_state *);
+void jq_teardown(jq_state **);
 
 
 #endif
diff --git a/jq_test.c b/jq_test.c
index c9bdaef4..8b5ee2c2 100644
--- a/jq_test.c
+++ b/jq_test.c
@@ -41,6 +41,7 @@ static int skipline(const char* buf) {
 static void run_jq_tests() {
   char buf[4096];
   int tests = 0, passed = 0, invalid = 0;
+  jq_state *jq = NULL;
 
   while (1) {
     if (!fgets(buf, sizeof(buf), testdata)) break;
@@ -59,13 +60,13 @@ static void run_jq_tests() {
     fgets(buf, sizeof(buf), testdata);
     jv input = jv_parse(buf);
     if (!jv_is_valid(input)){ invalid++; continue; }
-    jq_init(bc, input);
+    jq_init(bc, input, &jq);
 
     while (fgets(buf, sizeof(buf), testdata)) {
       if (skipline(buf)) break;
       jv expected = jv_parse(buf);
       if (!jv_is_valid(expected)){ invalid++; continue; }
-      jv actual = jq_next();
+      jv actual = jq_next(jq);
       if (!jv_is_valid(actual)) {
         jv_free(actual);
         printf("*** Insufficient results\n");
@@ -88,7 +89,7 @@ static void run_jq_tests() {
       jv_free(actual);
     }
     if (pass) {
-      jv extra = jq_next();
+      jv extra = jq_next(jq);
       if (jv_is_valid(extra)) {
         printf("*** Superfluous result: ");
         jv_dump(extra, 0);
@@ -98,7 +99,7 @@ static void run_jq_tests() {
         jv_free(extra);
       }
     }
-    jq_teardown();
+    jq_teardown(&jq);
     bytecode_free(bc);
     passed+=pass;
   }
diff --git a/main.c b/main.c
index e18f6fdd..92aab150 100644
--- a/main.c
+++ b/main.c
@@ -63,9 +63,10 @@ static int options = 0;
 static struct bytecode* bc;
 
 static void process(jv value) {
-  jq_init(bc, value);
+  jq_state *jq = NULL;
+  jq_init(bc, value, &jq);
   jv result;
-  while (jv_is_valid(result = jq_next())) {
+  while (jv_is_valid(result = jq_next(jq))) {
     if ((options & RAW_OUTPUT) && jv_get_kind(result) == JV_KIND_STRING) {
       fwrite(jv_string_value(result), 1, jv_string_length(jv_copy(result)), stdout);
       jv_free(result);
@@ -85,7 +86,7 @@ static void process(jv value) {
     printf("\n");
   }
   jv_free(result);
-  jq_teardown();
+  jq_teardown(&jq);
 }
 
 static jv slurp_file(const char* filename) {

From 312ab754a21237ba39997306725a7600a872d7c5 Mon Sep 17 00:00:00 2001
From: Nicolas Williams <nico@cryptonector.com>
Date: Sun, 28 Apr 2013 20:12:15 -0500
Subject: [PATCH 227/284] Remove unnecessary #includes

---
 main.c | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/main.c b/main.c
index 92aab150..ac80e4d0 100644
--- a/main.c
+++ b/main.c
@@ -5,11 +5,8 @@
 #include <ctype.h>
 #include <unistd.h>
 #include "compile.h"
-#include "builtin.h"
 #include "jv.h"
 #include "jv_parse.h"
-#include "locfile.h"
-#include "parser.h"
 #include "execute.h"
 #include "jv_alloc.h"
 #include "version.gen.h"

From a136c3b7c93e68a8f3c94dc6307fff6688e44b68 Mon Sep 17 00:00:00 2001
From: Nicolas Williams <nico@cryptonector.com>
Date: Sun, 28 Apr 2013 20:12:49 -0500
Subject: [PATCH 228/284] Build and install libjq

---
 Makefile | 41 +++++++++++++++++++++++++++++++++++++++--
 1 file changed, 39 insertions(+), 2 deletions(-)

diff --git a/Makefile b/Makefile
index 69e97c71..539118fa 100644
--- a/Makefile
+++ b/Makefile
@@ -37,6 +37,7 @@ jq: $(JQ_SRC) main.c
 test: jq_test
 	valgrind --error-exitcode=1 -q --leak-check=full ./jq_test >/dev/null
 
+LIBRARIES=libjq
 BINARIES=jq jq_test
 PLATFORMS=linux32 linux64 osx32 osx64 win32 win64
 
@@ -55,6 +56,14 @@ build/win64%:   CC='x86_64-w64-mingw32-gcc -m64' EXTRA_CFLAGS=-DJQ_DEFAULT_ENABL
 
 BIN_SUFFIX_win32 = .exe
 BIN_SUFFIX_win64 = .exe
+LIB_SUFFIX_win32 = .dll
+LIB_SUFFIX_win64 = .dll
+
+LIB_SUFFIX_linux32 = .so
+LIB_SUFFIX_linux64 = .so
+
+LIB_SUFFIX_osx32 = .so
+LIB_SUFFIX_osx64 = .so
 
 ALL_BINARIES=\
   $(foreach platform, $(PLATFORMS), \
@@ -67,11 +76,27 @@ $(ALL_BINARIES): build/%:
 	make -B $(BINARIES) CC=$(CC)
 	$(foreach binary, $(BINARIES), cp $(binary) $(@D)/$(binary)$(suffix $*);)
 
+libjq: CFLAGS += -fPIC
+libjq: $(JQ_SRC)
+	$(CC) -shared -Wl,-soname,libjq.so.1 $(CFLAGS) $(CFLAGS_OPT) -o $@ $^
+
+ALL_LIBRARIES=\
+  $(foreach platform, $(PLATFORMS), \
+    $(foreach library, $(LIBRARIES), \
+      build/$(platform)/$(library)$(LIB_SUFFIX_$(platform))))
+
+$(ALL_LIBRARIES): build/%:
+	mkdir -p $(@D)
+	echo $(dir $*)
+	make -B $(LIBRARIES) CC=$(CC)
+	$(foreach library, $(LIBRARIES), cp $(library) $(@D)/$(library)$(suffix $*);)
+
 binaries: $(ALL_BINARIES)
+libraries: $(ALL_LIBRARIES)
 
 clean:
 	rm -rf build
-	rm -f $(BINARIES) *.gen.*
+	rm -f $(LIBRARIES) $(BINARIES) *.gen.*
 
 releasedep: lexer.gen.c parser.gen.c jv_utf8_tables.gen.h
 
@@ -87,14 +112,26 @@ tarball: docs/content/2.download/source/jq.tgz
 jq.1: docs/content/3.manual/manual.yml
 	( cd docs; rake manpage; ) > $@
 
-install: jq jq.1
+install: jq jq.1 libjq
 	install -d -m 0755 $(prefix)/bin
+	install -d -m 0755 $(prefix)/lib
+	install -d -m 0755 $(prefix)/include
+	install -d -m 0755 $(prefix)/include/jq
 	install -m 0755 jq $(prefix)/bin
+	ln libjq libjq.so.1
+	install -m 0755 execute.h $(prefix)/include/jq
+	install -m 0755 compile.h $(prefix)/include/jq
+	install -m 0755 jv.h $(prefix)/include/jq
+	install -m 0755 jv_parse.h $(prefix)/include/jq
+	install -m 0755 jv_alloc.h $(prefix)/include/jq
+	install -m 0755 libjq.so.1 $(prefix)/bin
+	install -m 0644 execute.h $(prefix)/bin
 	install -d -m 0755 $(mandir)/man1
 	install -m 0755 jq.1 $(mandir)/man1
 
 uninstall:
 	rm -vf $(prefix)/bin/jq
+	rm -vf $(prefix)/lib/libjq.so.1
 	rm -vf $(mandir)/man1/jq.1
 
 

From 47e015e9468ce109c0fb28562d2b768ba29d2de3 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 5 May 2013 22:37:46 +0100
Subject: [PATCH 229/284] Make a few constant globals actually const.

This means the .data and .bss sections are empty, a good thing
in a shared library (see #98).
---
 builtin.c  | 10 +++-------
 compile.c  |  8 ++++----
 compile.h  |  3 ++-
 jv_parse.c |  4 ++--
 jv_print.c |  4 ++--
 5 files changed, 13 insertions(+), 16 deletions(-)

diff --git a/builtin.c b/builtin.c
index 76e559ea..b9c60b83 100644
--- a/builtin.c
+++ b/builtin.c
@@ -1,6 +1,5 @@
 #include <string.h>
 #include "builtin.h"
-#include "bytecode.h"
 #include "compile.h"
 #include "parser.h"
 #include "locfile.h"
@@ -469,7 +468,7 @@ static jv f_error(jv input, jv msg) {
   return jv_invalid_with_msg(msg);
 }
 
-static struct cfunction function_list[] = {
+static const struct cfunction function_list[] = {
   {(cfunction_ptr)f_plus, "_plus", 3},
   {(cfunction_ptr)f_negate, "_negate", 1},
   {(cfunction_ptr)f_minus, "_minus", 3},
@@ -501,9 +500,6 @@ static struct cfunction function_list[] = {
   {(cfunction_ptr)f_format, "format", 2},
 };
 
-static struct symbol_table cbuiltins = 
-  {function_list, sizeof(function_list)/sizeof(function_list[0])};
-
 struct bytecoded_builtin { const char* name; block code; };
 static block bind_bytecoded_builtins(block b) {
   block builtins = gen_noop();
@@ -537,7 +533,7 @@ static block bind_bytecoded_builtins(block b) {
   return block_bind(builtins, b, OP_IS_CALL_PSEUDO);
 }
 
-static const char* jq_builtins[] = {
+static const char* const jq_builtins[] = {
   "def map(f): [.[] | f];",
   "def select(f): if f then . else empty end;",
   "def sort_by(f): _sort_by_impl(map([f]));",
@@ -564,5 +560,5 @@ block builtins_bind(block b) {
     locfile_free(&src);
   }
   b = bind_bytecoded_builtins(b);
-  return gen_cbinding(&cbuiltins, b);
+  return gen_cbinding(function_list, sizeof(function_list)/sizeof(function_list[0]), b);
 }
diff --git a/compile.c b/compile.c
index b06e4f75..69044626 100644
--- a/compile.c
+++ b/compile.c
@@ -30,7 +30,7 @@ struct inst {
     uint16_t intval;
     struct inst* target;
     jv constant;
-    struct cfunction* cfunc;
+    const struct cfunction* cfunc;
   } imm;
 
   location source;
@@ -377,10 +377,10 @@ block gen_cond(block cond, block iftrue, block iffalse) {
                               BLOCK(gen_op_simple(POP), iffalse)));
 }
 
-block gen_cbinding(struct symbol_table* t, block code) {
-  for (int cfunc=0; cfunc<t->ncfunctions; cfunc++) {
+block gen_cbinding(const struct cfunction* cfunctions, int ncfunctions, block code) {
+  for (int cfunc=0; cfunc<ncfunctions; cfunc++) {
     inst* i = inst_new(CLOSURE_CREATE_C);
-    i->imm.cfunc = &t->cfunctions[cfunc];
+    i->imm.cfunc = &cfunctions[cfunc];
     i->symbol = strdup(i->imm.cfunc->name);
     code = block_bind(inst_block(i), code, OP_IS_CALL_PSEUDO);
   }
diff --git a/compile.h b/compile.h
index 150eef28..f982e3bf 100644
--- a/compile.h
+++ b/compile.h
@@ -7,6 +7,7 @@
 
 struct bytecode;
 struct symbol_table;
+struct cfunction;
 
 struct inst;
 typedef struct inst inst;
@@ -41,7 +42,7 @@ block gen_or(block a, block b);
 
 block gen_cond(block cond, block iftrue, block iffalse);
 
-block gen_cbinding(struct symbol_table* functions, block b);
+block gen_cbinding(const struct cfunction* functions, int nfunctions, block b);
 
 void block_append(block* b, block b2);
 block block_join(block a, block b);
diff --git a/jv_parse.c b/jv_parse.c
index f55c17e5..a8617e06 100644
--- a/jv_parse.c
+++ b/jv_parse.c
@@ -283,7 +283,7 @@ static chclass classify(char c) {
 }
 
 
-static presult OK = "output produced";
+static const presult OK = "output produced";
 
 static int check_done(struct jv_parser* p, jv* out) {
   if (p->stackpos == 0 && jv_is_valid(p->next)) {
@@ -341,7 +341,7 @@ static pfunc scan(struct jv_parser* p, char ch, jv* out) {
   return answer;
 }
 
-static unsigned char UTF8_BOM[] = {0xEF,0xBB,0xBF};
+static const unsigned char UTF8_BOM[] = {0xEF,0xBB,0xBF};
 
 void jv_parser_set_buf(struct jv_parser* p, const char* buf, int length, int is_partial) {
   assert((p->curr_buf == 0 || p->curr_buf_pos == p->curr_buf_length)
diff --git a/jv_print.c b/jv_print.c
index 388bf663..6396d7c8 100644
--- a/jv_print.c
+++ b/jv_print.c
@@ -12,10 +12,10 @@
 
 // Colour table. See http://en.wikipedia.org/wiki/ANSI_escape_code#Colors
 // for how to choose these.
-static jv_kind colour_kinds[] = 
+static const jv_kind colour_kinds[] = 
   {JV_KIND_NULL,   JV_KIND_FALSE, JV_KIND_TRUE, JV_KIND_NUMBER,
    JV_KIND_STRING, JV_KIND_ARRAY, JV_KIND_OBJECT};
-static const char* colours[] =
+static const char* const colours[] =
   {COL("30;1"),    COL("0"),      COL("0"),     COL("0"),
    COL("32"),      COL("37"),     COL("37")};
 #define FIELD_COLOUR COL("34;1")

From a49402c53a99e6ab58c20921c80603d777666db4 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 5 May 2013 22:53:45 +0100
Subject: [PATCH 230/284] Combine the functionality of jq and jq_test

One binary is much simpler. ./jq --run-tests now runs the tests.
---
 Makefile  | 6 +++---
 jq_test.c | 3 ++-
 main.c    | 6 ++++++
 3 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/Makefile b/Makefile
index aa2cc133..45f8ea75 100644
--- a/Makefile
+++ b/Makefile
@@ -27,15 +27,15 @@ main.c: version.gen.h
 JQ_SRC=parser.gen.c lexer.gen.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c jv_aux.c jv_alloc.c
 
 jq_test: CFLAGS += -DJQ_DEBUG=1
-jq_test: $(JQ_SRC) jq_test.c
+jq_test: $(JQ_SRC) main.c jq_test.c
 	$(CC) $(CFLAGS) $(CFLAGS_DEBUG) -o $@ $^
 
 jq: CFLAGS += -O -DJQ_DEBUG=0
-jq: $(JQ_SRC) main.c
+jq: $(JQ_SRC) main.c jq_test.c
 	$(CC) $(CFLAGS) $(CFLAGS_OPT) -o $@ $^
 
 test: jq_test
-	valgrind --error-exitcode=1 -q --leak-check=full ./jq_test >/dev/null
+	valgrind --error-exitcode=1 -q --leak-check=full ./jq_test --run-tests >/dev/null
 
 LIBRARIES=libjq
 BINARIES=jq jq_test
diff --git a/jq_test.c b/jq_test.c
index 8b5ee2c2..cbcbd8f5 100644
--- a/jq_test.c
+++ b/jq_test.c
@@ -10,7 +10,7 @@ static void run_jq_tests();
 
 FILE* testdata;
 
-int main(int argc, char* argv[]) {
+int jq_testsuite(int argc, char* argv[]) {
   jv_test();
   if (argc == 1) {
     testdata = fopen("testdata", "r");
@@ -26,6 +26,7 @@ int main(int argc, char* argv[]) {
   }
   run_jq_tests();
   if (testdata != stdin) fclose(testdata);
+  return 0;
 }
 
 
diff --git a/main.c b/main.c
index ac80e4d0..06466d4e 100644
--- a/main.c
+++ b/main.c
@@ -11,6 +11,8 @@
 #include "jv_alloc.h"
 #include "version.gen.h"
 
+int jq_testsuite(int argc, char* argv[]);
+
 static const char* progname;
 
 static void usage() {
@@ -140,6 +142,10 @@ static int read_more(char* buf, size_t size) {
 int main(int argc, char* argv[]) {
   if (argc) progname = argv[0];
 
+  if (argc > 1 && !strcmp(argv[1], "--run-tests")) {
+    return jq_testsuite(argc - 1, argv + 1);
+  }
+
   const char* program = 0;
   input_filenames = jv_mem_alloc(sizeof(const char*) * argc);
   ninput_files = 0;

From c1748fa633b327ab4c0146c70680b1583e74e54f Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 5 May 2013 22:59:46 +0100
Subject: [PATCH 231/284] WIP

---
 jq_test.c |  2 --
 main.c    | 13 +++++++++----
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/jq_test.c b/jq_test.c
index cbcbd8f5..5abd0275 100644
--- a/jq_test.c
+++ b/jq_test.c
@@ -53,11 +53,9 @@ static void run_jq_tests() {
     tests++;
     struct bytecode* bc = jq_compile(buf);
     if (!bc) {invalid++; continue;}
-#if JQ_DEBUG
     printf("Disassembly:\n");
     dump_disassembly(2, bc);
     printf("\n");
-#endif
     fgets(buf, sizeof(buf), testdata);
     jv input = jv_parse(buf);
     if (!jv_is_valid(input)){ invalid++; continue; }
diff --git a/main.c b/main.c
index 06466d4e..71150161 100644
--- a/main.c
+++ b/main.c
@@ -57,6 +57,9 @@ enum {
   NO_COLOUR_OUTPUT = 128,
 
   FROM_FILE = 256,
+
+  /* debugging only */
+  DUMP_DISASM = 2048,
 };
 static int options = 0;
 static struct bytecode* bc;
@@ -180,6 +183,8 @@ int main(int argc, char* argv[]) {
       options |= PROVIDE_NULL;
     } else if (isoption(argv[i], 'f', "from-file")) {
       options |= FROM_FILE;
+    } else if (isoption(argv[i],  0,  "debug-dump-disasm")) {
+      options |= DUMP_DISASM;
     } else if (isoption(argv[i], 'h', "help")) {
       usage();
     } else if (isoption(argv[i], 'V', "version")) {
@@ -213,10 +218,10 @@ int main(int argc, char* argv[]) {
   }
   if (!bc) return 1;
 
-#if JQ_DEBUG
-  dump_disassembly(0, bc);
-  printf("\n");
-#endif
+  if (options & DUMP_DISASM) {
+    dump_disassembly(0, bc);
+    printf("\n");
+  }
 
   if (options & PROVIDE_NULL) {
     process(jv_null());

From 1741d8c1618c1826628c9deb70f3876ed22501f3 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 5 May 2013 23:12:10 +0100
Subject: [PATCH 232/284] Remove JQ_DEBUG #define and jq_test binary,
 simplifying build.

The debugging features previously available via JQ_DEBUG are now
command-line options.
---
 Makefile   | 10 +++-----
 execute.c  | 70 +++++++++++++++++++++++++++++-------------------------
 execute.h  |  3 ++-
 jq_test.c  |  2 +-
 jv_alloc.c |  2 +-
 jv_alloc.h |  4 ++--
 main.c     | 15 +++++++-----
 7 files changed, 56 insertions(+), 50 deletions(-)

diff --git a/Makefile b/Makefile
index 45f8ea75..9b3b6631 100644
--- a/Makefile
+++ b/Makefile
@@ -26,19 +26,15 @@ main.c: version.gen.h
 
 JQ_SRC=parser.gen.c lexer.gen.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c jv_aux.c jv_alloc.c
 
-jq_test: CFLAGS += -DJQ_DEBUG=1
-jq_test: $(JQ_SRC) main.c jq_test.c
-	$(CC) $(CFLAGS) $(CFLAGS_DEBUG) -o $@ $^
 
-jq: CFLAGS += -O -DJQ_DEBUG=0
 jq: $(JQ_SRC) main.c jq_test.c
 	$(CC) $(CFLAGS) $(CFLAGS_OPT) -o $@ $^
 
-test: jq_test
-	valgrind --error-exitcode=1 -q --leak-check=full ./jq_test --run-tests >/dev/null
+test: jq
+	valgrind --error-exitcode=1 -q --leak-check=full ./jq --run-tests >/dev/null
 
 LIBRARIES=libjq
-BINARIES=jq jq_test
+BINARIES=jq
 PLATFORMS=linux32 linux64 osx32 osx64 win32 win64
 
 build/linux32%: CC='x86_64-linux-gnu-gcc -m32'
diff --git a/execute.c b/execute.c
index 7f1dea9f..22ffadbb 100644
--- a/execute.c
+++ b/execute.c
@@ -29,6 +29,7 @@ struct jq_state {
   struct forkable_stack fork_stk;
   jv* pathbuf;
   int pathsize; // number of allocated elements
+  int debug_trace_enabled;
 };
 
 int path_push(jq_state *jq, stackval sv, jv val) {
@@ -162,29 +163,29 @@ jv jq_next(jq_state *jq) {
   while (1) {
     uint16_t opcode = *pc;
 
-#if JQ_DEBUG
-    dump_operation(frame_current_bytecode(&jq->frame_stk), pc);
-    printf("\t");
-    const struct opcode_description* opdesc = opcode_describe(opcode);
-    data_stk_elem* param;
-    int stack_in = opdesc->stack_in;
-    if (stack_in == -1) stack_in = pc[1];
-    for (int i=0; i<stack_in; i++) {
-      if (i == 0) {
-        param = forkable_stack_peek(&jq->data_stk);
-      } else {
-        printf(" | ");
-        param = forkable_stack_peek_next(&jq->data_stk, param);
+    if (jq->debug_trace_enabled) {
+      dump_operation(frame_current_bytecode(&jq->frame_stk), pc);
+      printf("\t");
+      const struct opcode_description* opdesc = opcode_describe(opcode);
+      data_stk_elem* param;
+      int stack_in = opdesc->stack_in;
+      if (stack_in == -1) stack_in = pc[1];
+      for (int i=0; i<stack_in; i++) {
+        if (i == 0) {
+          param = forkable_stack_peek(&jq->data_stk);
+        } else {
+          printf(" | ");
+          param = forkable_stack_peek_next(&jq->data_stk, param);
+        }
+        if (!param) break;
+        jv_dump(jv_copy(param->sv.value), 0);
+        printf("<%d>", jv_get_refcnt(param->sv.value));
       }
-      if (!param) break;
-      jv_dump(jv_copy(param->sv.value), 0);
-      printf("<%d>", jv_get_refcnt(param->sv.value));
+
+      if (backtracking) printf("\t<backtracking>");
+
+      printf("\n");
     }
-
-    if (backtracking) printf("\t<backtracking>");
-
-    printf("\n");
-#endif
     if (backtracking) {
       opcode = ON_BACKTRACK(opcode);
       backtracking = 0;
@@ -265,11 +266,11 @@ jv jq_next(jq_state *jq) {
       uint16_t v = *pc++;
       frame_ptr fp = frame_get_level(&jq->frame_stk, frame_current(&jq->frame_stk), level);
       jv* var = frame_local_var(fp, v);
-      #if JQ_DEBUG
-      printf("V%d = ", v);
-      jv_dump(jv_copy(*var), 0);
-      printf("\n");
-      #endif
+      if (jq->debug_trace_enabled) {
+        printf("V%d = ", v);
+        jv_dump(jv_copy(*var), 0);
+        printf("\n");
+      }
       stack_push(jq, stackval_replace(stack_pop(jq), jv_copy(*var)));
       break;
     }
@@ -280,11 +281,11 @@ jv jq_next(jq_state *jq) {
       frame_ptr fp = frame_get_level(&jq->frame_stk, frame_current(&jq->frame_stk), level);
       jv* var = frame_local_var(fp, v);
       stackval val = stack_pop(jq);
-      #if JQ_DEBUG
-      printf("V%d = ", v);
-      jv_dump(jv_copy(val.value), 0);
-      printf("\n");
-      #endif
+      if (jq->debug_trace_enabled) {
+        printf("V%d = ", v);
+        jv_dump(jv_copy(val.value), 0);
+        printf("\n");
+      }
       jv_free(*var);
       *var = val.value;
       break;
@@ -463,7 +464,7 @@ jv jq_next(jq_state *jq) {
 }
 
 
-void jq_init(struct bytecode* bc, jv input, jq_state **jq) {
+void jq_init(struct bytecode* bc, jv input, jq_state **jq, int flags) {
   jq_state *new_jq;
   new_jq = jv_mem_alloc(sizeof(*new_jq));
   memset(new_jq, 0, sizeof(*new_jq));
@@ -475,6 +476,11 @@ void jq_init(struct bytecode* bc, jv input, jq_state **jq) {
   struct closure top = {bc, -1};
   frame_push(&new_jq->frame_stk, top, 0);
   frame_push_backtrack(&new_jq->frame_stk, bc->code);
+  if (flags & JQ_DEBUG_TRACE) {
+    new_jq->debug_trace_enabled = 1;
+  } else {
+    new_jq->debug_trace_enabled = 0;
+  }
   *jq = new_jq;
 }
 
diff --git a/execute.h b/execute.h
index 77509f21..1cf14df7 100644
--- a/execute.h
+++ b/execute.h
@@ -6,8 +6,9 @@
 struct bytecode* jq_compile(const char* str);
 
 typedef struct jq_state jq_state;
+enum {JQ_DEBUG_TRACE = 1};
 
-void jq_init(struct bytecode* bc, jv value, jq_state **);
+void jq_init(struct bytecode* bc, jv value, jq_state **, int flags);
 jv jq_next(jq_state *);
 void jq_teardown(jq_state **);
 
diff --git a/jq_test.c b/jq_test.c
index 5abd0275..64b88fb6 100644
--- a/jq_test.c
+++ b/jq_test.c
@@ -59,7 +59,7 @@ static void run_jq_tests() {
     fgets(buf, sizeof(buf), testdata);
     jv input = jv_parse(buf);
     if (!jv_is_valid(input)){ invalid++; continue; }
-    jq_init(bc, input, &jq);
+    jq_init(bc, input, &jq, JQ_DEBUG_TRACE);
 
     while (fgets(buf, sizeof(buf), testdata)) {
       if (skipline(buf)) break;
diff --git a/jv_alloc.c b/jv_alloc.c
index e127029d..4fd36a60 100644
--- a/jv_alloc.c
+++ b/jv_alloc.c
@@ -27,7 +27,7 @@ void* jv_mem_realloc(void* p, size_t sz) {
   return p;
 }
 
-#if JQ_DEBUG
+#ifndef NDEBUG
 volatile char jv_mem_uninitialised;
 __attribute__((constructor)) void jv_mem_uninit_setup(){
   char* p = malloc(1);
diff --git a/jv_alloc.h b/jv_alloc.h
index b4e72c0d..9cf1d34e 100644
--- a/jv_alloc.h
+++ b/jv_alloc.h
@@ -3,12 +3,12 @@
 
 #include <stddef.h>
 
-#if JQ_DEBUG
+#ifndef NDEBUG
 extern volatile char jv_mem_uninitialised;
 #endif
 
 static void jv_mem_invalidate(void* mem, size_t n) {
-#if JQ_DEBUG
+#ifndef NDEBUG
   char* m = mem;
   while (n--) *m++ ^= jv_mem_uninitialised ^ jv_mem_uninitialised;
 #endif
diff --git a/main.c b/main.c
index 71150161..d2c553c0 100644
--- a/main.c
+++ b/main.c
@@ -64,9 +64,9 @@ enum {
 static int options = 0;
 static struct bytecode* bc;
 
-static void process(jv value) {
+static void process(jv value, int flags) {
   jq_state *jq = NULL;
-  jq_init(bc, value, &jq);
+  jq_init(bc, value, &jq, flags);
   jv result;
   while (jv_is_valid(result = jq_next(jq))) {
     if ((options & RAW_OUTPUT) && jv_get_kind(result) == JV_KIND_STRING) {
@@ -153,6 +153,7 @@ int main(int argc, char* argv[]) {
   input_filenames = jv_mem_alloc(sizeof(const char*) * argc);
   ninput_files = 0;
   int further_args_are_files = 0;
+  int jq_flags = 0;
   for (int i=1; i<argc; i++) {
     if (further_args_are_files) {
       input_filenames[ninput_files++] = argv[i];
@@ -185,6 +186,8 @@ int main(int argc, char* argv[]) {
       options |= FROM_FILE;
     } else if (isoption(argv[i],  0,  "debug-dump-disasm")) {
       options |= DUMP_DISASM;
+    } else if (isoption(argv[i],  0,  "debug-trace")) {
+      jq_flags |= JQ_DEBUG_TRACE;
     } else if (isoption(argv[i], 'h', "help")) {
       usage();
     } else if (isoption(argv[i], 'V', "version")) {
@@ -224,7 +227,7 @@ int main(int argc, char* argv[]) {
   }
 
   if (options & PROVIDE_NULL) {
-    process(jv_null());
+    process(jv_null(), jq_flags);
   } else {
     jv slurped;
     if (options & SLURP) {
@@ -245,7 +248,7 @@ int main(int argc, char* argv[]) {
             slurped = jv_string_concat(slurped, jv_string(buf));
           } else {
             if (buf[len-1] == '\n') buf[len-1] = 0;
-            process(jv_string(buf));
+            process(jv_string(buf), jq_flags);
           }
         }
       } else {
@@ -255,7 +258,7 @@ int main(int argc, char* argv[]) {
           if (options & SLURP) {
             slurped = jv_array_append(slurped, value);
           } else {
-            process(value);
+            process(value, jq_flags);
           }
         }
         if (jv_invalid_has_msg(jv_copy(value))) {
@@ -270,7 +273,7 @@ int main(int argc, char* argv[]) {
     }
     jv_parser_free(&parser);
     if (options & SLURP) {
-      process(slurped);
+      process(slurped, jq_flags);
     }
   }
   jv_mem_free(input_filenames);

From 8bf4a73f3ddf08bfc4bd7367ea14524abe24552a Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 6 May 2013 01:14:53 +0100
Subject: [PATCH 233/284] Fix some bad escaping

---
 docs/content/3.manual/manual.yml | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 21907b95..166a385a 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -144,7 +144,7 @@ sections:
           
           The simplest *useful* filter is .foo. When given a
           JSON object (aka dictionary or hash) as input, it produces
-          the value at the key "foo", or null if there\'s none present.
+          the value at the key "foo", or null if there's none present.
 
         examples:
           - program: '.foo'
@@ -218,8 +218,8 @@ sections:
       - title: "`|`"
         body: |
           The | operator combines two filters by feeding the output(s) of
-          the one on the left into the input of the one on the right. It\'s
-          pretty much the same as the Unix shell\'s pipe, if you\'re used to
+          the one on the left into the input of the one on the right. It's
+          pretty much the same as the Unix shell's pipe, if you're used to
           that. 
 
           If the one on the left produces multiple results, the one on
@@ -257,7 +257,7 @@ sections:
           in `[.foo, .bar, .baz]`) or to "collect" all the results of a
           filter into an array (as in `[.items[].name]`)
         
-          Once you understand the "," operator, you can look at jq\'s array
+          Once you understand the "," operator, you can look at jq's array
           syntax in a different light: the expression [1,2,3] is not using a
           built-in syntax for comma-separated arrays, but is instead applying
           the `[]` operator (collect results) to the expression 1,2,3 (which
@@ -279,8 +279,8 @@ sections:
           
           If the keys are "sensible" (all alphabetic characters), then
           the quotes can be left off. The value can be any expression
-          (although you may need to wrap it in parentheses if it\'s a
-          complicated one), which gets applied to the {} expression\'s
+          (although you may need to wrap it in parentheses if it's a
+          complicated one), which gets applied to the {} expression's
           input (remember, all filters have an input and an
           output).
           
@@ -294,10 +294,10 @@ sections:
           
               {user: .user, title: .title}
           
-          Because that\'s so common, there\'s a shortcut syntax: `{user, title}`.
+          Because that's so common, there's a shortcut syntax: `{user, title}`.
           
           If one of the expressions produces multiple results,
-          multiple dictionaries will be produced. If the input\'s
+          multiple dictionaries will be produced. If the input's
           
               {"user":"stedolan","titles":["JQ Primer", "More JQ"]}
           

From 7f979cf1c746dfde7302eb7e7891c377a007a013 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 6 May 2013 01:15:33 +0100
Subject: [PATCH 234/284] Update gems and use HTTPS to get them.

---
 docs/Gemfile      |  3 ++-
 docs/Gemfile.lock | 46 ++++++++++++++++++++++++++++------------------
 2 files changed, 30 insertions(+), 19 deletions(-)

diff --git a/docs/Gemfile b/docs/Gemfile
index f06950f6..208c9c95 100644
--- a/docs/Gemfile
+++ b/docs/Gemfile
@@ -1,5 +1,6 @@
-source :rubygems
+source "https://rubygems.org"
 
+gem "rake"
 gem "bonsai"
 gem "maruku"
 gem "ronn"
diff --git a/docs/Gemfile.lock b/docs/Gemfile.lock
index ccbc84fe..4116dd6a 100644
--- a/docs/Gemfile.lock
+++ b/docs/Gemfile.lock
@@ -1,11 +1,15 @@
 GEM
-  remote: http://rubygems.org/
+  remote: https://rubygems.org/
   specs:
-    activesupport (3.2.9)
+    POpen4 (0.1.4)
+      Platform (>= 0.4.0)
+      open4
+    Platform (0.4.0)
+    activesupport (3.2.12)
       i18n (~> 0.6)
       multi_json (~> 1.0)
-    addressable (2.3.2)
-    bonsai (1.4.7)
+    addressable (2.3.4)
+    bonsai (1.4.8)
       activesupport (>= 3.0.3)
       builder (>= 3.0.0)
       i18n (>= 0.5.0)
@@ -17,32 +21,37 @@ GEM
       sinatra (>= 1.0)
       tilt (>= 1.3)
       watch (>= 0.1.0)
-    builder (3.1.4)
+      yui-compressor
+    builder (3.2.0)
     hpricot (0.8.6)
-    i18n (0.6.1)
-    launchy (2.1.2)
+    i18n (0.6.4)
+    launchy (2.3.0)
       addressable (~> 2.3)
-    liquid (2.4.1)
+    liquid (2.5.0)
     maruku (0.6.1)
       syntax (>= 1.0.0)
-    multi_json (1.5.0)
+    multi_json (1.7.3)
     mustache (0.99.4)
-    rack (1.4.1)
-    rack-protection (1.3.2)
+    open4 (1.3.0)
+    rack (1.5.2)
+    rack-protection (1.5.0)
       rack
-    rdiscount (1.6.8)
+    rake (10.0.3)
+    rdiscount (2.0.7.2)
     ronn (0.7.3)
       hpricot (>= 0.8.2)
       mustache (>= 0.7.0)
       rdiscount (>= 1.5.8)
-    sass (3.2.3)
-    sinatra (1.3.3)
-      rack (~> 1.3, >= 1.3.6)
-      rack-protection (~> 1.2)
-      tilt (~> 1.3, >= 1.3.3)
+    sass (3.2.8)
+    sinatra (1.4.2)
+      rack (~> 1.5, >= 1.5.2)
+      rack-protection (~> 1.4)
+      tilt (~> 1.3, >= 1.3.4)
     syntax (1.0.0)
-    tilt (1.3.3)
+    tilt (1.4.0)
     watch (0.1.0)
+    yui-compressor (0.9.6)
+      POpen4 (>= 0.1.4)
 
 PLATFORMS
   ruby
@@ -50,4 +59,5 @@ PLATFORMS
 DEPENDENCIES
   bonsai
   maruku
+  rake
   ronn

From cacda19e75f878e4274574eed01829f92ede7b72 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 6 May 2013 02:34:02 +0100
Subject: [PATCH 235/284] Add documentation for "type".

Closes #75.
---
 docs/content/3.manual/manual.yml | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 166a385a..374d5046 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -537,6 +537,18 @@ sections:
             input: '[1, "1", [1]]'
             output: ['"1"', '"1"', '"[1]"']
 
+      - title: `type`
+        body: |
+          
+          The `type` function returns the type of its argument as a
+          string, which is one of null, boolean, number, string, array
+          or object.
+
+        examples:
+          - program: 'map(type)'
+            input: '[0, false, [], {}, null, "hello"]'
+            output: ['["number", "boolean", "array", "object", "null", "string"]']
+
       - title: `sort, sort_by`
         body: |
           

From fee38afd8bb0b1d226241c52094f7f1d0f2f8339 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 6 May 2013 02:37:34 +0100
Subject: [PATCH 236/284] Document behaviour of .[] on objects.

Closes #57.
---
 docs/content/3.manual/manual.yml | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 374d5046..eac28a3c 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -181,6 +181,9 @@ sections:
           numbers as three separate results, rather than as a single
           array.
 
+          You can also use this on an object, and it will return all
+          the values of the object.
+
         examples:
           - program: '.[]'
             input: '[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]'
@@ -192,6 +195,10 @@ sections:
             input: '[]'
             output: []
 
+          - program: '.[]'
+            input: '{"a": 1, "b": 2}'
+            output: ['[1, 2]']
+
       - title: "`,`"
         body: |
           

From 48be23233ad63bf1bd218c259efedff3e52106c5 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 6 May 2013 13:46:16 +0100
Subject: [PATCH 237/284] Add the "has" function. Closes #74.

---
 builtin.c                        |  1 +
 docs/content/3.manual/manual.yml | 19 +++++++++++++++++++
 jv_aux.c                         | 28 ++++++++++++++++++++++++++++
 jv_aux.h                         |  1 +
 4 files changed, 49 insertions(+)

diff --git a/builtin.c b/builtin.c
index b9c60b83..39570188 100644
--- a/builtin.c
+++ b/builtin.c
@@ -480,6 +480,7 @@ static const struct cfunction function_list[] = {
   {(cfunction_ptr)jv_setpath, "setpath", 3}, // FIXME typechecking
   {(cfunction_ptr)jv_getpath, "getpath", 2},
   {(cfunction_ptr)jv_delpaths, "delpaths", 2},
+  {(cfunction_ptr)jv_has, "has", 2},
   {(cfunction_ptr)f_equal, "_equal", 3},
   {(cfunction_ptr)f_notequal, "_notequal", 3},
   {(cfunction_ptr)f_less, "_less", 3},
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 6f80b78b..7b490659 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -453,6 +453,25 @@ sections:
             input: '[42,3,35]'
             output: ['[0,1,2]']
 
+      - title: `has`
+        body: |
+          
+          The builtin function `has` returns whether the input object
+          has the given key, or the input array has an element at the
+          given index.
+
+          `has($key)` has the same effect as checking whether `$key`
+          is a member of the array returned by `keys`, although `has`
+          will be faster.
+
+        examples:
+          - program: 'map(has("foo"))'
+            input: '[{"foo": 42}, {}]'
+            output: ['[true, false]']
+          - program: 'map(has(2))'
+            input: '[[0,1], ["a","b","c"]]'
+            output: ['[false, true]']
+
       - title: `select`
         body: |
           
diff --git a/jv_aux.c b/jv_aux.c
index 2c33491d..1f40cc4b 100644
--- a/jv_aux.c
+++ b/jv_aux.c
@@ -60,6 +60,34 @@ jv jv_set(jv t, jv k, jv v) {
   return t;
 }
 
+jv jv_has(jv t, jv k) {
+  assert(jv_is_valid(t));
+  assert(jv_is_valid(k));
+  jv ret;
+  if (jv_get_kind(t) == JV_KIND_NULL) {
+    jv_free(t);
+    jv_free(k);
+    ret = jv_false();
+  } else if (jv_get_kind(t) == JV_KIND_OBJECT &&
+             jv_get_kind(k) == JV_KIND_STRING) {
+    jv elem = jv_object_get(t, k);
+    ret = jv_bool(jv_is_valid(elem));
+    jv_free(elem);
+  } else if (jv_get_kind(t) == JV_KIND_ARRAY &&
+             jv_get_kind(k) == JV_KIND_NUMBER) {
+    jv elem = jv_array_get(t, (int)jv_number_value(k));
+    ret = jv_bool(jv_is_valid(elem));
+    jv_free(elem);
+  } else {
+    ret = jv_invalid_with_msg(jv_string_fmt("Cannot check whether %s has a %s key",
+                                            jv_kind_name(jv_get_kind(t)),
+                                            jv_kind_name(jv_get_kind(k))));
+    jv_free(t);
+    jv_free(k);
+  }
+  return ret;
+}
+
 // assumes keys is a sorted array
 jv jv_dels(jv t, jv keys) {
   assert(jv_get_kind(keys) == JV_KIND_ARRAY);
diff --git a/jv_aux.h b/jv_aux.h
index 561f1083..5a47b70c 100644
--- a/jv_aux.h
+++ b/jv_aux.h
@@ -5,6 +5,7 @@
 
 jv jv_get(jv t, jv k);
 jv jv_set(jv t, jv k, jv v);
+jv jv_has(jv t, jv k);
 jv jv_setpath(jv root, jv path, jv value);
 jv jv_getpath(jv root, jv path);
 jv jv_delpaths(jv root, jv paths);

From 5be97463ecd4f93fdfbaec457d9100beeb9dc603 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 6 May 2013 14:21:00 +0100
Subject: [PATCH 238/284] Add a --arg option to allow variables to be passed
 from the cmdline.

Closes #107
---
 compile.c                        |  6 ++++++
 compile.h                        |  2 ++
 docs/content/3.manual/manual.yml |  6 ++++++
 execute.c                        | 15 ++++++++++++++-
 execute.h                        |  4 ++++
 main.c                           | 15 +++++++++++++--
 parser.y                         |  4 +---
 7 files changed, 46 insertions(+), 6 deletions(-)

diff --git a/compile.c b/compile.c
index 69044626..77dfd904 100644
--- a/compile.c
+++ b/compile.c
@@ -371,6 +371,12 @@ block gen_or(block a, block b) {
                                                    gen_const(jv_false())))));
 }
 
+block gen_var_binding(block var, const char* name, block body) {
+  return BLOCK(gen_op_simple(DUP), var,
+               block_bind(gen_op_var_unbound(STOREV, name),
+                          body, OP_HAS_VARIABLE));
+}
+
 block gen_cond(block cond, block iftrue, block iffalse) {
   return BLOCK(gen_op_simple(DUP), cond, 
                gen_condbranch(BLOCK(gen_op_simple(POP), iftrue),
diff --git a/compile.h b/compile.h
index f982e3bf..00a863c6 100644
--- a/compile.h
+++ b/compile.h
@@ -40,6 +40,8 @@ block gen_condbranch(block iftrue, block iffalse);
 block gen_and(block a, block b);
 block gen_or(block a, block b);
 
+block gen_var_binding(block var, const char* name, block body);
+
 block gen_cond(block cond, block iftrue, block iffalse);
 
 block gen_cbinding(const struct cfunction* functions, int nfunctions, block b);
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 7b490659..c85fcd57 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -121,6 +121,12 @@ sections:
         formatted as a JSON string with quotes. This can be useful for
         making jq filters talk to non-JSON-based systems.
 
+      * `--arg name value`:
+
+        This option passes a value to the jq program as a predefined
+        variable. If you run jq with `--arg foo bar`, then `$foo` is
+        available in the program and has the value `"bar"`.
+
   - title: Basic filters
     entries:
       - title: "`.`"
diff --git a/execute.c b/execute.c
index 22ffadbb..5651dcf5 100644
--- a/execute.c
+++ b/execute.c
@@ -506,13 +506,22 @@ void jq_teardown(jq_state **jq) {
   jv_mem_free(old_jq);
 }
 
-struct bytecode* jq_compile(const char* str) {
+struct bytecode* jq_compile_args(const char* str, jv args) {
+  assert(jv_get_kind(args) == JV_KIND_ARRAY);
   struct locfile locations;
   locfile_init(&locations, str, strlen(str));
   block program;
   struct bytecode* bc = 0;
   int nerrors = jq_parse(&locations, &program);
   if (nerrors == 0) {
+    for (int i=0; i<jv_array_length(jv_copy(args)); i++) {
+      jv arg = jv_array_get(jv_copy(args), i);
+      jv name = jv_object_get(jv_copy(arg), jv_string("name"));
+      jv value = jv_object_get(arg, jv_string("value"));
+      program = gen_var_binding(gen_const(value), jv_string_value(name), program);
+      jv_free(name);
+    }
+    jv_free(args);
     program = builtins_bind(program);
     nerrors = block_compile(program, &locations, &bc);
   }
@@ -522,3 +531,7 @@ struct bytecode* jq_compile(const char* str) {
   locfile_free(&locations);
   return bc;
 }
+
+struct bytecode* jq_compile(const char* str) {
+  return jq_compile_args(str, jv_array());
+}
diff --git a/execute.h b/execute.h
index 1cf14df7..004b66ba 100644
--- a/execute.h
+++ b/execute.h
@@ -3,8 +3,12 @@
 #include "bytecode.h"
 
 
+
 struct bytecode* jq_compile(const char* str);
 
+/* args must be an array of the form [{name:"foo", value:"thing"}, {name:"bar",value:3}] */
+struct bytecode* jq_compile_args(const char* str, jv args);
+
 typedef struct jq_state jq_state;
 enum {JQ_DEBUG_TRACE = 1};
 
diff --git a/main.c b/main.c
index d2c553c0..afdff189 100644
--- a/main.c
+++ b/main.c
@@ -154,6 +154,7 @@ int main(int argc, char* argv[]) {
   ninput_files = 0;
   int further_args_are_files = 0;
   int jq_flags = 0;
+  jv program_arguments = jv_array();
   for (int i=1; i<argc; i++) {
     if (further_args_are_files) {
       input_filenames[ninput_files++] = argv[i];
@@ -184,6 +185,16 @@ int main(int argc, char* argv[]) {
       options |= PROVIDE_NULL;
     } else if (isoption(argv[i], 'f', "from-file")) {
       options |= FROM_FILE;
+    } else if (isoption(argv[i], 0, "arg")) {
+      if (i >= argc - 2) {
+        fprintf(stderr, "%s: --arg takes two parameters (e.g. -a varname value)\n", progname);
+        die();
+      }
+      jv arg = jv_object();
+      arg = jv_object_set(arg, jv_string("name"), jv_string(argv[i+1]));
+      arg = jv_object_set(arg, jv_string("value"), jv_string(argv[i+2]));
+      program_arguments = jv_array_append(program_arguments, arg);
+      i += 2; // skip the next two arguments
     } else if (isoption(argv[i],  0,  "debug-dump-disasm")) {
       options |= DUMP_DISASM;
     } else if (isoption(argv[i],  0,  "debug-trace")) {
@@ -214,10 +225,10 @@ int main(int argc, char* argv[]) {
       jv_free(data);
       return 1;
     }
-    bc = jq_compile(jv_string_value(data));
+    bc = jq_compile_args(jv_string_value(data), program_arguments);
     jv_free(data);
   } else {
-    bc = jq_compile(program);
+    bc = jq_compile_args(program, program_arguments);
   }
   if (!bc) return 1;
 
diff --git a/parser.y b/parser.y
index 92cd9db8..8c663b9b 100644
--- a/parser.y
+++ b/parser.y
@@ -201,9 +201,7 @@ FuncDef Exp %prec ';' {
 } |
 
 Term "as" '$' IDENT '|' Exp {
-  $$ = BLOCK(gen_op_simple(DUP), $1, 
-             block_bind(gen_op_var_unbound(STOREV, jv_string_value($4)), 
-                        $6, OP_HAS_VARIABLE));
+  $$ = gen_var_binding($1, jv_string_value($4), $6);
   jv_free($4);
 } |
 

From 74eb914aba5ff4abfed2574f4555c6a358ae6dbd Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 6 May 2013 15:03:14 +0100
Subject: [PATCH 239/284] Add trailing slashes to various internal doc links.

Fixes #110
---
 docs/Rakefile                       | 2 +-
 docs/content/1.tutorial/default.yml | 4 ++--
 docs/content/index/index.yml        | 2 +-
 docs/templates/index.liquid         | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/docs/Rakefile b/docs/Rakefile
index 231f01b6..2d7b2fe8 100644
--- a/docs/Rakefile
+++ b/docs/Rakefile
@@ -47,7 +47,7 @@ task :serve do
         run Bonsai::DevelopmentServer
       }
       Rack::Handler.default.run(app, :Port => 5000) do
-        Launchy.open("http://localhost:5000/jq")
+        Launchy.open("http://localhost:5000/jq/")
       end
     }    
     Watch.new("{content,templates,public}/**/*") { Bonsai::Exporter.process! }
diff --git a/docs/content/1.tutorial/default.yml b/docs/content/1.tutorial/default.yml
index dbae38e9..cc5c81fe 100644
--- a/docs/content/1.tutorial/default.yml
+++ b/docs/content/1.tutorial/default.yml
@@ -237,5 +237,5 @@ body:
       - - -
 
       Here endeth the tutorial! There's lots more to play with, go
-      read [the manual](../manual) if you're interested, and [download
-      jq](../download) if you haven't already.
\ No newline at end of file
+      read [the manual](../manual/) if you're interested, and [download
+      jq](../download/) if you haven't already.
\ No newline at end of file
diff --git a/docs/content/index/index.yml b/docs/content/index/index.yml
index cf713f25..6b6faf35 100644
--- a/docs/content/index/index.yml
+++ b/docs/content/index/index.yml
@@ -23,5 +23,5 @@ body3: |
   shorter and simpler than you'd expect.
   
 tail: |
-  Go read the [tutorial](tutorial) for more, or the [manual](manual)
+  Go read the [tutorial](tutorial/) for more, or the [manual](manual/)
   for *way* more.
\ No newline at end of file
diff --git a/docs/templates/index.liquid b/docs/templates/index.liquid
index 7785526c..4165c766 100644
--- a/docs/templates/index.liquid
+++ b/docs/templates/index.liquid
@@ -18,7 +18,7 @@
               <ul class="dropdown-menu">
                 <li><a href="{{root}}/download/linux64/jq">Linux (64-bit)</a></li>
                 <li><a href="{{root}}/download/osx64/jq">OS X (64-bit)</a></li>
-                <li><a href="{{root}}/download">Other platforms and source</a></li>
+                <li><a href="{{root}}/download/">Other platforms and source</a></li>
               </ul>
             </div>
 

From 65deaaacf507c9e1d01773887d8c56be847ff1bd Mon Sep 17 00:00:00 2001
From: Nicolas Williams <nico@cryptonector.com>
Date: Sat, 4 May 2013 17:03:01 -0500
Subject: [PATCH 240/284] Fix #111: exit(1) when inputs are not valid JSON

---
 main.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/main.c b/main.c
index afdff189..423510b6 100644
--- a/main.c
+++ b/main.c
@@ -143,6 +143,7 @@ static int read_more(char* buf, size_t size) {
 }
 
 int main(int argc, char* argv[]) {
+  int ret = 0;
   if (argc) progname = argv[0];
 
   if (argc > 1 && !strcmp(argv[1], "--run-tests")) {
@@ -276,6 +277,7 @@ int main(int argc, char* argv[]) {
           jv msg = jv_invalid_get_msg(value);
           fprintf(stderr, "parse error: %s\n", jv_string_value(msg));
           jv_free(msg);
+          ret = 1;
           break;
         } else {
           jv_free(value);
@@ -283,11 +285,14 @@ int main(int argc, char* argv[]) {
       }
     }
     jv_parser_free(&parser);
+    if (ret != 0)
+      goto out;
     if (options & SLURP) {
       process(slurped, jq_flags);
     }
   }
+out:
   jv_mem_free(input_filenames);
   bytecode_free(bc);
-  return 0;
+  return ret;
 }

From fb3c124af11a378e25ffd3bb5c806a14636ce35b Mon Sep 17 00:00:00 2001
From: Nicolas Williams <nico@cryptonector.com>
Date: Sun, 5 May 2013 23:28:11 -0500
Subject: [PATCH 241/284] Rename complex to nontrivial for safety (#113)

---
 jq_test.c |   8 +--
 jv.c      | 170 +++++++++++++++++++++++++++---------------------------
 jv.h      |   4 +-
 3 files changed, 91 insertions(+), 91 deletions(-)

diff --git a/jq_test.c b/jq_test.c
index 64b88fb6..6f6ed02f 100644
--- a/jq_test.c
+++ b/jq_test.c
@@ -132,9 +132,9 @@ static void jv_test() {
     jv_free(a2);
 
 
-    assert(a.val.complex.ptr->count == 1);
+    assert(a.val.nontrivial.ptr->count == 1);
     a = jv_array_append(a, jv_copy(a));
-    assert(a.val.complex.ptr->count == 1);
+    assert(a.val.nontrivial.ptr->count == 1);
 
     assert(jv_array_length(jv_copy(a)) == 2);
     assert(jv_number_value(jv_array_get(jv_copy(a), 0)) == 42);
@@ -167,9 +167,9 @@ static void jv_test() {
 
     jv_free(subarray);
 
-    void* before = sub2.val.complex.ptr;
+    void* before = sub2.val.nontrivial.ptr;
     sub2 = jv_array_append(sub2, jv_number(200));
-    void* after = sub2.val.complex.ptr;
+    void* after = sub2.val.nontrivial.ptr;
     assert(before == after);
     jv_free(sub2);
 
diff --git a/jv.c b/jv.c
index fb4d2103..4ed623f0 100644
--- a/jv.c
+++ b/jv.c
@@ -13,20 +13,20 @@
  * Internal refcounting helpers
  */
 
-static void jvp_refcnt_init(jv_complex* c) {
+static void jvp_refcnt_init(jv_nontrivial* c) {
   c->ptr->count = 1;
 }
 
-static void jvp_refcnt_inc(jv_complex* c) {
+static void jvp_refcnt_inc(jv_nontrivial* c) {
   c->ptr->count++;
 }
 
-static int jvp_refcnt_dec(jv_complex* c) {
+static int jvp_refcnt_dec(jv_nontrivial* c) {
   c->ptr->count--;
   return c->ptr->count == 0;
 }
 
-static int jvp_refcnt_unshared(jv_complex* c) {
+static int jvp_refcnt_unshared(jv_nontrivial* c) {
   assert(c->ptr->count > 0);
   return c->ptr->count == 1;
 }
@@ -86,9 +86,9 @@ typedef struct {
 jv jv_invalid_with_msg(jv err) {
   jv x;
   x.kind = JV_KIND_INVALID;
-  x.val.complex.i[0] = x.val.complex.i[1] = 0;
+  x.val.nontrivial.i[0] = x.val.nontrivial.i[1] = 0;
   jvp_invalid* i = jv_mem_alloc(sizeof(jvp_invalid));
-  x.val.complex.ptr = &i->refcnt;
+  x.val.nontrivial.ptr = &i->refcnt;
   i->refcnt.count = 1;
   i->errmsg = err;
   return x;
@@ -99,7 +99,7 @@ jv jv_invalid() {
 }
 
 jv jv_invalid_get_msg(jv inv) {
-  jv x = jv_copy(((jvp_invalid*)inv.val.complex.ptr)->errmsg);
+  jv x = jv_copy(((jvp_invalid*)inv.val.nontrivial.ptr)->errmsg);
   jv_free(inv);
   return x;
 }
@@ -111,7 +111,7 @@ int jv_invalid_has_msg(jv inv) {
   return r;
 }
 
-static void jvp_invalid_free(jv_complex* x) {
+static void jvp_invalid_free(jv_nontrivial* x) {
   if (jvp_refcnt_dec(x)) {
     jv_free(((jvp_invalid*)x->ptr)->errmsg);
     jv_mem_free(x->ptr);
@@ -153,7 +153,7 @@ typedef struct {
   jv elements[];
 } jvp_array;
 
-static jvp_array* jvp_array_ptr(jv_complex* a) {
+static jvp_array* jvp_array_ptr(jv_nontrivial* a) {
   return (jvp_array*)a->ptr;
 }
 
@@ -165,12 +165,12 @@ static jvp_array* jvp_array_alloc(unsigned size) {
   return a;
 }
 
-static jv_complex jvp_array_new(unsigned size) {
-  jv_complex r = {&jvp_array_alloc(size)->refcnt, {0, 0}};
+static jv_nontrivial jvp_array_new(unsigned size) {
+  jv_nontrivial r = {&jvp_array_alloc(size)->refcnt, {0, 0}};
   return r;
 }
 
-static void jvp_array_free(jv_complex* a) {
+static void jvp_array_free(jv_nontrivial* a) {
   if (jvp_refcnt_dec(a)) {
     jvp_array* array = jvp_array_ptr(a);
     for (int i=0; i<array->length; i++) {
@@ -180,11 +180,11 @@ static void jvp_array_free(jv_complex* a) {
   }
 }
 
-static int jvp_array_length(jv_complex* a) {
+static int jvp_array_length(jv_nontrivial* a) {
   return a->i[1] - a->i[0];
 }
 
-static jv* jvp_array_read(jv_complex* a, int i) {
+static jv* jvp_array_read(jv_nontrivial* a, int i) {
   if (i >= 0 && i < jvp_array_length(a)) {
     jvp_array* array = jvp_array_ptr(a);
     assert(i + a->i[0] < array->length);
@@ -194,7 +194,7 @@ static jv* jvp_array_read(jv_complex* a, int i) {
   }
 }
 
-static jv* jvp_array_write(jv_complex* a, int i) {
+static jv* jvp_array_write(jv_nontrivial* a, int i) {
   assert(i >= 0);
   jvp_array* array = jvp_array_ptr(a);
 
@@ -237,7 +237,7 @@ static jv* jvp_array_write(jv_complex* a, int i) {
   return &new_array->elements[i];
 }
 
-static int jvp_array_equal(jv_complex* a, jv_complex* b) {
+static int jvp_array_equal(jv_nontrivial* a, jv_nontrivial* b) {
   if (jvp_array_length(a) != jvp_array_length(b)) 
     return 0;
   if (jvp_array_ptr(a) == jvp_array_ptr(b) &&
@@ -251,11 +251,11 @@ static int jvp_array_equal(jv_complex* a, jv_complex* b) {
   return 1;
 }
 
-static jv_complex jvp_array_slice(jv_complex* a, int start, int end) {
+static jv_nontrivial jvp_array_slice(jv_nontrivial* a, int start, int end) {
   // FIXME: maybe slice should reallocate if the slice is small enough
   assert(start <= end);
   assert(a->i[0] + end <= a->i[1]);
-  jv_complex slice = *a;
+  jv_nontrivial slice = *a;
   slice.i[0] += start;
   slice.i[1] = slice.i[0] + (end - start);
   return slice;
@@ -268,7 +268,7 @@ static jv_complex jvp_array_slice(jv_complex* a, int start, int end) {
 jv jv_array_sized(int n) {
   jv j;
   j.kind = JV_KIND_ARRAY;
-  j.val.complex = jvp_array_new(n);
+  j.val.nontrivial = jvp_array_new(n);
   return j;
 }
 
@@ -278,14 +278,14 @@ jv jv_array() {
 
 int jv_array_length(jv j) {
   assert(jv_get_kind(j) == JV_KIND_ARRAY);
-  int len = jvp_array_length(&j.val.complex);
+  int len = jvp_array_length(&j.val.nontrivial);
   jv_free(j);
   return len;
 }
 
 jv jv_array_get(jv j, int idx) {
   assert(jv_get_kind(j) == JV_KIND_ARRAY);
-  jv* slot = jvp_array_read(&j.val.complex, idx);
+  jv* slot = jvp_array_read(&j.val.nontrivial, idx);
   jv val;
   if (slot) {
     val = jv_copy(*slot);
@@ -299,7 +299,7 @@ jv jv_array_get(jv j, int idx) {
 jv jv_array_set(jv j, int idx, jv val) {
   assert(jv_get_kind(j) == JV_KIND_ARRAY);
   // copy/free of val,j coalesced
-  jv* slot = jvp_array_write(&j.val.complex, idx);
+  jv* slot = jvp_array_write(&j.val.nontrivial, idx);
   jv_free(*slot);
   *slot = val;
   return j;
@@ -325,7 +325,7 @@ jv jv_array_concat(jv a, jv b) {
 jv jv_array_slice(jv a, int start, int end) {
   assert(jv_get_kind(a) == JV_KIND_ARRAY);
   // copy/free of a coalesced
-  a.val.complex = jvp_array_slice(&a.val.complex, start, end);
+  a.val.nontrivial = jvp_array_slice(&a.val.nontrivial, start, end);
   return a;
 }
 
@@ -365,7 +365,7 @@ typedef struct {
   char data[];
 } jvp_string;
 
-static jvp_string* jvp_string_ptr(jv_complex* a) {
+static jvp_string* jvp_string_ptr(jv_nontrivial* a) {
   return (jvp_string*)a->ptr;
 }
 
@@ -376,16 +376,16 @@ static jvp_string* jvp_string_alloc(uint32_t size) {
   return s;
 }
 
-static jv_complex jvp_string_new(const char* data, uint32_t length) {
+static jv_nontrivial jvp_string_new(const char* data, uint32_t length) {
   jvp_string* s = jvp_string_alloc(length);
   s->length_hashed = length << 1;
   memcpy(s->data, data, length);
   s->data[length] = 0;
-  jv_complex r = {&s->refcnt, {0,0}};
+  jv_nontrivial r = {&s->refcnt, {0,0}};
   return r;
 }
 
-static void jvp_string_free(jv_complex* s) {
+static void jvp_string_free(jv_nontrivial* s) {
   if (jvp_refcnt_dec(s)) {
     jvp_string* str = jvp_string_ptr(s);
     jv_mem_free(str);
@@ -393,12 +393,12 @@ static void jvp_string_free(jv_complex* s) {
 }
 
 static void jvp_string_free_p(jvp_string* s) {
-  jv_complex p = {&s->refcnt,{0,0}};
+  jv_nontrivial p = {&s->refcnt,{0,0}};
   jvp_string_free(&p);
 }
 
 static jvp_string* jvp_string_copy_p(jvp_string* s) {
-  jv_complex p = {&s->refcnt,{0,0}};
+  jv_nontrivial p = {&s->refcnt,{0,0}};
   jvp_refcnt_inc(&p);
   return s;
 }
@@ -413,7 +413,7 @@ static uint32_t jvp_string_remaining_space(jvp_string* s) {
   return r;
 }
 
-static void jvp_string_append(jv_complex* string, const char* data, uint32_t len) {
+static void jvp_string_append(jv_nontrivial* string, const char* data, uint32_t len) {
   jvp_string* s = jvp_string_ptr(string);
   uint32_t currlen = jvp_string_length(s);
     
@@ -433,7 +433,7 @@ static void jvp_string_append(jv_complex* string, const char* data, uint32_t len
     memcpy(news->data + currlen, data, len);
     news->data[currlen + len] = 0;
     jvp_string_free(string);
-    jv_complex r = {&news->refcnt, {0,0}};
+    jv_nontrivial r = {&news->refcnt, {0,0}};
     *string = r;
   }
 }
@@ -508,7 +508,7 @@ static int jvp_string_equal_hashed(jvp_string* a, jvp_string* b) {
   return memcmp(a->data, b->data, jvp_string_length(a)) == 0;
 }
 
-static int jvp_string_equal(jv_complex* a, jv_complex* b) {
+static int jvp_string_equal(jv_nontrivial* a, jv_nontrivial* b) {
   jvp_string* stra = jvp_string_ptr(a);
   jvp_string* strb = jvp_string_ptr(b);
   if (jvp_string_length(stra) != jvp_string_length(strb)) return 0;
@@ -522,7 +522,7 @@ static int jvp_string_equal(jv_complex* a, jv_complex* b) {
 jv jv_string_sized(const char* str, int len) {
   jv j;
   j.kind = JV_KIND_STRING;
-  j.val.complex = jvp_string_new(str, len);
+  j.val.nontrivial = jvp_string_new(str, len);
   return j;
 }
 
@@ -532,32 +532,32 @@ jv jv_string(const char* str) {
 
 int jv_string_length(jv j) {
   assert(jv_get_kind(j) == JV_KIND_STRING);
-  int r = jvp_string_length(jvp_string_ptr(&j.val.complex));
+  int r = jvp_string_length(jvp_string_ptr(&j.val.nontrivial));
   jv_free(j);
   return r;
 }
 
 uint32_t jv_string_hash(jv j) {
   assert(jv_get_kind(j) == JV_KIND_STRING);
-  uint32_t hash = jvp_string_hash(jvp_string_ptr(&j.val.complex));
+  uint32_t hash = jvp_string_hash(jvp_string_ptr(&j.val.nontrivial));
   jv_free(j);
   return hash;
 }
 
 const char* jv_string_value(jv j) {
   assert(jv_get_kind(j) == JV_KIND_STRING);
-  return jvp_string_ptr(&j.val.complex)->data;
+  return jvp_string_ptr(&j.val.nontrivial)->data;
 }
 
 jv jv_string_concat(jv a, jv b) {
-  jvp_string* sb = jvp_string_ptr(&b.val.complex);
-  jvp_string_append(&a.val.complex, sb->data, jvp_string_length(sb));
+  jvp_string* sb = jvp_string_ptr(&b.val.nontrivial);
+  jvp_string_append(&a.val.nontrivial, sb->data, jvp_string_length(sb));
   jv_free(b);
   return a;
 }
 
 jv jv_string_append_buf(jv a, const char* buf, int len) {
-  jvp_string_append(&a.val.complex, buf, len);
+  jvp_string_append(&a.val.nontrivial, buf, len);
   return a;
 }
 
@@ -602,8 +602,8 @@ typedef struct {
 } jvp_object;
 
 
-/* warning: complex justification of alignment */
-static jv_complex jvp_object_new(int size) {
+/* warning: nontrivial justification of alignment */
+static jv_nontrivial jvp_object_new(int size) {
   // Allocates an object of (size) slots and (size*2) hash buckets.
 
   // size must be a power of two
@@ -620,7 +620,7 @@ static jv_complex jvp_object_new(int size) {
   }
   obj->first_free = size - 1;
   int* hashbuckets = (int*)(&obj->elements[size]);
-  jv_complex r = {&obj->refcnt, 
+  jv_nontrivial r = {&obj->refcnt, 
                   {size*2 - 1, (char*)hashbuckets - (char*)obj}};
   for (int i=0; i<size*2; i++) {
     hashbuckets[i] = -1;
@@ -628,39 +628,39 @@ static jv_complex jvp_object_new(int size) {
   return r;
 }
 
-static jvp_object* jvp_object_ptr(jv_complex* o) {
+static jvp_object* jvp_object_ptr(jv_nontrivial* o) {
   return (jvp_object*)o->ptr;
 }
 
-static uint32_t jvp_object_mask(jv_complex* o) {
+static uint32_t jvp_object_mask(jv_nontrivial* o) {
   return o->i[0];
 }
 
-static int jvp_object_size(jv_complex* o) {
+static int jvp_object_size(jv_nontrivial* o) {
   return (o->i[0] + 1) >> 1;
 }
 
-static int* jvp_object_buckets(jv_complex* o) {
+static int* jvp_object_buckets(jv_nontrivial* o) {
   int* buckets = (int*)((char*)o->ptr + o->i[1]);
   assert(buckets == (int*)&jvp_object_ptr(o)->elements[jvp_object_size(o)]);
   return buckets;
 }
 
-static int* jvp_object_find_bucket(jv_complex* object, jvp_string* key) {
+static int* jvp_object_find_bucket(jv_nontrivial* object, jvp_string* key) {
   return jvp_object_buckets(object) + (jvp_object_mask(object) & jvp_string_hash(key));
 }
 
-static struct object_slot* jvp_object_get_slot(jv_complex* object, int slot) {
+static struct object_slot* jvp_object_get_slot(jv_nontrivial* object, int slot) {
   assert(slot == -1 || (slot >= 0 && slot < jvp_object_size(object)));
   if (slot == -1) return 0;
   else return &jvp_object_ptr(object)->elements[slot];
 }
 
-static struct object_slot* jvp_object_next_slot(jv_complex* object, struct object_slot* slot) {
+static struct object_slot* jvp_object_next_slot(jv_nontrivial* object, struct object_slot* slot) {
   return jvp_object_get_slot(object, slot->next);
 }
 
-static struct object_slot* jvp_object_find_slot(jv_complex* object, jvp_string* keystr, int* bucket) {
+static struct object_slot* jvp_object_find_slot(jv_nontrivial* object, jvp_string* keystr, int* bucket) {
   for (struct object_slot* curr = jvp_object_get_slot(object, *bucket); 
        curr; 
        curr = jvp_object_next_slot(object, curr)) {
@@ -671,7 +671,7 @@ static struct object_slot* jvp_object_find_slot(jv_complex* object, jvp_string*
   return 0;
 }
 
-static struct object_slot* jvp_object_add_slot(jv_complex* object, jvp_string* key, int* bucket) {
+static struct object_slot* jvp_object_add_slot(jv_nontrivial* object, jvp_string* key, int* bucket) {
   jvp_object* o = jvp_object_ptr(object);
   int newslot_idx = o->first_free;
   struct object_slot* newslot = jvp_object_get_slot(object, newslot_idx);
@@ -684,7 +684,7 @@ static struct object_slot* jvp_object_add_slot(jv_complex* object, jvp_string* k
   return newslot;
 }
 
-static void jvp_object_free_slot(jv_complex* object, struct object_slot* slot) {
+static void jvp_object_free_slot(jv_nontrivial* object, struct object_slot* slot) {
   jvp_object* o = jvp_object_ptr(object);
   slot->next = o->first_free;
   assert(slot->string);
@@ -694,14 +694,14 @@ static void jvp_object_free_slot(jv_complex* object, struct object_slot* slot) {
   o->first_free = slot - jvp_object_get_slot(object, 0);
 }
 
-static jv* jvp_object_read(jv_complex* object, jvp_string* key) {
+static jv* jvp_object_read(jv_nontrivial* object, jvp_string* key) {
   int* bucket = jvp_object_find_bucket(object, key);
   struct object_slot* slot = jvp_object_find_slot(object, key, bucket);
   if (slot == 0) return 0;
   else return &slot->value;
 }
 
-static void jvp_object_free(jv_complex* o) {
+static void jvp_object_free(jv_nontrivial* o) {
   if (jvp_refcnt_dec(o)) {
     for (int i=0; i<jvp_object_size(o); i++) {
       struct object_slot* slot = jvp_object_get_slot(o, i);
@@ -714,10 +714,10 @@ static void jvp_object_free(jv_complex* o) {
   }
 }
 
-static void jvp_object_rehash(jv_complex* object) {
+static void jvp_object_rehash(jv_nontrivial* object) {
   assert(jvp_refcnt_unshared(object));
   int size = jvp_object_size(object);
-  jv_complex new_object = jvp_object_new(size * 2);
+  jv_nontrivial new_object = jvp_object_new(size * 2);
   for (int i=0; i<size; i++) {
     struct object_slot* slot = jvp_object_get_slot(object, i);
     if (!slot->string) continue;
@@ -733,11 +733,11 @@ static void jvp_object_rehash(jv_complex* object) {
   *object = new_object;
 }
 
-static void jvp_object_unshare(jv_complex* object) {
+static void jvp_object_unshare(jv_nontrivial* object) {
   if (jvp_refcnt_unshared(object))
     return;
 
-  jv_complex new_object = jvp_object_new(jvp_object_size(object));
+  jv_nontrivial new_object = jvp_object_new(jvp_object_size(object));
   jvp_object_ptr(&new_object)->first_free = jvp_object_ptr(object)->first_free;
   for (int i=0; i<jvp_object_size(&new_object); i++) {
     struct object_slot* old_slot = jvp_object_get_slot(object, i);
@@ -758,7 +758,7 @@ static void jvp_object_unshare(jv_complex* object) {
   assert(jvp_refcnt_unshared(object));
 }
 
-static jv* jvp_object_write(jv_complex* object, jvp_string* key) {
+static jv* jvp_object_write(jv_nontrivial* object, jvp_string* key) {
   jvp_object_unshare(object);
   int* bucket = jvp_object_find_bucket(object, key);
   struct object_slot* slot = jvp_object_find_slot(object, key, bucket);
@@ -781,7 +781,7 @@ static jv* jvp_object_write(jv_complex* object, jvp_string* key) {
   return &slot->value;
 }
 
-static int jvp_object_delete(jv_complex* object, jvp_string* key) {
+static int jvp_object_delete(jv_nontrivial* object, jvp_string* key) {
   jvp_object_unshare(object);
   int* bucket = jvp_object_find_bucket(object, key);
   int* prev_ptr = bucket;
@@ -798,7 +798,7 @@ static int jvp_object_delete(jv_complex* object, jvp_string* key) {
   return 0;
 }
 
-static int jvp_object_length(jv_complex* object) {
+static int jvp_object_length(jv_nontrivial* object) {
   int n = 0;
   for (int i=0; i<jvp_object_size(object); i++) {
     struct object_slot* slot = jvp_object_get_slot(object, i);
@@ -807,7 +807,7 @@ static int jvp_object_length(jv_complex* object) {
   return n;
 }
 
-static int jvp_object_equal(jv_complex* o1, jv_complex* o2) {
+static int jvp_object_equal(jv_nontrivial* o1, jv_nontrivial* o2) {
   int len2 = jvp_object_length(o2);
   int len1 = 0;
   for (int i=0; i<jvp_object_size(o1); i++) {
@@ -829,14 +829,14 @@ static int jvp_object_equal(jv_complex* o1, jv_complex* o2) {
 jv jv_object() {
   jv j;
   j.kind = JV_KIND_OBJECT;
-  j.val.complex = jvp_object_new(8);
+  j.val.nontrivial = jvp_object_new(8);
   return j;
 }
 
 jv jv_object_get(jv object, jv key) {
   assert(jv_get_kind(object) == JV_KIND_OBJECT);
   assert(jv_get_kind(key) == JV_KIND_STRING);
-  jv* slot = jvp_object_read(&object.val.complex, jvp_string_ptr(&key.val.complex));
+  jv* slot = jvp_object_read(&object.val.nontrivial, jvp_string_ptr(&key.val.nontrivial));
   jv val;
   if (slot) {
     val = jv_copy(*slot);
@@ -852,7 +852,7 @@ jv jv_object_set(jv object, jv key, jv value) {
   assert(jv_get_kind(object) == JV_KIND_OBJECT);
   assert(jv_get_kind(key) == JV_KIND_STRING);
   // copy/free of object, key, value coalesced
-  jv* slot = jvp_object_write(&object.val.complex, jvp_string_ptr(&key.val.complex));
+  jv* slot = jvp_object_write(&object.val.nontrivial, jvp_string_ptr(&key.val.nontrivial));
   jv_free(*slot);
   *slot = value;
   return object;
@@ -861,14 +861,14 @@ jv jv_object_set(jv object, jv key, jv value) {
 jv jv_object_delete(jv object, jv key) {
   assert(jv_get_kind(object) == JV_KIND_OBJECT);
   assert(jv_get_kind(key) == JV_KIND_STRING);
-  jvp_object_delete(&object.val.complex, jvp_string_ptr(&key.val.complex));
+  jvp_object_delete(&object.val.nontrivial, jvp_string_ptr(&key.val.nontrivial));
   jv_free(key);
   return object;
 }
 
 int jv_object_length(jv object) {
   assert(jv_get_kind(object) == JV_KIND_OBJECT);
-  int n = jvp_object_length(&object.val.complex);
+  int n = jvp_object_length(&object.val.nontrivial);
   jv_free(object);
   return n;
 }
@@ -919,7 +919,7 @@ int jv_object_iter(jv object) {
 int jv_object_iter_next(jv object, int iter) {
   assert(jv_get_kind(object) == JV_KIND_OBJECT);
   assert(iter != ITER_FINISHED);
-  jv_complex* o = &object.val.complex;
+  jv_nontrivial* o = &object.val.nontrivial;
   struct object_slot* slot;
   do {
     iter++;
@@ -931,18 +931,18 @@ int jv_object_iter_next(jv object, int iter) {
 }
 
 jv jv_object_iter_key(jv object, int iter) {
-  jvp_string* s = jvp_object_get_slot(&object.val.complex, iter)->string;
+  jvp_string* s = jvp_object_get_slot(&object.val.nontrivial, iter)->string;
   assert(s);
   jv j;
   j.kind = JV_KIND_STRING;
-  j.val.complex.ptr = &s->refcnt;
-  j.val.complex.i[0] = 0;
-  j.val.complex.i[1] = 0;
+  j.val.nontrivial.ptr = &s->refcnt;
+  j.val.nontrivial.i[0] = 0;
+  j.val.nontrivial.i[1] = 0;
   return jv_copy(j);
 }
 
 jv jv_object_iter_value(jv object, int iter) {
-  return jv_copy(jvp_object_get_slot(&object.val.complex, iter)->value);
+  return jv_copy(jvp_object_get_slot(&object.val.nontrivial, iter)->value);
 }
 
 /*
@@ -953,20 +953,20 @@ jv jv_copy(jv j) {
       jv_get_kind(j) == JV_KIND_STRING || 
       jv_get_kind(j) == JV_KIND_OBJECT ||
       jv_get_kind(j) == JV_KIND_INVALID) {
-    jvp_refcnt_inc(&j.val.complex);
+    jvp_refcnt_inc(&j.val.nontrivial);
   }
   return j;
 }
 
 void jv_free(jv j) {
   if (jv_get_kind(j) == JV_KIND_ARRAY) {
-    jvp_array_free(&j.val.complex);
+    jvp_array_free(&j.val.nontrivial);
   } else if (jv_get_kind(j) == JV_KIND_STRING) {
-    jvp_string_free(&j.val.complex);
+    jvp_string_free(&j.val.nontrivial);
   } else if (jv_get_kind(j) == JV_KIND_OBJECT) {
-    jvp_object_free(&j.val.complex);
+    jvp_object_free(&j.val.nontrivial);
   } else if (jv_get_kind(j) == JV_KIND_INVALID) {
-    jvp_invalid_free(&j.val.complex);
+    jvp_invalid_free(&j.val.nontrivial);
   }
 }
 
@@ -975,7 +975,7 @@ int jv_get_refcnt(jv j) {
   case JV_KIND_ARRAY:
   case JV_KIND_STRING:
   case JV_KIND_OBJECT:
-    return j.val.complex.ptr->count;
+    return j.val.nontrivial.ptr->count;
   default:
     return 1;
   }
@@ -991,20 +991,20 @@ int jv_equal(jv a, jv b) {
     r = 0;
   } else if (jv_get_kind(a) == JV_KIND_NUMBER) {
     r = jv_number_value(a) == jv_number_value(b);
-  } else if (a.val.complex.ptr == b.val.complex.ptr &&
-             a.val.complex.i[0] == b.val.complex.i[0] &&
-             a.val.complex.i[1] == b.val.complex.i[1]) {
+  } else if (a.val.nontrivial.ptr == b.val.nontrivial.ptr &&
+             a.val.nontrivial.i[0] == b.val.nontrivial.i[0] &&
+             a.val.nontrivial.i[1] == b.val.nontrivial.i[1]) {
     r = 1;
   } else {
     switch (jv_get_kind(a)) {
     case JV_KIND_ARRAY:
-      r = jvp_array_equal(&a.val.complex, &b.val.complex);
+      r = jvp_array_equal(&a.val.nontrivial, &b.val.nontrivial);
       break;
     case JV_KIND_STRING:
-      r = jvp_string_equal(&a.val.complex, &b.val.complex);
+      r = jvp_string_equal(&a.val.nontrivial, &b.val.nontrivial);
       break;
     case JV_KIND_OBJECT:
-      r = jvp_object_equal(&a.val.complex, &b.val.complex);
+      r = jvp_object_equal(&a.val.nontrivial, &b.val.nontrivial);
       break;
     default:
       r = 1;
diff --git a/jv.h b/jv.h
index c3bff367..a64f3acc 100644
--- a/jv.h
+++ b/jv.h
@@ -25,13 +25,13 @@ typedef struct {
 typedef struct{
   jv_refcnt* ptr;
   int i[2];
-} jv_complex;
+} jv_nontrivial;
 
 typedef struct {
   jv_kind kind;
   union {
     double number;
-    jv_complex complex;
+    jv_nontrivial nontrivial;
   } val;
 } jv;
 

From 1ebb3825400074dc62e92d161f76a57ef4fd40d4 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 8 May 2013 01:02:18 +0100
Subject: [PATCH 242/284] Check in jv_utf8_tables.gen.h, it is unlikely to
 change.

---
 gen_utf8_tables.py |  2 ++
 jv_unicode.c       |  2 +-
 jv_utf8_tables.h   | 35 +++++++++++++++++++++++++++++++++++
 3 files changed, 38 insertions(+), 1 deletion(-)
 create mode 100644 jv_utf8_tables.h

diff --git a/gen_utf8_tables.py b/gen_utf8_tables.py
index 98df9144..2ccab491 100644
--- a/gen_utf8_tables.py
+++ b/gen_utf8_tables.py
@@ -1,5 +1,7 @@
 #!/usr/bin/python
 
+# This program was used to generate jv_utf8_tables.gen.h
+
 mask = lambda n: (1 << n) - 1
 
 
diff --git a/jv_unicode.c b/jv_unicode.c
index b1417a2a..375ad367 100644
--- a/jv_unicode.c
+++ b/jv_unicode.c
@@ -1,7 +1,7 @@
 #include <stdio.h>
 #include <assert.h>
 #include "jv_unicode.h"
-#include "jv_utf8_tables.gen.h"
+#include "jv_utf8_tables.h"
 
 const char* jvp_utf8_next(const char* in, const char* end, int* codepoint) {
   if (in == end) {
diff --git a/jv_utf8_tables.h b/jv_utf8_tables.h
new file mode 100644
index 00000000..24d9a63a
--- /dev/null
+++ b/jv_utf8_tables.h
@@ -0,0 +1,35 @@
+#define UTF8_CONTINUATION_BYTE ((unsigned char)255)
+static const unsigned char utf8_coding_length[] =
+ {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+  0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+  0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+  0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+  0x04, 0x04, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+static const unsigned char utf8_coding_bits[] =
+ {0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+  0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
+  0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
+  0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
+  0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
+  0x00, 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
+  0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
+  0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+  0x07, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

From d121420757001950604473f5b0f7a592caa1433e Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 8 May 2013 02:30:08 +0100
Subject: [PATCH 243/284] Clean up autotools config.

Remove some of @stagrlee's hard work since jq's testsuite is
less silly than when he wrote the autotools config.
---
 Makefile.am                | 175 ++++++++++---------------------------
 configure.ac               |  32 +------
 jq_test.c                  |  30 +------
 setup.sh                   |   2 +-
 testdata => tests/all.test |   0
 tests/run                  |   3 +
 6 files changed, 55 insertions(+), 187 deletions(-)
 rename testdata => tests/all.test (100%)
 create mode 100755 tests/run

diff --git a/Makefile.am b/Makefile.am
index 2aa2dda0..5018439f 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,164 +1,83 @@
-# Converted to automake by thompson@dtosolutions.com 26NOV12
+### C source files to be built
 
-# setup is only used by distribution developers, not package developers.
-# Still, as a matter of allowing patching, its not a bad idea to distribute 
-# the developer setup script in the tarball.
-EXTRA_DIST = \
-  setup.sh \
-  config.h.in \
-  ChangeLog \
-  VERSION \
-  lexer.l \
-  lexer.h \
-  gen_utf8_tables.py \
-  jq.spec \
-  testdata \
-  docs/content/1.tutorial/default.yml \
-  docs/content/2.download/default.yml \
-  docs/content/3.manual/manual.yml \
-  docs/content/index/index.yml \
-  docs/Gemfile \
-  docs/Gemfile.lock \
-  docs/public/.htaccess \
-  docs/public/bootstrap/css/bootstrap-responsive.css \
-  docs/public/bootstrap/css/bootstrap-responsive.min.css \
-  docs/public/bootstrap/css/bootstrap.css \
-  docs/public/bootstrap/css/bootstrap.min.css \
-  docs/public/bootstrap/img/glyphicons-halflings-white.png \
-  docs/public/bootstrap/img/glyphicons-halflings.png \
-  docs/public/bootstrap/js/bootstrap.js \
-  docs/public/bootstrap/js/bootstrap.min.js \
-  docs/public/css/base.scss \
-  docs/public/jq.png \
-  docs/public/robots.txt \
-  docs/Rakefile \
-  docs/site.yml \
-  docs/templates/default.liquid \
-  docs/templates/index.liquid \
-  docs/templates/manual.liquid \
-  docs/templates/shared/_footer.liquid \
-  docs/templates/shared/_head.liquid \
-  docs/templates/shared/_header.liquid
+JQ_INCS = jq_parser.h builtin.h bytecode.h compile.h execute.h		\
+  forkable_stack.h frame_layout.h jv.h jv_alloc.h jv_aux.h jv_dtoa.h	\
+  jv_parse.h jv_unicode.h locfile.h opcode.h opcode_list.h parser.y	\
+  jv_utf8_tables.h
 
-# README.md is expected in Github projects, good stuff in it, so we'll 
-# distribute it and install it with the package in the doc directory.
-docdir = ${datadir}/doc/${PACKAGE}
-dist_doc_DATA = README.md INSTALL COPYING AUTHORS README NEWS
+JQ_SRC = opcode.c bytecode.c compile.c execute.c builtin.c jv.c		\
+  jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c jv_aux.c jv_alloc.c	\
+  lexer.c jq_test.c ${JQ_INCS}
 
-JQ_INCS = \
-  jq_parser.h \
-  builtin.h \
-  bytecode.h \
-  compile.h \
-  execute.h \
-  forkable_stack.h \
-  frame_layout.h \
-  jv.h \
-  jv_alloc.h \
-  jv_aux.h \
-  jv_dtoa.h \
-  jv_parse.h \
-  jv_unicode.h \
-  locfile.h \
-  opcode.h \
-  opcode_list.h \
-  parser.y \
-  jv_utf8_tables.gen.h
 
-JQ_SRC = \
-  opcode.c \
-  bytecode.c \
-  compile.c \
-  execute.c \
-  builtin.c \
-  jv.c \
-  jv_parse.c \
-  jv_print.c \
-  jv_dtoa.c \
-  jv_unicode.c \
-  jv_aux.c \
-  jv_alloc.c \
-  lexer.c \
-  ${JQ_INCS}
+### C build options
 
-if DEVELOPMENT_ENABLED
-DEVCFLAGS = -Wextra -Wall -Wno-missing-field-initializers -Wno-unused-parameter -std=gnu99 -ggdb -Wno-unused-function -O0 -DJQ_DEBUG=1
-RPMBINS = jq jq_test
-else
-DEVCFLAGS = -DJQ_DEBUG=0
-RPMBINS = jq
-endif
+AM_CFLAGS = -Wextra -Wall -Wno-missing-field-initializers	\
+  -Wno-unused-parameter -Wno-unused-function
+
+
+### Generating the lexer and parser
+
+# While there is some autoconf macro support for lex/flex, it doesn't support
+# header file creation so we'll use good old make
+BUILT_SOURCES = lexer.h lexer.c
+lexer.c: lexer.l
+	flex -o lexer.c --header-file=lexer.h lexer.l
+lexer.h: lexer.c
 
 # Tell YACC (bison) autoconf macros that you want a header file created.
 # If the --warnings=all fails, you probably have an old version of bison
 # OSX ships an old bison, so update with homebrew or macports
 AM_YFLAGS = --warnings=all -d
 
+
+
+### Building the jq binary
+
+main.c: config.h
+
 bin_PROGRAMS = jq
-BUILT_SOURCES = jv_utf8_tables.gen.h lexer.h lexer.c
 jq_SOURCES = ${JQ_SRC} main.c
-jq_CPPFLAGS = ${DEVCFLAGS}
 
-# always test, but conditionally distribute to /usr/libexec/jq/jq_test
-if DEVELOPMENT_ENABLED
-  pkglibexec_PROGRAMS = jq_test
-  # automake doesn't like putting data in libexec (pkglibexec_DATA)
-  # so we'll create our own macro and distribute testdata
-  mydatadir = ${libexecdir}/${PACKAGE}
-  mydata_DATA = testdata
 
-  DEVBUILD=yes
-else
-  noinst_PROGRAMS = jq_test
-
-  DEVBUILD=no
-endif
-
-jq_test_SOURCES = ${JQ_SRC} jq_test.c
-jq_test_CPPFLAGS = ${DEVCFLAGS}
+### Tests
 
 # this is what gets "make check" to work
-TESTS = jq_test
-LOG_COMPILER = valgrind
-AM_LOG_FLAGS = --error-exitcode=1 -q --leak-check=full
+TESTS = tests/all.test
+TEST_LOG_COMPILER = tests/run
+
+
+
+### Packaging
+
+# setup is only used by distribution developers, not package developers.
+# Still, as a matter of allowing patching, its not a bad idea to distribute 
+# the developer setup script in the tarball.
+EXTRA_DIST = setup.sh config.h.in ChangeLog VERSION lexer.l lexer.h	\
+  gen_utf8_tables.py jq.spec testdata
+
+# README.md is expected in Github projects, good stuff in it, so we'll 
+# distribute it and install it with the package in the doc directory.
+docdir = ${datadir}/doc/${PACKAGE}
+dist_doc_DATA = README.md INSTALL COPYING AUTHORS README NEWS
 
 man_MANS = jq.1
 
 jq.1 :
 	cd ${abs_srcdir}/docs; rake manpage > ${abs_builddir}/$@
 
-# nasty circular dependency on header files between the generated C files
-parser.o: lexer.c
-
-lexer.o: parcer.c
-
-lexer.c: parser.h
-
-# While there is some autoconf macro support for lex/flex, it doesn't support
-# header file creation so we'll use good old make
-lexer.c: lexer.l
-	flex -o lexer.c --header-file=lexer.h lexer.l
-lexer.h: lexer.c
-
-jv_utf8_tables.gen.h: gen_utf8_tables.py
-	python $^ > $@
-
-jv_unicode.c: jv_utf8_tables.gen.h
-
 ChangeLog:
 	git log --name-status > $@ || echo "no changelog" > $@
 
-main.c: config.h
-
 releasetag:
 	git tag -s "jq-$$(cat VERSION)" -m "jq release $$(cat VERSION)"
 
 RELEASE ?= 1
-rpm: ${RPMBINS}
+rpm: jq
 	@echo "Packaging jq as an RPM ..."
 	mkdir -p rpm/SOURCES rpm/BUILD rpm/BUILDROOT rpm/RPMS rpm/SPECS
 	cp jq-$$(cat VERSION).tar.gz rpm/SOURCES/
-	rpmbuild -tb --define "_topdir ${PWD}/rpm" --define "_prefix /usr" --define "myver $$(cat VERSION)" --define "myrel ${RELEASE}" --define "devbuild ${DEVBUILD}" rpm/SOURCES/jq-$$(cat VERSION).tar.gz
+	rpmbuild -tb --define "_topdir ${PWD}/rpm" --define "_prefix /usr" --define "myver $$(cat VERSION)" --define "myrel ${RELEASE}" rpm/SOURCES/jq-$$(cat VERSION).tar.gz
 	find rpm/RPMS/ -name "*.rpm" -exec mv {} ./ \;
 	rm -rf rpm
 
diff --git a/configure.ac b/configure.ac
index 5f939493..fe81d972 100644
--- a/configure.ac
+++ b/configure.ac
@@ -16,33 +16,10 @@ AM_PROG_CC_C_O
 dnl couldn't use AM_PROG_LEX as it doesn't support header files like the
 dnl AC_PROG_YACC macros...
 
-dnl   CFLAGS is concidered a packagers variable, not a developer variable
-dnl   in Auto-tools.  For developer ease of use, CFLAGS are set how the
-dnl   developers like them by default but the packager can disable if so
-dnl   desired.  This is useful if something other than gcc is needed or
-dnl   for distros that need to heavily tweek the compiler (gentoo, ARM cpu
-dnl   linux's, etc)
-AC_ARG_ENABLE(
-  [devel],
-  [AC_HELP_STRING(
-    [--enable-devel],
-    [Build the tests and enable the same CFLAGS used by jq developers @<:@default=no@:>@])],
-  [],
-  [enable_devel=no]
-)
-AC_MSG_RESULT($enable_devel)
-AM_CONDITIONAL([DEVELOPMENT_ENABLED], [test x$enable_devel = xyes])
-
 dnl
 dnl these program checks should probably be deleted
 dnl
 
-dnl Check for sed
-AC_CHECK_PROGS(regex_cmd, sed)
-if test x$regex_cmd = "x" ; then
-    AC_MSG_NOTICE([sed is required to patch jq.])
-fi
-
 dnl Check for flex
 AC_CHECK_PROGS(flex_cmd, flex)
 if test x$flex_cmd = "x" ; then
@@ -55,12 +32,6 @@ if test x$bison_cmd = "x" ; then
     AC_MSG_NOTICE([bison is required to patch jq.])
 fi
 
-dnl Check for python
-AC_CHECK_PROGS(python_cmd, python)
-if test x$python_cmd = "x" ; then
-    AC_MSG_NOTICE([python is required to patch jq.])
-fi
-
 dnl Check for valgrind
 AC_CHECK_PROGS(valgrind_cmd, valgrind)
 if test x$valgrind_cmd = "x" ; then
@@ -72,3 +43,6 @@ AC_CONFIG_HEADERS(config.h)
 AM_INIT_AUTOMAKE([-Wall dist-bzip2 dist-zip])
 AC_CONFIG_FILES([Makefile])
 AC_OUTPUT
+
+
+dnl FIXME should disable colour output on windows somehow
diff --git a/jq_test.c b/jq_test.c
index 39f2664f..294a27f7 100644
--- a/jq_test.c
+++ b/jq_test.c
@@ -10,39 +10,11 @@ static void run_jq_tests();
 
 
 int jq_testsuite(int argc, char* argv[]) {
-  FILE* testdata;
   jv_test();
-  if (argc == 1) {
-    testdata = fopen("testdata", "r");
-    if ( NULL == testdata )
-    {
-      /* in an autoconf distcheck, the binary file will be in a _build subdirectory */
-      testdata = fopen("../testdata", "r");
-      if ( NULL == testdata )
-      {
-        fprintf(stderr, "Could not find testdata file\n");
-        exit(1);
-      }
-    }
-
-  } else if (argc == 2) {
-    if (!strcmp(argv[1], "-")) {
-      testdata = stdin;
-    } else {
-      testdata = fopen(argv[1], "r");
-    }
-  } else {
-    printf("usage: %s OR cat testdata | %s - OR %s testdata\n", argv[0], argv[0], argv[0]);
-    return 127;
-  }
-  run_jq_tests(testdata);
-  if (testdata != stdin) fclose(testdata);
+  run_jq_tests(stdin);
   return 0;
 }
 
-
-
-
 static int skipline(const char* buf) {
   int p = 0;
   while (buf[p] == ' ' || buf[p] == '\t') p++;
diff --git a/setup.sh b/setup.sh
index ef92f88a..50cc4eea 100755
--- a/setup.sh
+++ b/setup.sh
@@ -24,7 +24,7 @@ elif [ "superclean" == "$1" ]; then
   fi
 else
   autoreconf --install
-  ./configure --enable-devel --prefix=/opt/junk
+  ./configure --prefix=/opt/junk
   make check
   mkdir tmp
   make DESTDIR=./tmp install
diff --git a/testdata b/tests/all.test
similarity index 100%
rename from testdata
rename to tests/all.test
diff --git a/tests/run b/tests/run
new file mode 100755
index 00000000..a4b5b320
--- /dev/null
+++ b/tests/run
@@ -0,0 +1,3 @@
+#!/bin/sh
+
+cat $@ | valgrind --error-exitcode=1 -q --leak-check=full ./jq --run-tests
\ No newline at end of file

From 9d245c88c4768444e7e36c88f9ae9976ecdcdec8 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 8 May 2013 18:55:10 +0100
Subject: [PATCH 244/284] Check in a pile of Autotools junk, including the
 configure script.

---
 .gitignore        |   17 +-
 Makefile.am       |    4 +-
 Makefile.in       | 1130 +++++++++
 NEWS              |    5 -
 README            |   11 +-
 VERSION           |    1 -
 aclocal.m4        | 1063 +++++++++
 config.h.in       |   28 +
 config/compile    |  343 +++
 config/depcomp    |  708 ++++++
 config/install-sh |  527 +++++
 config/missing    |  331 +++
 config/ylwrap     |  226 ++
 configure         | 5766 +++++++++++++++++++++++++++++++++++++++++++++
 configure.ac      |    2 +-
 15 files changed, 10142 insertions(+), 20 deletions(-)
 create mode 100644 Makefile.in
 delete mode 100644 NEWS
 mode change 100644 => 120000 README
 delete mode 100644 VERSION
 create mode 100644 aclocal.m4
 create mode 100644 config.h.in
 create mode 100755 config/compile
 create mode 100755 config/depcomp
 create mode 100755 config/install-sh
 create mode 100755 config/missing
 create mode 100755 config/ylwrap
 create mode 100755 configure

diff --git a/.gitignore b/.gitignore
index f76b15d8..96cd2892 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,10 +1,25 @@
 *.o
 *~
 
-jq_test
 build
 jq
 jq.1
 
 # Something delightfully recursive happens otherwise
 docs/content/2.download/source/*
+
+# Autogenerated
+lexer.c
+lexer.h
+parser.c
+parser.h
+
+# Autotools junk
+.deps
+*.log
+stamp-h1
+config.log
+config.status
+autom4te.cache
+config.h
+Makefile
\ No newline at end of file
diff --git a/Makefile.am b/Makefile.am
index 5018439f..0810f0c6 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -53,13 +53,13 @@ TEST_LOG_COMPILER = tests/run
 # setup is only used by distribution developers, not package developers.
 # Still, as a matter of allowing patching, its not a bad idea to distribute 
 # the developer setup script in the tarball.
-EXTRA_DIST = setup.sh config.h.in ChangeLog VERSION lexer.l lexer.h	\
+EXTRA_DIST = setup.sh config.h.in ChangeLog lexer.l lexer.h	\
   gen_utf8_tables.py jq.spec testdata
 
 # README.md is expected in Github projects, good stuff in it, so we'll 
 # distribute it and install it with the package in the doc directory.
 docdir = ${datadir}/doc/${PACKAGE}
-dist_doc_DATA = README.md INSTALL COPYING AUTHORS README NEWS
+dist_doc_DATA = README.md COPYING AUTHORS README
 
 man_MANS = jq.1
 
diff --git a/Makefile.in b/Makefile.in
new file mode 100644
index 00000000..5a8e9a9c
--- /dev/null
+++ b/Makefile.in
@@ -0,0 +1,1130 @@
+# Makefile.in generated by automake 1.11.6 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
+# Foundation, Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+### C source files to be built
+
+
+VPATH = @srcdir@
+am__make_dryrun = \
+  { \
+    am__dry=no; \
+    case $$MAKEFLAGS in \
+      *\\[\ \	]*) \
+        echo 'am--echo: ; @echo "AM"  OK' | $(MAKE) -f - 2>/dev/null \
+          | grep '^AM OK$$' >/dev/null || am__dry=yes;; \
+      *) \
+        for am__flg in $$MAKEFLAGS; do \
+          case $$am__flg in \
+            *=*|--*) ;; \
+            *n*) am__dry=yes; break;; \
+          esac; \
+        done;; \
+    esac; \
+    test $$am__dry = yes; \
+  }
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+bin_PROGRAMS = jq$(EXEEXT)
+subdir = .
+DIST_COMMON = README $(am__configure_deps) $(dist_doc_DATA) \
+	$(srcdir)/Makefile.am $(srcdir)/Makefile.in \
+	$(srcdir)/config.h.in $(top_srcdir)/configure AUTHORS COPYING \
+	ChangeLog config/compile config/depcomp config/install-sh \
+	config/missing config/ylwrap parser.c parser.h
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \
+ configure.lineno config.status.lineno
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__installdirs = "$(DESTDIR)$(bindir)" "$(DESTDIR)$(man1dir)" \
+	"$(DESTDIR)$(docdir)"
+PROGRAMS = $(bin_PROGRAMS)
+am__objects_1 = parser.$(OBJEXT)
+am__objects_2 = opcode.$(OBJEXT) bytecode.$(OBJEXT) compile.$(OBJEXT) \
+	execute.$(OBJEXT) builtin.$(OBJEXT) jv.$(OBJEXT) \
+	jv_parse.$(OBJEXT) jv_print.$(OBJEXT) jv_dtoa.$(OBJEXT) \
+	jv_unicode.$(OBJEXT) jv_aux.$(OBJEXT) jv_alloc.$(OBJEXT) \
+	lexer.$(OBJEXT) jq_test.$(OBJEXT) $(am__objects_1)
+am_jq_OBJECTS = $(am__objects_2) main.$(OBJEXT)
+jq_OBJECTS = $(am_jq_OBJECTS)
+jq_LDADD = $(LDADD)
+DEFAULT_INCLUDES = -I.@am__isrc@
+depcomp = $(SHELL) $(top_srcdir)/config/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+AM_V_CC = $(am__v_CC_@AM_V@)
+am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
+am__v_CC_0 = @echo "  CC    " $@;
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+CCLD = $(CC)
+LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CCLD = $(am__v_CCLD_@AM_V@)
+am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
+am__v_CCLD_0 = @echo "  CCLD  " $@;
+YACCCOMPILE = $(YACC) $(AM_YFLAGS) $(YFLAGS)
+AM_V_YACC = $(am__v_YACC_@AM_V@)
+am__v_YACC_ = $(am__v_YACC_@AM_DEFAULT_V@)
+am__v_YACC_0 = @echo "  YACC  " $@;
+YLWRAP = $(top_srcdir)/config/ylwrap
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo "  GEN   " $@;
+SOURCES = $(jq_SOURCES)
+DIST_SOURCES = $(jq_SOURCES)
+am__can_run_installinfo = \
+  case $$AM_UPDATE_INFO_DIR in \
+    n|no|NO) false;; \
+    *) (install-info --version) >/dev/null 2>&1;; \
+  esac
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+  for p in $$list; do echo "$$p $$p"; done | \
+  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+    if (++n[$$2] == $(am__install_max)) \
+      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+    END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+  test -z "$$files" \
+    || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+    || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+         $(am__cd) "$$dir" && rm -f $$files; }; \
+  }
+man1dir = $(mandir)/man1
+NROFF = nroff
+MANS = $(man_MANS)
+DATA = $(dist_doc_DATA)
+ETAGS = etags
+CTAGS = ctags
+am__tty_colors = \
+red=; grn=; lgn=; blu=; std=
+# Restructured Text title and section.
+am__rst_title = sed 's/.*/   &   /;h;s/./=/g;p;x;p;g;p;s/.*//'
+am__rst_section = sed 'p;s/./=/g;p;g'
+# Put stdin (possibly several lines separated by ".  ") in a box.
+# Prefix each line by 'col' and terminate each with 'std', for coloring.
+# Multi line coloring is problematic with "less -R", so we really need
+# to color each line individually.
+am__text_box = $(AWK) '{			\
+  n = split($$0, lines, "\\.  "); max = 0;	\
+  for (i = 1; i <= n; ++i)			\
+    if (max < length(lines[i]))			\
+      max = length(lines[i]);			\
+  for (i = 0; i < max; ++i)			\
+    line = line "=";				\
+  print col line std;				\
+  for (i = 1; i <= n; ++i)			\
+    if (lines[i])				\
+      print col lines[i] std;			\
+  print col line std;				\
+}'
+# Solaris 10 'make', and several other traditional 'make' implementations,
+# pass "-e" to $(SHELL), and POSIX 2008 even requires this.  Work around it
+# by disabling -e (using the XSI extension "set +e") if it's set.
+am__sh_e_setup = case $$- in *e*) set +e;; esac
+# To be inserted before the command running the test.  Creates the
+# directory for the log if needed.  Stores in $dir the directory
+# containing $f, in $tst the test, in $log the log, and passes
+# TESTS_ENVIRONMENT.  Save and restore TERM around use of
+# TESTS_ENVIRONMENT, in case that unsets it.
+am__check_pre = \
+$(am__sh_e_setup);					\
+$(am__vpath_adj_setup) $(am__vpath_adj)			\
+srcdir=$(srcdir); export srcdir;			\
+rm -f $@-t;						\
+am__trap='rm -f '\''$(abs_builddir)/$@-t'\''; (exit $$st); exit $$st'; \
+trap "st=129; $$am__trap" 1; trap "st=130; $$am__trap" 2;	\
+trap "st=141; $$am__trap" 13; trap "st=143; $$am__trap" 15; \
+am__odir=`echo "./$@" | sed 's|/[^/]*$$||'`;		\
+test "x$$am__odir" = x. || $(MKDIR_P) "$$am__odir" || exit $$?;	\
+if test -f "./$$f"; then dir=./;			\
+elif test -f "$$f"; then dir=;				\
+else dir="$(srcdir)/"; fi;				\
+tst=$$dir$$f; log='$@'; __SAVED_TERM=$$TERM;		\
+$(TESTS_ENVIRONMENT)
+# To be appended to the command running the test.  Handle the stdout
+# and stderr redirection, and catch the exit status.
+am__check_post = \
+>$@-t 2>&1;						\
+estatus=$$?;						\
+if test -n '$(DISABLE_HARD_ERRORS)'			\
+   && test $$estatus -eq 99; then			\
+  estatus=1;						\
+fi;							\
+TERM=$$__SAVED_TERM; export TERM;			\
+$(am__tty_colors);					\
+xfailed=PASS;						\
+case " $(XFAIL_TESTS) " in				\
+  *[\ \	]$$f[\ \	]* | *[\ \	]$$dir$$f[\ \	]*) \
+    xfailed=XFAIL;;					\
+esac;							\
+case $$estatus.$$xfailed in				\
+    0.XFAIL) col=$$red; res=XPASS;;			\
+    0.*)     col=$$grn; res=PASS ;;			\
+    77.*)    col=$$blu; res=SKIP ;;			\
+    99.*)    col=$$red; res=FAIL ;;			\
+    *.XFAIL) col=$$lgn; res=XFAIL;;			\
+    *.*)     col=$$red; res=FAIL ;;			\
+esac;							\
+echo "$${col}$$res$${std}: $$f";			\
+echo "$$res: $$f (exit: $$estatus)" |			\
+  $(am__rst_section) >$@;				\
+cat $@-t >>$@;						\
+rm -f $@-t
+RECHECK_LOGS = $(TEST_LOGS)
+AM_RECURSIVE_TARGETS = check recheck check-html recheck-html
+TEST_SUITE_HTML = $(TEST_SUITE_LOG:.log=.html)
+TEST_SUITE_LOG = test-suite.log
+TEST_EXTENSIONS = @EXEEXT@ .test
+am__test_logs1 = $(TESTS:=.log)
+am__test_logs2 = $(am__test_logs1:@EXEEXT@.log=.log)
+TEST_LOGS = $(am__test_logs2:.test.log=.log)
+TEST_LOG_COMPILE = $(TEST_LOG_COMPILER) $(AM_TEST_LOG_FLAGS) \
+	$(TEST_LOG_FLAGS)
+TEST_LOGS_TMP = $(TEST_LOGS:.log=.log-t)
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+distdir = $(PACKAGE)-$(VERSION)
+top_distdir = $(distdir)
+am__remove_distdir = \
+  if test -d "$(distdir)"; then \
+    find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \
+      && rm -rf "$(distdir)" \
+      || { sleep 5 && rm -rf "$(distdir)"; }; \
+  else :; fi
+DIST_ARCHIVES = $(distdir).tar.gz $(distdir).tar.bz2 $(distdir).zip
+GZIP_ENV = --best
+distuninstallcheck_listfiles = find . -type f -print
+am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \
+  | sed 's|^\./|$(prefix)/|' | grep -v '$(infodir)/dir$$'
+distcleancheck_listfiles = find . -type f -print
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EXEEXT = @EXEEXT@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MKDIR_P = @MKDIR_P@
+OBJEXT = @OBJEXT@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+YACC = @YACC@
+YFLAGS = @YFLAGS@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_CC = @ac_ct_CC@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+bison_cmd = @bison_cmd@
+build_alias = @build_alias@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+
+# README.md is expected in Github projects, good stuff in it, so we'll 
+# distribute it and install it with the package in the doc directory.
+docdir = ${datadir}/doc/${PACKAGE}
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+flex_cmd = @flex_cmd@
+host_alias = @host_alias@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+valgrind_cmd = @valgrind_cmd@
+JQ_INCS = jq_parser.h builtin.h bytecode.h compile.h execute.h		\
+  forkable_stack.h frame_layout.h jv.h jv_alloc.h jv_aux.h jv_dtoa.h	\
+  jv_parse.h jv_unicode.h locfile.h opcode.h opcode_list.h parser.y	\
+  jv_utf8_tables.h
+
+JQ_SRC = opcode.c bytecode.c compile.c execute.c builtin.c jv.c		\
+  jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c jv_aux.c jv_alloc.c	\
+  lexer.c jq_test.c ${JQ_INCS}
+
+
+### C build options
+AM_CFLAGS = -Wextra -Wall -Wno-missing-field-initializers	\
+  -Wno-unused-parameter -Wno-unused-function
+
+
+### Generating the lexer and parser
+
+# While there is some autoconf macro support for lex/flex, it doesn't support
+# header file creation so we'll use good old make
+BUILT_SOURCES = lexer.h lexer.c
+
+# Tell YACC (bison) autoconf macros that you want a header file created.
+# If the --warnings=all fails, you probably have an old version of bison
+# OSX ships an old bison, so update with homebrew or macports
+AM_YFLAGS = --warnings=all -d
+jq_SOURCES = ${JQ_SRC} main.c
+
+### Tests
+
+# this is what gets "make check" to work
+TESTS = tests/all.test
+TEST_LOG_COMPILER = tests/run
+
+### Packaging
+
+# setup is only used by distribution developers, not package developers.
+# Still, as a matter of allowing patching, its not a bad idea to distribute 
+# the developer setup script in the tarball.
+EXTRA_DIST = setup.sh config.h.in ChangeLog lexer.l lexer.h	\
+  gen_utf8_tables.py jq.spec testdata
+
+dist_doc_DATA = README.md COPYING AUTHORS README
+man_MANS = jq.1
+all: $(BUILT_SOURCES) config.h
+	$(MAKE) $(AM_MAKEFLAGS) all-am
+
+.SUFFIXES:
+.SUFFIXES: .c .html .log .o .obj .test .test$(EXEEXT) .y
+am--refresh: Makefile
+	@:
+$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      echo ' cd $(srcdir) && $(AUTOMAKE) --foreign'; \
+	      $(am__cd) $(srcdir) && $(AUTOMAKE) --foreign \
+		&& exit 0; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    echo ' $(SHELL) ./config.status'; \
+	    $(SHELL) ./config.status;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	$(SHELL) ./config.status --recheck
+
+$(top_srcdir)/configure:  $(am__configure_deps)
+	$(am__cd) $(srcdir) && $(AUTOCONF)
+$(ACLOCAL_M4):  $(am__aclocal_m4_deps)
+	$(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS)
+$(am__aclocal_m4_deps):
+
+config.h: stamp-h1
+	@if test ! -f $@; then rm -f stamp-h1; else :; fi
+	@if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) stamp-h1; else :; fi
+
+stamp-h1: $(srcdir)/config.h.in $(top_builddir)/config.status
+	@rm -f stamp-h1
+	cd $(top_builddir) && $(SHELL) ./config.status config.h
+$(srcdir)/config.h.in:  $(am__configure_deps) 
+	($(am__cd) $(top_srcdir) && $(AUTOHEADER))
+	rm -f stamp-h1
+	touch $@
+
+distclean-hdr:
+	-rm -f config.h stamp-h1
+install-binPROGRAMS: $(bin_PROGRAMS)
+	@$(NORMAL_INSTALL)
+	@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+	if test -n "$$list"; then \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \
+	fi; \
+	for p in $$list; do echo "$$p $$p"; done | \
+	sed 's/$(EXEEXT)$$//' | \
+	while read p p1; do if test -f $$p; \
+	  then echo "$$p"; echo "$$p"; else :; fi; \
+	done | \
+	sed -e 'p;s,.*/,,;n;h' -e 's|.*|.|' \
+	    -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
+	sed 'N;N;N;s,\n, ,g' | \
+	$(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
+	  { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
+	    if ($$2 == $$4) files[d] = files[d] " " $$1; \
+	    else { print "f", $$3 "/" $$4, $$1; } } \
+	  END { for (d in files) print "f", d, files[d] }' | \
+	while read type dir files; do \
+	    if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
+	    test -z "$$files" || { \
+	      echo " $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
+	      $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
+	    } \
+	; done
+
+uninstall-binPROGRAMS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+	files=`for p in $$list; do echo "$$p"; done | \
+	  sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
+	      -e 's/$$/$(EXEEXT)/' `; \
+	test -n "$$list" || exit 0; \
+	echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
+	cd "$(DESTDIR)$(bindir)" && rm -f $$files
+
+clean-binPROGRAMS:
+	-test -z "$(bin_PROGRAMS)" || rm -f $(bin_PROGRAMS)
+parser.h: parser.c
+	@if test ! -f $@; then rm -f parser.c; else :; fi
+	@if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) parser.c; else :; fi
+jq$(EXEEXT): $(jq_OBJECTS) $(jq_DEPENDENCIES) $(EXTRA_jq_DEPENDENCIES) 
+	@rm -f jq$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(jq_OBJECTS) $(jq_LDADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/builtin.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bytecode.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compile.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/execute.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/jq_test.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/jv.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/jv_alloc.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/jv_aux.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/jv_dtoa.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/jv_parse.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/jv_print.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/jv_unicode.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/lexer.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/main.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/opcode.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/parser.Po@am__quote@
+
+.c.o:
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c $<
+
+.c.obj:
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c `$(CYGPATH_W) '$<'`
+
+.y.c:
+	$(AM_V_YACC)$(am__skipyacc) $(SHELL) $(YLWRAP) $< y.tab.c $@ y.tab.h $*.h y.output $*.output -- $(YACCCOMPILE)
+install-man1: $(man_MANS)
+	@$(NORMAL_INSTALL)
+	@list1=''; \
+	list2='$(man_MANS)'; \
+	test -n "$(man1dir)" \
+	  && test -n "`echo $$list1$$list2`" \
+	  || exit 0; \
+	echo " $(MKDIR_P) '$(DESTDIR)$(man1dir)'"; \
+	$(MKDIR_P) "$(DESTDIR)$(man1dir)" || exit 1; \
+	{ for i in $$list1; do echo "$$i"; done;  \
+	if test -n "$$list2"; then \
+	  for i in $$list2; do echo "$$i"; done \
+	    | sed -n '/\.1[a-z]*$$/p'; \
+	fi; \
+	} | while read p; do \
+	  if test -f $$p; then d=; else d="$(srcdir)/"; fi; \
+	  echo "$$d$$p"; echo "$$p"; \
+	done | \
+	sed -e 'n;s,.*/,,;p;h;s,.*\.,,;s,^[^1][0-9a-z]*$$,1,;x' \
+	      -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,' | \
+	sed 'N;N;s,\n, ,g' | { \
+	list=; while read file base inst; do \
+	  if test "$$base" = "$$inst"; then list="$$list $$file"; else \
+	    echo " $(INSTALL_DATA) '$$file' '$(DESTDIR)$(man1dir)/$$inst'"; \
+	    $(INSTALL_DATA) "$$file" "$(DESTDIR)$(man1dir)/$$inst" || exit $$?; \
+	  fi; \
+	done; \
+	for i in $$list; do echo "$$i"; done | $(am__base_list) | \
+	while read files; do \
+	  test -z "$$files" || { \
+	    echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(man1dir)'"; \
+	    $(INSTALL_DATA) $$files "$(DESTDIR)$(man1dir)" || exit $$?; }; \
+	done; }
+
+uninstall-man1:
+	@$(NORMAL_UNINSTALL)
+	@list=''; test -n "$(man1dir)" || exit 0; \
+	files=`{ for i in $$list; do echo "$$i"; done; \
+	l2='$(man_MANS)'; for i in $$l2; do echo "$$i"; done | \
+	  sed -n '/\.1[a-z]*$$/p'; \
+	} | sed -e 's,.*/,,;h;s,.*\.,,;s,^[^1][0-9a-z]*$$,1,;x' \
+	      -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,'`; \
+	dir='$(DESTDIR)$(man1dir)'; $(am__uninstall_files_from_dir)
+install-dist_docDATA: $(dist_doc_DATA)
+	@$(NORMAL_INSTALL)
+	@list='$(dist_doc_DATA)'; test -n "$(docdir)" || list=; \
+	if test -n "$$list"; then \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(docdir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(docdir)" || exit 1; \
+	fi; \
+	for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  echo "$$d$$p"; \
+	done | $(am__base_list) | \
+	while read files; do \
+	  echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(docdir)'"; \
+	  $(INSTALL_DATA) $$files "$(DESTDIR)$(docdir)" || exit $$?; \
+	done
+
+uninstall-dist_docDATA:
+	@$(NORMAL_UNINSTALL)
+	@list='$(dist_doc_DATA)'; test -n "$(docdir)" || list=; \
+	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+	dir='$(DESTDIR)$(docdir)'; $(am__uninstall_files_from_dir)
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	mkid -fID $$unique
+tags: TAGS
+
+TAGS:  $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	set x; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: CTAGS
+CTAGS:  $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+$(TEST_SUITE_LOG): $(TEST_LOGS)
+	@$(am__sh_e_setup);						\
+	list='$(TEST_LOGS)';						\
+	results=`for f in $$list; do					\
+		   test -r $$f && read line < $$f && echo "$$line"	\
+		     || echo FAIL;					\
+		 done`;							\
+	all=`echo "$$results" | sed '/^$$/d' | wc -l | sed -e 's/^[	 ]*//'`; \
+	fail=`echo "$$results" | grep -c '^FAIL'`;			\
+	pass=`echo "$$results" | grep -c '^PASS'`;			\
+	skip=`echo "$$results" | grep -c '^SKIP'`;			\
+	xfail=`echo "$$results" | grep -c '^XFAIL'`;			\
+	xpass=`echo "$$results" | grep -c '^XPASS'`;			\
+	failures=`expr $$fail + $$xpass`;				\
+	all=`expr $$all - $$skip`;					\
+	if test "$$all" -eq 1; then tests=test; All=;			\
+	else tests=tests; All="All "; fi;				\
+	case fail=$$fail:xpass=$$xpass:xfail=$$xfail in			\
+	  fail=0:xpass=0:xfail=0)					\
+	    msg="$$All$$all $$tests passed.  ";				\
+	    exit=true;;							\
+	  fail=0:xpass=0:xfail=*)					\
+	    msg="$$All$$all $$tests behaved as expected";		\
+	    if test "$$xfail" -eq 1; then xfailures=failure;		\
+	    else xfailures=failures; fi;				\
+	    msg="$$msg ($$xfail expected $$xfailures).  ";		\
+	    exit=true;;							\
+	  fail=*:xpass=0:xfail=*)					\
+	    msg="$$fail of $$all $$tests failed.  ";			\
+	    exit=false;;						\
+	  fail=*:xpass=*:xfail=*)					\
+	    msg="$$failures of $$all $$tests did not behave as expected"; \
+	    if test "$$xpass" -eq 1; then xpasses=pass;			\
+	    else xpasses=passes; fi;					\
+	    msg="$$msg ($$xpass unexpected $$xpasses).  ";		\
+	    exit=false;;						\
+	  *)								\
+	    echo >&2 "incorrect case"; exit 4;;				\
+	esac;								\
+	if test "$$skip" -ne 0; then					\
+	  if test "$$skip" -eq 1; then					\
+	    msg="$$msg($$skip test was not run).  ";			\
+	  else								\
+	    msg="$$msg($$skip tests were not run).  ";			\
+	  fi;								\
+	fi;								\
+	{								\
+	  echo "$(PACKAGE_STRING): $(subdir)/$(TEST_SUITE_LOG)" |	\
+	    $(am__rst_title);						\
+	  echo "$$msg";							\
+	  echo;								\
+	  echo ".. contents:: :depth: 2";				\
+	  echo;								\
+	  for f in $$list; do						\
+	    test -r $$f && read line < $$f || line=;			\
+	    case $$line in						\
+	      PASS:*|XFAIL:*);;						\
+	      *) echo; cat $$f;;					\
+	    esac;							\
+	  done;								\
+	} >$(TEST_SUITE_LOG).tmp;					\
+	mv $(TEST_SUITE_LOG).tmp $(TEST_SUITE_LOG);			\
+	if test "$$failures" -ne 0; then				\
+	  msg="$${msg}See $(subdir)/$(TEST_SUITE_LOG).  ";		\
+	  if test -n "$(PACKAGE_BUGREPORT)"; then			\
+	    msg="$${msg}Please report to $(PACKAGE_BUGREPORT).  ";	\
+	  fi;								\
+	fi;								\
+	test x"$$VERBOSE" = x || $$exit || cat $(TEST_SUITE_LOG);	\
+	$(am__tty_colors);						\
+	if $$exit; then							\
+	  col="$$grn";							\
+	 else								\
+	  col="$$red";							\
+	fi;								\
+	echo "$$msg" | $(am__text_box) "col=$$col" "std=$$std";		\
+	$$exit || exit 1
+
+check-TESTS recheck:
+	@if test $@ != recheck; then \
+	   list='$(RECHECK_LOGS)'; test -z "$$list" || rm -f $$list; \
+	 fi
+	@test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
+	@list='' list2='$(TEST_LOGS)'; for f in $$list2; do \
+	  test .log = $$f && continue; \
+	  if test $@ = recheck; then \
+	    test -f $$f || continue; \
+	    if test -r $$f && read line < $$f; then \
+	      case $$line in FAIL*|XPASS*) : ;; *) continue;; esac; \
+	    fi; \
+	  fi; \
+	  if test -z "$$list"; then list=$$f; else list="$$list $$f"; fi; \
+	done; \
+	if test $@ = recheck && test -n "$$list"; then \
+	  $(am__make_dryrun) || rm -f $$list || exit 1; \
+	fi; \
+	$(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) TEST_LOGS="$$list"
+recheck: 
+
+am--mostlyclean-test-html:
+	list='$(TEST_LOGS:.log=.html)'; test -z "$$list" || rm -f $$list
+	rm -f $(TEST_SUITE_HTML)
+
+.log.html:
+	@list='$(RST2HTML) $$RST2HTML rst2html rst2html.py';		\
+	for r2h in $$list; do						\
+	  if ($$r2h --version) >/dev/null 2>&1; then			\
+	    R2H=$$r2h;							\
+	  fi;								\
+	done;								\
+	if test -z "$$R2H"; then					\
+	  echo >&2 "cannot find rst2html, cannot create $@";		\
+	  exit 2;							\
+	fi;								\
+	$$R2H $< >$@.tmp
+	@mv $@.tmp $@
+
+# Be sure to run check first, and then to convert the result.
+# Beware of concurrent executions.  Run "check" not "check-TESTS", as
+# check-SCRIPTS and other dependencies are rebuilt by the former only.
+# And expect check to fail.
+check-html recheck-html:
+	@target=`echo $@ | sed 's/-html$$//'`; \
+	rv=0; $(MAKE) $(AM_MAKEFLAGS) $$target || rv=$$?; \
+	$(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_HTML) TEST_LOGS= || exit 4; \
+	exit $$rv
+.test.log:
+	@p='$<'; $(am__check_pre) $(TEST_LOG_COMPILE) "$$tst" $(am__check_post)
+@am__EXEEXT_TRUE@.test$(EXEEXT).log:
+@am__EXEEXT_TRUE@	@p='$<'; $(am__check_pre) $(TEST_LOG_COMPILE) "$$tst" $(am__check_post)
+
+distdir: $(DISTFILES)
+	@list='$(MANS)'; if test -n "$$list"; then \
+	  list=`for p in $$list; do \
+	    if test -f $$p; then d=; else d="$(srcdir)/"; fi; \
+	    if test -f "$$d$$p"; then echo "$$d$$p"; else :; fi; done`; \
+	  if test -n "$$list" && \
+	    grep 'ab help2man is required to generate this page' $$list >/dev/null; then \
+	    echo "error: found man pages containing the \`missing help2man' replacement text:" >&2; \
+	    grep -l 'ab help2man is required to generate this page' $$list | sed 's/^/         /' >&2; \
+	    echo "       to fix them, install help2man, remove and regenerate the man pages;" >&2; \
+	    echo "       typically \`make maintainer-clean' will remove them" >&2; \
+	    exit 1; \
+	  else :; fi; \
+	else :; fi
+	$(am__remove_distdir)
+	test -d "$(distdir)" || mkdir "$(distdir)"
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+	-test -n "$(am__skip_mode_fix)" \
+	|| find "$(distdir)" -type d ! -perm -755 \
+		-exec chmod u+rwx,go+rx {} \; -o \
+	  ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \
+	  ! -type d ! -perm -400 -exec chmod a+r {} \; -o \
+	  ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \
+	|| chmod -R a+r "$(distdir)"
+dist-gzip: distdir
+	tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
+	$(am__remove_distdir)
+dist-bzip2: distdir
+	tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2
+	$(am__remove_distdir)
+
+dist-lzip: distdir
+	tardir=$(distdir) && $(am__tar) | lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz
+	$(am__remove_distdir)
+
+dist-lzma: distdir
+	tardir=$(distdir) && $(am__tar) | lzma -9 -c >$(distdir).tar.lzma
+	$(am__remove_distdir)
+
+dist-xz: distdir
+	tardir=$(distdir) && $(am__tar) | XZ_OPT=$${XZ_OPT--e} xz -c >$(distdir).tar.xz
+	$(am__remove_distdir)
+
+dist-tarZ: distdir
+	tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z
+	$(am__remove_distdir)
+
+dist-shar: distdir
+	shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz
+	$(am__remove_distdir)
+dist-zip: distdir
+	-rm -f $(distdir).zip
+	zip -rq $(distdir).zip $(distdir)
+	$(am__remove_distdir)
+
+dist dist-all: distdir
+	tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
+	tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2
+	-rm -f $(distdir).zip
+	zip -rq $(distdir).zip $(distdir)
+	$(am__remove_distdir)
+
+# This target untars the dist file and tries a VPATH configuration.  Then
+# it guarantees that the distribution is self-contained by making another
+# tarfile.
+distcheck: dist
+	case '$(DIST_ARCHIVES)' in \
+	*.tar.gz*) \
+	  GZIP=$(GZIP_ENV) gzip -dc $(distdir).tar.gz | $(am__untar) ;;\
+	*.tar.bz2*) \
+	  bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\
+	*.tar.lzma*) \
+	  lzma -dc $(distdir).tar.lzma | $(am__untar) ;;\
+	*.tar.lz*) \
+	  lzip -dc $(distdir).tar.lz | $(am__untar) ;;\
+	*.tar.xz*) \
+	  xz -dc $(distdir).tar.xz | $(am__untar) ;;\
+	*.tar.Z*) \
+	  uncompress -c $(distdir).tar.Z | $(am__untar) ;;\
+	*.shar.gz*) \
+	  GZIP=$(GZIP_ENV) gzip -dc $(distdir).shar.gz | unshar ;;\
+	*.zip*) \
+	  unzip $(distdir).zip ;;\
+	esac
+	chmod -R a-w $(distdir); chmod u+w $(distdir)
+	mkdir $(distdir)/_build
+	mkdir $(distdir)/_inst
+	chmod a-w $(distdir)
+	test -d $(distdir)/_build || exit 0; \
+	dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \
+	  && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \
+	  && am__cwd=`pwd` \
+	  && $(am__cd) $(distdir)/_build \
+	  && ../configure --srcdir=.. --prefix="$$dc_install_base" \
+	    $(AM_DISTCHECK_CONFIGURE_FLAGS) \
+	    $(DISTCHECK_CONFIGURE_FLAGS) \
+	  && $(MAKE) $(AM_MAKEFLAGS) \
+	  && $(MAKE) $(AM_MAKEFLAGS) dvi \
+	  && $(MAKE) $(AM_MAKEFLAGS) check \
+	  && $(MAKE) $(AM_MAKEFLAGS) install \
+	  && $(MAKE) $(AM_MAKEFLAGS) installcheck \
+	  && $(MAKE) $(AM_MAKEFLAGS) uninstall \
+	  && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \
+	        distuninstallcheck \
+	  && chmod -R a-w "$$dc_install_base" \
+	  && ({ \
+	       (cd ../.. && umask 077 && mkdir "$$dc_destdir") \
+	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \
+	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \
+	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \
+	            distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \
+	      } || { rm -rf "$$dc_destdir"; exit 1; }) \
+	  && rm -rf "$$dc_destdir" \
+	  && $(MAKE) $(AM_MAKEFLAGS) dist \
+	  && rm -rf $(DIST_ARCHIVES) \
+	  && $(MAKE) $(AM_MAKEFLAGS) distcleancheck \
+	  && cd "$$am__cwd" \
+	  || exit 1
+	$(am__remove_distdir)
+	@(echo "$(distdir) archives ready for distribution: "; \
+	  list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \
+	  sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x'
+distuninstallcheck:
+	@test -n '$(distuninstallcheck_dir)' || { \
+	  echo 'ERROR: trying to run $@ with an empty' \
+	       '$$(distuninstallcheck_dir)' >&2; \
+	  exit 1; \
+	}; \
+	$(am__cd) '$(distuninstallcheck_dir)' || { \
+	  echo 'ERROR: cannot chdir into $(distuninstallcheck_dir)' >&2; \
+	  exit 1; \
+	}; \
+	test `$(am__distuninstallcheck_listfiles) | wc -l` -eq 0 \
+	   || { echo "ERROR: files left after uninstall:" ; \
+	        if test -n "$(DESTDIR)"; then \
+	          echo "  (check DESTDIR support)"; \
+	        fi ; \
+	        $(distuninstallcheck_listfiles) ; \
+	        exit 1; } >&2
+distcleancheck: distclean
+	@if test '$(srcdir)' = . ; then \
+	  echo "ERROR: distcleancheck can only run from a VPATH build" ; \
+	  exit 1 ; \
+	fi
+	@test `$(distcleancheck_listfiles) | wc -l` -eq 0 \
+	  || { echo "ERROR: files left in build directory after distclean:" ; \
+	       $(distcleancheck_listfiles) ; \
+	       exit 1; } >&2
+check-am: all-am
+	$(MAKE) $(AM_MAKEFLAGS) check-TESTS
+check: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) check-am
+all-am: Makefile $(PROGRAMS) $(MANS) $(DATA) config.h
+installdirs:
+	for dir in "$(DESTDIR)$(bindir)" "$(DESTDIR)$(man1dir)" "$(DESTDIR)$(docdir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	if test -z '$(STRIP)'; then \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	      install; \
+	else \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+	fi
+mostlyclean-generic:
+	-test -z "$(TEST_LOGS)" || rm -f $(TEST_LOGS)
+	-test -z "$(TEST_LOGS_TMP)" || rm -f $(TEST_LOGS_TMP)
+	-test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+	-rm -f parser.c
+	-rm -f parser.h
+	-test -z "$(BUILT_SOURCES)" || rm -f $(BUILT_SOURCES)
+clean: clean-am
+
+clean-am: clean-binPROGRAMS clean-generic clean-local mostlyclean-am
+
+distclean: distclean-am
+	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-hdr distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-dist_docDATA install-man
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-binPROGRAMS
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man: install-man1
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
+	-rm -rf $(top_srcdir)/autom4te.cache
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: am--mostlyclean-test-html mostlyclean-compile \
+	mostlyclean-generic
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-binPROGRAMS uninstall-dist_docDATA \
+	uninstall-man
+
+uninstall-man: uninstall-man1
+
+.MAKE: all check check-am check-html install install-am install-strip \
+	recheck-html
+
+.PHONY: CTAGS GTAGS all all-am am--mostlyclean-test-html am--refresh \
+	check check-TESTS check-am check-html clean clean-binPROGRAMS \
+	clean-generic clean-local ctags dist dist-all dist-bzip2 \
+	dist-gzip dist-lzip dist-lzma dist-shar dist-tarZ dist-xz \
+	dist-zip distcheck distclean distclean-compile \
+	distclean-generic distclean-hdr distclean-tags distcleancheck \
+	distdir distuninstallcheck dvi dvi-am html html-am info \
+	info-am install install-am install-binPROGRAMS install-data \
+	install-data-am install-dist_docDATA install-dvi \
+	install-dvi-am install-exec install-exec-am install-html \
+	install-html-am install-info install-info-am install-man \
+	install-man1 install-pdf install-pdf-am install-ps \
+	install-ps-am install-strip installcheck installcheck-am \
+	installdirs maintainer-clean maintainer-clean-generic \
+	mostlyclean mostlyclean-compile mostlyclean-generic pdf pdf-am \
+	ps ps-am recheck recheck-html tags uninstall uninstall-am \
+	uninstall-binPROGRAMS uninstall-dist_docDATA uninstall-man \
+	uninstall-man1
+
+lexer.c: lexer.l
+	flex -o lexer.c --header-file=lexer.h lexer.l
+lexer.h: lexer.c
+
+### Building the jq binary
+
+main.c: config.h
+
+jq.1 :
+	cd ${abs_srcdir}/docs; rake manpage > ${abs_builddir}/$@
+
+ChangeLog:
+	git log --name-status > $@ || echo "no changelog" > $@
+
+releasetag:
+	git tag -s "jq-$$(cat VERSION)" -m "jq release $$(cat VERSION)"
+
+RELEASE ?= 1
+rpm: jq
+	@echo "Packaging jq as an RPM ..."
+	mkdir -p rpm/SOURCES rpm/BUILD rpm/BUILDROOT rpm/RPMS rpm/SPECS
+	cp jq-$$(cat VERSION).tar.gz rpm/SOURCES/
+	rpmbuild -tb --define "_topdir ${PWD}/rpm" --define "_prefix /usr" --define "myver $$(cat VERSION)" --define "myrel ${RELEASE}" rpm/SOURCES/jq-$$(cat VERSION).tar.gz
+	find rpm/RPMS/ -name "*.rpm" -exec mv {} ./ \;
+	rm -rf rpm
+
+dist-clean-local:
+	rm -f ${BUILT_SOURCES}
+
+# Not sure why this doesn't get cleaned up automatically, guess
+# automake used to man pages which are hand coded?
+clean-local:
+	rm -f jq.1
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/NEWS b/NEWS
deleted file mode 100644
index 16a32b3c..00000000
--- a/NEWS
+++ /dev/null
@@ -1,5 +0,0 @@
-
-   NEWS for jq 
-
-
-
diff --git a/README b/README
deleted file mode 100644
index d84e95ee..00000000
--- a/README
+++ /dev/null
@@ -1,10 +0,0 @@
-Since this is a github project and an autoconf project, the
-README file is not used, README.md is the file to READ!
-
-When you checkout the file, run "setup.sh" which gets autoconf initialized.
-Then follow the instructions in INSTALL.  Real standard stuff...
-
-
-   $ ./setup.sh             # initializes Autoconf and builds your release
-   $ ./setup.sh clean       # cleans all the temp files out of your tree
-   $ ./setup.sh superclean  # deletes your release files so you can try again
diff --git a/README b/README
new file mode 120000
index 00000000..42061c01
--- /dev/null
+++ b/README
@@ -0,0 +1 @@
+README.md
\ No newline at end of file
diff --git a/VERSION b/VERSION
deleted file mode 100644
index 5625e59d..00000000
--- a/VERSION
+++ /dev/null
@@ -1 +0,0 @@
-1.2
diff --git a/aclocal.m4 b/aclocal.m4
new file mode 100644
index 00000000..81e394eb
--- /dev/null
+++ b/aclocal.m4
@@ -0,0 +1,1063 @@
+# generated automatically by aclocal 1.11.6 -*- Autoconf -*-
+
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+# 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation,
+# Inc.
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+m4_ifndef([AC_AUTOCONF_VERSION],
+  [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
+m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.69],,
+[m4_warning([this file was generated for autoconf 2.69.
+You have another version of autoconf.  It may work, but is not guaranteed to.
+If you have problems, you may need to regenerate the build system entirely.
+To do so, use the procedure documented by the package, typically `autoreconf'.])])
+
+# Copyright (C) 2002, 2003, 2005, 2006, 2007, 2008, 2011 Free Software
+# Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 1
+
+# AM_AUTOMAKE_VERSION(VERSION)
+# ----------------------------
+# Automake X.Y traces this macro to ensure aclocal.m4 has been
+# generated from the m4 files accompanying Automake X.Y.
+# (This private macro should not be called outside this file.)
+AC_DEFUN([AM_AUTOMAKE_VERSION],
+[am__api_version='1.11'
+dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
+dnl require some minimum version.  Point them to the right macro.
+m4_if([$1], [1.11.6], [],
+      [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl
+])
+
+# _AM_AUTOCONF_VERSION(VERSION)
+# -----------------------------
+# aclocal traces this macro to find the Autoconf version.
+# This is a private macro too.  Using m4_define simplifies
+# the logic in aclocal, which can simply ignore this definition.
+m4_define([_AM_AUTOCONF_VERSION], [])
+
+# AM_SET_CURRENT_AUTOMAKE_VERSION
+# -------------------------------
+# Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced.
+# This function is AC_REQUIREd by AM_INIT_AUTOMAKE.
+AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
+[AM_AUTOMAKE_VERSION([1.11.6])dnl
+m4_ifndef([AC_AUTOCONF_VERSION],
+  [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
+_AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))])
+
+# AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-
+
+# Copyright (C) 2001, 2003, 2005, 2011 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 1
+
+# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets
+# $ac_aux_dir to `$srcdir/foo'.  In other projects, it is set to
+# `$srcdir', `$srcdir/..', or `$srcdir/../..'.
+#
+# Of course, Automake must honor this variable whenever it calls a
+# tool from the auxiliary directory.  The problem is that $srcdir (and
+# therefore $ac_aux_dir as well) can be either absolute or relative,
+# depending on how configure is run.  This is pretty annoying, since
+# it makes $ac_aux_dir quite unusable in subdirectories: in the top
+# source directory, any form will work fine, but in subdirectories a
+# relative path needs to be adjusted first.
+#
+# $ac_aux_dir/missing
+#    fails when called from a subdirectory if $ac_aux_dir is relative
+# $top_srcdir/$ac_aux_dir/missing
+#    fails if $ac_aux_dir is absolute,
+#    fails when called from a subdirectory in a VPATH build with
+#          a relative $ac_aux_dir
+#
+# The reason of the latter failure is that $top_srcdir and $ac_aux_dir
+# are both prefixed by $srcdir.  In an in-source build this is usually
+# harmless because $srcdir is `.', but things will broke when you
+# start a VPATH build or use an absolute $srcdir.
+#
+# So we could use something similar to $top_srcdir/$ac_aux_dir/missing,
+# iff we strip the leading $srcdir from $ac_aux_dir.  That would be:
+#   am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"`
+# and then we would define $MISSING as
+#   MISSING="\${SHELL} $am_aux_dir/missing"
+# This will work as long as MISSING is not called from configure, because
+# unfortunately $(top_srcdir) has no meaning in configure.
+# However there are other variables, like CC, which are often used in
+# configure, and could therefore not use this "fixed" $ac_aux_dir.
+#
+# Another solution, used here, is to always expand $ac_aux_dir to an
+# absolute PATH.  The drawback is that using absolute paths prevent a
+# configured tree to be moved without reconfiguration.
+
+AC_DEFUN([AM_AUX_DIR_EXPAND],
+[dnl Rely on autoconf to set up CDPATH properly.
+AC_PREREQ([2.50])dnl
+# expand $ac_aux_dir to an absolute path
+am_aux_dir=`cd $ac_aux_dir && pwd`
+])
+
+# AM_CONDITIONAL                                            -*- Autoconf -*-
+
+# Copyright (C) 1997, 2000, 2001, 2003, 2004, 2005, 2006, 2008
+# Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 9
+
+# AM_CONDITIONAL(NAME, SHELL-CONDITION)
+# -------------------------------------
+# Define a conditional.
+AC_DEFUN([AM_CONDITIONAL],
+[AC_PREREQ(2.52)dnl
+ ifelse([$1], [TRUE],  [AC_FATAL([$0: invalid condition: $1])],
+	[$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl
+AC_SUBST([$1_TRUE])dnl
+AC_SUBST([$1_FALSE])dnl
+_AM_SUBST_NOTMAKE([$1_TRUE])dnl
+_AM_SUBST_NOTMAKE([$1_FALSE])dnl
+m4_define([_AM_COND_VALUE_$1], [$2])dnl
+if $2; then
+  $1_TRUE=
+  $1_FALSE='#'
+else
+  $1_TRUE='#'
+  $1_FALSE=
+fi
+AC_CONFIG_COMMANDS_PRE(
+[if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then
+  AC_MSG_ERROR([[conditional "$1" was never defined.
+Usually this means the macro was only invoked conditionally.]])
+fi])])
+
+# Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2009,
+# 2010, 2011 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 12
+
+# There are a few dirty hacks below to avoid letting `AC_PROG_CC' be
+# written in clear, in which case automake, when reading aclocal.m4,
+# will think it sees a *use*, and therefore will trigger all it's
+# C support machinery.  Also note that it means that autoscan, seeing
+# CC etc. in the Makefile, will ask for an AC_PROG_CC use...
+
+
+# _AM_DEPENDENCIES(NAME)
+# ----------------------
+# See how the compiler implements dependency checking.
+# NAME is "CC", "CXX", "GCJ", or "OBJC".
+# We try a few techniques and use that to set a single cache variable.
+#
+# We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was
+# modified to invoke _AM_DEPENDENCIES(CC); we would have a circular
+# dependency, and given that the user is not expected to run this macro,
+# just rely on AC_PROG_CC.
+AC_DEFUN([_AM_DEPENDENCIES],
+[AC_REQUIRE([AM_SET_DEPDIR])dnl
+AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl
+AC_REQUIRE([AM_MAKE_INCLUDE])dnl
+AC_REQUIRE([AM_DEP_TRACK])dnl
+
+ifelse([$1], CC,   [depcc="$CC"   am_compiler_list=],
+       [$1], CXX,  [depcc="$CXX"  am_compiler_list=],
+       [$1], OBJC, [depcc="$OBJC" am_compiler_list='gcc3 gcc'],
+       [$1], UPC,  [depcc="$UPC"  am_compiler_list=],
+       [$1], GCJ,  [depcc="$GCJ"  am_compiler_list='gcc3 gcc'],
+                   [depcc="$$1"   am_compiler_list=])
+
+AC_CACHE_CHECK([dependency style of $depcc],
+               [am_cv_$1_dependencies_compiler_type],
+[if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+  # We make a subdir and do the tests there.  Otherwise we can end up
+  # making bogus files that we don't know about and never remove.  For
+  # instance it was reported that on HP-UX the gcc test will end up
+  # making a dummy file named `D' -- because `-MD' means `put the output
+  # in D'.
+  rm -rf conftest.dir
+  mkdir conftest.dir
+  # Copy depcomp to subdir because otherwise we won't find it if we're
+  # using a relative directory.
+  cp "$am_depcomp" conftest.dir
+  cd conftest.dir
+  # We will build objects and dependencies in a subdirectory because
+  # it helps to detect inapplicable dependency modes.  For instance
+  # both Tru64's cc and ICC support -MD to output dependencies as a
+  # side effect of compilation, but ICC will put the dependencies in
+  # the current directory while Tru64 will put them in the object
+  # directory.
+  mkdir sub
+
+  am_cv_$1_dependencies_compiler_type=none
+  if test "$am_compiler_list" = ""; then
+     am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp`
+  fi
+  am__universal=false
+  m4_case([$1], [CC],
+    [case " $depcc " in #(
+     *\ -arch\ *\ -arch\ *) am__universal=true ;;
+     esac],
+    [CXX],
+    [case " $depcc " in #(
+     *\ -arch\ *\ -arch\ *) am__universal=true ;;
+     esac])
+
+  for depmode in $am_compiler_list; do
+    # Setup a source with many dependencies, because some compilers
+    # like to wrap large dependency lists on column 80 (with \), and
+    # we should not choose a depcomp mode which is confused by this.
+    #
+    # We need to recreate these files for each test, as the compiler may
+    # overwrite some of them when testing with obscure command lines.
+    # This happens at least with the AIX C compiler.
+    : > sub/conftest.c
+    for i in 1 2 3 4 5 6; do
+      echo '#include "conftst'$i'.h"' >> sub/conftest.c
+      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
+      # Solaris 8's {/usr,}/bin/sh.
+      touch sub/conftst$i.h
+    done
+    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
+
+    # We check with `-c' and `-o' for the sake of the "dashmstdout"
+    # mode.  It turns out that the SunPro C++ compiler does not properly
+    # handle `-M -o', and we need to detect this.  Also, some Intel
+    # versions had trouble with output in subdirs
+    am__obj=sub/conftest.${OBJEXT-o}
+    am__minus_obj="-o $am__obj"
+    case $depmode in
+    gcc)
+      # This depmode causes a compiler race in universal mode.
+      test "$am__universal" = false || continue
+      ;;
+    nosideeffect)
+      # after this tag, mechanisms are not by side-effect, so they'll
+      # only be used when explicitly requested
+      if test "x$enable_dependency_tracking" = xyes; then
+	continue
+      else
+	break
+      fi
+      ;;
+    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
+      # This compiler won't grok `-c -o', but also, the minuso test has
+      # not run yet.  These depmodes are late enough in the game, and
+      # so weak that their functioning should not be impacted.
+      am__obj=conftest.${OBJEXT-o}
+      am__minus_obj=
+      ;;
+    none) break ;;
+    esac
+    if depmode=$depmode \
+       source=sub/conftest.c object=$am__obj \
+       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
+       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
+         >/dev/null 2>conftest.err &&
+       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
+       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
+      # icc doesn't choke on unknown options, it will just issue warnings
+      # or remarks (even with -Werror).  So we grep stderr for any message
+      # that says an option was ignored or not supported.
+      # When given -MP, icc 7.0 and 7.1 complain thusly:
+      #   icc: Command line warning: ignoring option '-M'; no argument required
+      # The diagnosis changed in icc 8.0:
+      #   icc: Command line remark: option '-MP' not supported
+      if (grep 'ignoring option' conftest.err ||
+          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
+        am_cv_$1_dependencies_compiler_type=$depmode
+        break
+      fi
+    fi
+  done
+
+  cd ..
+  rm -rf conftest.dir
+else
+  am_cv_$1_dependencies_compiler_type=none
+fi
+])
+AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type])
+AM_CONDITIONAL([am__fastdep$1], [
+  test "x$enable_dependency_tracking" != xno \
+  && test "$am_cv_$1_dependencies_compiler_type" = gcc3])
+])
+
+
+# AM_SET_DEPDIR
+# -------------
+# Choose a directory name for dependency files.
+# This macro is AC_REQUIREd in _AM_DEPENDENCIES
+AC_DEFUN([AM_SET_DEPDIR],
+[AC_REQUIRE([AM_SET_LEADING_DOT])dnl
+AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl
+])
+
+
+# AM_DEP_TRACK
+# ------------
+AC_DEFUN([AM_DEP_TRACK],
+[AC_ARG_ENABLE(dependency-tracking,
+[  --disable-dependency-tracking  speeds up one-time build
+  --enable-dependency-tracking   do not reject slow dependency extractors])
+if test "x$enable_dependency_tracking" != xno; then
+  am_depcomp="$ac_aux_dir/depcomp"
+  AMDEPBACKSLASH='\'
+  am__nodep='_no'
+fi
+AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno])
+AC_SUBST([AMDEPBACKSLASH])dnl
+_AM_SUBST_NOTMAKE([AMDEPBACKSLASH])dnl
+AC_SUBST([am__nodep])dnl
+_AM_SUBST_NOTMAKE([am__nodep])dnl
+])
+
+# Generate code to set up dependency tracking.              -*- Autoconf -*-
+
+# Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2008
+# Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+#serial 5
+
+# _AM_OUTPUT_DEPENDENCY_COMMANDS
+# ------------------------------
+AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
+[{
+  # Autoconf 2.62 quotes --file arguments for eval, but not when files
+  # are listed without --file.  Let's play safe and only enable the eval
+  # if we detect the quoting.
+  case $CONFIG_FILES in
+  *\'*) eval set x "$CONFIG_FILES" ;;
+  *)   set x $CONFIG_FILES ;;
+  esac
+  shift
+  for mf
+  do
+    # Strip MF so we end up with the name of the file.
+    mf=`echo "$mf" | sed -e 's/:.*$//'`
+    # Check whether this is an Automake generated Makefile or not.
+    # We used to match only the files named `Makefile.in', but
+    # some people rename them; so instead we look at the file content.
+    # Grep'ing the first line is not enough: some people post-process
+    # each Makefile.in and add a new line on top of each file to say so.
+    # Grep'ing the whole file is not good either: AIX grep has a line
+    # limit of 2048, but all sed's we know have understand at least 4000.
+    if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
+      dirpart=`AS_DIRNAME("$mf")`
+    else
+      continue
+    fi
+    # Extract the definition of DEPDIR, am__include, and am__quote
+    # from the Makefile without running `make'.
+    DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
+    test -z "$DEPDIR" && continue
+    am__include=`sed -n 's/^am__include = //p' < "$mf"`
+    test -z "am__include" && continue
+    am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
+    # When using ansi2knr, U may be empty or an underscore; expand it
+    U=`sed -n 's/^U = //p' < "$mf"`
+    # Find all dependency output files, they are included files with
+    # $(DEPDIR) in their names.  We invoke sed twice because it is the
+    # simplest approach to changing $(DEPDIR) to its actual value in the
+    # expansion.
+    for file in `sed -n "
+      s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
+	 sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
+      # Make sure the directory exists.
+      test -f "$dirpart/$file" && continue
+      fdir=`AS_DIRNAME(["$file"])`
+      AS_MKDIR_P([$dirpart/$fdir])
+      # echo "creating $dirpart/$file"
+      echo '# dummy' > "$dirpart/$file"
+    done
+  done
+}
+])# _AM_OUTPUT_DEPENDENCY_COMMANDS
+
+
+# AM_OUTPUT_DEPENDENCY_COMMANDS
+# -----------------------------
+# This macro should only be invoked once -- use via AC_REQUIRE.
+#
+# This code is only required when automatic dependency tracking
+# is enabled.  FIXME.  This creates each `.P' file that we will
+# need in order to bootstrap the dependency handling code.
+AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],
+[AC_CONFIG_COMMANDS([depfiles],
+     [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS],
+     [AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"])
+])
+
+# Do all the work for Automake.                             -*- Autoconf -*-
+
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+# 2005, 2006, 2008, 2009 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 16
+
+# This macro actually does too much.  Some checks are only needed if
+# your package does certain things.  But this isn't really a big deal.
+
+# AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE])
+# AM_INIT_AUTOMAKE([OPTIONS])
+# -----------------------------------------------
+# The call with PACKAGE and VERSION arguments is the old style
+# call (pre autoconf-2.50), which is being phased out.  PACKAGE
+# and VERSION should now be passed to AC_INIT and removed from
+# the call to AM_INIT_AUTOMAKE.
+# We support both call styles for the transition.  After
+# the next Automake release, Autoconf can make the AC_INIT
+# arguments mandatory, and then we can depend on a new Autoconf
+# release and drop the old call support.
+AC_DEFUN([AM_INIT_AUTOMAKE],
+[AC_PREREQ([2.62])dnl
+dnl Autoconf wants to disallow AM_ names.  We explicitly allow
+dnl the ones we care about.
+m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl
+AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl
+AC_REQUIRE([AC_PROG_INSTALL])dnl
+if test "`cd $srcdir && pwd`" != "`pwd`"; then
+  # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
+  # is not polluted with repeated "-I."
+  AC_SUBST([am__isrc], [' -I$(srcdir)'])_AM_SUBST_NOTMAKE([am__isrc])dnl
+  # test to see if srcdir already configured
+  if test -f $srcdir/config.status; then
+    AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
+  fi
+fi
+
+# test whether we have cygpath
+if test -z "$CYGPATH_W"; then
+  if (cygpath --version) >/dev/null 2>/dev/null; then
+    CYGPATH_W='cygpath -w'
+  else
+    CYGPATH_W=echo
+  fi
+fi
+AC_SUBST([CYGPATH_W])
+
+# Define the identity of the package.
+dnl Distinguish between old-style and new-style calls.
+m4_ifval([$2],
+[m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl
+ AC_SUBST([PACKAGE], [$1])dnl
+ AC_SUBST([VERSION], [$2])],
+[_AM_SET_OPTIONS([$1])dnl
+dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT.
+m4_if(m4_ifdef([AC_PACKAGE_NAME], 1)m4_ifdef([AC_PACKAGE_VERSION], 1), 11,,
+  [m4_fatal([AC_INIT should be called with package and version arguments])])dnl
+ AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl
+ AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl
+
+_AM_IF_OPTION([no-define],,
+[AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package])
+ AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package])])dnl
+
+# Some tools Automake needs.
+AC_REQUIRE([AM_SANITY_CHECK])dnl
+AC_REQUIRE([AC_ARG_PROGRAM])dnl
+AM_MISSING_PROG(ACLOCAL, aclocal-${am__api_version})
+AM_MISSING_PROG(AUTOCONF, autoconf)
+AM_MISSING_PROG(AUTOMAKE, automake-${am__api_version})
+AM_MISSING_PROG(AUTOHEADER, autoheader)
+AM_MISSING_PROG(MAKEINFO, makeinfo)
+AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
+AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl
+AC_REQUIRE([AM_PROG_MKDIR_P])dnl
+# We need awk for the "check" target.  The system "awk" is bad on
+# some platforms.
+AC_REQUIRE([AC_PROG_AWK])dnl
+AC_REQUIRE([AC_PROG_MAKE_SET])dnl
+AC_REQUIRE([AM_SET_LEADING_DOT])dnl
+_AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])],
+	      [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])],
+			     [_AM_PROG_TAR([v7])])])
+_AM_IF_OPTION([no-dependencies],,
+[AC_PROVIDE_IFELSE([AC_PROG_CC],
+		  [_AM_DEPENDENCIES(CC)],
+		  [define([AC_PROG_CC],
+			  defn([AC_PROG_CC])[_AM_DEPENDENCIES(CC)])])dnl
+AC_PROVIDE_IFELSE([AC_PROG_CXX],
+		  [_AM_DEPENDENCIES(CXX)],
+		  [define([AC_PROG_CXX],
+			  defn([AC_PROG_CXX])[_AM_DEPENDENCIES(CXX)])])dnl
+AC_PROVIDE_IFELSE([AC_PROG_OBJC],
+		  [_AM_DEPENDENCIES(OBJC)],
+		  [define([AC_PROG_OBJC],
+			  defn([AC_PROG_OBJC])[_AM_DEPENDENCIES(OBJC)])])dnl
+])
+_AM_IF_OPTION([silent-rules], [AC_REQUIRE([AM_SILENT_RULES])])dnl
+dnl The `parallel-tests' driver may need to know about EXEEXT, so add the
+dnl `am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen.  This macro
+dnl is hooked onto _AC_COMPILER_EXEEXT early, see below.
+AC_CONFIG_COMMANDS_PRE(dnl
+[m4_provide_if([_AM_COMPILER_EXEEXT],
+  [AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl
+])
+
+dnl Hook into `_AC_COMPILER_EXEEXT' early to learn its expansion.  Do not
+dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further
+dnl mangled by Autoconf and run in a shell conditional statement.
+m4_define([_AC_COMPILER_EXEEXT],
+m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])])
+
+
+# When config.status generates a header, we must update the stamp-h file.
+# This file resides in the same directory as the config header
+# that is generated.  The stamp files are numbered to have different names.
+
+# Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the
+# loop where config.status creates the headers, so we can generate
+# our stamp files there.
+AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK],
+[# Compute $1's index in $config_headers.
+_am_arg=$1
+_am_stamp_count=1
+for _am_header in $config_headers :; do
+  case $_am_header in
+    $_am_arg | $_am_arg:* )
+      break ;;
+    * )
+      _am_stamp_count=`expr $_am_stamp_count + 1` ;;
+  esac
+done
+echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count])
+
+# Copyright (C) 2001, 2003, 2005, 2008, 2011 Free Software Foundation,
+# Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 1
+
+# AM_PROG_INSTALL_SH
+# ------------------
+# Define $install_sh.
+AC_DEFUN([AM_PROG_INSTALL_SH],
+[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+if test x"${install_sh}" != xset; then
+  case $am_aux_dir in
+  *\ * | *\	*)
+    install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
+  *)
+    install_sh="\${SHELL} $am_aux_dir/install-sh"
+  esac
+fi
+AC_SUBST(install_sh)])
+
+# Copyright (C) 2003, 2005  Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 2
+
+# Check whether the underlying file-system supports filenames
+# with a leading dot.  For instance MS-DOS doesn't.
+AC_DEFUN([AM_SET_LEADING_DOT],
+[rm -rf .tst 2>/dev/null
+mkdir .tst 2>/dev/null
+if test -d .tst; then
+  am__leading_dot=.
+else
+  am__leading_dot=_
+fi
+rmdir .tst 2>/dev/null
+AC_SUBST([am__leading_dot])])
+
+# Check to see how 'make' treats includes.	            -*- Autoconf -*-
+
+# Copyright (C) 2001, 2002, 2003, 2005, 2009  Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 4
+
+# AM_MAKE_INCLUDE()
+# -----------------
+# Check to see how make treats includes.
+AC_DEFUN([AM_MAKE_INCLUDE],
+[am_make=${MAKE-make}
+cat > confinc << 'END'
+am__doit:
+	@echo this is the am__doit target
+.PHONY: am__doit
+END
+# If we don't find an include directive, just comment out the code.
+AC_MSG_CHECKING([for style of include used by $am_make])
+am__include="#"
+am__quote=
+_am_result=none
+# First try GNU make style include.
+echo "include confinc" > confmf
+# Ignore all kinds of additional output from `make'.
+case `$am_make -s -f confmf 2> /dev/null` in #(
+*the\ am__doit\ target*)
+  am__include=include
+  am__quote=
+  _am_result=GNU
+  ;;
+esac
+# Now try BSD make style include.
+if test "$am__include" = "#"; then
+   echo '.include "confinc"' > confmf
+   case `$am_make -s -f confmf 2> /dev/null` in #(
+   *the\ am__doit\ target*)
+     am__include=.include
+     am__quote="\""
+     _am_result=BSD
+     ;;
+   esac
+fi
+AC_SUBST([am__include])
+AC_SUBST([am__quote])
+AC_MSG_RESULT([$_am_result])
+rm -f confinc confmf
+])
+
+# Copyright (C) 1999, 2000, 2001, 2003, 2004, 2005, 2008
+# Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 6
+
+# AM_PROG_CC_C_O
+# --------------
+# Like AC_PROG_CC_C_O, but changed for automake.
+AC_DEFUN([AM_PROG_CC_C_O],
+[AC_REQUIRE([AC_PROG_CC_C_O])dnl
+AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+AC_REQUIRE_AUX_FILE([compile])dnl
+# FIXME: we rely on the cache variable name because
+# there is no other way.
+set dummy $CC
+am_cc=`echo $[2] | sed ['s/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/']`
+eval am_t=\$ac_cv_prog_cc_${am_cc}_c_o
+if test "$am_t" != yes; then
+   # Losing compiler, so override with the script.
+   # FIXME: It is wrong to rewrite CC.
+   # But if we don't then we get into trouble of one sort or another.
+   # A longer-term fix would be to have automake use am__CC in this case,
+   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
+   CC="$am_aux_dir/compile $CC"
+fi
+dnl Make sure AC_PROG_CC is never called again, or it will override our
+dnl setting of CC.
+m4_define([AC_PROG_CC],
+          [m4_fatal([AC_PROG_CC cannot be called after AM_PROG_CC_C_O])])
+])
+
+# Fake the existence of programs that GNU maintainers use.  -*- Autoconf -*-
+
+# Copyright (C) 1997, 1999, 2000, 2001, 2003, 2004, 2005, 2008
+# Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 6
+
+# AM_MISSING_PROG(NAME, PROGRAM)
+# ------------------------------
+AC_DEFUN([AM_MISSING_PROG],
+[AC_REQUIRE([AM_MISSING_HAS_RUN])
+$1=${$1-"${am_missing_run}$2"}
+AC_SUBST($1)])
+
+
+# AM_MISSING_HAS_RUN
+# ------------------
+# Define MISSING if not defined so far and test if it supports --run.
+# If it does, set am_missing_run to use it, otherwise, to nothing.
+AC_DEFUN([AM_MISSING_HAS_RUN],
+[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+AC_REQUIRE_AUX_FILE([missing])dnl
+if test x"${MISSING+set}" != xset; then
+  case $am_aux_dir in
+  *\ * | *\	*)
+    MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;;
+  *)
+    MISSING="\${SHELL} $am_aux_dir/missing" ;;
+  esac
+fi
+# Use eval to expand $SHELL
+if eval "$MISSING --run true"; then
+  am_missing_run="$MISSING --run "
+else
+  am_missing_run=
+  AC_MSG_WARN([`missing' script is too old or missing])
+fi
+])
+
+# Copyright (C) 2003, 2004, 2005, 2006, 2011 Free Software Foundation,
+# Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 1
+
+# AM_PROG_MKDIR_P
+# ---------------
+# Check for `mkdir -p'.
+AC_DEFUN([AM_PROG_MKDIR_P],
+[AC_PREREQ([2.60])dnl
+AC_REQUIRE([AC_PROG_MKDIR_P])dnl
+dnl Automake 1.8 to 1.9.6 used to define mkdir_p.  We now use MKDIR_P,
+dnl while keeping a definition of mkdir_p for backward compatibility.
+dnl @MKDIR_P@ is magic: AC_OUTPUT adjusts its value for each Makefile.
+dnl However we cannot define mkdir_p as $(MKDIR_P) for the sake of
+dnl Makefile.ins that do not define MKDIR_P, so we do our own
+dnl adjustment using top_builddir (which is defined more often than
+dnl MKDIR_P).
+AC_SUBST([mkdir_p], ["$MKDIR_P"])dnl
+case $mkdir_p in
+  [[\\/$]]* | ?:[[\\/]]*) ;;
+  */*) mkdir_p="\$(top_builddir)/$mkdir_p" ;;
+esac
+])
+
+# Helper functions for option handling.                     -*- Autoconf -*-
+
+# Copyright (C) 2001, 2002, 2003, 2005, 2008, 2010 Free Software
+# Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 5
+
+# _AM_MANGLE_OPTION(NAME)
+# -----------------------
+AC_DEFUN([_AM_MANGLE_OPTION],
+[[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])])
+
+# _AM_SET_OPTION(NAME)
+# --------------------
+# Set option NAME.  Presently that only means defining a flag for this option.
+AC_DEFUN([_AM_SET_OPTION],
+[m4_define(_AM_MANGLE_OPTION([$1]), 1)])
+
+# _AM_SET_OPTIONS(OPTIONS)
+# ------------------------
+# OPTIONS is a space-separated list of Automake options.
+AC_DEFUN([_AM_SET_OPTIONS],
+[m4_foreach_w([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])])
+
+# _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET])
+# -------------------------------------------
+# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
+AC_DEFUN([_AM_IF_OPTION],
+[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])
+
+# Check to make sure that the build environment is sane.    -*- Autoconf -*-
+
+# Copyright (C) 1996, 1997, 2000, 2001, 2003, 2005, 2008
+# Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 5
+
+# AM_SANITY_CHECK
+# ---------------
+AC_DEFUN([AM_SANITY_CHECK],
+[AC_MSG_CHECKING([whether build environment is sane])
+# Just in case
+sleep 1
+echo timestamp > conftest.file
+# Reject unsafe characters in $srcdir or the absolute working directory
+# name.  Accept space and tab only in the latter.
+am_lf='
+'
+case `pwd` in
+  *[[\\\"\#\$\&\'\`$am_lf]]*)
+    AC_MSG_ERROR([unsafe absolute working directory name]);;
+esac
+case $srcdir in
+  *[[\\\"\#\$\&\'\`$am_lf\ \	]]*)
+    AC_MSG_ERROR([unsafe srcdir value: `$srcdir']);;
+esac
+
+# Do `set' in a subshell so we don't clobber the current shell's
+# arguments.  Must try -L first in case configure is actually a
+# symlink; some systems play weird games with the mod time of symlinks
+# (eg FreeBSD returns the mod time of the symlink's containing
+# directory).
+if (
+   set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
+   if test "$[*]" = "X"; then
+      # -L didn't work.
+      set X `ls -t "$srcdir/configure" conftest.file`
+   fi
+   rm -f conftest.file
+   if test "$[*]" != "X $srcdir/configure conftest.file" \
+      && test "$[*]" != "X conftest.file $srcdir/configure"; then
+
+      # If neither matched, then we have a broken ls.  This can happen
+      # if, for instance, CONFIG_SHELL is bash and it inherits a
+      # broken ls alias from the environment.  This has actually
+      # happened.  Such a system could not be considered "sane".
+      AC_MSG_ERROR([ls -t appears to fail.  Make sure there is not a broken
+alias in your environment])
+   fi
+
+   test "$[2]" = conftest.file
+   )
+then
+   # Ok.
+   :
+else
+   AC_MSG_ERROR([newly created file is older than distributed files!
+Check your system clock])
+fi
+AC_MSG_RESULT(yes)])
+
+# Copyright (C) 2009, 2011  Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 2
+
+# AM_SILENT_RULES([DEFAULT])
+# --------------------------
+# Enable less verbose build rules; with the default set to DEFAULT
+# (`yes' being less verbose, `no' or empty being verbose).
+AC_DEFUN([AM_SILENT_RULES],
+[AC_ARG_ENABLE([silent-rules],
+[  --enable-silent-rules          less verbose build output (undo: `make V=1')
+  --disable-silent-rules         verbose build output (undo: `make V=0')])
+case $enable_silent_rules in
+yes) AM_DEFAULT_VERBOSITY=0;;
+no)  AM_DEFAULT_VERBOSITY=1;;
+*)   AM_DEFAULT_VERBOSITY=m4_if([$1], [yes], [0], [1]);;
+esac
+dnl
+dnl A few `make' implementations (e.g., NonStop OS and NextStep)
+dnl do not support nested variable expansions.
+dnl See automake bug#9928 and bug#10237.
+am_make=${MAKE-make}
+AC_CACHE_CHECK([whether $am_make supports nested variables],
+   [am_cv_make_support_nested_variables],
+   [if AS_ECHO([['TRUE=$(BAR$(V))
+BAR0=false
+BAR1=true
+V=1
+am__doit:
+	@$(TRUE)
+.PHONY: am__doit']]) | $am_make -f - >/dev/null 2>&1; then
+  am_cv_make_support_nested_variables=yes
+else
+  am_cv_make_support_nested_variables=no
+fi])
+if test $am_cv_make_support_nested_variables = yes; then
+  dnl Using `$V' instead of `$(V)' breaks IRIX make.
+  AM_V='$(V)'
+  AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
+else
+  AM_V=$AM_DEFAULT_VERBOSITY
+  AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
+fi
+AC_SUBST([AM_V])dnl
+AM_SUBST_NOTMAKE([AM_V])dnl
+AC_SUBST([AM_DEFAULT_V])dnl
+AM_SUBST_NOTMAKE([AM_DEFAULT_V])dnl
+AC_SUBST([AM_DEFAULT_VERBOSITY])dnl
+AM_BACKSLASH='\'
+AC_SUBST([AM_BACKSLASH])dnl
+_AM_SUBST_NOTMAKE([AM_BACKSLASH])dnl
+])
+
+# Copyright (C) 2001, 2003, 2005, 2011 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 1
+
+# AM_PROG_INSTALL_STRIP
+# ---------------------
+# One issue with vendor `install' (even GNU) is that you can't
+# specify the program used to strip binaries.  This is especially
+# annoying in cross-compiling environments, where the build's strip
+# is unlikely to handle the host's binaries.
+# Fortunately install-sh will honor a STRIPPROG variable, so we
+# always use install-sh in `make install-strip', and initialize
+# STRIPPROG with the value of the STRIP variable (set by the user).
+AC_DEFUN([AM_PROG_INSTALL_STRIP],
+[AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
+# Installed binaries are usually stripped using `strip' when the user
+# run `make install-strip'.  However `strip' might not be the right
+# tool to use in cross-compilation environments, therefore Automake
+# will honor the `STRIP' environment variable to overrule this program.
+dnl Don't test for $cross_compiling = yes, because it might be `maybe'.
+if test "$cross_compiling" != no; then
+  AC_CHECK_TOOL([STRIP], [strip], :)
+fi
+INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
+AC_SUBST([INSTALL_STRIP_PROGRAM])])
+
+# Copyright (C) 2006, 2008, 2010 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 3
+
+# _AM_SUBST_NOTMAKE(VARIABLE)
+# ---------------------------
+# Prevent Automake from outputting VARIABLE = @VARIABLE@ in Makefile.in.
+# This macro is traced by Automake.
+AC_DEFUN([_AM_SUBST_NOTMAKE])
+
+# AM_SUBST_NOTMAKE(VARIABLE)
+# --------------------------
+# Public sister of _AM_SUBST_NOTMAKE.
+AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)])
+
+# Check how to create a tarball.                            -*- Autoconf -*-
+
+# Copyright (C) 2004, 2005, 2012 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 2
+
+# _AM_PROG_TAR(FORMAT)
+# --------------------
+# Check how to create a tarball in format FORMAT.
+# FORMAT should be one of `v7', `ustar', or `pax'.
+#
+# Substitute a variable $(am__tar) that is a command
+# writing to stdout a FORMAT-tarball containing the directory
+# $tardir.
+#     tardir=directory && $(am__tar) > result.tar
+#
+# Substitute a variable $(am__untar) that extract such
+# a tarball read from stdin.
+#     $(am__untar) < result.tar
+AC_DEFUN([_AM_PROG_TAR],
+[# Always define AMTAR for backward compatibility.  Yes, it's still used
+# in the wild :-(  We should find a proper way to deprecate it ...
+AC_SUBST([AMTAR], ['$${TAR-tar}'])
+m4_if([$1], [v7],
+     [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'],
+     [m4_case([$1], [ustar],, [pax],,
+              [m4_fatal([Unknown tar format])])
+AC_MSG_CHECKING([how to create a $1 tar archive])
+# Loop over all known methods to create a tar archive until one works.
+_am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none'
+_am_tools=${am_cv_prog_tar_$1-$_am_tools}
+# Do not fold the above two line into one, because Tru64 sh and
+# Solaris sh will not grok spaces in the rhs of `-'.
+for _am_tool in $_am_tools
+do
+  case $_am_tool in
+  gnutar)
+    for _am_tar in tar gnutar gtar;
+    do
+      AM_RUN_LOG([$_am_tar --version]) && break
+    done
+    am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"'
+    am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"'
+    am__untar="$_am_tar -xf -"
+    ;;
+  plaintar)
+    # Must skip GNU tar: if it does not support --format= it doesn't create
+    # ustar tarball either.
+    (tar --version) >/dev/null 2>&1 && continue
+    am__tar='tar chf - "$$tardir"'
+    am__tar_='tar chf - "$tardir"'
+    am__untar='tar xf -'
+    ;;
+  pax)
+    am__tar='pax -L -x $1 -w "$$tardir"'
+    am__tar_='pax -L -x $1 -w "$tardir"'
+    am__untar='pax -r'
+    ;;
+  cpio)
+    am__tar='find "$$tardir" -print | cpio -o -H $1 -L'
+    am__tar_='find "$tardir" -print | cpio -o -H $1 -L'
+    am__untar='cpio -i -H $1 -d'
+    ;;
+  none)
+    am__tar=false
+    am__tar_=false
+    am__untar=false
+    ;;
+  esac
+
+  # If the value was cached, stop now.  We just wanted to have am__tar
+  # and am__untar set.
+  test -n "${am_cv_prog_tar_$1}" && break
+
+  # tar/untar a dummy directory, and stop if the command works
+  rm -rf conftest.dir
+  mkdir conftest.dir
+  echo GrepMe > conftest.dir/file
+  AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar])
+  rm -rf conftest.dir
+  if test -s conftest.tar; then
+    AM_RUN_LOG([$am__untar <conftest.tar])
+    grep GrepMe conftest.dir/file >/dev/null 2>&1 && break
+  fi
+done
+rm -rf conftest.dir
+
+AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool])
+AC_MSG_RESULT([$am_cv_prog_tar_$1])])
+AC_SUBST([am__tar])
+AC_SUBST([am__untar])
+]) # _AM_PROG_TAR
+
diff --git a/config.h.in b/config.h.in
new file mode 100644
index 00000000..dbfa12bc
--- /dev/null
+++ b/config.h.in
@@ -0,0 +1,28 @@
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to 1 if your C compiler doesn't accept -c and -o together. */
+#undef NO_MINUS_C_MINUS_O
+
+/* Name of package */
+#undef PACKAGE
+
+/* Define to the address where bug reports for this package should be sent. */
+#undef PACKAGE_BUGREPORT
+
+/* Define to the full name of this package. */
+#undef PACKAGE_NAME
+
+/* Define to the full name and version of this package. */
+#undef PACKAGE_STRING
+
+/* Define to the one symbol short name of this package. */
+#undef PACKAGE_TARNAME
+
+/* Define to the home page for this package. */
+#undef PACKAGE_URL
+
+/* Define to the version of this package. */
+#undef PACKAGE_VERSION
+
+/* Version number of package */
+#undef VERSION
diff --git a/config/compile b/config/compile
new file mode 100755
index 00000000..862a14e8
--- /dev/null
+++ b/config/compile
@@ -0,0 +1,343 @@
+#! /bin/sh
+# Wrapper for compilers which do not understand '-c -o'.
+
+scriptversion=2012-03-05.13; # UTC
+
+# Copyright (C) 1999, 2000, 2003, 2004, 2005, 2009, 2010, 2012 Free
+# Software Foundation, Inc.
+# Written by Tom Tromey <tromey@cygnus.com>.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# This file is maintained in Automake, please report
+# bugs to <bug-automake@gnu.org> or send patches to
+# <automake-patches@gnu.org>.
+
+nl='
+'
+
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent tools from complaining about whitespace usage.
+IFS=" ""	$nl"
+
+file_conv=
+
+# func_file_conv build_file lazy
+# Convert a $build file to $host form and store it in $file
+# Currently only supports Windows hosts. If the determined conversion
+# type is listed in (the comma separated) LAZY, no conversion will
+# take place.
+func_file_conv ()
+{
+  file=$1
+  case $file in
+    / | /[!/]*) # absolute file, and not a UNC file
+      if test -z "$file_conv"; then
+	# lazily determine how to convert abs files
+	case `uname -s` in
+	  MINGW*)
+	    file_conv=mingw
+	    ;;
+	  CYGWIN*)
+	    file_conv=cygwin
+	    ;;
+	  *)
+	    file_conv=wine
+	    ;;
+	esac
+      fi
+      case $file_conv/,$2, in
+	*,$file_conv,*)
+	  ;;
+	mingw/*)
+	  file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'`
+	  ;;
+	cygwin/*)
+	  file=`cygpath -m "$file" || echo "$file"`
+	  ;;
+	wine/*)
+	  file=`winepath -w "$file" || echo "$file"`
+	  ;;
+      esac
+      ;;
+  esac
+}
+
+# func_cl_dashL linkdir
+# Make cl look for libraries in LINKDIR
+func_cl_dashL ()
+{
+  func_file_conv "$1"
+  if test -z "$lib_path"; then
+    lib_path=$file
+  else
+    lib_path="$lib_path;$file"
+  fi
+  linker_opts="$linker_opts -LIBPATH:$file"
+}
+
+# func_cl_dashl library
+# Do a library search-path lookup for cl
+func_cl_dashl ()
+{
+  lib=$1
+  found=no
+  save_IFS=$IFS
+  IFS=';'
+  for dir in $lib_path $LIB
+  do
+    IFS=$save_IFS
+    if $shared && test -f "$dir/$lib.dll.lib"; then
+      found=yes
+      lib=$dir/$lib.dll.lib
+      break
+    fi
+    if test -f "$dir/$lib.lib"; then
+      found=yes
+      lib=$dir/$lib.lib
+      break
+    fi
+  done
+  IFS=$save_IFS
+
+  if test "$found" != yes; then
+    lib=$lib.lib
+  fi
+}
+
+# func_cl_wrapper cl arg...
+# Adjust compile command to suit cl
+func_cl_wrapper ()
+{
+  # Assume a capable shell
+  lib_path=
+  shared=:
+  linker_opts=
+  for arg
+  do
+    if test -n "$eat"; then
+      eat=
+    else
+      case $1 in
+	-o)
+	  # configure might choose to run compile as 'compile cc -o foo foo.c'.
+	  eat=1
+	  case $2 in
+	    *.o | *.[oO][bB][jJ])
+	      func_file_conv "$2"
+	      set x "$@" -Fo"$file"
+	      shift
+	      ;;
+	    *)
+	      func_file_conv "$2"
+	      set x "$@" -Fe"$file"
+	      shift
+	      ;;
+	  esac
+	  ;;
+	-I)
+	  eat=1
+	  func_file_conv "$2" mingw
+	  set x "$@" -I"$file"
+	  shift
+	  ;;
+	-I*)
+	  func_file_conv "${1#-I}" mingw
+	  set x "$@" -I"$file"
+	  shift
+	  ;;
+	-l)
+	  eat=1
+	  func_cl_dashl "$2"
+	  set x "$@" "$lib"
+	  shift
+	  ;;
+	-l*)
+	  func_cl_dashl "${1#-l}"
+	  set x "$@" "$lib"
+	  shift
+	  ;;
+	-L)
+	  eat=1
+	  func_cl_dashL "$2"
+	  ;;
+	-L*)
+	  func_cl_dashL "${1#-L}"
+	  ;;
+	-static)
+	  shared=false
+	  ;;
+	-Wl,*)
+	  arg=${1#-Wl,}
+	  save_ifs="$IFS"; IFS=','
+	  for flag in $arg; do
+	    IFS="$save_ifs"
+	    linker_opts="$linker_opts $flag"
+	  done
+	  IFS="$save_ifs"
+	  ;;
+	-Xlinker)
+	  eat=1
+	  linker_opts="$linker_opts $2"
+	  ;;
+	-*)
+	  set x "$@" "$1"
+	  shift
+	  ;;
+	*.cc | *.CC | *.cxx | *.CXX | *.[cC]++)
+	  func_file_conv "$1"
+	  set x "$@" -Tp"$file"
+	  shift
+	  ;;
+	*.c | *.cpp | *.CPP | *.lib | *.LIB | *.Lib | *.OBJ | *.obj | *.[oO])
+	  func_file_conv "$1" mingw
+	  set x "$@" "$file"
+	  shift
+	  ;;
+	*)
+	  set x "$@" "$1"
+	  shift
+	  ;;
+      esac
+    fi
+    shift
+  done
+  if test -n "$linker_opts"; then
+    linker_opts="-link$linker_opts"
+  fi
+  exec "$@" $linker_opts
+  exit 1
+}
+
+eat=
+
+case $1 in
+  '')
+     echo "$0: No command.  Try '$0 --help' for more information." 1>&2
+     exit 1;
+     ;;
+  -h | --h*)
+    cat <<\EOF
+Usage: compile [--help] [--version] PROGRAM [ARGS]
+
+Wrapper for compilers which do not understand '-c -o'.
+Remove '-o dest.o' from ARGS, run PROGRAM with the remaining
+arguments, and rename the output as expected.
+
+If you are trying to build a whole package this is not the
+right script to run: please start by reading the file 'INSTALL'.
+
+Report bugs to <bug-automake@gnu.org>.
+EOF
+    exit $?
+    ;;
+  -v | --v*)
+    echo "compile $scriptversion"
+    exit $?
+    ;;
+  cl | *[/\\]cl | cl.exe | *[/\\]cl.exe )
+    func_cl_wrapper "$@"      # Doesn't return...
+    ;;
+esac
+
+ofile=
+cfile=
+
+for arg
+do
+  if test -n "$eat"; then
+    eat=
+  else
+    case $1 in
+      -o)
+	# configure might choose to run compile as 'compile cc -o foo foo.c'.
+	# So we strip '-o arg' only if arg is an object.
+	eat=1
+	case $2 in
+	  *.o | *.obj)
+	    ofile=$2
+	    ;;
+	  *)
+	    set x "$@" -o "$2"
+	    shift
+	    ;;
+	esac
+	;;
+      *.c)
+	cfile=$1
+	set x "$@" "$1"
+	shift
+	;;
+      *)
+	set x "$@" "$1"
+	shift
+	;;
+    esac
+  fi
+  shift
+done
+
+if test -z "$ofile" || test -z "$cfile"; then
+  # If no '-o' option was seen then we might have been invoked from a
+  # pattern rule where we don't need one.  That is ok -- this is a
+  # normal compilation that the losing compiler can handle.  If no
+  # '.c' file was seen then we are probably linking.  That is also
+  # ok.
+  exec "$@"
+fi
+
+# Name of file we expect compiler to create.
+cofile=`echo "$cfile" | sed 's|^.*[\\/]||; s|^[a-zA-Z]:||; s/\.c$/.o/'`
+
+# Create the lock directory.
+# Note: use '[/\\:.-]' here to ensure that we don't use the same name
+# that we are using for the .o file.  Also, base the name on the expected
+# object file name, since that is what matters with a parallel build.
+lockdir=`echo "$cofile" | sed -e 's|[/\\:.-]|_|g'`.d
+while true; do
+  if mkdir "$lockdir" >/dev/null 2>&1; then
+    break
+  fi
+  sleep 1
+done
+# FIXME: race condition here if user kills between mkdir and trap.
+trap "rmdir '$lockdir'; exit 1" 1 2 15
+
+# Run the compile.
+"$@"
+ret=$?
+
+if test -f "$cofile"; then
+  test "$cofile" = "$ofile" || mv "$cofile" "$ofile"
+elif test -f "${cofile}bj"; then
+  test "${cofile}bj" = "$ofile" || mv "${cofile}bj" "$ofile"
+fi
+
+rmdir "$lockdir"
+exit $ret
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:
diff --git a/config/depcomp b/config/depcomp
new file mode 100755
index 00000000..25a39e6c
--- /dev/null
+++ b/config/depcomp
@@ -0,0 +1,708 @@
+#! /bin/sh
+# depcomp - compile a program generating dependencies as side-effects
+
+scriptversion=2012-03-27.16; # UTC
+
+# Copyright (C) 1999, 2000, 2003, 2004, 2005, 2006, 2007, 2009, 2010,
+# 2011, 2012 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# Originally written by Alexandre Oliva <oliva@dcc.unicamp.br>.
+
+case $1 in
+  '')
+     echo "$0: No command.  Try '$0 --help' for more information." 1>&2
+     exit 1;
+     ;;
+  -h | --h*)
+    cat <<\EOF
+Usage: depcomp [--help] [--version] PROGRAM [ARGS]
+
+Run PROGRAMS ARGS to compile a file, generating dependencies
+as side-effects.
+
+Environment variables:
+  depmode     Dependency tracking mode.
+  source      Source file read by 'PROGRAMS ARGS'.
+  object      Object file output by 'PROGRAMS ARGS'.
+  DEPDIR      directory where to store dependencies.
+  depfile     Dependency file to output.
+  tmpdepfile  Temporary file to use when outputting dependencies.
+  libtool     Whether libtool is used (yes/no).
+
+Report bugs to <bug-automake@gnu.org>.
+EOF
+    exit $?
+    ;;
+  -v | --v*)
+    echo "depcomp $scriptversion"
+    exit $?
+    ;;
+esac
+
+# A tabulation character.
+tab='	'
+# A newline character.
+nl='
+'
+
+if test -z "$depmode" || test -z "$source" || test -z "$object"; then
+  echo "depcomp: Variables source, object and depmode must be set" 1>&2
+  exit 1
+fi
+
+# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po.
+depfile=${depfile-`echo "$object" |
+  sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`}
+tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`}
+
+rm -f "$tmpdepfile"
+
+# Some modes work just like other modes, but use different flags.  We
+# parameterize here, but still list the modes in the big case below,
+# to make depend.m4 easier to write.  Note that we *cannot* use a case
+# here, because this file can only contain one case statement.
+if test "$depmode" = hp; then
+  # HP compiler uses -M and no extra arg.
+  gccflag=-M
+  depmode=gcc
+fi
+
+if test "$depmode" = dashXmstdout; then
+   # This is just like dashmstdout with a different argument.
+   dashmflag=-xM
+   depmode=dashmstdout
+fi
+
+cygpath_u="cygpath -u -f -"
+if test "$depmode" = msvcmsys; then
+   # This is just like msvisualcpp but w/o cygpath translation.
+   # Just convert the backslash-escaped backslashes to single forward
+   # slashes to satisfy depend.m4
+   cygpath_u='sed s,\\\\,/,g'
+   depmode=msvisualcpp
+fi
+
+if test "$depmode" = msvc7msys; then
+   # This is just like msvc7 but w/o cygpath translation.
+   # Just convert the backslash-escaped backslashes to single forward
+   # slashes to satisfy depend.m4
+   cygpath_u='sed s,\\\\,/,g'
+   depmode=msvc7
+fi
+
+if test "$depmode" = xlc; then
+   # IBM C/C++ Compilers xlc/xlC can output gcc-like dependency informations.
+   gccflag=-qmakedep=gcc,-MF
+   depmode=gcc
+fi
+
+case "$depmode" in
+gcc3)
+## gcc 3 implements dependency tracking that does exactly what
+## we want.  Yay!  Note: for some reason libtool 1.4 doesn't like
+## it if -MD -MP comes after the -MF stuff.  Hmm.
+## Unfortunately, FreeBSD c89 acceptance of flags depends upon
+## the command line argument order; so add the flags where they
+## appear in depend2.am.  Note that the slowdown incurred here
+## affects only configure: in makefiles, %FASTDEP% shortcuts this.
+  for arg
+  do
+    case $arg in
+    -c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;;
+    *)  set fnord "$@" "$arg" ;;
+    esac
+    shift # fnord
+    shift # $arg
+  done
+  "$@"
+  stat=$?
+  if test $stat -eq 0; then :
+  else
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  mv "$tmpdepfile" "$depfile"
+  ;;
+
+gcc)
+## There are various ways to get dependency output from gcc.  Here's
+## why we pick this rather obscure method:
+## - Don't want to use -MD because we'd like the dependencies to end
+##   up in a subdir.  Having to rename by hand is ugly.
+##   (We might end up doing this anyway to support other compilers.)
+## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
+##   -MM, not -M (despite what the docs say).
+## - Using -M directly means running the compiler twice (even worse
+##   than renaming).
+  if test -z "$gccflag"; then
+    gccflag=-MD,
+  fi
+  "$@" -Wp,"$gccflag$tmpdepfile"
+  stat=$?
+  if test $stat -eq 0; then :
+  else
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  alpha=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
+## The second -e expression handles DOS-style file names with drive letters.
+  sed -e 's/^[^:]*: / /' \
+      -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"
+## This next piece of magic avoids the "deleted header file" problem.
+## The problem is that when a header file which appears in a .P file
+## is deleted, the dependency causes make to die (because there is
+## typically no way to rebuild the header).  We avoid this by adding
+## dummy dependencies for each header file.  Too bad gcc doesn't do
+## this for us directly.
+  tr ' ' "$nl" < "$tmpdepfile" |
+## Some versions of gcc put a space before the ':'.  On the theory
+## that the space means something, we add a space to the output as
+## well.  hp depmode also adds that space, but also prefixes the VPATH
+## to the object.  Take care to not repeat it in the output.
+## Some versions of the HPUX 10.20 sed can't process this invocation
+## correctly.  Breaking it into two sed invocations is a workaround.
+    sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \
+      | sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+hp)
+  # This case exists only to let depend.m4 do its work.  It works by
+  # looking at the text of this script.  This case will never be run,
+  # since it is checked for above.
+  exit 1
+  ;;
+
+sgi)
+  if test "$libtool" = yes; then
+    "$@" "-Wp,-MDupdate,$tmpdepfile"
+  else
+    "$@" -MDupdate "$tmpdepfile"
+  fi
+  stat=$?
+  if test $stat -eq 0; then :
+  else
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+
+  if test -f "$tmpdepfile"; then  # yes, the sourcefile depend on other files
+    echo "$object : \\" > "$depfile"
+
+    # Clip off the initial element (the dependent).  Don't try to be
+    # clever and replace this with sed code, as IRIX sed won't handle
+    # lines with more than a fixed number of characters (4096 in
+    # IRIX 6.2 sed, 8192 in IRIX 6.5).  We also remove comment lines;
+    # the IRIX cc adds comments like '#:fec' to the end of the
+    # dependency line.
+    tr ' ' "$nl" < "$tmpdepfile" \
+    | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' | \
+    tr "$nl" ' ' >> "$depfile"
+    echo >> "$depfile"
+
+    # The second pass generates a dummy entry for each header file.
+    tr ' ' "$nl" < "$tmpdepfile" \
+   | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
+   >> "$depfile"
+  else
+    # The sourcefile does not contain any dependencies, so just
+    # store a dummy comment line, to avoid errors with the Makefile
+    # "include basename.Plo" scheme.
+    echo "#dummy" > "$depfile"
+  fi
+  rm -f "$tmpdepfile"
+  ;;
+
+xlc)
+  # This case exists only to let depend.m4 do its work.  It works by
+  # looking at the text of this script.  This case will never be run,
+  # since it is checked for above.
+  exit 1
+  ;;
+
+aix)
+  # The C for AIX Compiler uses -M and outputs the dependencies
+  # in a .u file.  In older versions, this file always lives in the
+  # current directory.  Also, the AIX compiler puts '$object:' at the
+  # start of each line; $object doesn't have directory information.
+  # Version 6 uses the directory in both cases.
+  dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
+  test "x$dir" = "x$object" && dir=
+  base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
+  if test "$libtool" = yes; then
+    tmpdepfile1=$dir$base.u
+    tmpdepfile2=$base.u
+    tmpdepfile3=$dir.libs/$base.u
+    "$@" -Wc,-M
+  else
+    tmpdepfile1=$dir$base.u
+    tmpdepfile2=$dir$base.u
+    tmpdepfile3=$dir$base.u
+    "$@" -M
+  fi
+  stat=$?
+
+  if test $stat -eq 0; then :
+  else
+    rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+    exit $stat
+  fi
+
+  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+  do
+    test -f "$tmpdepfile" && break
+  done
+  if test -f "$tmpdepfile"; then
+    # Each line is of the form 'foo.o: dependent.h'.
+    # Do two passes, one to just change these to
+    # '$object: dependent.h' and one to simply 'dependent.h:'.
+    sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
+    sed -e 's,^.*\.[a-z]*:['"$tab"' ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
+  else
+    # The sourcefile does not contain any dependencies, so just
+    # store a dummy comment line, to avoid errors with the Makefile
+    # "include basename.Plo" scheme.
+    echo "#dummy" > "$depfile"
+  fi
+  rm -f "$tmpdepfile"
+  ;;
+
+icc)
+  # Intel's C compiler anf tcc (Tiny C Compiler) understand '-MD -MF file'.
+  # However on
+  #    $CC -MD -MF foo.d -c -o sub/foo.o sub/foo.c
+  # ICC 7.0 will fill foo.d with something like
+  #    foo.o: sub/foo.c
+  #    foo.o: sub/foo.h
+  # which is wrong.  We want
+  #    sub/foo.o: sub/foo.c
+  #    sub/foo.o: sub/foo.h
+  #    sub/foo.c:
+  #    sub/foo.h:
+  # ICC 7.1 will output
+  #    foo.o: sub/foo.c sub/foo.h
+  # and will wrap long lines using '\':
+  #    foo.o: sub/foo.c ... \
+  #     sub/foo.h ... \
+  #     ...
+  # tcc 0.9.26 (FIXME still under development at the moment of writing)
+  # will emit a similar output, but also prepend the continuation lines
+  # with horizontal tabulation characters.
+  "$@" -MD -MF "$tmpdepfile"
+  stat=$?
+  if test $stat -eq 0; then :
+  else
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  # Each line is of the form 'foo.o: dependent.h',
+  # or 'foo.o: dep1.h dep2.h \', or ' dep3.h dep4.h \'.
+  # Do two passes, one to just change these to
+  # '$object: dependent.h' and one to simply 'dependent.h:'.
+  sed -e "s/^[ $tab][ $tab]*/  /" -e "s,^[^:]*:,$object :," \
+    < "$tmpdepfile" > "$depfile"
+  sed '
+    s/[ '"$tab"'][ '"$tab"']*/ /g
+    s/^ *//
+    s/ *\\*$//
+    s/^[^:]*: *//
+    /^$/d
+    /:$/d
+    s/$/ :/
+  ' < "$tmpdepfile" >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+hp2)
+  # The "hp" stanza above does not work with aCC (C++) and HP's ia64
+  # compilers, which have integrated preprocessors.  The correct option
+  # to use with these is +Maked; it writes dependencies to a file named
+  # 'foo.d', which lands next to the object file, wherever that
+  # happens to be.
+  # Much of this is similar to the tru64 case; see comments there.
+  dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
+  test "x$dir" = "x$object" && dir=
+  base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
+  if test "$libtool" = yes; then
+    tmpdepfile1=$dir$base.d
+    tmpdepfile2=$dir.libs/$base.d
+    "$@" -Wc,+Maked
+  else
+    tmpdepfile1=$dir$base.d
+    tmpdepfile2=$dir$base.d
+    "$@" +Maked
+  fi
+  stat=$?
+  if test $stat -eq 0; then :
+  else
+     rm -f "$tmpdepfile1" "$tmpdepfile2"
+     exit $stat
+  fi
+
+  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2"
+  do
+    test -f "$tmpdepfile" && break
+  done
+  if test -f "$tmpdepfile"; then
+    sed -e "s,^.*\.[a-z]*:,$object:," "$tmpdepfile" > "$depfile"
+    # Add 'dependent.h:' lines.
+    sed -ne '2,${
+	       s/^ *//
+	       s/ \\*$//
+	       s/$/:/
+	       p
+	     }' "$tmpdepfile" >> "$depfile"
+  else
+    echo "#dummy" > "$depfile"
+  fi
+  rm -f "$tmpdepfile" "$tmpdepfile2"
+  ;;
+
+tru64)
+   # The Tru64 compiler uses -MD to generate dependencies as a side
+   # effect.  'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'.
+   # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
+   # dependencies in 'foo.d' instead, so we check for that too.
+   # Subdirectories are respected.
+   dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
+   test "x$dir" = "x$object" && dir=
+   base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
+
+   if test "$libtool" = yes; then
+      # With Tru64 cc, shared objects can also be used to make a
+      # static library.  This mechanism is used in libtool 1.4 series to
+      # handle both shared and static libraries in a single compilation.
+      # With libtool 1.4, dependencies were output in $dir.libs/$base.lo.d.
+      #
+      # With libtool 1.5 this exception was removed, and libtool now
+      # generates 2 separate objects for the 2 libraries.  These two
+      # compilations output dependencies in $dir.libs/$base.o.d and
+      # in $dir$base.o.d.  We have to check for both files, because
+      # one of the two compilations can be disabled.  We should prefer
+      # $dir$base.o.d over $dir.libs/$base.o.d because the latter is
+      # automatically cleaned when .libs/ is deleted, while ignoring
+      # the former would cause a distcleancheck panic.
+      tmpdepfile1=$dir.libs/$base.lo.d   # libtool 1.4
+      tmpdepfile2=$dir$base.o.d          # libtool 1.5
+      tmpdepfile3=$dir.libs/$base.o.d    # libtool 1.5
+      tmpdepfile4=$dir.libs/$base.d      # Compaq CCC V6.2-504
+      "$@" -Wc,-MD
+   else
+      tmpdepfile1=$dir$base.o.d
+      tmpdepfile2=$dir$base.d
+      tmpdepfile3=$dir$base.d
+      tmpdepfile4=$dir$base.d
+      "$@" -MD
+   fi
+
+   stat=$?
+   if test $stat -eq 0; then :
+   else
+      rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
+      exit $stat
+   fi
+
+   for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
+   do
+     test -f "$tmpdepfile" && break
+   done
+   if test -f "$tmpdepfile"; then
+      sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
+      sed -e 's,^.*\.[a-z]*:['"$tab"' ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
+   else
+      echo "#dummy" > "$depfile"
+   fi
+   rm -f "$tmpdepfile"
+   ;;
+
+msvc7)
+  if test "$libtool" = yes; then
+    showIncludes=-Wc,-showIncludes
+  else
+    showIncludes=-showIncludes
+  fi
+  "$@" $showIncludes > "$tmpdepfile"
+  stat=$?
+  grep -v '^Note: including file: ' "$tmpdepfile"
+  if test "$stat" = 0; then :
+  else
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  # The first sed program below extracts the file names and escapes
+  # backslashes for cygpath.  The second sed program outputs the file
+  # name when reading, but also accumulates all include files in the
+  # hold buffer in order to output them again at the end.  This only
+  # works with sed implementations that can handle large buffers.
+  sed < "$tmpdepfile" -n '
+/^Note: including file:  *\(.*\)/ {
+  s//\1/
+  s/\\/\\\\/g
+  p
+}' | $cygpath_u | sort -u | sed -n '
+s/ /\\ /g
+s/\(.*\)/'"$tab"'\1 \\/p
+s/.\(.*\) \\/\1:/
+H
+$ {
+  s/.*/'"$tab"'/
+  G
+  p
+}' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+msvc7msys)
+  # This case exists only to let depend.m4 do its work.  It works by
+  # looking at the text of this script.  This case will never be run,
+  # since it is checked for above.
+  exit 1
+  ;;
+
+#nosideeffect)
+  # This comment above is used by automake to tell side-effect
+  # dependency tracking mechanisms from slower ones.
+
+dashmstdout)
+  # Important note: in order to support this mode, a compiler *must*
+  # always write the preprocessed file to stdout, regardless of -o.
+  "$@" || exit $?
+
+  # Remove the call to Libtool.
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+
+  # Remove '-o $object'.
+  IFS=" "
+  for arg
+  do
+    case $arg in
+    -o)
+      shift
+      ;;
+    $object)
+      shift
+      ;;
+    *)
+      set fnord "$@" "$arg"
+      shift # fnord
+      shift # $arg
+      ;;
+    esac
+  done
+
+  test -z "$dashmflag" && dashmflag=-M
+  # Require at least two characters before searching for ':'
+  # in the target name.  This is to cope with DOS-style filenames:
+  # a dependency such as 'c:/foo/bar' could be seen as target 'c' otherwise.
+  "$@" $dashmflag |
+    sed 's:^['"$tab"' ]*[^:'"$tab"' ][^:][^:]*\:['"$tab"' ]*:'"$object"'\: :' > "$tmpdepfile"
+  rm -f "$depfile"
+  cat < "$tmpdepfile" > "$depfile"
+  tr ' ' "$nl" < "$tmpdepfile" | \
+## Some versions of the HPUX 10.20 sed can't process this invocation
+## correctly.  Breaking it into two sed invocations is a workaround.
+    sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+dashXmstdout)
+  # This case only exists to satisfy depend.m4.  It is never actually
+  # run, as this mode is specially recognized in the preamble.
+  exit 1
+  ;;
+
+makedepend)
+  "$@" || exit $?
+  # Remove any Libtool call
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+  # X makedepend
+  shift
+  cleared=no eat=no
+  for arg
+  do
+    case $cleared in
+    no)
+      set ""; shift
+      cleared=yes ;;
+    esac
+    if test $eat = yes; then
+      eat=no
+      continue
+    fi
+    case "$arg" in
+    -D*|-I*)
+      set fnord "$@" "$arg"; shift ;;
+    # Strip any option that makedepend may not understand.  Remove
+    # the object too, otherwise makedepend will parse it as a source file.
+    -arch)
+      eat=yes ;;
+    -*|$object)
+      ;;
+    *)
+      set fnord "$@" "$arg"; shift ;;
+    esac
+  done
+  obj_suffix=`echo "$object" | sed 's/^.*\././'`
+  touch "$tmpdepfile"
+  ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@"
+  rm -f "$depfile"
+  # makedepend may prepend the VPATH from the source file name to the object.
+  # No need to regex-escape $object, excess matching of '.' is harmless.
+  sed "s|^.*\($object *:\)|\1|" "$tmpdepfile" > "$depfile"
+  sed '1,2d' "$tmpdepfile" | tr ' ' "$nl" | \
+## Some versions of the HPUX 10.20 sed can't process this invocation
+## correctly.  Breaking it into two sed invocations is a workaround.
+    sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile" "$tmpdepfile".bak
+  ;;
+
+cpp)
+  # Important note: in order to support this mode, a compiler *must*
+  # always write the preprocessed file to stdout.
+  "$@" || exit $?
+
+  # Remove the call to Libtool.
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+
+  # Remove '-o $object'.
+  IFS=" "
+  for arg
+  do
+    case $arg in
+    -o)
+      shift
+      ;;
+    $object)
+      shift
+      ;;
+    *)
+      set fnord "$@" "$arg"
+      shift # fnord
+      shift # $arg
+      ;;
+    esac
+  done
+
+  "$@" -E |
+    sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
+       -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' |
+    sed '$ s: \\$::' > "$tmpdepfile"
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  cat < "$tmpdepfile" >> "$depfile"
+  sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+msvisualcpp)
+  # Important note: in order to support this mode, a compiler *must*
+  # always write the preprocessed file to stdout.
+  "$@" || exit $?
+
+  # Remove the call to Libtool.
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+
+  IFS=" "
+  for arg
+  do
+    case "$arg" in
+    -o)
+      shift
+      ;;
+    $object)
+      shift
+      ;;
+    "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")
+	set fnord "$@"
+	shift
+	shift
+	;;
+    *)
+	set fnord "$@" "$arg"
+	shift
+	shift
+	;;
+    esac
+  done
+  "$@" -E 2>/dev/null |
+  sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile"
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::'"$tab"'\1 \\:p' >> "$depfile"
+  echo "$tab" >> "$depfile"
+  sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+msvcmsys)
+  # This case exists only to let depend.m4 do its work.  It works by
+  # looking at the text of this script.  This case will never be run,
+  # since it is checked for above.
+  exit 1
+  ;;
+
+none)
+  exec "$@"
+  ;;
+
+*)
+  echo "Unknown depmode $depmode" 1>&2
+  exit 1
+  ;;
+esac
+
+exit 0
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:
diff --git a/config/install-sh b/config/install-sh
new file mode 100755
index 00000000..a9244eb0
--- /dev/null
+++ b/config/install-sh
@@ -0,0 +1,527 @@
+#!/bin/sh
+# install - install a program, script, or datafile
+
+scriptversion=2011-01-19.21; # UTC
+
+# This originates from X11R5 (mit/util/scripts/install.sh), which was
+# later released in X11R6 (xc/config/util/install.sh) with the
+# following copyright and license.
+#
+# Copyright (C) 1994 X Consortium
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
+# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# Except as contained in this notice, the name of the X Consortium shall not
+# be used in advertising or otherwise to promote the sale, use or other deal-
+# ings in this Software without prior written authorization from the X Consor-
+# tium.
+#
+#
+# FSF changes to this file are in the public domain.
+#
+# Calling this script install-sh is preferred over install.sh, to prevent
+# `make' implicit rules from creating a file called install from it
+# when there is no Makefile.
+#
+# This script is compatible with the BSD install script, but was written
+# from scratch.
+
+nl='
+'
+IFS=" ""	$nl"
+
+# set DOITPROG to echo to test this script
+
+# Don't use :- since 4.3BSD and earlier shells don't like it.
+doit=${DOITPROG-}
+if test -z "$doit"; then
+  doit_exec=exec
+else
+  doit_exec=$doit
+fi
+
+# Put in absolute file names if you don't have them in your path;
+# or use environment vars.
+
+chgrpprog=${CHGRPPROG-chgrp}
+chmodprog=${CHMODPROG-chmod}
+chownprog=${CHOWNPROG-chown}
+cmpprog=${CMPPROG-cmp}
+cpprog=${CPPROG-cp}
+mkdirprog=${MKDIRPROG-mkdir}
+mvprog=${MVPROG-mv}
+rmprog=${RMPROG-rm}
+stripprog=${STRIPPROG-strip}
+
+posix_glob='?'
+initialize_posix_glob='
+  test "$posix_glob" != "?" || {
+    if (set -f) 2>/dev/null; then
+      posix_glob=
+    else
+      posix_glob=:
+    fi
+  }
+'
+
+posix_mkdir=
+
+# Desired mode of installed file.
+mode=0755
+
+chgrpcmd=
+chmodcmd=$chmodprog
+chowncmd=
+mvcmd=$mvprog
+rmcmd="$rmprog -f"
+stripcmd=
+
+src=
+dst=
+dir_arg=
+dst_arg=
+
+copy_on_change=false
+no_target_directory=
+
+usage="\
+Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
+   or: $0 [OPTION]... SRCFILES... DIRECTORY
+   or: $0 [OPTION]... -t DIRECTORY SRCFILES...
+   or: $0 [OPTION]... -d DIRECTORIES...
+
+In the 1st form, copy SRCFILE to DSTFILE.
+In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
+In the 4th, create DIRECTORIES.
+
+Options:
+     --help     display this help and exit.
+     --version  display version info and exit.
+
+  -c            (ignored)
+  -C            install only if different (preserve the last data modification time)
+  -d            create directories instead of installing files.
+  -g GROUP      $chgrpprog installed files to GROUP.
+  -m MODE       $chmodprog installed files to MODE.
+  -o USER       $chownprog installed files to USER.
+  -s            $stripprog installed files.
+  -t DIRECTORY  install into DIRECTORY.
+  -T            report an error if DSTFILE is a directory.
+
+Environment variables override the default commands:
+  CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
+  RMPROG STRIPPROG
+"
+
+while test $# -ne 0; do
+  case $1 in
+    -c) ;;
+
+    -C) copy_on_change=true;;
+
+    -d) dir_arg=true;;
+
+    -g) chgrpcmd="$chgrpprog $2"
+	shift;;
+
+    --help) echo "$usage"; exit $?;;
+
+    -m) mode=$2
+	case $mode in
+	  *' '* | *'	'* | *'
+'*	  | *'*'* | *'?'* | *'['*)
+	    echo "$0: invalid mode: $mode" >&2
+	    exit 1;;
+	esac
+	shift;;
+
+    -o) chowncmd="$chownprog $2"
+	shift;;
+
+    -s) stripcmd=$stripprog;;
+
+    -t) dst_arg=$2
+	# Protect names problematic for `test' and other utilities.
+	case $dst_arg in
+	  -* | [=\(\)!]) dst_arg=./$dst_arg;;
+	esac
+	shift;;
+
+    -T) no_target_directory=true;;
+
+    --version) echo "$0 $scriptversion"; exit $?;;
+
+    --)	shift
+	break;;
+
+    -*)	echo "$0: invalid option: $1" >&2
+	exit 1;;
+
+    *)  break;;
+  esac
+  shift
+done
+
+if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
+  # When -d is used, all remaining arguments are directories to create.
+  # When -t is used, the destination is already specified.
+  # Otherwise, the last argument is the destination.  Remove it from $@.
+  for arg
+  do
+    if test -n "$dst_arg"; then
+      # $@ is not empty: it contains at least $arg.
+      set fnord "$@" "$dst_arg"
+      shift # fnord
+    fi
+    shift # arg
+    dst_arg=$arg
+    # Protect names problematic for `test' and other utilities.
+    case $dst_arg in
+      -* | [=\(\)!]) dst_arg=./$dst_arg;;
+    esac
+  done
+fi
+
+if test $# -eq 0; then
+  if test -z "$dir_arg"; then
+    echo "$0: no input file specified." >&2
+    exit 1
+  fi
+  # It's OK to call `install-sh -d' without argument.
+  # This can happen when creating conditional directories.
+  exit 0
+fi
+
+if test -z "$dir_arg"; then
+  do_exit='(exit $ret); exit $ret'
+  trap "ret=129; $do_exit" 1
+  trap "ret=130; $do_exit" 2
+  trap "ret=141; $do_exit" 13
+  trap "ret=143; $do_exit" 15
+
+  # Set umask so as not to create temps with too-generous modes.
+  # However, 'strip' requires both read and write access to temps.
+  case $mode in
+    # Optimize common cases.
+    *644) cp_umask=133;;
+    *755) cp_umask=22;;
+
+    *[0-7])
+      if test -z "$stripcmd"; then
+	u_plus_rw=
+      else
+	u_plus_rw='% 200'
+      fi
+      cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
+    *)
+      if test -z "$stripcmd"; then
+	u_plus_rw=
+      else
+	u_plus_rw=,u+rw
+      fi
+      cp_umask=$mode$u_plus_rw;;
+  esac
+fi
+
+for src
+do
+  # Protect names problematic for `test' and other utilities.
+  case $src in
+    -* | [=\(\)!]) src=./$src;;
+  esac
+
+  if test -n "$dir_arg"; then
+    dst=$src
+    dstdir=$dst
+    test -d "$dstdir"
+    dstdir_status=$?
+  else
+
+    # Waiting for this to be detected by the "$cpprog $src $dsttmp" command
+    # might cause directories to be created, which would be especially bad
+    # if $src (and thus $dsttmp) contains '*'.
+    if test ! -f "$src" && test ! -d "$src"; then
+      echo "$0: $src does not exist." >&2
+      exit 1
+    fi
+
+    if test -z "$dst_arg"; then
+      echo "$0: no destination specified." >&2
+      exit 1
+    fi
+    dst=$dst_arg
+
+    # If destination is a directory, append the input filename; won't work
+    # if double slashes aren't ignored.
+    if test -d "$dst"; then
+      if test -n "$no_target_directory"; then
+	echo "$0: $dst_arg: Is a directory" >&2
+	exit 1
+      fi
+      dstdir=$dst
+      dst=$dstdir/`basename "$src"`
+      dstdir_status=0
+    else
+      # Prefer dirname, but fall back on a substitute if dirname fails.
+      dstdir=`
+	(dirname "$dst") 2>/dev/null ||
+	expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	     X"$dst" : 'X\(//\)[^/]' \| \
+	     X"$dst" : 'X\(//\)$' \| \
+	     X"$dst" : 'X\(/\)' \| . 2>/dev/null ||
+	echo X"$dst" |
+	    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+		   s//\1/
+		   q
+		 }
+		 /^X\(\/\/\)[^/].*/{
+		   s//\1/
+		   q
+		 }
+		 /^X\(\/\/\)$/{
+		   s//\1/
+		   q
+		 }
+		 /^X\(\/\).*/{
+		   s//\1/
+		   q
+		 }
+		 s/.*/./; q'
+      `
+
+      test -d "$dstdir"
+      dstdir_status=$?
+    fi
+  fi
+
+  obsolete_mkdir_used=false
+
+  if test $dstdir_status != 0; then
+    case $posix_mkdir in
+      '')
+	# Create intermediate dirs using mode 755 as modified by the umask.
+	# This is like FreeBSD 'install' as of 1997-10-28.
+	umask=`umask`
+	case $stripcmd.$umask in
+	  # Optimize common cases.
+	  *[2367][2367]) mkdir_umask=$umask;;
+	  .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;
+
+	  *[0-7])
+	    mkdir_umask=`expr $umask + 22 \
+	      - $umask % 100 % 40 + $umask % 20 \
+	      - $umask % 10 % 4 + $umask % 2
+	    `;;
+	  *) mkdir_umask=$umask,go-w;;
+	esac
+
+	# With -d, create the new directory with the user-specified mode.
+	# Otherwise, rely on $mkdir_umask.
+	if test -n "$dir_arg"; then
+	  mkdir_mode=-m$mode
+	else
+	  mkdir_mode=
+	fi
+
+	posix_mkdir=false
+	case $umask in
+	  *[123567][0-7][0-7])
+	    # POSIX mkdir -p sets u+wx bits regardless of umask, which
+	    # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
+	    ;;
+	  *)
+	    tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
+	    trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0
+
+	    if (umask $mkdir_umask &&
+		exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1
+	    then
+	      if test -z "$dir_arg" || {
+		   # Check for POSIX incompatibilities with -m.
+		   # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
+		   # other-writeable bit of parent directory when it shouldn't.
+		   # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
+		   ls_ld_tmpdir=`ls -ld "$tmpdir"`
+		   case $ls_ld_tmpdir in
+		     d????-?r-*) different_mode=700;;
+		     d????-?--*) different_mode=755;;
+		     *) false;;
+		   esac &&
+		   $mkdirprog -m$different_mode -p -- "$tmpdir" && {
+		     ls_ld_tmpdir_1=`ls -ld "$tmpdir"`
+		     test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
+		   }
+		 }
+	      then posix_mkdir=:
+	      fi
+	      rmdir "$tmpdir/d" "$tmpdir"
+	    else
+	      # Remove any dirs left behind by ancient mkdir implementations.
+	      rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null
+	    fi
+	    trap '' 0;;
+	esac;;
+    esac
+
+    if
+      $posix_mkdir && (
+	umask $mkdir_umask &&
+	$doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
+      )
+    then :
+    else
+
+      # The umask is ridiculous, or mkdir does not conform to POSIX,
+      # or it failed possibly due to a race condition.  Create the
+      # directory the slow way, step by step, checking for races as we go.
+
+      case $dstdir in
+	/*) prefix='/';;
+	[-=\(\)!]*) prefix='./';;
+	*)  prefix='';;
+      esac
+
+      eval "$initialize_posix_glob"
+
+      oIFS=$IFS
+      IFS=/
+      $posix_glob set -f
+      set fnord $dstdir
+      shift
+      $posix_glob set +f
+      IFS=$oIFS
+
+      prefixes=
+
+      for d
+      do
+	test X"$d" = X && continue
+
+	prefix=$prefix$d
+	if test -d "$prefix"; then
+	  prefixes=
+	else
+	  if $posix_mkdir; then
+	    (umask=$mkdir_umask &&
+	     $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
+	    # Don't fail if two instances are running concurrently.
+	    test -d "$prefix" || exit 1
+	  else
+	    case $prefix in
+	      *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
+	      *) qprefix=$prefix;;
+	    esac
+	    prefixes="$prefixes '$qprefix'"
+	  fi
+	fi
+	prefix=$prefix/
+      done
+
+      if test -n "$prefixes"; then
+	# Don't fail if two instances are running concurrently.
+	(umask $mkdir_umask &&
+	 eval "\$doit_exec \$mkdirprog $prefixes") ||
+	  test -d "$dstdir" || exit 1
+	obsolete_mkdir_used=true
+      fi
+    fi
+  fi
+
+  if test -n "$dir_arg"; then
+    { test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
+    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
+    { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
+      test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
+  else
+
+    # Make a couple of temp file names in the proper directory.
+    dsttmp=$dstdir/_inst.$$_
+    rmtmp=$dstdir/_rm.$$_
+
+    # Trap to clean up those temp files at exit.
+    trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
+
+    # Copy the file name to the temp name.
+    (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&
+
+    # and set any options; do chmod last to preserve setuid bits.
+    #
+    # If any of these fail, we abort the whole thing.  If we want to
+    # ignore errors from any of these, just make sure not to ignore
+    # errors from the above "$doit $cpprog $src $dsttmp" command.
+    #
+    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
+    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
+    { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
+    { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
+
+    # If -C, don't bother to copy if it wouldn't change the file.
+    if $copy_on_change &&
+       old=`LC_ALL=C ls -dlL "$dst"	2>/dev/null` &&
+       new=`LC_ALL=C ls -dlL "$dsttmp"	2>/dev/null` &&
+
+       eval "$initialize_posix_glob" &&
+       $posix_glob set -f &&
+       set X $old && old=:$2:$4:$5:$6 &&
+       set X $new && new=:$2:$4:$5:$6 &&
+       $posix_glob set +f &&
+
+       test "$old" = "$new" &&
+       $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
+    then
+      rm -f "$dsttmp"
+    else
+      # Rename the file to the real destination.
+      $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
+
+      # The rename failed, perhaps because mv can't rename something else
+      # to itself, or perhaps because mv is so ancient that it does not
+      # support -f.
+      {
+	# Now remove or move aside any old file at destination location.
+	# We try this two ways since rm can't unlink itself on some
+	# systems and the destination file might be busy for other
+	# reasons.  In this case, the final cleanup might fail but the new
+	# file should still install successfully.
+	{
+	  test ! -f "$dst" ||
+	  $doit $rmcmd -f "$dst" 2>/dev/null ||
+	  { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
+	    { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
+	  } ||
+	  { echo "$0: cannot unlink or rename $dst" >&2
+	    (exit 1); exit 1
+	  }
+	} &&
+
+	# Now rename the file to the real destination.
+	$doit $mvcmd "$dsttmp" "$dst"
+      }
+    fi || exit 1
+
+    trap '' 0
+  fi
+done
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:
diff --git a/config/missing b/config/missing
new file mode 100755
index 00000000..86a8fc31
--- /dev/null
+++ b/config/missing
@@ -0,0 +1,331 @@
+#! /bin/sh
+# Common stub for a few missing GNU programs while installing.
+
+scriptversion=2012-01-06.13; # UTC
+
+# Copyright (C) 1996, 1997, 1999, 2000, 2002, 2003, 2004, 2005, 2006,
+# 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
+# Originally by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+if test $# -eq 0; then
+  echo 1>&2 "Try \`$0 --help' for more information"
+  exit 1
+fi
+
+run=:
+sed_output='s/.* --output[ =]\([^ ]*\).*/\1/p'
+sed_minuso='s/.* -o \([^ ]*\).*/\1/p'
+
+# In the cases where this matters, `missing' is being run in the
+# srcdir already.
+if test -f configure.ac; then
+  configure_ac=configure.ac
+else
+  configure_ac=configure.in
+fi
+
+msg="missing on your system"
+
+case $1 in
+--run)
+  # Try to run requested program, and just exit if it succeeds.
+  run=
+  shift
+  "$@" && exit 0
+  # Exit code 63 means version mismatch.  This often happens
+  # when the user try to use an ancient version of a tool on
+  # a file that requires a minimum version.  In this case we
+  # we should proceed has if the program had been absent, or
+  # if --run hadn't been passed.
+  if test $? = 63; then
+    run=:
+    msg="probably too old"
+  fi
+  ;;
+
+  -h|--h|--he|--hel|--help)
+    echo "\
+$0 [OPTION]... PROGRAM [ARGUMENT]...
+
+Handle \`PROGRAM [ARGUMENT]...' for when PROGRAM is missing, or return an
+error status if there is no known handling for PROGRAM.
+
+Options:
+  -h, --help      display this help and exit
+  -v, --version   output version information and exit
+  --run           try to run the given command, and emulate it if it fails
+
+Supported PROGRAM values:
+  aclocal      touch file \`aclocal.m4'
+  autoconf     touch file \`configure'
+  autoheader   touch file \`config.h.in'
+  autom4te     touch the output file, or create a stub one
+  automake     touch all \`Makefile.in' files
+  bison        create \`y.tab.[ch]', if possible, from existing .[ch]
+  flex         create \`lex.yy.c', if possible, from existing .c
+  help2man     touch the output file
+  lex          create \`lex.yy.c', if possible, from existing .c
+  makeinfo     touch the output file
+  yacc         create \`y.tab.[ch]', if possible, from existing .[ch]
+
+Version suffixes to PROGRAM as well as the prefixes \`gnu-', \`gnu', and
+\`g' are ignored when checking the name.
+
+Send bug reports to <bug-automake@gnu.org>."
+    exit $?
+    ;;
+
+  -v|--v|--ve|--ver|--vers|--versi|--versio|--version)
+    echo "missing $scriptversion (GNU Automake)"
+    exit $?
+    ;;
+
+  -*)
+    echo 1>&2 "$0: Unknown \`$1' option"
+    echo 1>&2 "Try \`$0 --help' for more information"
+    exit 1
+    ;;
+
+esac
+
+# normalize program name to check for.
+program=`echo "$1" | sed '
+  s/^gnu-//; t
+  s/^gnu//; t
+  s/^g//; t'`
+
+# Now exit if we have it, but it failed.  Also exit now if we
+# don't have it and --version was passed (most likely to detect
+# the program).  This is about non-GNU programs, so use $1 not
+# $program.
+case $1 in
+  lex*|yacc*)
+    # Not GNU programs, they don't have --version.
+    ;;
+
+  *)
+    if test -z "$run" && ($1 --version) > /dev/null 2>&1; then
+       # We have it, but it failed.
+       exit 1
+    elif test "x$2" = "x--version" || test "x$2" = "x--help"; then
+       # Could not run --version or --help.  This is probably someone
+       # running `$TOOL --version' or `$TOOL --help' to check whether
+       # $TOOL exists and not knowing $TOOL uses missing.
+       exit 1
+    fi
+    ;;
+esac
+
+# If it does not exist, or fails to run (possibly an outdated version),
+# try to emulate it.
+case $program in
+  aclocal*)
+    echo 1>&2 "\
+WARNING: \`$1' is $msg.  You should only need it if
+         you modified \`acinclude.m4' or \`${configure_ac}'.  You might want
+         to install the \`Automake' and \`Perl' packages.  Grab them from
+         any GNU archive site."
+    touch aclocal.m4
+    ;;
+
+  autoconf*)
+    echo 1>&2 "\
+WARNING: \`$1' is $msg.  You should only need it if
+         you modified \`${configure_ac}'.  You might want to install the
+         \`Autoconf' and \`GNU m4' packages.  Grab them from any GNU
+         archive site."
+    touch configure
+    ;;
+
+  autoheader*)
+    echo 1>&2 "\
+WARNING: \`$1' is $msg.  You should only need it if
+         you modified \`acconfig.h' or \`${configure_ac}'.  You might want
+         to install the \`Autoconf' and \`GNU m4' packages.  Grab them
+         from any GNU archive site."
+    files=`sed -n 's/^[ ]*A[CM]_CONFIG_HEADER(\([^)]*\)).*/\1/p' ${configure_ac}`
+    test -z "$files" && files="config.h"
+    touch_files=
+    for f in $files; do
+      case $f in
+      *:*) touch_files="$touch_files "`echo "$f" |
+				       sed -e 's/^[^:]*://' -e 's/:.*//'`;;
+      *) touch_files="$touch_files $f.in";;
+      esac
+    done
+    touch $touch_files
+    ;;
+
+  automake*)
+    echo 1>&2 "\
+WARNING: \`$1' is $msg.  You should only need it if
+         you modified \`Makefile.am', \`acinclude.m4' or \`${configure_ac}'.
+         You might want to install the \`Automake' and \`Perl' packages.
+         Grab them from any GNU archive site."
+    find . -type f -name Makefile.am -print |
+	   sed 's/\.am$/.in/' |
+	   while read f; do touch "$f"; done
+    ;;
+
+  autom4te*)
+    echo 1>&2 "\
+WARNING: \`$1' is needed, but is $msg.
+         You might have modified some files without having the
+         proper tools for further handling them.
+         You can get \`$1' as part of \`Autoconf' from any GNU
+         archive site."
+
+    file=`echo "$*" | sed -n "$sed_output"`
+    test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
+    if test -f "$file"; then
+	touch $file
+    else
+	test -z "$file" || exec >$file
+	echo "#! /bin/sh"
+	echo "# Created by GNU Automake missing as a replacement of"
+	echo "#  $ $@"
+	echo "exit 0"
+	chmod +x $file
+	exit 1
+    fi
+    ;;
+
+  bison*|yacc*)
+    echo 1>&2 "\
+WARNING: \`$1' $msg.  You should only need it if
+         you modified a \`.y' file.  You may need the \`Bison' package
+         in order for those modifications to take effect.  You can get
+         \`Bison' from any GNU archive site."
+    rm -f y.tab.c y.tab.h
+    if test $# -ne 1; then
+        eval LASTARG=\${$#}
+	case $LASTARG in
+	*.y)
+	    SRCFILE=`echo "$LASTARG" | sed 's/y$/c/'`
+	    if test -f "$SRCFILE"; then
+	         cp "$SRCFILE" y.tab.c
+	    fi
+	    SRCFILE=`echo "$LASTARG" | sed 's/y$/h/'`
+	    if test -f "$SRCFILE"; then
+	         cp "$SRCFILE" y.tab.h
+	    fi
+	  ;;
+	esac
+    fi
+    if test ! -f y.tab.h; then
+	echo >y.tab.h
+    fi
+    if test ! -f y.tab.c; then
+	echo 'main() { return 0; }' >y.tab.c
+    fi
+    ;;
+
+  lex*|flex*)
+    echo 1>&2 "\
+WARNING: \`$1' is $msg.  You should only need it if
+         you modified a \`.l' file.  You may need the \`Flex' package
+         in order for those modifications to take effect.  You can get
+         \`Flex' from any GNU archive site."
+    rm -f lex.yy.c
+    if test $# -ne 1; then
+        eval LASTARG=\${$#}
+	case $LASTARG in
+	*.l)
+	    SRCFILE=`echo "$LASTARG" | sed 's/l$/c/'`
+	    if test -f "$SRCFILE"; then
+	         cp "$SRCFILE" lex.yy.c
+	    fi
+	  ;;
+	esac
+    fi
+    if test ! -f lex.yy.c; then
+	echo 'main() { return 0; }' >lex.yy.c
+    fi
+    ;;
+
+  help2man*)
+    echo 1>&2 "\
+WARNING: \`$1' is $msg.  You should only need it if
+	 you modified a dependency of a manual page.  You may need the
+	 \`Help2man' package in order for those modifications to take
+	 effect.  You can get \`Help2man' from any GNU archive site."
+
+    file=`echo "$*" | sed -n "$sed_output"`
+    test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
+    if test -f "$file"; then
+	touch $file
+    else
+	test -z "$file" || exec >$file
+	echo ".ab help2man is required to generate this page"
+	exit $?
+    fi
+    ;;
+
+  makeinfo*)
+    echo 1>&2 "\
+WARNING: \`$1' is $msg.  You should only need it if
+         you modified a \`.texi' or \`.texinfo' file, or any other file
+         indirectly affecting the aspect of the manual.  The spurious
+         call might also be the consequence of using a buggy \`make' (AIX,
+         DU, IRIX).  You might want to install the \`Texinfo' package or
+         the \`GNU make' package.  Grab either from any GNU archive site."
+    # The file to touch is that specified with -o ...
+    file=`echo "$*" | sed -n "$sed_output"`
+    test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
+    if test -z "$file"; then
+      # ... or it is the one specified with @setfilename ...
+      infile=`echo "$*" | sed 's/.* \([^ ]*\) *$/\1/'`
+      file=`sed -n '
+	/^@setfilename/{
+	  s/.* \([^ ]*\) *$/\1/
+	  p
+	  q
+	}' $infile`
+      # ... or it is derived from the source name (dir/f.texi becomes f.info)
+      test -z "$file" && file=`echo "$infile" | sed 's,.*/,,;s,.[^.]*$,,'`.info
+    fi
+    # If the file does not exist, the user really needs makeinfo;
+    # let's fail without touching anything.
+    test -f $file || exit 1
+    touch $file
+    ;;
+
+  *)
+    echo 1>&2 "\
+WARNING: \`$1' is needed, and is $msg.
+         You might have modified some files without having the
+         proper tools for further handling them.  Check the \`README' file,
+         it often tells you about the needed prerequisites for installing
+         this package.  You may also peek at any GNU archive site, in case
+         some other package would contain this missing \`$1' program."
+    exit 1
+    ;;
+esac
+
+exit 0
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:
diff --git a/config/ylwrap b/config/ylwrap
new file mode 100755
index 00000000..92536350
--- /dev/null
+++ b/config/ylwrap
@@ -0,0 +1,226 @@
+#! /bin/sh
+# ylwrap - wrapper for lex/yacc invocations.
+
+scriptversion=2011-08-25.18; # UTC
+
+# Copyright (C) 1996, 1997, 1998, 1999, 2001, 2002, 2003, 2004, 2005,
+# 2007, 2009, 2010, 2011 Free Software Foundation, Inc.
+#
+# Written by Tom Tromey <tromey@cygnus.com>.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# This file is maintained in Automake, please report
+# bugs to <bug-automake@gnu.org> or send patches to
+# <automake-patches@gnu.org>.
+
+case "$1" in
+  '')
+    echo "$0: No files given.  Try \`$0 --help' for more information." 1>&2
+    exit 1
+    ;;
+  --basedir)
+    basedir=$2
+    shift 2
+    ;;
+  -h|--h*)
+    cat <<\EOF
+Usage: ylwrap [--help|--version] INPUT [OUTPUT DESIRED]... -- PROGRAM [ARGS]...
+
+Wrapper for lex/yacc invocations, renaming files as desired.
+
+  INPUT is the input file
+  OUTPUT is one file PROG generates
+  DESIRED is the file we actually want instead of OUTPUT
+  PROGRAM is program to run
+  ARGS are passed to PROG
+
+Any number of OUTPUT,DESIRED pairs may be used.
+
+Report bugs to <bug-automake@gnu.org>.
+EOF
+    exit $?
+    ;;
+  -v|--v*)
+    echo "ylwrap $scriptversion"
+    exit $?
+    ;;
+esac
+
+
+# The input.
+input="$1"
+shift
+case "$input" in
+  [\\/]* | ?:[\\/]*)
+    # Absolute path; do nothing.
+    ;;
+  *)
+    # Relative path.  Make it absolute.
+    input="`pwd`/$input"
+    ;;
+esac
+
+pairlist=
+while test "$#" -ne 0; do
+  if test "$1" = "--"; then
+    shift
+    break
+  fi
+  pairlist="$pairlist $1"
+  shift
+done
+
+# The program to run.
+prog="$1"
+shift
+# Make any relative path in $prog absolute.
+case "$prog" in
+  [\\/]* | ?:[\\/]*) ;;
+  *[\\/]*) prog="`pwd`/$prog" ;;
+esac
+
+# FIXME: add hostname here for parallel makes that run commands on
+# other machines.  But that might take us over the 14-char limit.
+dirname=ylwrap$$
+do_exit="cd '`pwd`' && rm -rf $dirname > /dev/null 2>&1;"' (exit $ret); exit $ret'
+trap "ret=129; $do_exit" 1
+trap "ret=130; $do_exit" 2
+trap "ret=141; $do_exit" 13
+trap "ret=143; $do_exit" 15
+mkdir $dirname || exit 1
+
+cd $dirname
+
+case $# in
+  0) "$prog" "$input" ;;
+  *) "$prog" "$@" "$input" ;;
+esac
+ret=$?
+
+if test $ret -eq 0; then
+  set X $pairlist
+  shift
+  first=yes
+  # Since DOS filename conventions don't allow two dots,
+  # the DOS version of Bison writes out y_tab.c instead of y.tab.c
+  # and y_tab.h instead of y.tab.h. Test to see if this is the case.
+  y_tab_nodot="no"
+  if test -f y_tab.c || test -f y_tab.h; then
+    y_tab_nodot="yes"
+  fi
+
+  # The directory holding the input.
+  input_dir=`echo "$input" | sed -e 's,\([\\/]\)[^\\/]*$,\1,'`
+  # Quote $INPUT_DIR so we can use it in a regexp.
+  # FIXME: really we should care about more than `.' and `\'.
+  input_rx=`echo "$input_dir" | sed 's,\\\\,\\\\\\\\,g;s,\\.,\\\\.,g'`
+
+  while test "$#" -ne 0; do
+    from="$1"
+    # Handle y_tab.c and y_tab.h output by DOS
+    if test $y_tab_nodot = "yes"; then
+      if test $from = "y.tab.c"; then
+        from="y_tab.c"
+      else
+        if test $from = "y.tab.h"; then
+          from="y_tab.h"
+        fi
+      fi
+    fi
+    if test -f "$from"; then
+      # If $2 is an absolute path name, then just use that,
+      # otherwise prepend `../'.
+      case "$2" in
+        [\\/]* | ?:[\\/]*) target="$2";;
+        *) target="../$2";;
+      esac
+
+      # We do not want to overwrite a header file if it hasn't
+      # changed.  This avoid useless recompilations.  However the
+      # parser itself (the first file) should always be updated,
+      # because it is the destination of the .y.c rule in the
+      # Makefile.  Divert the output of all other files to a temporary
+      # file so we can compare them to existing versions.
+      if test $first = no; then
+        realtarget="$target"
+        target="tmp-`echo $target | sed s/.*[\\/]//g`"
+      fi
+      # Edit out `#line' or `#' directives.
+      #
+      # We don't want the resulting debug information to point at
+      # an absolute srcdir; it is better for it to just mention the
+      # .y file with no path.
+      #
+      # We want to use the real output file name, not yy.lex.c for
+      # instance.
+      #
+      # We want the include guards to be adjusted too.
+      FROM=`echo "$from" | sed \
+            -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'\
+            -e 's/[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]/_/g'`
+      TARGET=`echo "$2" | sed \
+            -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'\
+            -e 's/[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]/_/g'`
+
+      sed -e "/^#/!b" -e "s,$input_rx,," -e "s,$from,$2," \
+          -e "s,$FROM,$TARGET," "$from" >"$target" || ret=$?
+
+      # Check whether header files must be updated.
+      if test $first = no; then
+        if test -f "$realtarget" && cmp -s "$realtarget" "$target"; then
+          echo "$2" is unchanged
+          rm -f "$target"
+        else
+          echo updating "$2"
+          mv -f "$target" "$realtarget"
+        fi
+      fi
+    else
+      # A missing file is only an error for the first file.  This
+      # is a blatant hack to let us support using "yacc -d".  If -d
+      # is not specified, we don't want an error when the header
+      # file is "missing".
+      if test $first = yes; then
+        ret=1
+      fi
+    fi
+    shift
+    shift
+    first=no
+  done
+else
+  ret=$?
+fi
+
+# Remove the directory.
+cd ..
+rm -rf $dirname
+
+exit $ret
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:
diff --git a/configure b/configure
new file mode 100755
index 00000000..7170e4a2
--- /dev/null
+++ b/configure
@@ -0,0 +1,5766 @@
+#! /bin/sh
+# Guess values for system-dependent variables and create Makefiles.
+# Generated by GNU Autoconf 2.69 for jq 1.2.
+#
+# Report bugs to <mu@netsoc.tcd.ie>.
+#
+#
+# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
+#
+#
+# This configure script is free software; the Free Software Foundation
+# gives unlimited permission to copy, distribute and modify it.
+## -------------------- ##
+## M4sh Initialization. ##
+## -------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+
+
+as_nl='
+'
+export as_nl
+# Printing a long string crashes Solaris 7 /usr/bin/printf.
+as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
+# Prefer a ksh shell builtin over an external printf program on Solaris,
+# but without wasting forks for bash or zsh.
+if test -z "$BASH_VERSION$ZSH_VERSION" \
+    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='print -r --'
+  as_echo_n='print -rn --'
+elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='printf %s\n'
+  as_echo_n='printf %s'
+else
+  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
+    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
+    as_echo_n='/usr/ucb/echo -n'
+  else
+    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
+    as_echo_n_body='eval
+      arg=$1;
+      case $arg in #(
+      *"$as_nl"*)
+	expr "X$arg" : "X\\(.*\\)$as_nl";
+	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
+      esac;
+      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
+    '
+    export as_echo_n_body
+    as_echo_n='sh -c $as_echo_n_body as_echo'
+  fi
+  export as_echo_body
+  as_echo='sh -c $as_echo_body as_echo'
+fi
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
+fi
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent editors from complaining about space-tab.
+# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+# splitting by setting IFS to empty value.)
+IFS=" ""	$as_nl"
+
+# Find who we are.  Look in the path if we contain no directory separator.
+as_myself=
+case $0 in #((
+  *[\\/]* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+  done
+IFS=$as_save_IFS
+
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  exit 1
+fi
+
+# Unset variables that we do not need and which cause bugs (e.g. in
+# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
+# suppresses any "Segmentation fault" message there.  '((' could
+# trigger a bug in pdksh 5.2.14.
+for as_var in BASH_ENV ENV MAIL MAILPATH
+do eval test x\${$as_var+set} = xset \
+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+done
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+LC_ALL=C
+export LC_ALL
+LANGUAGE=C
+export LANGUAGE
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+# Use a proper internal environment variable to ensure we don't fall
+  # into an infinite loop, continuously re-executing ourselves.
+  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
+    _as_can_reexec=no; export _as_can_reexec;
+    # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+  *v*x* | *x*v* ) as_opts=-vx ;;
+  *v* ) as_opts=-v ;;
+  *x* ) as_opts=-x ;;
+  * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+as_fn_exit 255
+  fi
+  # We don't want this to propagate to other subprocesses.
+          { _as_can_reexec=; unset _as_can_reexec;}
+if test "x$CONFIG_SHELL" = x; then
+  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '\${1+\"\$@\"}'='\"\$@\"'
+  setopt NO_GLOB_SUBST
+else
+  case \`(set -o) 2>/dev/null\` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+"
+  as_required="as_fn_return () { (exit \$1); }
+as_fn_success () { as_fn_return 0; }
+as_fn_failure () { as_fn_return 1; }
+as_fn_ret_success () { return 0; }
+as_fn_ret_failure () { return 1; }
+
+exitcode=0
+as_fn_success || { exitcode=1; echo as_fn_success failed.; }
+as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
+as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
+as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
+if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
+
+else
+  exitcode=1; echo positional parameters were not saved.
+fi
+test x\$exitcode = x0 || exit 1
+test -x / || exit 1"
+  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
+  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
+  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
+  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1"
+  if (eval "$as_required") 2>/dev/null; then :
+  as_have_required=yes
+else
+  as_have_required=no
+fi
+  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
+
+else
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+as_found=false
+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  as_found=:
+  case $as_dir in #(
+	 /*)
+	   for as_base in sh bash ksh sh5; do
+	     # Try only shells that exist, to save several forks.
+	     as_shell=$as_dir/$as_base
+	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
+		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
+  CONFIG_SHELL=$as_shell as_have_required=yes
+		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
+  break 2
+fi
+fi
+	   done;;
+       esac
+  as_found=false
+done
+$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
+	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
+  CONFIG_SHELL=$SHELL as_have_required=yes
+fi; }
+IFS=$as_save_IFS
+
+
+      if test "x$CONFIG_SHELL" != x; then :
+  export CONFIG_SHELL
+             # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+  *v*x* | *x*v* ) as_opts=-vx ;;
+  *v* ) as_opts=-v ;;
+  *x* ) as_opts=-x ;;
+  * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+exit 255
+fi
+
+    if test x$as_have_required = xno; then :
+  $as_echo "$0: This script requires a shell more modern than all"
+  $as_echo "$0: the shells that I found on your system."
+  if test x${ZSH_VERSION+set} = xset ; then
+    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
+    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
+  else
+    $as_echo "$0: Please tell bug-autoconf@gnu.org and mu@netsoc.tcd.ie
+$0: about your system, including any error possibly output
+$0: before this message. Then install a modern shell, or
+$0: manually run the script under such a shell if you do
+$0: have one."
+  fi
+  exit 1
+fi
+fi
+fi
+SHELL=${CONFIG_SHELL-/bin/sh}
+export SHELL
+# Unset more variables known to interfere with behavior of common tools.
+CLICOLOR_FORCE= GREP_OPTIONS=
+unset CLICOLOR_FORCE GREP_OPTIONS
+
+## --------------------- ##
+## M4sh Shell Functions. ##
+## --------------------- ##
+# as_fn_unset VAR
+# ---------------
+# Portably unset VAR.
+as_fn_unset ()
+{
+  { eval $1=; unset $1;}
+}
+as_unset=as_fn_unset
+
+# as_fn_set_status STATUS
+# -----------------------
+# Set $? to STATUS, without forking.
+as_fn_set_status ()
+{
+  return $1
+} # as_fn_set_status
+
+# as_fn_exit STATUS
+# -----------------
+# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
+as_fn_exit ()
+{
+  set +e
+  as_fn_set_status $1
+  exit $1
+} # as_fn_exit
+
+# as_fn_mkdir_p
+# -------------
+# Create "$as_dir" as a directory, including parents if necessary.
+as_fn_mkdir_p ()
+{
+
+  case $as_dir in #(
+  -*) as_dir=./$as_dir;;
+  esac
+  test -d "$as_dir" || eval $as_mkdir_p || {
+    as_dirs=
+    while :; do
+      case $as_dir in #(
+      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+      *) as_qdir=$as_dir;;
+      esac
+      as_dirs="'$as_qdir' $as_dirs"
+      as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      test -d "$as_dir" && break
+    done
+    test -z "$as_dirs" || eval "mkdir $as_dirs"
+  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
+
+
+} # as_fn_mkdir_p
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+  test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+# as_fn_append VAR VALUE
+# ----------------------
+# Append the text in VALUE to the end of the definition contained in VAR. Take
+# advantage of any shell optimizations that allow amortized linear growth over
+# repeated appends, instead of the typical quadratic growth present in naive
+# implementations.
+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
+  eval 'as_fn_append ()
+  {
+    eval $1+=\$2
+  }'
+else
+  as_fn_append ()
+  {
+    eval $1=\$$1\$2
+  }
+fi # as_fn_append
+
+# as_fn_arith ARG...
+# ------------------
+# Perform arithmetic evaluation on the ARGs, and store the result in the
+# global $as_val. Take advantage of shells that can avoid forks. The arguments
+# must be portable across $(()) and expr.
+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
+  eval 'as_fn_arith ()
+  {
+    as_val=$(( $* ))
+  }'
+else
+  as_fn_arith ()
+  {
+    as_val=`expr "$@" || test $? -eq 1`
+  }
+fi # as_fn_arith
+
+
+# as_fn_error STATUS ERROR [LINENO LOG_FD]
+# ----------------------------------------
+# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
+# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
+# script with STATUS, using 1 if that was 0.
+as_fn_error ()
+{
+  as_status=$1; test $as_status -eq 0 && as_status=1
+  if test "$4"; then
+    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+  fi
+  $as_echo "$as_me: error: $2" >&2
+  as_fn_exit $as_status
+} # as_fn_error
+
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
+
+as_me=`$as_basename -- "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+
+  as_lineno_1=$LINENO as_lineno_1a=$LINENO
+  as_lineno_2=$LINENO as_lineno_2a=$LINENO
+  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
+  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
+  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
+  sed -n '
+    p
+    /[$]LINENO/=
+  ' <$as_myself |
+    sed '
+      s/[$]LINENO.*/&-/
+      t lineno
+      b
+      :lineno
+      N
+      :loop
+      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
+      t loop
+      s/-\n.*//
+    ' >$as_me.lineno &&
+  chmod +x "$as_me.lineno" ||
+    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
+
+  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
+  # already done that, so ensure we don't try to do so again and fall
+  # in an infinite loop.  This has already happened in practice.
+  _as_can_reexec=no; export _as_can_reexec
+  # Don't try to exec as it changes $[0], causing all sort of problems
+  # (the dirname of $[0] is not the place where we might find the
+  # original and so on.  Autoconf is especially sensitive to this).
+  . "./$as_me.lineno"
+  # Exit status is that of the last command.
+  exit
+}
+
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+  case `echo 'xy\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  xy)  ECHO_C='\c';;
+  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
+       ECHO_T='	';;
+  esac;;
+*)
+  ECHO_N='-n';;
+esac
+
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
+else
+  rm -f conf$$.dir
+  mkdir conf$$.dir 2>/dev/null
+fi
+if (echo >conf$$.file) 2>/dev/null; then
+  if ln -s conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s='ln -s'
+    # ... but there are two gotchas:
+    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+    # In both cases, we have to default to `cp -pR'.
+    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+      as_ln_s='cp -pR'
+  elif ln conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s=ln
+  else
+    as_ln_s='cp -pR'
+  fi
+else
+  as_ln_s='cp -pR'
+fi
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p='mkdir -p "$as_dir"'
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+
+test -n "$DJDIR" || exec 7<&0 </dev/null
+exec 6>&1
+
+# Name of the host.
+# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
+# so uname gets run too.
+ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
+
+#
+# Initializations.
+#
+ac_default_prefix=/usr/local
+ac_clean_files=
+ac_config_libobj_dir=.
+LIBOBJS=
+cross_compiling=no
+subdirs=
+MFLAGS=
+MAKEFLAGS=
+
+# Identity of this package.
+PACKAGE_NAME='jq'
+PACKAGE_TARNAME='jq'
+PACKAGE_VERSION='1.2'
+PACKAGE_STRING='jq 1.2'
+PACKAGE_BUGREPORT='mu@netsoc.tcd.ie'
+PACKAGE_URL='http://stedolan.github.com/jq/'
+
+ac_subst_vars='am__EXEEXT_FALSE
+am__EXEEXT_TRUE
+LTLIBOBJS
+LIBOBJS
+valgrind_cmd
+bison_cmd
+flex_cmd
+YFLAGS
+YACC
+CPP
+am__fastdepCC_FALSE
+am__fastdepCC_TRUE
+CCDEPMODE
+am__nodep
+AMDEPBACKSLASH
+AMDEP_FALSE
+AMDEP_TRUE
+am__quote
+am__include
+DEPDIR
+OBJEXT
+EXEEXT
+ac_ct_CC
+CPPFLAGS
+LDFLAGS
+CFLAGS
+CC
+AM_BACKSLASH
+AM_DEFAULT_VERBOSITY
+AM_DEFAULT_V
+AM_V
+am__untar
+am__tar
+AMTAR
+am__leading_dot
+SET_MAKE
+AWK
+mkdir_p
+MKDIR_P
+INSTALL_STRIP_PROGRAM
+STRIP
+install_sh
+MAKEINFO
+AUTOHEADER
+AUTOMAKE
+AUTOCONF
+ACLOCAL
+VERSION
+PACKAGE
+CYGPATH_W
+am__isrc
+INSTALL_DATA
+INSTALL_SCRIPT
+INSTALL_PROGRAM
+target_alias
+host_alias
+build_alias
+LIBS
+ECHO_T
+ECHO_N
+ECHO_C
+DEFS
+mandir
+localedir
+libdir
+psdir
+pdfdir
+dvidir
+htmldir
+infodir
+docdir
+oldincludedir
+includedir
+localstatedir
+sharedstatedir
+sysconfdir
+datadir
+datarootdir
+libexecdir
+sbindir
+bindir
+program_transform_name
+prefix
+exec_prefix
+PACKAGE_URL
+PACKAGE_BUGREPORT
+PACKAGE_STRING
+PACKAGE_VERSION
+PACKAGE_TARNAME
+PACKAGE_NAME
+PATH_SEPARATOR
+SHELL'
+ac_subst_files=''
+ac_user_opts='
+enable_option_checking
+enable_silent_rules
+enable_dependency_tracking
+'
+      ac_precious_vars='build_alias
+host_alias
+target_alias
+CC
+CFLAGS
+LDFLAGS
+LIBS
+CPPFLAGS
+CPP
+YACC
+YFLAGS'
+
+
+# Initialize some variables set by options.
+ac_init_help=
+ac_init_version=false
+ac_unrecognized_opts=
+ac_unrecognized_sep=
+# The variables have the same names as the options, with
+# dashes changed to underlines.
+cache_file=/dev/null
+exec_prefix=NONE
+no_create=
+no_recursion=
+prefix=NONE
+program_prefix=NONE
+program_suffix=NONE
+program_transform_name=s,x,x,
+silent=
+site=
+srcdir=
+verbose=
+x_includes=NONE
+x_libraries=NONE
+
+# Installation directory options.
+# These are left unexpanded so users can "make install exec_prefix=/foo"
+# and all the variables that are supposed to be based on exec_prefix
+# by default will actually change.
+# Use braces instead of parens because sh, perl, etc. also accept them.
+# (The list follows the same order as the GNU Coding Standards.)
+bindir='${exec_prefix}/bin'
+sbindir='${exec_prefix}/sbin'
+libexecdir='${exec_prefix}/libexec'
+datarootdir='${prefix}/share'
+datadir='${datarootdir}'
+sysconfdir='${prefix}/etc'
+sharedstatedir='${prefix}/com'
+localstatedir='${prefix}/var'
+includedir='${prefix}/include'
+oldincludedir='/usr/include'
+docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
+infodir='${datarootdir}/info'
+htmldir='${docdir}'
+dvidir='${docdir}'
+pdfdir='${docdir}'
+psdir='${docdir}'
+libdir='${exec_prefix}/lib'
+localedir='${datarootdir}/locale'
+mandir='${datarootdir}/man'
+
+ac_prev=
+ac_dashdash=
+for ac_option
+do
+  # If the previous option needs an argument, assign it.
+  if test -n "$ac_prev"; then
+    eval $ac_prev=\$ac_option
+    ac_prev=
+    continue
+  fi
+
+  case $ac_option in
+  *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
+  *=)   ac_optarg= ;;
+  *)    ac_optarg=yes ;;
+  esac
+
+  # Accept the important Cygnus configure options, so we can diagnose typos.
+
+  case $ac_dashdash$ac_option in
+  --)
+    ac_dashdash=yes ;;
+
+  -bindir | --bindir | --bindi | --bind | --bin | --bi)
+    ac_prev=bindir ;;
+  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
+    bindir=$ac_optarg ;;
+
+  -build | --build | --buil | --bui | --bu)
+    ac_prev=build_alias ;;
+  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
+    build_alias=$ac_optarg ;;
+
+  -cache-file | --cache-file | --cache-fil | --cache-fi \
+  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
+    ac_prev=cache_file ;;
+  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
+  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
+    cache_file=$ac_optarg ;;
+
+  --config-cache | -C)
+    cache_file=config.cache ;;
+
+  -datadir | --datadir | --datadi | --datad)
+    ac_prev=datadir ;;
+  -datadir=* | --datadir=* | --datadi=* | --datad=*)
+    datadir=$ac_optarg ;;
+
+  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
+  | --dataroo | --dataro | --datar)
+    ac_prev=datarootdir ;;
+  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
+  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
+    datarootdir=$ac_optarg ;;
+
+  -disable-* | --disable-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid feature name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"enable_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval enable_$ac_useropt=no ;;
+
+  -docdir | --docdir | --docdi | --doc | --do)
+    ac_prev=docdir ;;
+  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
+    docdir=$ac_optarg ;;
+
+  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
+    ac_prev=dvidir ;;
+  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
+    dvidir=$ac_optarg ;;
+
+  -enable-* | --enable-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid feature name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"enable_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval enable_$ac_useropt=\$ac_optarg ;;
+
+  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
+  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
+  | --exec | --exe | --ex)
+    ac_prev=exec_prefix ;;
+  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
+  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
+  | --exec=* | --exe=* | --ex=*)
+    exec_prefix=$ac_optarg ;;
+
+  -gas | --gas | --ga | --g)
+    # Obsolete; use --with-gas.
+    with_gas=yes ;;
+
+  -help | --help | --hel | --he | -h)
+    ac_init_help=long ;;
+  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
+    ac_init_help=recursive ;;
+  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
+    ac_init_help=short ;;
+
+  -host | --host | --hos | --ho)
+    ac_prev=host_alias ;;
+  -host=* | --host=* | --hos=* | --ho=*)
+    host_alias=$ac_optarg ;;
+
+  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
+    ac_prev=htmldir ;;
+  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
+  | --ht=*)
+    htmldir=$ac_optarg ;;
+
+  -includedir | --includedir | --includedi | --included | --include \
+  | --includ | --inclu | --incl | --inc)
+    ac_prev=includedir ;;
+  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
+  | --includ=* | --inclu=* | --incl=* | --inc=*)
+    includedir=$ac_optarg ;;
+
+  -infodir | --infodir | --infodi | --infod | --info | --inf)
+    ac_prev=infodir ;;
+  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
+    infodir=$ac_optarg ;;
+
+  -libdir | --libdir | --libdi | --libd)
+    ac_prev=libdir ;;
+  -libdir=* | --libdir=* | --libdi=* | --libd=*)
+    libdir=$ac_optarg ;;
+
+  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
+  | --libexe | --libex | --libe)
+    ac_prev=libexecdir ;;
+  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
+  | --libexe=* | --libex=* | --libe=*)
+    libexecdir=$ac_optarg ;;
+
+  -localedir | --localedir | --localedi | --localed | --locale)
+    ac_prev=localedir ;;
+  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
+    localedir=$ac_optarg ;;
+
+  -localstatedir | --localstatedir | --localstatedi | --localstated \
+  | --localstate | --localstat | --localsta | --localst | --locals)
+    ac_prev=localstatedir ;;
+  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
+  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
+    localstatedir=$ac_optarg ;;
+
+  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
+    ac_prev=mandir ;;
+  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
+    mandir=$ac_optarg ;;
+
+  -nfp | --nfp | --nf)
+    # Obsolete; use --without-fp.
+    with_fp=no ;;
+
+  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
+  | --no-cr | --no-c | -n)
+    no_create=yes ;;
+
+  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
+  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
+    no_recursion=yes ;;
+
+  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
+  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
+  | --oldin | --oldi | --old | --ol | --o)
+    ac_prev=oldincludedir ;;
+  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
+  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
+  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
+    oldincludedir=$ac_optarg ;;
+
+  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
+    ac_prev=prefix ;;
+  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
+    prefix=$ac_optarg ;;
+
+  -program-prefix | --program-prefix | --program-prefi | --program-pref \
+  | --program-pre | --program-pr | --program-p)
+    ac_prev=program_prefix ;;
+  -program-prefix=* | --program-prefix=* | --program-prefi=* \
+  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
+    program_prefix=$ac_optarg ;;
+
+  -program-suffix | --program-suffix | --program-suffi | --program-suff \
+  | --program-suf | --program-su | --program-s)
+    ac_prev=program_suffix ;;
+  -program-suffix=* | --program-suffix=* | --program-suffi=* \
+  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
+    program_suffix=$ac_optarg ;;
+
+  -program-transform-name | --program-transform-name \
+  | --program-transform-nam | --program-transform-na \
+  | --program-transform-n | --program-transform- \
+  | --program-transform | --program-transfor \
+  | --program-transfo | --program-transf \
+  | --program-trans | --program-tran \
+  | --progr-tra | --program-tr | --program-t)
+    ac_prev=program_transform_name ;;
+  -program-transform-name=* | --program-transform-name=* \
+  | --program-transform-nam=* | --program-transform-na=* \
+  | --program-transform-n=* | --program-transform-=* \
+  | --program-transform=* | --program-transfor=* \
+  | --program-transfo=* | --program-transf=* \
+  | --program-trans=* | --program-tran=* \
+  | --progr-tra=* | --program-tr=* | --program-t=*)
+    program_transform_name=$ac_optarg ;;
+
+  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
+    ac_prev=pdfdir ;;
+  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
+    pdfdir=$ac_optarg ;;
+
+  -psdir | --psdir | --psdi | --psd | --ps)
+    ac_prev=psdir ;;
+  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
+    psdir=$ac_optarg ;;
+
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil)
+    silent=yes ;;
+
+  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
+    ac_prev=sbindir ;;
+  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
+  | --sbi=* | --sb=*)
+    sbindir=$ac_optarg ;;
+
+  -sharedstatedir | --sharedstatedir | --sharedstatedi \
+  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
+  | --sharedst | --shareds | --shared | --share | --shar \
+  | --sha | --sh)
+    ac_prev=sharedstatedir ;;
+  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
+  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
+  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
+  | --sha=* | --sh=*)
+    sharedstatedir=$ac_optarg ;;
+
+  -site | --site | --sit)
+    ac_prev=site ;;
+  -site=* | --site=* | --sit=*)
+    site=$ac_optarg ;;
+
+  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
+    ac_prev=srcdir ;;
+  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
+    srcdir=$ac_optarg ;;
+
+  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
+  | --syscon | --sysco | --sysc | --sys | --sy)
+    ac_prev=sysconfdir ;;
+  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
+  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
+    sysconfdir=$ac_optarg ;;
+
+  -target | --target | --targe | --targ | --tar | --ta | --t)
+    ac_prev=target_alias ;;
+  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
+    target_alias=$ac_optarg ;;
+
+  -v | -verbose | --verbose | --verbos | --verbo | --verb)
+    verbose=yes ;;
+
+  -version | --version | --versio | --versi | --vers | -V)
+    ac_init_version=: ;;
+
+  -with-* | --with-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid package name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"with_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval with_$ac_useropt=\$ac_optarg ;;
+
+  -without-* | --without-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid package name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"with_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval with_$ac_useropt=no ;;
+
+  --x)
+    # Obsolete; use --with-x.
+    with_x=yes ;;
+
+  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
+  | --x-incl | --x-inc | --x-in | --x-i)
+    ac_prev=x_includes ;;
+  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
+  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
+    x_includes=$ac_optarg ;;
+
+  -x-libraries | --x-libraries | --x-librarie | --x-librari \
+  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
+    ac_prev=x_libraries ;;
+  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
+  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
+    x_libraries=$ac_optarg ;;
+
+  -*) as_fn_error $? "unrecognized option: \`$ac_option'
+Try \`$0 --help' for more information"
+    ;;
+
+  *=*)
+    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
+    # Reject names that are not valid shell variable names.
+    case $ac_envvar in #(
+      '' | [0-9]* | *[!_$as_cr_alnum]* )
+      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
+    esac
+    eval $ac_envvar=\$ac_optarg
+    export $ac_envvar ;;
+
+  *)
+    # FIXME: should be removed in autoconf 3.0.
+    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
+    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
+    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
+    ;;
+
+  esac
+done
+
+if test -n "$ac_prev"; then
+  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
+  as_fn_error $? "missing argument to $ac_option"
+fi
+
+if test -n "$ac_unrecognized_opts"; then
+  case $enable_option_checking in
+    no) ;;
+    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
+    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
+  esac
+fi
+
+# Check all directory arguments for consistency.
+for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
+		datadir sysconfdir sharedstatedir localstatedir includedir \
+		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
+		libdir localedir mandir
+do
+  eval ac_val=\$$ac_var
+  # Remove trailing slashes.
+  case $ac_val in
+    */ )
+      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
+      eval $ac_var=\$ac_val;;
+  esac
+  # Be sure to have absolute directory names.
+  case $ac_val in
+    [\\/$]* | ?:[\\/]* )  continue;;
+    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
+  esac
+  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
+done
+
+# There might be people who depend on the old broken behavior: `$host'
+# used to hold the argument of --host etc.
+# FIXME: To remove some day.
+build=$build_alias
+host=$host_alias
+target=$target_alias
+
+# FIXME: To remove some day.
+if test "x$host_alias" != x; then
+  if test "x$build_alias" = x; then
+    cross_compiling=maybe
+  elif test "x$build_alias" != "x$host_alias"; then
+    cross_compiling=yes
+  fi
+fi
+
+ac_tool_prefix=
+test -n "$host_alias" && ac_tool_prefix=$host_alias-
+
+test "$silent" = yes && exec 6>/dev/null
+
+
+ac_pwd=`pwd` && test -n "$ac_pwd" &&
+ac_ls_di=`ls -di .` &&
+ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
+  as_fn_error $? "working directory cannot be determined"
+test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
+  as_fn_error $? "pwd does not report name of working directory"
+
+
+# Find the source files, if location was not specified.
+if test -z "$srcdir"; then
+  ac_srcdir_defaulted=yes
+  # Try the directory containing this script, then the parent directory.
+  ac_confdir=`$as_dirname -- "$as_myself" ||
+$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_myself" : 'X\(//\)[^/]' \| \
+	 X"$as_myself" : 'X\(//\)$' \| \
+	 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_myself" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  srcdir=$ac_confdir
+  if test ! -r "$srcdir/$ac_unique_file"; then
+    srcdir=..
+  fi
+else
+  ac_srcdir_defaulted=no
+fi
+if test ! -r "$srcdir/$ac_unique_file"; then
+  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
+  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
+fi
+ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
+ac_abs_confdir=`(
+	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
+	pwd)`
+# When building in place, set srcdir=.
+if test "$ac_abs_confdir" = "$ac_pwd"; then
+  srcdir=.
+fi
+# Remove unnecessary trailing slashes from srcdir.
+# Double slashes in file names in object file debugging info
+# mess up M-x gdb in Emacs.
+case $srcdir in
+*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
+esac
+for ac_var in $ac_precious_vars; do
+  eval ac_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_env_${ac_var}_value=\$${ac_var}
+  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_cv_env_${ac_var}_value=\$${ac_var}
+done
+
+#
+# Report the --help message.
+#
+if test "$ac_init_help" = "long"; then
+  # Omit some internal or obsolete options to make the list less imposing.
+  # This message is too long to be a string in the A/UX 3.1 sh.
+  cat <<_ACEOF
+\`configure' configures jq 1.2 to adapt to many kinds of systems.
+
+Usage: $0 [OPTION]... [VAR=VALUE]...
+
+To assign environment variables (e.g., CC, CFLAGS...), specify them as
+VAR=VALUE.  See below for descriptions of some of the useful variables.
+
+Defaults for the options are specified in brackets.
+
+Configuration:
+  -h, --help              display this help and exit
+      --help=short        display options specific to this package
+      --help=recursive    display the short help of all the included packages
+  -V, --version           display version information and exit
+  -q, --quiet, --silent   do not print \`checking ...' messages
+      --cache-file=FILE   cache test results in FILE [disabled]
+  -C, --config-cache      alias for \`--cache-file=config.cache'
+  -n, --no-create         do not create output files
+      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
+
+Installation directories:
+  --prefix=PREFIX         install architecture-independent files in PREFIX
+                          [$ac_default_prefix]
+  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
+                          [PREFIX]
+
+By default, \`make install' will install all the files in
+\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
+an installation prefix other than \`$ac_default_prefix' using \`--prefix',
+for instance \`--prefix=\$HOME'.
+
+For better control, use the options below.
+
+Fine tuning of the installation directories:
+  --bindir=DIR            user executables [EPREFIX/bin]
+  --sbindir=DIR           system admin executables [EPREFIX/sbin]
+  --libexecdir=DIR        program executables [EPREFIX/libexec]
+  --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
+  --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
+  --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
+  --libdir=DIR            object code libraries [EPREFIX/lib]
+  --includedir=DIR        C header files [PREFIX/include]
+  --oldincludedir=DIR     C header files for non-gcc [/usr/include]
+  --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
+  --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
+  --infodir=DIR           info documentation [DATAROOTDIR/info]
+  --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
+  --mandir=DIR            man documentation [DATAROOTDIR/man]
+  --docdir=DIR            documentation root [DATAROOTDIR/doc/jq]
+  --htmldir=DIR           html documentation [DOCDIR]
+  --dvidir=DIR            dvi documentation [DOCDIR]
+  --pdfdir=DIR            pdf documentation [DOCDIR]
+  --psdir=DIR             ps documentation [DOCDIR]
+_ACEOF
+
+  cat <<\_ACEOF
+
+Program names:
+  --program-prefix=PREFIX            prepend PREFIX to installed program names
+  --program-suffix=SUFFIX            append SUFFIX to installed program names
+  --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
+_ACEOF
+fi
+
+if test -n "$ac_init_help"; then
+  case $ac_init_help in
+     short | recursive ) echo "Configuration of jq 1.2:";;
+   esac
+  cat <<\_ACEOF
+
+Optional Features:
+  --disable-option-checking  ignore unrecognized --enable/--with options
+  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
+  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
+  --enable-silent-rules          less verbose build output (undo: `make V=1')
+  --disable-silent-rules         verbose build output (undo: `make V=0')
+  --disable-dependency-tracking  speeds up one-time build
+  --enable-dependency-tracking   do not reject slow dependency extractors
+
+Some influential environment variables:
+  CC          C compiler command
+  CFLAGS      C compiler flags
+  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
+              nonstandard directory <lib dir>
+  LIBS        libraries to pass to the linker, e.g. -l<library>
+  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
+              you have headers in a nonstandard directory <include dir>
+  CPP         C preprocessor
+  YACC        The `Yet Another Compiler Compiler' implementation to use.
+              Defaults to the first program found out of: `bison -y', `byacc',
+              `yacc'.
+  YFLAGS      The list of arguments that will be passed by default to $YACC.
+              This script will default YFLAGS to the empty string to avoid a
+              default value of `-d' given by some make applications.
+
+Use these variables to override the choices made by `configure' or to help
+it to find libraries and programs with nonstandard names/locations.
+
+Report bugs to <mu@netsoc.tcd.ie>.
+jq home page: <http://stedolan.github.com/jq/>.
+_ACEOF
+ac_status=$?
+fi
+
+if test "$ac_init_help" = "recursive"; then
+  # If there are subdirs, report their specific --help.
+  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
+    test -d "$ac_dir" ||
+      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
+      continue
+    ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  [\\/]* | ?:[\\/]* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+    cd "$ac_dir" || { ac_status=$?; continue; }
+    # Check for guested configure.
+    if test -f "$ac_srcdir/configure.gnu"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
+    elif test -f "$ac_srcdir/configure"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure" --help=recursive
+    else
+      $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+    fi || ac_status=$?
+    cd "$ac_pwd" || { ac_status=$?; break; }
+  done
+fi
+
+test -n "$ac_init_help" && exit $ac_status
+if $ac_init_version; then
+  cat <<\_ACEOF
+jq configure 1.2
+generated by GNU Autoconf 2.69
+
+Copyright (C) 2012 Free Software Foundation, Inc.
+This configure script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it.
+_ACEOF
+  exit
+fi
+
+## ------------------------ ##
+## Autoconf initialization. ##
+## ------------------------ ##
+
+# ac_fn_c_try_compile LINENO
+# --------------------------
+# Try to compile conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext
+  if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_compile
+
+# ac_fn_c_try_cpp LINENO
+# ----------------------
+# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_cpp ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_cpp conftest.$ac_ext"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } > conftest.i && {
+	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+    ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_cpp
+cat >config.log <<_ACEOF
+This file contains any messages produced by compilers while
+running configure, to aid debugging if configure makes a mistake.
+
+It was created by jq $as_me 1.2, which was
+generated by GNU Autoconf 2.69.  Invocation command line was
+
+  $ $0 $@
+
+_ACEOF
+exec 5>>config.log
+{
+cat <<_ASUNAME
+## --------- ##
+## Platform. ##
+## --------- ##
+
+hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
+
+/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
+/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
+/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
+/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
+
+_ASUNAME
+
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    $as_echo "PATH: $as_dir"
+  done
+IFS=$as_save_IFS
+
+} >&5
+
+cat >&5 <<_ACEOF
+
+
+## ----------- ##
+## Core tests. ##
+## ----------- ##
+
+_ACEOF
+
+
+# Keep a trace of the command line.
+# Strip out --no-create and --no-recursion so they do not pile up.
+# Strip out --silent because we don't want to record it for future runs.
+# Also quote any args containing shell meta-characters.
+# Make two passes to allow for proper duplicate-argument suppression.
+ac_configure_args=
+ac_configure_args0=
+ac_configure_args1=
+ac_must_keep_next=false
+for ac_pass in 1 2
+do
+  for ac_arg
+  do
+    case $ac_arg in
+    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
+    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+    | -silent | --silent | --silen | --sile | --sil)
+      continue ;;
+    *\'*)
+      ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    esac
+    case $ac_pass in
+    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
+    2)
+      as_fn_append ac_configure_args1 " '$ac_arg'"
+      if test $ac_must_keep_next = true; then
+	ac_must_keep_next=false # Got value, back to normal.
+      else
+	case $ac_arg in
+	  *=* | --config-cache | -C | -disable-* | --disable-* \
+	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
+	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
+	  | -with-* | --with-* | -without-* | --without-* | --x)
+	    case "$ac_configure_args0 " in
+	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
+	    esac
+	    ;;
+	  -* ) ac_must_keep_next=true ;;
+	esac
+      fi
+      as_fn_append ac_configure_args " '$ac_arg'"
+      ;;
+    esac
+  done
+done
+{ ac_configure_args0=; unset ac_configure_args0;}
+{ ac_configure_args1=; unset ac_configure_args1;}
+
+# When interrupted or exit'd, cleanup temporary files, and complete
+# config.log.  We remove comments because anyway the quotes in there
+# would cause problems or look ugly.
+# WARNING: Use '\'' to represent an apostrophe within the trap.
+# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
+trap 'exit_status=$?
+  # Save into config.log some information that might help in debugging.
+  {
+    echo
+
+    $as_echo "## ---------------- ##
+## Cache variables. ##
+## ---------------- ##"
+    echo
+    # The following way of writing the cache mishandles newlines in values,
+(
+  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+      *) { eval $ac_var=; unset $ac_var;} ;;
+      esac ;;
+    esac
+  done
+  (set) 2>&1 |
+    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
+      sed -n \
+	"s/'\''/'\''\\\\'\'''\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
+      ;; #(
+    *)
+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+      ;;
+    esac |
+    sort
+)
+    echo
+
+    $as_echo "## ----------------- ##
+## Output variables. ##
+## ----------------- ##"
+    echo
+    for ac_var in $ac_subst_vars
+    do
+      eval ac_val=\$$ac_var
+      case $ac_val in
+      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+      esac
+      $as_echo "$ac_var='\''$ac_val'\''"
+    done | sort
+    echo
+
+    if test -n "$ac_subst_files"; then
+      $as_echo "## ------------------- ##
+## File substitutions. ##
+## ------------------- ##"
+      echo
+      for ac_var in $ac_subst_files
+      do
+	eval ac_val=\$$ac_var
+	case $ac_val in
+	*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+	esac
+	$as_echo "$ac_var='\''$ac_val'\''"
+      done | sort
+      echo
+    fi
+
+    if test -s confdefs.h; then
+      $as_echo "## ----------- ##
+## confdefs.h. ##
+## ----------- ##"
+      echo
+      cat confdefs.h
+      echo
+    fi
+    test "$ac_signal" != 0 &&
+      $as_echo "$as_me: caught signal $ac_signal"
+    $as_echo "$as_me: exit $exit_status"
+  } >&5
+  rm -f core *.core core.conftest.* &&
+    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
+    exit $exit_status
+' 0
+for ac_signal in 1 2 13 15; do
+  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
+done
+ac_signal=0
+
+# confdefs.h avoids OS command line length limits that DEFS can exceed.
+rm -f -r conftest* confdefs.h
+
+$as_echo "/* confdefs.h */" > confdefs.h
+
+# Predefined preprocessor variables.
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_NAME "$PACKAGE_NAME"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_VERSION "$PACKAGE_VERSION"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_STRING "$PACKAGE_STRING"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_URL "$PACKAGE_URL"
+_ACEOF
+
+
+# Let the site file select an alternate cache file if it wants to.
+# Prefer an explicitly selected file to automatically selected ones.
+ac_site_file1=NONE
+ac_site_file2=NONE
+if test -n "$CONFIG_SITE"; then
+  # We do not want a PATH search for config.site.
+  case $CONFIG_SITE in #((
+    -*)  ac_site_file1=./$CONFIG_SITE;;
+    */*) ac_site_file1=$CONFIG_SITE;;
+    *)   ac_site_file1=./$CONFIG_SITE;;
+  esac
+elif test "x$prefix" != xNONE; then
+  ac_site_file1=$prefix/share/config.site
+  ac_site_file2=$prefix/etc/config.site
+else
+  ac_site_file1=$ac_default_prefix/share/config.site
+  ac_site_file2=$ac_default_prefix/etc/config.site
+fi
+for ac_site_file in "$ac_site_file1" "$ac_site_file2"
+do
+  test "x$ac_site_file" = xNONE && continue
+  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
+$as_echo "$as_me: loading site script $ac_site_file" >&6;}
+    sed 's/^/| /' "$ac_site_file" >&5
+    . "$ac_site_file" \
+      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "failed to load site script $ac_site_file
+See \`config.log' for more details" "$LINENO" 5; }
+  fi
+done
+
+if test -r "$cache_file"; then
+  # Some versions of bash will fail to source /dev/null (special files
+  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
+  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
+$as_echo "$as_me: loading cache $cache_file" >&6;}
+    case $cache_file in
+      [\\/]* | ?:[\\/]* ) . "$cache_file";;
+      *)                      . "./$cache_file";;
+    esac
+  fi
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
+$as_echo "$as_me: creating cache $cache_file" >&6;}
+  >$cache_file
+fi
+
+# Check that the precious variables saved in the cache have kept the same
+# value.
+ac_cache_corrupted=false
+for ac_var in $ac_precious_vars; do
+  eval ac_old_set=\$ac_cv_env_${ac_var}_set
+  eval ac_new_set=\$ac_env_${ac_var}_set
+  eval ac_old_val=\$ac_cv_env_${ac_var}_value
+  eval ac_new_val=\$ac_env_${ac_var}_value
+  case $ac_old_set,$ac_new_set in
+    set,)
+      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,set)
+      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
+$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,);;
+    *)
+      if test "x$ac_old_val" != "x$ac_new_val"; then
+	# differences in whitespace do not lead to failure.
+	ac_old_val_w=`echo x $ac_old_val`
+	ac_new_val_w=`echo x $ac_new_val`
+	if test "$ac_old_val_w" != "$ac_new_val_w"; then
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
+$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
+	  ac_cache_corrupted=:
+	else
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
+$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
+	  eval $ac_var=\$ac_old_val
+	fi
+	{ $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
+$as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
+	{ $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
+$as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
+      fi;;
+  esac
+  # Pass precious variables to config.status.
+  if test "$ac_new_set" = set; then
+    case $ac_new_val in
+    *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+    *) ac_arg=$ac_var=$ac_new_val ;;
+    esac
+    case " $ac_configure_args " in
+      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
+      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
+    esac
+  fi
+done
+if $ac_cache_corrupted; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
+$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
+  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
+fi
+## -------------------- ##
+## Main body of script. ##
+## -------------------- ##
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
+
+ac_aux_dir=
+for ac_dir in config "$srcdir"/config; do
+  if test -f "$ac_dir/install-sh"; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/install-sh -c"
+    break
+  elif test -f "$ac_dir/install.sh"; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/install.sh -c"
+    break
+  elif test -f "$ac_dir/shtool"; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/shtool install -c"
+    break
+  fi
+done
+if test -z "$ac_aux_dir"; then
+  as_fn_error $? "cannot find install-sh, install.sh, or shtool in config \"$srcdir\"/config" "$LINENO" 5
+fi
+
+# These three variables are undocumented and unsupported,
+# and are intended to be withdrawn in a future Autoconf release.
+# They can cause serious problems if a builder's source tree is in a directory
+# whose full name contains unusual characters.
+ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
+ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
+ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
+
+
+am__api_version='1.11'
+
+# Find a good install program.  We prefer a C program (faster),
+# so one script is as good as another.  But avoid the broken or
+# incompatible versions:
+# SysV /etc/install, /usr/sbin/install
+# SunOS /usr/etc/install
+# IRIX /sbin/install
+# AIX /bin/install
+# AmigaOS /C/install, which installs bootblocks on floppy discs
+# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
+# AFS /usr/afsws/bin/install, which mishandles nonexistent args
+# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+# OS/2's system install, which has a completely different semantic
+# ./install, which can be erroneously created by make from ./install.sh.
+# Reject install programs that cannot install multiple files.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
+$as_echo_n "checking for a BSD-compatible install... " >&6; }
+if test -z "$INSTALL"; then
+if ${ac_cv_path_install+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    # Account for people who put trailing slashes in PATH elements.
+case $as_dir/ in #((
+  ./ | .// | /[cC]/* | \
+  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
+  ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
+  /usr/ucb/* ) ;;
+  *)
+    # OSF1 and SCO ODT 3.0 have their own names for install.
+    # Don't use installbsd from OSF since it installs stuff as root
+    # by default.
+    for ac_prog in ginstall scoinst install; do
+      for ac_exec_ext in '' $ac_executable_extensions; do
+	if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
+	  if test $ac_prog = install &&
+	    grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+	    # AIX install.  It has an incompatible calling convention.
+	    :
+	  elif test $ac_prog = install &&
+	    grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+	    # program-specific install script used by HP pwplus--don't use.
+	    :
+	  else
+	    rm -rf conftest.one conftest.two conftest.dir
+	    echo one > conftest.one
+	    echo two > conftest.two
+	    mkdir conftest.dir
+	    if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
+	      test -s conftest.one && test -s conftest.two &&
+	      test -s conftest.dir/conftest.one &&
+	      test -s conftest.dir/conftest.two
+	    then
+	      ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
+	      break 3
+	    fi
+	  fi
+	fi
+      done
+    done
+    ;;
+esac
+
+  done
+IFS=$as_save_IFS
+
+rm -rf conftest.one conftest.two conftest.dir
+
+fi
+  if test "${ac_cv_path_install+set}" = set; then
+    INSTALL=$ac_cv_path_install
+  else
+    # As a last resort, use the slow shell script.  Don't cache a
+    # value for INSTALL within a source directory, because that will
+    # break other packages using the cache if that directory is
+    # removed, or if the value is a relative name.
+    INSTALL=$ac_install_sh
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
+$as_echo "$INSTALL" >&6; }
+
+# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+# It thinks the first close brace ends the variable substitution.
+test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
+
+test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
+
+test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5
+$as_echo_n "checking whether build environment is sane... " >&6; }
+# Just in case
+sleep 1
+echo timestamp > conftest.file
+# Reject unsafe characters in $srcdir or the absolute working directory
+# name.  Accept space and tab only in the latter.
+am_lf='
+'
+case `pwd` in
+  *[\\\"\#\$\&\'\`$am_lf]*)
+    as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;;
+esac
+case $srcdir in
+  *[\\\"\#\$\&\'\`$am_lf\ \	]*)
+    as_fn_error $? "unsafe srcdir value: \`$srcdir'" "$LINENO" 5;;
+esac
+
+# Do `set' in a subshell so we don't clobber the current shell's
+# arguments.  Must try -L first in case configure is actually a
+# symlink; some systems play weird games with the mod time of symlinks
+# (eg FreeBSD returns the mod time of the symlink's containing
+# directory).
+if (
+   set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
+   if test "$*" = "X"; then
+      # -L didn't work.
+      set X `ls -t "$srcdir/configure" conftest.file`
+   fi
+   rm -f conftest.file
+   if test "$*" != "X $srcdir/configure conftest.file" \
+      && test "$*" != "X conftest.file $srcdir/configure"; then
+
+      # If neither matched, then we have a broken ls.  This can happen
+      # if, for instance, CONFIG_SHELL is bash and it inherits a
+      # broken ls alias from the environment.  This has actually
+      # happened.  Such a system could not be considered "sane".
+      as_fn_error $? "ls -t appears to fail.  Make sure there is not a broken
+alias in your environment" "$LINENO" 5
+   fi
+
+   test "$2" = conftest.file
+   )
+then
+   # Ok.
+   :
+else
+   as_fn_error $? "newly created file is older than distributed files!
+Check your system clock" "$LINENO" 5
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+test "$program_prefix" != NONE &&
+  program_transform_name="s&^&$program_prefix&;$program_transform_name"
+# Use a double $ so make ignores it.
+test "$program_suffix" != NONE &&
+  program_transform_name="s&\$&$program_suffix&;$program_transform_name"
+# Double any \ or $.
+# By default was `s,x,x', remove it if useless.
+ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
+program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"`
+
+# expand $ac_aux_dir to an absolute path
+am_aux_dir=`cd $ac_aux_dir && pwd`
+
+if test x"${MISSING+set}" != xset; then
+  case $am_aux_dir in
+  *\ * | *\	*)
+    MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;;
+  *)
+    MISSING="\${SHELL} $am_aux_dir/missing" ;;
+  esac
+fi
+# Use eval to expand $SHELL
+if eval "$MISSING --run true"; then
+  am_missing_run="$MISSING --run "
+else
+  am_missing_run=
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`missing' script is too old or missing" >&5
+$as_echo "$as_me: WARNING: \`missing' script is too old or missing" >&2;}
+fi
+
+if test x"${install_sh}" != xset; then
+  case $am_aux_dir in
+  *\ * | *\	*)
+    install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
+  *)
+    install_sh="\${SHELL} $am_aux_dir/install-sh"
+  esac
+fi
+
+# Installed binaries are usually stripped using `strip' when the user
+# run `make install-strip'.  However `strip' might not be the right
+# tool to use in cross-compilation environments, therefore Automake
+# will honor the `STRIP' environment variable to overrule this program.
+if test "$cross_compiling" != no; then
+  if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+set dummy ${ac_tool_prefix}strip; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_STRIP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$STRIP"; then
+  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+STRIP=$ac_cv_prog_STRIP
+if test -n "$STRIP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
+$as_echo "$STRIP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_STRIP"; then
+  ac_ct_STRIP=$STRIP
+  # Extract the first word of "strip", so it can be a program name with args.
+set dummy strip; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_STRIP"; then
+  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_STRIP="strip"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+if test -n "$ac_ct_STRIP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
+$as_echo "$ac_ct_STRIP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_STRIP" = x; then
+    STRIP=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    STRIP=$ac_ct_STRIP
+  fi
+else
+  STRIP="$ac_cv_prog_STRIP"
+fi
+
+fi
+INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a thread-safe mkdir -p" >&5
+$as_echo_n "checking for a thread-safe mkdir -p... " >&6; }
+if test -z "$MKDIR_P"; then
+  if ${ac_cv_path_mkdir+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in mkdir gmkdir; do
+	 for ac_exec_ext in '' $ac_executable_extensions; do
+	   as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext" || continue
+	   case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #(
+	     'mkdir (GNU coreutils) '* | \
+	     'mkdir (coreutils) '* | \
+	     'mkdir (fileutils) '4.1*)
+	       ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext
+	       break 3;;
+	   esac
+	 done
+       done
+  done
+IFS=$as_save_IFS
+
+fi
+
+  test -d ./--version && rmdir ./--version
+  if test "${ac_cv_path_mkdir+set}" = set; then
+    MKDIR_P="$ac_cv_path_mkdir -p"
+  else
+    # As a last resort, use the slow shell script.  Don't cache a
+    # value for MKDIR_P within a source directory, because that will
+    # break other packages using the cache if that directory is
+    # removed, or if the value is a relative name.
+    MKDIR_P="$ac_install_sh -d"
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5
+$as_echo "$MKDIR_P" >&6; }
+
+mkdir_p="$MKDIR_P"
+case $mkdir_p in
+  [\\/$]* | ?:[\\/]*) ;;
+  */*) mkdir_p="\$(top_builddir)/$mkdir_p" ;;
+esac
+
+for ac_prog in gawk mawk nawk awk
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_AWK+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$AWK"; then
+  ac_cv_prog_AWK="$AWK" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_AWK="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+AWK=$ac_cv_prog_AWK
+if test -n "$AWK"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
+$as_echo "$AWK" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$AWK" && break
+done
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
+$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
+set x ${MAKE-make}
+ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
+if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat >conftest.make <<\_ACEOF
+SHELL = /bin/sh
+all:
+	@echo '@@@%%%=$(MAKE)=@@@%%%'
+_ACEOF
+# GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
+case `${MAKE-make} -f conftest.make 2>/dev/null` in
+  *@@@%%%=?*=@@@%%%*)
+    eval ac_cv_prog_make_${ac_make}_set=yes;;
+  *)
+    eval ac_cv_prog_make_${ac_make}_set=no;;
+esac
+rm -f conftest.make
+fi
+if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+  SET_MAKE=
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+  SET_MAKE="MAKE=${MAKE-make}"
+fi
+
+rm -rf .tst 2>/dev/null
+mkdir .tst 2>/dev/null
+if test -d .tst; then
+  am__leading_dot=.
+else
+  am__leading_dot=_
+fi
+rmdir .tst 2>/dev/null
+
+if test "`cd $srcdir && pwd`" != "`pwd`"; then
+  # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
+  # is not polluted with repeated "-I."
+  am__isrc=' -I$(srcdir)'
+  # test to see if srcdir already configured
+  if test -f $srcdir/config.status; then
+    as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5
+  fi
+fi
+
+# test whether we have cygpath
+if test -z "$CYGPATH_W"; then
+  if (cygpath --version) >/dev/null 2>/dev/null; then
+    CYGPATH_W='cygpath -w'
+  else
+    CYGPATH_W=echo
+  fi
+fi
+
+
+# Define the identity of the package.
+ PACKAGE='jq'
+ VERSION='1.2'
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE "$PACKAGE"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define VERSION "$VERSION"
+_ACEOF
+
+# Some tools Automake needs.
+
+ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}
+
+
+AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}
+
+
+AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}
+
+
+AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}
+
+
+MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
+
+# We need awk for the "check" target.  The system "awk" is bad on
+# some platforms.
+# Always define AMTAR for backward compatibility.  Yes, it's still used
+# in the wild :-(  We should find a proper way to deprecate it ...
+AMTAR='$${TAR-tar}'
+
+am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'
+
+
+
+
+
+# Check whether --enable-silent-rules was given.
+if test "${enable_silent_rules+set}" = set; then :
+  enableval=$enable_silent_rules;
+fi
+
+case $enable_silent_rules in
+yes) AM_DEFAULT_VERBOSITY=0;;
+no)  AM_DEFAULT_VERBOSITY=1;;
+*)   AM_DEFAULT_VERBOSITY=0;;
+esac
+am_make=${MAKE-make}
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5
+$as_echo_n "checking whether $am_make supports nested variables... " >&6; }
+if ${am_cv_make_support_nested_variables+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if $as_echo 'TRUE=$(BAR$(V))
+BAR0=false
+BAR1=true
+V=1
+am__doit:
+	@$(TRUE)
+.PHONY: am__doit' | $am_make -f - >/dev/null 2>&1; then
+  am_cv_make_support_nested_variables=yes
+else
+  am_cv_make_support_nested_variables=no
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5
+$as_echo "$am_cv_make_support_nested_variables" >&6; }
+if test $am_cv_make_support_nested_variables = yes; then
+    AM_V='$(V)'
+  AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
+else
+  AM_V=$AM_DEFAULT_VERBOSITY
+  AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
+fi
+AM_BACKSLASH='\'
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}gcc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_CC"; then
+  ac_ct_CC=$CC
+  # Extract the first word of "gcc", so it can be a program name with args.
+set dummy gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="gcc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+$as_echo "$ac_ct_CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
+else
+  CC="$ac_cv_prog_CC"
+fi
+
+if test -z "$CC"; then
+          if test -n "$ac_tool_prefix"; then
+    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}cc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  fi
+fi
+if test -z "$CC"; then
+  # Extract the first word of "cc", so it can be a program name with args.
+set dummy cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+  ac_prog_rejected=no
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+       ac_prog_rejected=yes
+       continue
+     fi
+    ac_cv_prog_CC="cc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+if test $ac_prog_rejected = yes; then
+  # We found a bogon in the path, so make sure we never use it.
+  set dummy $ac_cv_prog_CC
+  shift
+  if test $# != 0; then
+    # We chose a different compiler from the bogus one.
+    # However, it has the same basename, so the bogon will be chosen
+    # first if we set CC to just the basename; use the full file name.
+    shift
+    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
+  fi
+fi
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$CC"; then
+  if test -n "$ac_tool_prefix"; then
+  for ac_prog in cl.exe
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+    test -n "$CC" && break
+  done
+fi
+if test -z "$CC"; then
+  ac_ct_CC=$CC
+  for ac_prog in cl.exe
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+$as_echo "$ac_ct_CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$ac_ct_CC" && break
+done
+
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
+fi
+
+fi
+
+
+test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "no acceptable C compiler found in \$PATH
+See \`config.log' for more details" "$LINENO" 5; }
+
+# Provide some information about the compiler.
+$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
+set X $ac_compile
+ac_compiler=$2
+for ac_option in --version -v -V -qversion; do
+  { { ac_try="$ac_compiler $ac_option >&5"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    sed '10a\
+... rest of stderr output deleted ...
+         10q' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+  fi
+  rm -f conftest.er1 conftest.err
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+done
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
+# Try to create an executable without -o first, disregard a.out.
+# It will help us diagnose broken compilers, and finding out an intuition
+# of exeext.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
+$as_echo_n "checking whether the C compiler works... " >&6; }
+ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
+
+# The possible output files:
+ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
+
+ac_rmfiles=
+for ac_file in $ac_files
+do
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
+  esac
+done
+rm -f $ac_rmfiles
+
+if { { ac_try="$ac_link_default"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link_default") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
+# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
+# in a Makefile.  We should not override ac_cv_exeext if it was cached,
+# so that the user can short-circuit this test for compilers unknown to
+# Autoconf.
+for ac_file in $ac_files ''
+do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
+	;;
+    [ab].out )
+	# We found the default executable, but exeext='' is most
+	# certainly right.
+	break;;
+    *.* )
+	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
+	then :; else
+	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	fi
+	# We set ac_cv_exeext here because the later test for it is not
+	# safe: cross compilers may not add the suffix if given an `-o'
+	# argument, so we may need to know it at that point already.
+	# Even if this section looks crufty: it has the advantage of
+	# actually working.
+	break;;
+    * )
+	break;;
+  esac
+done
+test "$ac_cv_exeext" = no && ac_cv_exeext=
+
+else
+  ac_file=''
+fi
+if test -z "$ac_file"; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+$as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error 77 "C compiler cannot create executables
+See \`config.log' for more details" "$LINENO" 5; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
+$as_echo_n "checking for C compiler default output file name... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
+$as_echo "$ac_file" >&6; }
+ac_exeext=$ac_cv_exeext
+
+rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
+ac_clean_files=$ac_clean_files_save
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
+$as_echo_n "checking for suffix of executables... " >&6; }
+if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  # If both `conftest.exe' and `conftest' are `present' (well, observable)
+# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
+# work properly (i.e., refer to `conftest.exe'), while it won't with
+# `rm'.
+for ac_file in conftest.exe conftest conftest.*; do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	  break;;
+    * ) break;;
+  esac
+done
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of executables: cannot compile and link
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+rm -f conftest conftest$ac_cv_exeext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
+$as_echo "$ac_cv_exeext" >&6; }
+
+rm -f conftest.$ac_ext
+EXEEXT=$ac_cv_exeext
+ac_exeext=$EXEEXT
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdio.h>
+int
+main ()
+{
+FILE *f = fopen ("conftest.out", "w");
+ return ferror (f) || fclose (f) != 0;
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files="$ac_clean_files conftest.out"
+# Check that the compiler produces executables we can run.  If not, either
+# the compiler is broken, or we cross compile.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
+$as_echo_n "checking whether we are cross compiling... " >&6; }
+if test "$cross_compiling" != yes; then
+  { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+  if { ac_try='./conftest$ac_cv_exeext'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then
+    cross_compiling=no
+  else
+    if test "$cross_compiling" = maybe; then
+	cross_compiling=yes
+    else
+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot run C compiled programs.
+If you meant to cross compile, use \`--host'.
+See \`config.log' for more details" "$LINENO" 5; }
+    fi
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
+$as_echo "$cross_compiling" >&6; }
+
+rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
+ac_clean_files=$ac_clean_files_save
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
+$as_echo_n "checking for suffix of object files... " >&6; }
+if ${ac_cv_objext+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.o conftest.obj
+if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  for ac_file in conftest.o conftest.obj conftest.*; do
+  test -f "$ac_file" || continue;
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
+    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
+       break;;
+  esac
+done
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of object files: cannot compile
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+rm -f conftest.$ac_cv_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
+$as_echo "$ac_cv_objext" >&6; }
+OBJEXT=$ac_cv_objext
+ac_objext=$OBJEXT
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
+$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
+if ${ac_cv_c_compiler_gnu+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+#ifndef __GNUC__
+       choke me
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_compiler_gnu=yes
+else
+  ac_compiler_gnu=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ac_cv_c_compiler_gnu=$ac_compiler_gnu
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
+$as_echo "$ac_cv_c_compiler_gnu" >&6; }
+if test $ac_compiler_gnu = yes; then
+  GCC=yes
+else
+  GCC=
+fi
+ac_test_CFLAGS=${CFLAGS+set}
+ac_save_CFLAGS=$CFLAGS
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
+$as_echo_n "checking whether $CC accepts -g... " >&6; }
+if ${ac_cv_prog_cc_g+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_save_c_werror_flag=$ac_c_werror_flag
+   ac_c_werror_flag=yes
+   ac_cv_prog_cc_g=no
+   CFLAGS="-g"
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_g=yes
+else
+  CFLAGS=""
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+
+else
+  ac_c_werror_flag=$ac_save_c_werror_flag
+	 CFLAGS="-g"
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_g=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+   ac_c_werror_flag=$ac_save_c_werror_flag
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
+$as_echo "$ac_cv_prog_cc_g" >&6; }
+if test "$ac_test_CFLAGS" = set; then
+  CFLAGS=$ac_save_CFLAGS
+elif test $ac_cv_prog_cc_g = yes; then
+  if test "$GCC" = yes; then
+    CFLAGS="-g -O2"
+  else
+    CFLAGS="-g"
+  fi
+else
+  if test "$GCC" = yes; then
+    CFLAGS="-O2"
+  else
+    CFLAGS=
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
+$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
+if ${ac_cv_prog_cc_c89+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_cv_prog_cc_c89=no
+ac_save_CC=$CC
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdarg.h>
+#include <stdio.h>
+struct stat;
+/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
+struct buf { int x; };
+FILE * (*rcsopen) (struct buf *, struct stat *, int);
+static char *e (p, i)
+     char **p;
+     int i;
+{
+  return p[i];
+}
+static char *f (char * (*g) (char **, int), char **p, ...)
+{
+  char *s;
+  va_list v;
+  va_start (v,p);
+  s = g (p, va_arg (v,int));
+  va_end (v);
+  return s;
+}
+
+/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+   function prototypes and stuff, but not '\xHH' hex character constants.
+   These don't provoke an error unfortunately, instead are silently treated
+   as 'x'.  The following induces an error, until -std is added to get
+   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+   array size at least.  It's necessary to write '\x00'==0 to get something
+   that's true only with -std.  */
+int osf4_cc_array ['\x00' == 0 ? 1 : -1];
+
+/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
+   inside strings and character constants.  */
+#define FOO(x) 'x'
+int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
+
+int test (int i, double x);
+struct s1 {int (*f) (int a);};
+struct s2 {int (*f) (double a);};
+int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
+int argc;
+char **argv;
+int
+main ()
+{
+return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
+  ;
+  return 0;
+}
+_ACEOF
+for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
+	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+do
+  CC="$ac_save_CC $ac_arg"
+  if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_c89=$ac_arg
+fi
+rm -f core conftest.err conftest.$ac_objext
+  test "x$ac_cv_prog_cc_c89" != "xno" && break
+done
+rm -f conftest.$ac_ext
+CC=$ac_save_CC
+
+fi
+# AC_CACHE_VAL
+case "x$ac_cv_prog_cc_c89" in
+  x)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+$as_echo "none needed" >&6; } ;;
+  xno)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+$as_echo "unsupported" >&6; } ;;
+  *)
+    CC="$CC $ac_cv_prog_cc_c89"
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
+$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
+esac
+if test "x$ac_cv_prog_cc_c89" != xno; then :
+
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+DEPDIR="${am__leading_dot}deps"
+
+ac_config_commands="$ac_config_commands depfiles"
+
+
+am_make=${MAKE-make}
+cat > confinc << 'END'
+am__doit:
+	@echo this is the am__doit target
+.PHONY: am__doit
+END
+# If we don't find an include directive, just comment out the code.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5
+$as_echo_n "checking for style of include used by $am_make... " >&6; }
+am__include="#"
+am__quote=
+_am_result=none
+# First try GNU make style include.
+echo "include confinc" > confmf
+# Ignore all kinds of additional output from `make'.
+case `$am_make -s -f confmf 2> /dev/null` in #(
+*the\ am__doit\ target*)
+  am__include=include
+  am__quote=
+  _am_result=GNU
+  ;;
+esac
+# Now try BSD make style include.
+if test "$am__include" = "#"; then
+   echo '.include "confinc"' > confmf
+   case `$am_make -s -f confmf 2> /dev/null` in #(
+   *the\ am__doit\ target*)
+     am__include=.include
+     am__quote="\""
+     _am_result=BSD
+     ;;
+   esac
+fi
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5
+$as_echo "$_am_result" >&6; }
+rm -f confinc confmf
+
+# Check whether --enable-dependency-tracking was given.
+if test "${enable_dependency_tracking+set}" = set; then :
+  enableval=$enable_dependency_tracking;
+fi
+
+if test "x$enable_dependency_tracking" != xno; then
+  am_depcomp="$ac_aux_dir/depcomp"
+  AMDEPBACKSLASH='\'
+  am__nodep='_no'
+fi
+ if test "x$enable_dependency_tracking" != xno; then
+  AMDEP_TRUE=
+  AMDEP_FALSE='#'
+else
+  AMDEP_TRUE='#'
+  AMDEP_FALSE=
+fi
+
+
+
+depcc="$CC"   am_compiler_list=
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
+$as_echo_n "checking dependency style of $depcc... " >&6; }
+if ${am_cv_CC_dependencies_compiler_type+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+  # We make a subdir and do the tests there.  Otherwise we can end up
+  # making bogus files that we don't know about and never remove.  For
+  # instance it was reported that on HP-UX the gcc test will end up
+  # making a dummy file named `D' -- because `-MD' means `put the output
+  # in D'.
+  rm -rf conftest.dir
+  mkdir conftest.dir
+  # Copy depcomp to subdir because otherwise we won't find it if we're
+  # using a relative directory.
+  cp "$am_depcomp" conftest.dir
+  cd conftest.dir
+  # We will build objects and dependencies in a subdirectory because
+  # it helps to detect inapplicable dependency modes.  For instance
+  # both Tru64's cc and ICC support -MD to output dependencies as a
+  # side effect of compilation, but ICC will put the dependencies in
+  # the current directory while Tru64 will put them in the object
+  # directory.
+  mkdir sub
+
+  am_cv_CC_dependencies_compiler_type=none
+  if test "$am_compiler_list" = ""; then
+     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
+  fi
+  am__universal=false
+  case " $depcc " in #(
+     *\ -arch\ *\ -arch\ *) am__universal=true ;;
+     esac
+
+  for depmode in $am_compiler_list; do
+    # Setup a source with many dependencies, because some compilers
+    # like to wrap large dependency lists on column 80 (with \), and
+    # we should not choose a depcomp mode which is confused by this.
+    #
+    # We need to recreate these files for each test, as the compiler may
+    # overwrite some of them when testing with obscure command lines.
+    # This happens at least with the AIX C compiler.
+    : > sub/conftest.c
+    for i in 1 2 3 4 5 6; do
+      echo '#include "conftst'$i'.h"' >> sub/conftest.c
+      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
+      # Solaris 8's {/usr,}/bin/sh.
+      touch sub/conftst$i.h
+    done
+    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
+
+    # We check with `-c' and `-o' for the sake of the "dashmstdout"
+    # mode.  It turns out that the SunPro C++ compiler does not properly
+    # handle `-M -o', and we need to detect this.  Also, some Intel
+    # versions had trouble with output in subdirs
+    am__obj=sub/conftest.${OBJEXT-o}
+    am__minus_obj="-o $am__obj"
+    case $depmode in
+    gcc)
+      # This depmode causes a compiler race in universal mode.
+      test "$am__universal" = false || continue
+      ;;
+    nosideeffect)
+      # after this tag, mechanisms are not by side-effect, so they'll
+      # only be used when explicitly requested
+      if test "x$enable_dependency_tracking" = xyes; then
+	continue
+      else
+	break
+      fi
+      ;;
+    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
+      # This compiler won't grok `-c -o', but also, the minuso test has
+      # not run yet.  These depmodes are late enough in the game, and
+      # so weak that their functioning should not be impacted.
+      am__obj=conftest.${OBJEXT-o}
+      am__minus_obj=
+      ;;
+    none) break ;;
+    esac
+    if depmode=$depmode \
+       source=sub/conftest.c object=$am__obj \
+       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
+       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
+         >/dev/null 2>conftest.err &&
+       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
+       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
+      # icc doesn't choke on unknown options, it will just issue warnings
+      # or remarks (even with -Werror).  So we grep stderr for any message
+      # that says an option was ignored or not supported.
+      # When given -MP, icc 7.0 and 7.1 complain thusly:
+      #   icc: Command line warning: ignoring option '-M'; no argument required
+      # The diagnosis changed in icc 8.0:
+      #   icc: Command line remark: option '-MP' not supported
+      if (grep 'ignoring option' conftest.err ||
+          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
+        am_cv_CC_dependencies_compiler_type=$depmode
+        break
+      fi
+    fi
+  done
+
+  cd ..
+  rm -rf conftest.dir
+else
+  am_cv_CC_dependencies_compiler_type=none
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
+$as_echo "$am_cv_CC_dependencies_compiler_type" >&6; }
+CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
+
+ if
+  test "x$enable_dependency_tracking" != xno \
+  && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
+  am__fastdepCC_TRUE=
+  am__fastdepCC_FALSE='#'
+else
+  am__fastdepCC_TRUE='#'
+  am__fastdepCC_FALSE=
+fi
+
+
+   case $ac_cv_prog_cc_stdc in #(
+  no) :
+    ac_cv_prog_cc_c99=no; ac_cv_prog_cc_c89=no ;; #(
+  *) :
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C99" >&5
+$as_echo_n "checking for $CC option to accept ISO C99... " >&6; }
+if ${ac_cv_prog_cc_c99+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_cv_prog_cc_c99=no
+ac_save_CC=$CC
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <wchar.h>
+#include <stdio.h>
+
+// Check varargs macros.  These examples are taken from C99 6.10.3.5.
+#define debug(...) fprintf (stderr, __VA_ARGS__)
+#define showlist(...) puts (#__VA_ARGS__)
+#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
+static void
+test_varargs_macros (void)
+{
+  int x = 1234;
+  int y = 5678;
+  debug ("Flag");
+  debug ("X = %d\n", x);
+  showlist (The first, second, and third items.);
+  report (x>y, "x is %d but y is %d", x, y);
+}
+
+// Check long long types.
+#define BIG64 18446744073709551615ull
+#define BIG32 4294967295ul
+#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
+#if !BIG_OK
+  your preprocessor is broken;
+#endif
+#if BIG_OK
+#else
+  your preprocessor is broken;
+#endif
+static long long int bignum = -9223372036854775807LL;
+static unsigned long long int ubignum = BIG64;
+
+struct incomplete_array
+{
+  int datasize;
+  double data[];
+};
+
+struct named_init {
+  int number;
+  const wchar_t *name;
+  double average;
+};
+
+typedef const char *ccp;
+
+static inline int
+test_restrict (ccp restrict text)
+{
+  // See if C++-style comments work.
+  // Iterate through items via the restricted pointer.
+  // Also check for declarations in for loops.
+  for (unsigned int i = 0; *(text+i) != '\0'; ++i)
+    continue;
+  return 0;
+}
+
+// Check varargs and va_copy.
+static void
+test_varargs (const char *format, ...)
+{
+  va_list args;
+  va_start (args, format);
+  va_list args_copy;
+  va_copy (args_copy, args);
+
+  const char *str;
+  int number;
+  float fnumber;
+
+  while (*format)
+    {
+      switch (*format++)
+	{
+	case 's': // string
+	  str = va_arg (args_copy, const char *);
+	  break;
+	case 'd': // int
+	  number = va_arg (args_copy, int);
+	  break;
+	case 'f': // float
+	  fnumber = va_arg (args_copy, double);
+	  break;
+	default:
+	  break;
+	}
+    }
+  va_end (args_copy);
+  va_end (args);
+}
+
+int
+main ()
+{
+
+  // Check bool.
+  _Bool success = false;
+
+  // Check restrict.
+  if (test_restrict ("String literal") == 0)
+    success = true;
+  char *restrict newvar = "Another string";
+
+  // Check varargs.
+  test_varargs ("s, d' f .", "string", 65, 34.234);
+  test_varargs_macros ();
+
+  // Check flexible array members.
+  struct incomplete_array *ia =
+    malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
+  ia->datasize = 10;
+  for (int i = 0; i < ia->datasize; ++i)
+    ia->data[i] = i * 1.234;
+
+  // Check named initializers.
+  struct named_init ni = {
+    .number = 34,
+    .name = L"Test wide string",
+    .average = 543.34343,
+  };
+
+  ni.number = 58;
+
+  int dynamic_array[ni.number];
+  dynamic_array[ni.number - 1] = 543;
+
+  // work around unused variable warnings
+  return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x'
+	  || dynamic_array[ni.number - 1] != 543);
+
+  ;
+  return 0;
+}
+_ACEOF
+for ac_arg in '' -std=gnu99 -std=c99 -c99 -AC99 -D_STDC_C99= -qlanglvl=extc99
+do
+  CC="$ac_save_CC $ac_arg"
+  if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_c99=$ac_arg
+fi
+rm -f core conftest.err conftest.$ac_objext
+  test "x$ac_cv_prog_cc_c99" != "xno" && break
+done
+rm -f conftest.$ac_ext
+CC=$ac_save_CC
+
+fi
+# AC_CACHE_VAL
+case "x$ac_cv_prog_cc_c99" in
+  x)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+$as_echo "none needed" >&6; } ;;
+  xno)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+$as_echo "unsupported" >&6; } ;;
+  *)
+    CC="$CC $ac_cv_prog_cc_c99"
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5
+$as_echo "$ac_cv_prog_cc_c99" >&6; } ;;
+esac
+if test "x$ac_cv_prog_cc_c99" != xno; then :
+  ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
+$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
+if ${ac_cv_prog_cc_c89+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_cv_prog_cc_c89=no
+ac_save_CC=$CC
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdarg.h>
+#include <stdio.h>
+struct stat;
+/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
+struct buf { int x; };
+FILE * (*rcsopen) (struct buf *, struct stat *, int);
+static char *e (p, i)
+     char **p;
+     int i;
+{
+  return p[i];
+}
+static char *f (char * (*g) (char **, int), char **p, ...)
+{
+  char *s;
+  va_list v;
+  va_start (v,p);
+  s = g (p, va_arg (v,int));
+  va_end (v);
+  return s;
+}
+
+/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+   function prototypes and stuff, but not '\xHH' hex character constants.
+   These don't provoke an error unfortunately, instead are silently treated
+   as 'x'.  The following induces an error, until -std is added to get
+   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+   array size at least.  It's necessary to write '\x00'==0 to get something
+   that's true only with -std.  */
+int osf4_cc_array ['\x00' == 0 ? 1 : -1];
+
+/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
+   inside strings and character constants.  */
+#define FOO(x) 'x'
+int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
+
+int test (int i, double x);
+struct s1 {int (*f) (int a);};
+struct s2 {int (*f) (double a);};
+int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
+int argc;
+char **argv;
+int
+main ()
+{
+return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
+  ;
+  return 0;
+}
+_ACEOF
+for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
+	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+do
+  CC="$ac_save_CC $ac_arg"
+  if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_c89=$ac_arg
+fi
+rm -f core conftest.err conftest.$ac_objext
+  test "x$ac_cv_prog_cc_c89" != "xno" && break
+done
+rm -f conftest.$ac_ext
+CC=$ac_save_CC
+
+fi
+# AC_CACHE_VAL
+case "x$ac_cv_prog_cc_c89" in
+  x)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+$as_echo "none needed" >&6; } ;;
+  xno)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+$as_echo "unsupported" >&6; } ;;
+  *)
+    CC="$CC $ac_cv_prog_cc_c89"
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
+$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
+esac
+if test "x$ac_cv_prog_cc_c89" != xno; then :
+  ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89
+else
+  ac_cv_prog_cc_stdc=no
+fi
+
+fi
+ ;;
+esac
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO Standard C" >&5
+$as_echo_n "checking for $CC option to accept ISO Standard C... " >&6; }
+  if ${ac_cv_prog_cc_stdc+:} false; then :
+  $as_echo_n "(cached) " >&6
+fi
+
+  case $ac_cv_prog_cc_stdc in #(
+  no) :
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+$as_echo "unsupported" >&6; } ;; #(
+  '') :
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+$as_echo "none needed" >&6; } ;; #(
+  *) :
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_stdc" >&5
+$as_echo "$ac_cv_prog_cc_stdc" >&6; } ;;
+esac
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
+$as_echo_n "checking how to run the C preprocessor... " >&6; }
+# On Suns, sometimes $CPP names a directory.
+if test -n "$CPP" && test -d "$CPP"; then
+  CPP=
+fi
+if test -z "$CPP"; then
+  if ${ac_cv_prog_CPP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+      # Double quotes because CPP needs to be expanded
+    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
+    do
+      ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+  break
+fi
+
+    done
+    ac_cv_prog_CPP=$CPP
+
+fi
+  CPP=$ac_cv_prog_CPP
+else
+  ac_cv_prog_CPP=$CPP
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
+$as_echo "$CPP" >&6; }
+ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+ac_c_preproc_warn_flag=yes
+for ac_prog in 'bison -y' byacc
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_YACC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$YACC"; then
+  ac_cv_prog_YACC="$YACC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_YACC="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+YACC=$ac_cv_prog_YACC
+if test -n "$YACC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $YACC" >&5
+$as_echo "$YACC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$YACC" && break
+done
+test -n "$YACC" || YACC="yacc"
+
+
+if test "x$CC" != xcc; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC and cc understand -c and -o together" >&5
+$as_echo_n "checking whether $CC and cc understand -c and -o together... " >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether cc understands -c and -o together" >&5
+$as_echo_n "checking whether cc understands -c and -o together... " >&6; }
+fi
+set dummy $CC; ac_cc=`$as_echo "$2" |
+		      sed 's/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/'`
+if eval \${ac_cv_prog_cc_${ac_cc}_c_o+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+# Make sure it works both with $CC and with simple cc.
+# We do the test twice because some compilers refuse to overwrite an
+# existing .o file with -o, though they will create one.
+ac_try='$CC -c conftest.$ac_ext -o conftest2.$ac_objext >&5'
+rm -f conftest2.*
+if { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } &&
+   test -f conftest2.$ac_objext && { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; };
+then
+  eval ac_cv_prog_cc_${ac_cc}_c_o=yes
+  if test "x$CC" != xcc; then
+    # Test first that cc exists at all.
+    if { ac_try='cc -c conftest.$ac_ext >&5'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then
+      ac_try='cc -c conftest.$ac_ext -o conftest2.$ac_objext >&5'
+      rm -f conftest2.*
+      if { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } &&
+	 test -f conftest2.$ac_objext && { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; };
+      then
+	# cc works too.
+	:
+      else
+	# cc exists but doesn't like -o.
+	eval ac_cv_prog_cc_${ac_cc}_c_o=no
+      fi
+    fi
+  fi
+else
+  eval ac_cv_prog_cc_${ac_cc}_c_o=no
+fi
+rm -f core conftest*
+
+fi
+if eval test \$ac_cv_prog_cc_${ac_cc}_c_o = yes; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+
+$as_echo "#define NO_MINUS_C_MINUS_O 1" >>confdefs.h
+
+fi
+
+# FIXME: we rely on the cache variable name because
+# there is no other way.
+set dummy $CC
+am_cc=`echo $2 | sed 's/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/'`
+eval am_t=\$ac_cv_prog_cc_${am_cc}_c_o
+if test "$am_t" != yes; then
+   # Losing compiler, so override with the script.
+   # FIXME: It is wrong to rewrite CC.
+   # But if we don't then we get into trouble of one sort or another.
+   # A longer-term fix would be to have automake use am__CC in this case,
+   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
+   CC="$am_aux_dir/compile $CC"
+fi
+
+
+
+
+
+for ac_prog in flex
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_flex_cmd+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$flex_cmd"; then
+  ac_cv_prog_flex_cmd="$flex_cmd" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_flex_cmd="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+flex_cmd=$ac_cv_prog_flex_cmd
+if test -n "$flex_cmd"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $flex_cmd" >&5
+$as_echo "$flex_cmd" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$flex_cmd" && break
+done
+
+if test x$flex_cmd = "x" ; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: flex is required to patch jq." >&5
+$as_echo "$as_me: flex is required to patch jq." >&6;}
+fi
+
+for ac_prog in bison
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_bison_cmd+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$bison_cmd"; then
+  ac_cv_prog_bison_cmd="$bison_cmd" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_bison_cmd="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+bison_cmd=$ac_cv_prog_bison_cmd
+if test -n "$bison_cmd"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $bison_cmd" >&5
+$as_echo "$bison_cmd" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$bison_cmd" && break
+done
+
+if test x$bison_cmd = "x" ; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: bison is required to patch jq." >&5
+$as_echo "$as_me: bison is required to patch jq." >&6;}
+fi
+
+for ac_prog in valgrind
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_valgrind_cmd+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$valgrind_cmd"; then
+  ac_cv_prog_valgrind_cmd="$valgrind_cmd" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_valgrind_cmd="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+valgrind_cmd=$ac_cv_prog_valgrind_cmd
+if test -n "$valgrind_cmd"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $valgrind_cmd" >&5
+$as_echo "$valgrind_cmd" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$valgrind_cmd" && break
+done
+
+if test x$valgrind_cmd = "x" ; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: valgrind is required to test jq." >&5
+$as_echo "$as_me: valgrind is required to test jq." >&6;}
+fi
+
+ac_config_headers="$ac_config_headers config.h"
+
+if test "`cd $srcdir && pwd`" != "`pwd`"; then
+  # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
+  # is not polluted with repeated "-I."
+  am__isrc=' -I$(srcdir)'
+  # test to see if srcdir already configured
+  if test -f $srcdir/config.status; then
+    as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5
+  fi
+fi
+
+# test whether we have cygpath
+if test -z "$CYGPATH_W"; then
+  if (cygpath --version) >/dev/null 2>/dev/null; then
+    CYGPATH_W='cygpath -w'
+  else
+    CYGPATH_W=echo
+  fi
+fi
+
+
+# Define the identity of the package.
+ PACKAGE='jq'
+ VERSION='1.2'
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE "$PACKAGE"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define VERSION "$VERSION"
+_ACEOF
+
+# Some tools Automake needs.
+
+ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}
+
+
+AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}
+
+
+AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}
+
+
+AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}
+
+
+MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
+
+# We need awk for the "check" target.  The system "awk" is bad on
+# some platforms.
+# Always define AMTAR for backward compatibility.  Yes, it's still used
+# in the wild :-(  We should find a proper way to deprecate it ...
+AMTAR='$${TAR-tar}'
+
+am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'
+
+
+
+
+depcc="$CC"   am_compiler_list=
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
+$as_echo_n "checking dependency style of $depcc... " >&6; }
+if ${am_cv_CC_dependencies_compiler_type+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+  # We make a subdir and do the tests there.  Otherwise we can end up
+  # making bogus files that we don't know about and never remove.  For
+  # instance it was reported that on HP-UX the gcc test will end up
+  # making a dummy file named `D' -- because `-MD' means `put the output
+  # in D'.
+  rm -rf conftest.dir
+  mkdir conftest.dir
+  # Copy depcomp to subdir because otherwise we won't find it if we're
+  # using a relative directory.
+  cp "$am_depcomp" conftest.dir
+  cd conftest.dir
+  # We will build objects and dependencies in a subdirectory because
+  # it helps to detect inapplicable dependency modes.  For instance
+  # both Tru64's cc and ICC support -MD to output dependencies as a
+  # side effect of compilation, but ICC will put the dependencies in
+  # the current directory while Tru64 will put them in the object
+  # directory.
+  mkdir sub
+
+  am_cv_CC_dependencies_compiler_type=none
+  if test "$am_compiler_list" = ""; then
+     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
+  fi
+  am__universal=false
+  case " $depcc " in #(
+     *\ -arch\ *\ -arch\ *) am__universal=true ;;
+     esac
+
+  for depmode in $am_compiler_list; do
+    # Setup a source with many dependencies, because some compilers
+    # like to wrap large dependency lists on column 80 (with \), and
+    # we should not choose a depcomp mode which is confused by this.
+    #
+    # We need to recreate these files for each test, as the compiler may
+    # overwrite some of them when testing with obscure command lines.
+    # This happens at least with the AIX C compiler.
+    : > sub/conftest.c
+    for i in 1 2 3 4 5 6; do
+      echo '#include "conftst'$i'.h"' >> sub/conftest.c
+      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
+      # Solaris 8's {/usr,}/bin/sh.
+      touch sub/conftst$i.h
+    done
+    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
+
+    # We check with `-c' and `-o' for the sake of the "dashmstdout"
+    # mode.  It turns out that the SunPro C++ compiler does not properly
+    # handle `-M -o', and we need to detect this.  Also, some Intel
+    # versions had trouble with output in subdirs
+    am__obj=sub/conftest.${OBJEXT-o}
+    am__minus_obj="-o $am__obj"
+    case $depmode in
+    gcc)
+      # This depmode causes a compiler race in universal mode.
+      test "$am__universal" = false || continue
+      ;;
+    nosideeffect)
+      # after this tag, mechanisms are not by side-effect, so they'll
+      # only be used when explicitly requested
+      if test "x$enable_dependency_tracking" = xyes; then
+	continue
+      else
+	break
+      fi
+      ;;
+    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
+      # This compiler won't grok `-c -o', but also, the minuso test has
+      # not run yet.  These depmodes are late enough in the game, and
+      # so weak that their functioning should not be impacted.
+      am__obj=conftest.${OBJEXT-o}
+      am__minus_obj=
+      ;;
+    none) break ;;
+    esac
+    if depmode=$depmode \
+       source=sub/conftest.c object=$am__obj \
+       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
+       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
+         >/dev/null 2>conftest.err &&
+       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
+       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
+      # icc doesn't choke on unknown options, it will just issue warnings
+      # or remarks (even with -Werror).  So we grep stderr for any message
+      # that says an option was ignored or not supported.
+      # When given -MP, icc 7.0 and 7.1 complain thusly:
+      #   icc: Command line warning: ignoring option '-M'; no argument required
+      # The diagnosis changed in icc 8.0:
+      #   icc: Command line remark: option '-MP' not supported
+      if (grep 'ignoring option' conftest.err ||
+          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
+        am_cv_CC_dependencies_compiler_type=$depmode
+        break
+      fi
+    fi
+  done
+
+  cd ..
+  rm -rf conftest.dir
+else
+  am_cv_CC_dependencies_compiler_type=none
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
+$as_echo "$am_cv_CC_dependencies_compiler_type" >&6; }
+CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
+
+ if
+  test "x$enable_dependency_tracking" != xno \
+  && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
+  am__fastdepCC_TRUE=
+  am__fastdepCC_FALSE='#'
+else
+  am__fastdepCC_TRUE='#'
+  am__fastdepCC_FALSE=
+fi
+
+
+
+ac_config_files="$ac_config_files Makefile"
+
+cat >confcache <<\_ACEOF
+# This file is a shell script that caches the results of configure
+# tests run on this system so they can be shared between configure
+# scripts and configure runs, see configure's option --config-cache.
+# It is not useful on other systems.  If it contains results you don't
+# want to keep, you may remove or edit it.
+#
+# config.status only pays attention to the cache file if you give it
+# the --recheck option to rerun configure.
+#
+# `ac_cv_env_foo' variables (set or unset) will be overridden when
+# loading this file, other *unset* `ac_cv_foo' will be assigned the
+# following values.
+
+_ACEOF
+
+# The following way of writing the cache mishandles newlines in values,
+# but we know of no workaround that is simple, portable, and efficient.
+# So, we kill variables containing newlines.
+# Ultrix sh set writes to stderr and can't be redirected directly,
+# and sets the high bit in the cache file unless we assign to the vars.
+(
+  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+      *) { eval $ac_var=; unset $ac_var;} ;;
+      esac ;;
+    esac
+  done
+
+  (set) 2>&1 |
+    case $as_nl`(ac_space=' '; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
+      # `set' does not quote correctly, so add quotes: double-quote
+      # substitution turns \\\\ into \\, and sed turns \\ into \.
+      sed -n \
+	"s/'/'\\\\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+      ;; #(
+    *)
+      # `set' quotes correctly as required by POSIX, so do not add quotes.
+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+      ;;
+    esac |
+    sort
+) |
+  sed '
+     /^ac_cv_env_/b end
+     t clear
+     :clear
+     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+     t end
+     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+     :end' >>confcache
+if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
+  if test -w "$cache_file"; then
+    if test "x$cache_file" != "x/dev/null"; then
+      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
+$as_echo "$as_me: updating cache $cache_file" >&6;}
+      if test ! -f "$cache_file" || test -h "$cache_file"; then
+	cat confcache >"$cache_file"
+      else
+        case $cache_file in #(
+        */* | ?:*)
+	  mv -f confcache "$cache_file"$$ &&
+	  mv -f "$cache_file"$$ "$cache_file" ;; #(
+        *)
+	  mv -f confcache "$cache_file" ;;
+	esac
+      fi
+    fi
+  else
+    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
+$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
+  fi
+fi
+rm -f confcache
+
+test "x$prefix" = xNONE && prefix=$ac_default_prefix
+# Let make expand exec_prefix.
+test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
+
+DEFS=-DHAVE_CONFIG_H
+
+ac_libobjs=
+ac_ltlibobjs=
+U=
+for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
+  # 1. Remove the extension, and $U if already installed.
+  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
+  ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
+  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
+  #    will be set to the directory where LIBOBJS objects are built.
+  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
+  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
+done
+LIBOBJS=$ac_libobjs
+
+LTLIBOBJS=$ac_ltlibobjs
+
+
+ if test -n "$EXEEXT"; then
+  am__EXEEXT_TRUE=
+  am__EXEEXT_FALSE='#'
+else
+  am__EXEEXT_TRUE='#'
+  am__EXEEXT_FALSE=
+fi
+
+if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
+  as_fn_error $? "conditional \"AMDEP\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
+  as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
+  as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+ if test -n "$EXEEXT"; then
+  am__EXEEXT_TRUE=
+  am__EXEEXT_FALSE='#'
+else
+  am__EXEEXT_TRUE='#'
+  am__EXEEXT_FALSE=
+fi
+
+
+: "${CONFIG_STATUS=./config.status}"
+ac_write_fail=0
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files $CONFIG_STATUS"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
+$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
+as_write_fail=0
+cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
+#! $SHELL
+# Generated by $as_me.
+# Run this file to recreate the current configuration.
+# Compiler output produced by configure, useful for debugging
+# configure, is in config.log if it exists.
+
+debug=false
+ac_cs_recheck=false
+ac_cs_silent=false
+
+SHELL=\${CONFIG_SHELL-$SHELL}
+export SHELL
+_ASEOF
+cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
+## -------------------- ##
+## M4sh Initialization. ##
+## -------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+
+
+as_nl='
+'
+export as_nl
+# Printing a long string crashes Solaris 7 /usr/bin/printf.
+as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
+# Prefer a ksh shell builtin over an external printf program on Solaris,
+# but without wasting forks for bash or zsh.
+if test -z "$BASH_VERSION$ZSH_VERSION" \
+    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='print -r --'
+  as_echo_n='print -rn --'
+elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='printf %s\n'
+  as_echo_n='printf %s'
+else
+  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
+    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
+    as_echo_n='/usr/ucb/echo -n'
+  else
+    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
+    as_echo_n_body='eval
+      arg=$1;
+      case $arg in #(
+      *"$as_nl"*)
+	expr "X$arg" : "X\\(.*\\)$as_nl";
+	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
+      esac;
+      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
+    '
+    export as_echo_n_body
+    as_echo_n='sh -c $as_echo_n_body as_echo'
+  fi
+  export as_echo_body
+  as_echo='sh -c $as_echo_body as_echo'
+fi
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
+fi
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent editors from complaining about space-tab.
+# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+# splitting by setting IFS to empty value.)
+IFS=" ""	$as_nl"
+
+# Find who we are.  Look in the path if we contain no directory separator.
+as_myself=
+case $0 in #((
+  *[\\/]* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+  done
+IFS=$as_save_IFS
+
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  exit 1
+fi
+
+# Unset variables that we do not need and which cause bugs (e.g. in
+# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
+# suppresses any "Segmentation fault" message there.  '((' could
+# trigger a bug in pdksh 5.2.14.
+for as_var in BASH_ENV ENV MAIL MAILPATH
+do eval test x\${$as_var+set} = xset \
+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+done
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+LC_ALL=C
+export LC_ALL
+LANGUAGE=C
+export LANGUAGE
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+
+# as_fn_error STATUS ERROR [LINENO LOG_FD]
+# ----------------------------------------
+# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
+# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
+# script with STATUS, using 1 if that was 0.
+as_fn_error ()
+{
+  as_status=$1; test $as_status -eq 0 && as_status=1
+  if test "$4"; then
+    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+  fi
+  $as_echo "$as_me: error: $2" >&2
+  as_fn_exit $as_status
+} # as_fn_error
+
+
+# as_fn_set_status STATUS
+# -----------------------
+# Set $? to STATUS, without forking.
+as_fn_set_status ()
+{
+  return $1
+} # as_fn_set_status
+
+# as_fn_exit STATUS
+# -----------------
+# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
+as_fn_exit ()
+{
+  set +e
+  as_fn_set_status $1
+  exit $1
+} # as_fn_exit
+
+# as_fn_unset VAR
+# ---------------
+# Portably unset VAR.
+as_fn_unset ()
+{
+  { eval $1=; unset $1;}
+}
+as_unset=as_fn_unset
+# as_fn_append VAR VALUE
+# ----------------------
+# Append the text in VALUE to the end of the definition contained in VAR. Take
+# advantage of any shell optimizations that allow amortized linear growth over
+# repeated appends, instead of the typical quadratic growth present in naive
+# implementations.
+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
+  eval 'as_fn_append ()
+  {
+    eval $1+=\$2
+  }'
+else
+  as_fn_append ()
+  {
+    eval $1=\$$1\$2
+  }
+fi # as_fn_append
+
+# as_fn_arith ARG...
+# ------------------
+# Perform arithmetic evaluation on the ARGs, and store the result in the
+# global $as_val. Take advantage of shells that can avoid forks. The arguments
+# must be portable across $(()) and expr.
+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
+  eval 'as_fn_arith ()
+  {
+    as_val=$(( $* ))
+  }'
+else
+  as_fn_arith ()
+  {
+    as_val=`expr "$@" || test $? -eq 1`
+  }
+fi # as_fn_arith
+
+
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
+
+as_me=`$as_basename -- "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+  case `echo 'xy\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  xy)  ECHO_C='\c';;
+  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
+       ECHO_T='	';;
+  esac;;
+*)
+  ECHO_N='-n';;
+esac
+
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
+else
+  rm -f conf$$.dir
+  mkdir conf$$.dir 2>/dev/null
+fi
+if (echo >conf$$.file) 2>/dev/null; then
+  if ln -s conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s='ln -s'
+    # ... but there are two gotchas:
+    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+    # In both cases, we have to default to `cp -pR'.
+    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+      as_ln_s='cp -pR'
+  elif ln conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s=ln
+  else
+    as_ln_s='cp -pR'
+  fi
+else
+  as_ln_s='cp -pR'
+fi
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+
+# as_fn_mkdir_p
+# -------------
+# Create "$as_dir" as a directory, including parents if necessary.
+as_fn_mkdir_p ()
+{
+
+  case $as_dir in #(
+  -*) as_dir=./$as_dir;;
+  esac
+  test -d "$as_dir" || eval $as_mkdir_p || {
+    as_dirs=
+    while :; do
+      case $as_dir in #(
+      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+      *) as_qdir=$as_dir;;
+      esac
+      as_dirs="'$as_qdir' $as_dirs"
+      as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      test -d "$as_dir" && break
+    done
+    test -z "$as_dirs" || eval "mkdir $as_dirs"
+  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
+
+
+} # as_fn_mkdir_p
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p='mkdir -p "$as_dir"'
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+  test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+
+exec 6>&1
+## ----------------------------------- ##
+## Main body of $CONFIG_STATUS script. ##
+## ----------------------------------- ##
+_ASEOF
+test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# Save the log message, to keep $0 and so on meaningful, and to
+# report actual input values of CONFIG_FILES etc. instead of their
+# values after options handling.
+ac_log="
+This file was extended by jq $as_me 1.2, which was
+generated by GNU Autoconf 2.69.  Invocation command line was
+
+  CONFIG_FILES    = $CONFIG_FILES
+  CONFIG_HEADERS  = $CONFIG_HEADERS
+  CONFIG_LINKS    = $CONFIG_LINKS
+  CONFIG_COMMANDS = $CONFIG_COMMANDS
+  $ $0 $@
+
+on `(hostname || uname -n) 2>/dev/null | sed 1q`
+"
+
+_ACEOF
+
+case $ac_config_files in *"
+"*) set x $ac_config_files; shift; ac_config_files=$*;;
+esac
+
+case $ac_config_headers in *"
+"*) set x $ac_config_headers; shift; ac_config_headers=$*;;
+esac
+
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+# Files that config.status was made for.
+config_files="$ac_config_files"
+config_headers="$ac_config_headers"
+config_commands="$ac_config_commands"
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+ac_cs_usage="\
+\`$as_me' instantiates files and other configuration actions
+from templates according to the current configuration.  Unless the files
+and actions are specified as TAGs, all are instantiated by default.
+
+Usage: $0 [OPTION]... [TAG]...
+
+  -h, --help       print this help, then exit
+  -V, --version    print version number and configuration settings, then exit
+      --config     print configuration, then exit
+  -q, --quiet, --silent
+                   do not print progress messages
+  -d, --debug      don't remove temporary files
+      --recheck    update $as_me by reconfiguring in the same conditions
+      --file=FILE[:TEMPLATE]
+                   instantiate the configuration file FILE
+      --header=FILE[:TEMPLATE]
+                   instantiate the configuration header FILE
+
+Configuration files:
+$config_files
+
+Configuration headers:
+$config_headers
+
+Configuration commands:
+$config_commands
+
+Report bugs to <mu@netsoc.tcd.ie>.
+jq home page: <http://stedolan.github.com/jq/>."
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
+ac_cs_version="\\
+jq config.status 1.2
+configured by $0, generated by GNU Autoconf 2.69,
+  with options \\"\$ac_cs_config\\"
+
+Copyright (C) 2012 Free Software Foundation, Inc.
+This config.status script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it."
+
+ac_pwd='$ac_pwd'
+srcdir='$srcdir'
+INSTALL='$INSTALL'
+MKDIR_P='$MKDIR_P'
+AWK='$AWK'
+test -n "\$AWK" || AWK=awk
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# The default lists apply if the user does not specify any file.
+ac_need_defaults=:
+while test $# != 0
+do
+  case $1 in
+  --*=?*)
+    ac_option=`expr "X$1" : 'X\([^=]*\)='`
+    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
+    ac_shift=:
+    ;;
+  --*=)
+    ac_option=`expr "X$1" : 'X\([^=]*\)='`
+    ac_optarg=
+    ac_shift=:
+    ;;
+  *)
+    ac_option=$1
+    ac_optarg=$2
+    ac_shift=shift
+    ;;
+  esac
+
+  case $ac_option in
+  # Handling of the options.
+  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+    ac_cs_recheck=: ;;
+  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
+    $as_echo "$ac_cs_version"; exit ;;
+  --config | --confi | --conf | --con | --co | --c )
+    $as_echo "$ac_cs_config"; exit ;;
+  --debug | --debu | --deb | --de | --d | -d )
+    debug=: ;;
+  --file | --fil | --fi | --f )
+    $ac_shift
+    case $ac_optarg in
+    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    '') as_fn_error $? "missing file argument" ;;
+    esac
+    as_fn_append CONFIG_FILES " '$ac_optarg'"
+    ac_need_defaults=false;;
+  --header | --heade | --head | --hea )
+    $ac_shift
+    case $ac_optarg in
+    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    esac
+    as_fn_append CONFIG_HEADERS " '$ac_optarg'"
+    ac_need_defaults=false;;
+  --he | --h)
+    # Conflict between --help and --header
+    as_fn_error $? "ambiguous option: \`$1'
+Try \`$0 --help' for more information.";;
+  --help | --hel | -h )
+    $as_echo "$ac_cs_usage"; exit ;;
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil | --si | --s)
+    ac_cs_silent=: ;;
+
+  # This is an error.
+  -*) as_fn_error $? "unrecognized option: \`$1'
+Try \`$0 --help' for more information." ;;
+
+  *) as_fn_append ac_config_targets " $1"
+     ac_need_defaults=false ;;
+
+  esac
+  shift
+done
+
+ac_configure_extra_args=
+
+if $ac_cs_silent; then
+  exec 6>/dev/null
+  ac_configure_extra_args="$ac_configure_extra_args --silent"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+if \$ac_cs_recheck; then
+  set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+  shift
+  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
+  CONFIG_SHELL='$SHELL'
+  export CONFIG_SHELL
+  exec "\$@"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+exec 5>>config.log
+{
+  echo
+  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+## Running $as_me. ##
+_ASBOX
+  $as_echo "$ac_log"
+} >&5
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+#
+# INIT-COMMANDS
+#
+AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+
+# Handling of arguments.
+for ac_config_target in $ac_config_targets
+do
+  case $ac_config_target in
+    "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
+    "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
+    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
+
+  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
+  esac
+done
+
+
+# If the user did not use the arguments to specify the items to instantiate,
+# then the envvar interface is used.  Set only those that are not.
+# We use the long form for the default assignment because of an extremely
+# bizarre bug on SunOS 4.1.3.
+if $ac_need_defaults; then
+  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
+  test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
+  test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
+fi
+
+# Have a temporary directory for convenience.  Make it in the build tree
+# simply because there is no reason against having it here, and in addition,
+# creating and moving files from /tmp can sometimes cause problems.
+# Hook for its removal unless debugging.
+# Note that there is a small window in which the directory will not be cleaned:
+# after its creation but before its name has been assigned to `$tmp'.
+$debug ||
+{
+  tmp= ac_tmp=
+  trap 'exit_status=$?
+  : "${ac_tmp:=$tmp}"
+  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
+' 0
+  trap 'as_fn_exit 1' 1 2 13 15
+}
+# Create a (secure) tmp directory for tmp files.
+
+{
+  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
+  test -d "$tmp"
+}  ||
+{
+  tmp=./conf$$-$RANDOM
+  (umask 077 && mkdir "$tmp")
+} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
+ac_tmp=$tmp
+
+# Set up the scripts for CONFIG_FILES section.
+# No need to generate them if there are no CONFIG_FILES.
+# This happens for instance with `./config.status config.h'.
+if test -n "$CONFIG_FILES"; then
+
+
+ac_cr=`echo X | tr X '\015'`
+# On cygwin, bash can eat \r inside `` if the user requested igncr.
+# But we know of no other shell where ac_cr would be empty at this
+# point, so we can use a bashism as a fallback.
+if test "x$ac_cr" = x; then
+  eval ac_cr=\$\'\\r\'
+fi
+ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
+if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
+  ac_cs_awk_cr='\\r'
+else
+  ac_cs_awk_cr=$ac_cr
+fi
+
+echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
+_ACEOF
+
+
+{
+  echo "cat >conf$$subs.awk <<_ACEOF" &&
+  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
+  echo "_ACEOF"
+} >conf$$subs.sh ||
+  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
+ac_delim='%!_!# '
+for ac_last_try in false false false false false :; do
+  . ./conf$$subs.sh ||
+    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+
+  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
+  if test $ac_delim_n = $ac_delim_num; then
+    break
+  elif $ac_last_try; then
+    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+  else
+    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+  fi
+done
+rm -f conf$$subs.sh
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
+_ACEOF
+sed -n '
+h
+s/^/S["/; s/!.*/"]=/
+p
+g
+s/^[^!]*!//
+:repl
+t repl
+s/'"$ac_delim"'$//
+t delim
+:nl
+h
+s/\(.\{148\}\)..*/\1/
+t more1
+s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
+p
+n
+b repl
+:more1
+s/["\\]/\\&/g; s/^/"/; s/$/"\\/
+p
+g
+s/.\{148\}//
+t nl
+:delim
+h
+s/\(.\{148\}\)..*/\1/
+t more2
+s/["\\]/\\&/g; s/^/"/; s/$/"/
+p
+b
+:more2
+s/["\\]/\\&/g; s/^/"/; s/$/"\\/
+p
+g
+s/.\{148\}//
+t delim
+' <conf$$subs.awk | sed '
+/^[^""]/{
+  N
+  s/\n//
+}
+' >>$CONFIG_STATUS || ac_write_fail=1
+rm -f conf$$subs.awk
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+_ACAWK
+cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
+  for (key in S) S_is_set[key] = 1
+  FS = ""
+
+}
+{
+  line = $ 0
+  nfields = split(line, field, "@")
+  substed = 0
+  len = length(field[1])
+  for (i = 2; i < nfields; i++) {
+    key = field[i]
+    keylen = length(key)
+    if (S_is_set[key]) {
+      value = S[key]
+      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
+      len += length(value) + length(field[++i])
+      substed = 1
+    } else
+      len += 1 + keylen
+  }
+
+  print line
+}
+
+_ACAWK
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
+  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
+else
+  cat
+fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
+  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
+_ACEOF
+
+# VPATH may cause trouble with some makes, so we remove sole $(srcdir),
+# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
+# trailing colons and then remove the whole line if VPATH becomes empty
+# (actually we leave an empty line to preserve line numbers).
+if test "x$srcdir" = x.; then
+  ac_vpsub='/^[	 ]*VPATH[	 ]*=[	 ]*/{
+h
+s///
+s/^/:/
+s/[	 ]*$/:/
+s/:\$(srcdir):/:/g
+s/:\${srcdir}:/:/g
+s/:@srcdir@:/:/g
+s/^:*//
+s/:*$//
+x
+s/\(=[	 ]*\).*/\1/
+G
+s/\n//
+s/^[^=]*=[	 ]*$//
+}'
+fi
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+fi # test -n "$CONFIG_FILES"
+
+# Set up the scripts for CONFIG_HEADERS section.
+# No need to generate them if there are no CONFIG_HEADERS.
+# This happens for instance with `./config.status Makefile'.
+if test -n "$CONFIG_HEADERS"; then
+cat >"$ac_tmp/defines.awk" <<\_ACAWK ||
+BEGIN {
+_ACEOF
+
+# Transform confdefs.h into an awk script `defines.awk', embedded as
+# here-document in config.status, that substitutes the proper values into
+# config.h.in to produce config.h.
+
+# Create a delimiter string that does not exist in confdefs.h, to ease
+# handling of long lines.
+ac_delim='%!_!# '
+for ac_last_try in false false :; do
+  ac_tt=`sed -n "/$ac_delim/p" confdefs.h`
+  if test -z "$ac_tt"; then
+    break
+  elif $ac_last_try; then
+    as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5
+  else
+    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+  fi
+done
+
+# For the awk script, D is an array of macro values keyed by name,
+# likewise P contains macro parameters if any.  Preserve backslash
+# newline sequences.
+
+ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
+sed -n '
+s/.\{148\}/&'"$ac_delim"'/g
+t rset
+:rset
+s/^[	 ]*#[	 ]*define[	 ][	 ]*/ /
+t def
+d
+:def
+s/\\$//
+t bsnl
+s/["\\]/\\&/g
+s/^ \('"$ac_word_re"'\)\(([^()]*)\)[	 ]*\(.*\)/P["\1"]="\2"\
+D["\1"]=" \3"/p
+s/^ \('"$ac_word_re"'\)[	 ]*\(.*\)/D["\1"]=" \2"/p
+d
+:bsnl
+s/["\\]/\\&/g
+s/^ \('"$ac_word_re"'\)\(([^()]*)\)[	 ]*\(.*\)/P["\1"]="\2"\
+D["\1"]=" \3\\\\\\n"\\/p
+t cont
+s/^ \('"$ac_word_re"'\)[	 ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p
+t cont
+d
+:cont
+n
+s/.\{148\}/&'"$ac_delim"'/g
+t clear
+:clear
+s/\\$//
+t bsnlc
+s/["\\]/\\&/g; s/^/"/; s/$/"/p
+d
+:bsnlc
+s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p
+b cont
+' <confdefs.h | sed '
+s/'"$ac_delim"'/"\\\
+"/g' >>$CONFIG_STATUS || ac_write_fail=1
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+  for (key in D) D_is_set[key] = 1
+  FS = ""
+}
+/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ {
+  line = \$ 0
+  split(line, arg, " ")
+  if (arg[1] == "#") {
+    defundef = arg[2]
+    mac1 = arg[3]
+  } else {
+    defundef = substr(arg[1], 2)
+    mac1 = arg[2]
+  }
+  split(mac1, mac2, "(") #)
+  macro = mac2[1]
+  prefix = substr(line, 1, index(line, defundef) - 1)
+  if (D_is_set[macro]) {
+    # Preserve the white space surrounding the "#".
+    print prefix "define", macro P[macro] D[macro]
+    next
+  } else {
+    # Replace #undef with comments.  This is necessary, for example,
+    # in the case of _POSIX_SOURCE, which is predefined and required
+    # on some systems where configure will not decide to define it.
+    if (defundef == "undef") {
+      print "/*", prefix defundef, macro, "*/"
+      next
+    }
+  }
+}
+{ print }
+_ACAWK
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+  as_fn_error $? "could not setup config headers machinery" "$LINENO" 5
+fi # test -n "$CONFIG_HEADERS"
+
+
+eval set X "  :F $CONFIG_FILES  :H $CONFIG_HEADERS    :C $CONFIG_COMMANDS"
+shift
+for ac_tag
+do
+  case $ac_tag in
+  :[FHLC]) ac_mode=$ac_tag; continue;;
+  esac
+  case $ac_mode$ac_tag in
+  :[FHL]*:*);;
+  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
+  :[FH]-) ac_tag=-:-;;
+  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
+  esac
+  ac_save_IFS=$IFS
+  IFS=:
+  set x $ac_tag
+  IFS=$ac_save_IFS
+  shift
+  ac_file=$1
+  shift
+
+  case $ac_mode in
+  :L) ac_source=$1;;
+  :[FH])
+    ac_file_inputs=
+    for ac_f
+    do
+      case $ac_f in
+      -) ac_f="$ac_tmp/stdin";;
+      *) # Look for the file first in the build tree, then in the source tree
+	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
+	 # because $ac_f cannot contain `:'.
+	 test -f "$ac_f" ||
+	   case $ac_f in
+	   [\\/$]*) false;;
+	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
+	   esac ||
+	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
+      esac
+      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
+      as_fn_append ac_file_inputs " '$ac_f'"
+    done
+
+    # Let's still pretend it is `configure' which instantiates (i.e., don't
+    # use $as_me), people would be surprised to read:
+    #    /* config.h.  Generated by config.status.  */
+    configure_input='Generated from '`
+	  $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
+	`' by configure.'
+    if test x"$ac_file" != x-; then
+      configure_input="$ac_file.  $configure_input"
+      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
+$as_echo "$as_me: creating $ac_file" >&6;}
+    fi
+    # Neutralize special characters interpreted by sed in replacement strings.
+    case $configure_input in #(
+    *\&* | *\|* | *\\* )
+       ac_sed_conf_input=`$as_echo "$configure_input" |
+       sed 's/[\\\\&|]/\\\\&/g'`;; #(
+    *) ac_sed_conf_input=$configure_input;;
+    esac
+
+    case $ac_tag in
+    *:-:* | *:-) cat >"$ac_tmp/stdin" \
+      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
+    esac
+    ;;
+  esac
+
+  ac_dir=`$as_dirname -- "$ac_file" ||
+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$ac_file" : 'X\(//\)[^/]' \| \
+	 X"$ac_file" : 'X\(//\)$' \| \
+	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$ac_file" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  as_dir="$ac_dir"; as_fn_mkdir_p
+  ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  [\\/]* | ?:[\\/]* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+
+  case $ac_mode in
+  :F)
+  #
+  # CONFIG_FILE
+  #
+
+  case $INSTALL in
+  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
+  *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
+  esac
+  ac_MKDIR_P=$MKDIR_P
+  case $MKDIR_P in
+  [\\/$]* | ?:[\\/]* ) ;;
+  */*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;;
+  esac
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# If the template does not know about datarootdir, expand it.
+# FIXME: This hack should be removed a few years after 2.60.
+ac_datarootdir_hack=; ac_datarootdir_seen=
+ac_sed_dataroot='
+/datarootdir/ {
+  p
+  q
+}
+/@datadir@/p
+/@docdir@/p
+/@infodir@/p
+/@localedir@/p
+/@mandir@/p'
+case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
+*datarootdir*) ac_datarootdir_seen=yes;;
+*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
+$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+  ac_datarootdir_hack='
+  s&@datadir@&$datadir&g
+  s&@docdir@&$docdir&g
+  s&@infodir@&$infodir&g
+  s&@localedir@&$localedir&g
+  s&@mandir@&$mandir&g
+  s&\\\${datarootdir}&$datarootdir&g' ;;
+esac
+_ACEOF
+
+# Neutralize VPATH when `$srcdir' = `.'.
+# Shell code in configure.ac might set extrasub.
+# FIXME: do we really want to maintain this feature?
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_sed_extra="$ac_vpsub
+$extrasub
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+:t
+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
+s|@configure_input@|$ac_sed_conf_input|;t t
+s&@top_builddir@&$ac_top_builddir_sub&;t t
+s&@top_build_prefix@&$ac_top_build_prefix&;t t
+s&@srcdir@&$ac_srcdir&;t t
+s&@abs_srcdir@&$ac_abs_srcdir&;t t
+s&@top_srcdir@&$ac_top_srcdir&;t t
+s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
+s&@builddir@&$ac_builddir&;t t
+s&@abs_builddir@&$ac_abs_builddir&;t t
+s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
+s&@INSTALL@&$ac_INSTALL&;t t
+s&@MKDIR_P@&$ac_MKDIR_P&;t t
+$ac_datarootdir_hack
+"
+eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
+  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+
+test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
+  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
+  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \
+      "$ac_tmp/out"`; test -z "$ac_out"; } &&
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined" >&5
+$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined" >&2;}
+
+  rm -f "$ac_tmp/stdin"
+  case $ac_file in
+  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
+  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
+  esac \
+  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+ ;;
+  :H)
+  #
+  # CONFIG_HEADER
+  #
+  if test x"$ac_file" != x-; then
+    {
+      $as_echo "/* $configure_input  */" \
+      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs"
+    } >"$ac_tmp/config.h" \
+      || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+    if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then
+      { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
+$as_echo "$as_me: $ac_file is unchanged" >&6;}
+    else
+      rm -f "$ac_file"
+      mv "$ac_tmp/config.h" "$ac_file" \
+	|| as_fn_error $? "could not create $ac_file" "$LINENO" 5
+    fi
+  else
+    $as_echo "/* $configure_input  */" \
+      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \
+      || as_fn_error $? "could not create -" "$LINENO" 5
+  fi
+# Compute "$ac_file"'s index in $config_headers.
+_am_arg="$ac_file"
+_am_stamp_count=1
+for _am_header in $config_headers :; do
+  case $_am_header in
+    $_am_arg | $_am_arg:* )
+      break ;;
+    * )
+      _am_stamp_count=`expr $_am_stamp_count + 1` ;;
+  esac
+done
+echo "timestamp for $_am_arg" >`$as_dirname -- "$_am_arg" ||
+$as_expr X"$_am_arg" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$_am_arg" : 'X\(//\)[^/]' \| \
+	 X"$_am_arg" : 'X\(//\)$' \| \
+	 X"$_am_arg" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$_am_arg" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`/stamp-h$_am_stamp_count
+ ;;
+
+  :C)  { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5
+$as_echo "$as_me: executing $ac_file commands" >&6;}
+ ;;
+  esac
+
+
+  case $ac_file$ac_mode in
+    "depfiles":C) test x"$AMDEP_TRUE" != x"" || {
+  # Autoconf 2.62 quotes --file arguments for eval, but not when files
+  # are listed without --file.  Let's play safe and only enable the eval
+  # if we detect the quoting.
+  case $CONFIG_FILES in
+  *\'*) eval set x "$CONFIG_FILES" ;;
+  *)   set x $CONFIG_FILES ;;
+  esac
+  shift
+  for mf
+  do
+    # Strip MF so we end up with the name of the file.
+    mf=`echo "$mf" | sed -e 's/:.*$//'`
+    # Check whether this is an Automake generated Makefile or not.
+    # We used to match only the files named `Makefile.in', but
+    # some people rename them; so instead we look at the file content.
+    # Grep'ing the first line is not enough: some people post-process
+    # each Makefile.in and add a new line on top of each file to say so.
+    # Grep'ing the whole file is not good either: AIX grep has a line
+    # limit of 2048, but all sed's we know have understand at least 4000.
+    if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
+      dirpart=`$as_dirname -- "$mf" ||
+$as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$mf" : 'X\(//\)[^/]' \| \
+	 X"$mf" : 'X\(//\)$' \| \
+	 X"$mf" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$mf" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+    else
+      continue
+    fi
+    # Extract the definition of DEPDIR, am__include, and am__quote
+    # from the Makefile without running `make'.
+    DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
+    test -z "$DEPDIR" && continue
+    am__include=`sed -n 's/^am__include = //p' < "$mf"`
+    test -z "am__include" && continue
+    am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
+    # When using ansi2knr, U may be empty or an underscore; expand it
+    U=`sed -n 's/^U = //p' < "$mf"`
+    # Find all dependency output files, they are included files with
+    # $(DEPDIR) in their names.  We invoke sed twice because it is the
+    # simplest approach to changing $(DEPDIR) to its actual value in the
+    # expansion.
+    for file in `sed -n "
+      s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
+	 sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
+      # Make sure the directory exists.
+      test -f "$dirpart/$file" && continue
+      fdir=`$as_dirname -- "$file" ||
+$as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$file" : 'X\(//\)[^/]' \| \
+	 X"$file" : 'X\(//\)$' \| \
+	 X"$file" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$file" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      as_dir=$dirpart/$fdir; as_fn_mkdir_p
+      # echo "creating $dirpart/$file"
+      echo '# dummy' > "$dirpart/$file"
+    done
+  done
+}
+ ;;
+
+  esac
+done # for ac_tag
+
+
+as_fn_exit 0
+_ACEOF
+ac_clean_files=$ac_clean_files_save
+
+test $ac_write_fail = 0 ||
+  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
+
+
+# configure is writing to config.log, and then calls config.status.
+# config.status does its own redirection, appending to config.log.
+# Unfortunately, on DOS this fails, as config.log is still kept open
+# by configure, so config.status won't be able to write to it; its
+# output is simply discarded.  So we exec the FD to /dev/null,
+# effectively closing config.log, so it can be properly (re)opened and
+# appended to by config.status.  When coming back to configure, we
+# need to make the FD available again.
+if test "$no_create" != yes; then
+  ac_cs_success=:
+  ac_config_status_args=
+  test "$silent" = yes &&
+    ac_config_status_args="$ac_config_status_args --quiet"
+  exec 5>/dev/null
+  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
+  exec 5>>config.log
+  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
+  # would make configure fail if this is the last instruction.
+  $ac_cs_success || as_fn_exit 1
+fi
+if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
+$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
+fi
+
+
+
diff --git a/configure.ac b/configure.ac
index fe81d972..b16f403b 100644
--- a/configure.ac
+++ b/configure.ac
@@ -4,7 +4,7 @@ AC_INIT([jq], m4_esyscmd([tr -d '\n' <VERSION]), [mu@netsoc.tcd.ie],
 dnl Created autoconf implementation thompson@dtosolutions, 26NOV12
 AC_PREREQ([2.61])
 AC_CONFIG_AUX_DIR([config])
-AM_INIT_AUTOMAKE([parallel-tests])
+AM_INIT_AUTOMAKE([parallel-tests foreign])
 AM_SILENT_RULES([yes])
 AC_PROG_CC
 AC_PROG_CC_STDC

From a511d03d85d734b149856289237ae5e2461f6bbe Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 8 May 2013 19:36:52 +0100
Subject: [PATCH 245/284] Configure whether colour is displayed by default
 directly in source

---
 configure.ac | 1 -
 main.c       | 6 ++++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/configure.ac b/configure.ac
index b16f403b..c42425d9 100644
--- a/configure.ac
+++ b/configure.ac
@@ -45,4 +45,3 @@ AC_CONFIG_FILES([Makefile])
 AC_OUTPUT
 
 
-dnl FIXME should disable colour output on windows somehow
diff --git a/main.c b/main.c
index 4b0d496d..774dc61e 100644
--- a/main.c
+++ b/main.c
@@ -74,8 +74,10 @@ static void process(jv value, int flags) {
       jv_free(result);
     } else {
       int dumpopts;
-#ifdef JQ_DEFAULT_ENABLE_COLOR
-      dumpopts = JQ_DEFAULT_ENABLE_COLOR ? JV_PRINT_COLOUR : 0;
+      /* Disable colour by default on Windows builds as Windows
+         terminals tend not to display it correctly */
+#ifdef WIN32
+      dumpopts = 0;
 #else
       dumpopts = isatty(fileno(stdout)) ? JV_PRINT_COLOUR : 0;
 #endif

From c710f91257a4fd02f51d0d4c0fa39b5db33437ec Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 8 May 2013 19:57:05 +0100
Subject: [PATCH 246/284] Add the parser to BUILT_SOURCES

---
 Makefile.am | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile.am b/Makefile.am
index 0810f0c6..52e73379 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -20,7 +20,7 @@ AM_CFLAGS = -Wextra -Wall -Wno-missing-field-initializers	\
 
 # While there is some autoconf macro support for lex/flex, it doesn't support
 # header file creation so we'll use good old make
-BUILT_SOURCES = lexer.h lexer.c
+BUILT_SOURCES = lexer.h lexer.c parser.h parser.c
 lexer.c: lexer.l
 	flex -o lexer.c --header-file=lexer.h lexer.l
 lexer.h: lexer.c

From 63b689bf5430ba82bede270999371795a90a5f39 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 8 May 2013 19:57:29 +0100
Subject: [PATCH 247/284] Use the version number from configure.ac in the
 website.

---
 Makefile.am   |  4 ++++
 Makefile.in   | 10 +++++++---
 configure.ac  |  2 +-
 docs/site.yml |  5 ++++-
 4 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/Makefile.am b/Makefile.am
index 52e73379..58250496 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -50,6 +50,10 @@ TEST_LOG_COMPILER = tests/run
 
 ### Packaging
 
+docs/site.yml: configure.ac
+	sed 's/^jq_version: .*/jq_version: $(VERSION)/' $@ > $@.new
+	mv $@.new $@
+
 # setup is only used by distribution developers, not package developers.
 # Still, as a matter of allowing patching, its not a bad idea to distribute 
 # the developer setup script in the tarball.
diff --git a/Makefile.in b/Makefile.in
index 5a8e9a9c..692cca20 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -359,7 +359,7 @@ AM_CFLAGS = -Wextra -Wall -Wno-missing-field-initializers	\
 
 # While there is some autoconf macro support for lex/flex, it doesn't support
 # header file creation so we'll use good old make
-BUILT_SOURCES = lexer.h lexer.c
+BUILT_SOURCES = lexer.h lexer.c parser.h parser.c
 
 # Tell YACC (bison) autoconf macros that you want a header file created.
 # If the --warnings=all fails, you probably have an old version of bison
@@ -373,8 +373,6 @@ jq_SOURCES = ${JQ_SRC} main.c
 TESTS = tests/all.test
 TEST_LOG_COMPILER = tests/run
 
-### Packaging
-
 # setup is only used by distribution developers, not package developers.
 # Still, as a matter of allowing patching, its not a bad idea to distribute 
 # the developer setup script in the tarball.
@@ -1099,6 +1097,12 @@ lexer.h: lexer.c
 
 main.c: config.h
 
+### Packaging
+
+docs/site.yml: configure.ac
+	sed 's/^jq_version: .*/jq_version: $(VERSION)/' $@ > $@.new
+	mv $@.new $@
+
 jq.1 :
 	cd ${abs_srcdir}/docs; rake manpage > ${abs_builddir}/$@
 
diff --git a/configure.ac b/configure.ac
index c42425d9..5bbc0b55 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1,4 +1,4 @@
-AC_INIT([jq], m4_esyscmd([tr -d '\n' <VERSION]), [mu@netsoc.tcd.ie],
+AC_INIT([jq], [1.2], [mu@netsoc.tcd.ie],
              [jq], [http://stedolan.github.com/jq/])
 
 dnl Created autoconf implementation thompson@dtosolutions, 26NOV12
diff --git a/docs/site.yml b/docs/site.yml
index 863d578d..ae66854f 100644
--- a/docs/site.yml
+++ b/docs/site.yml
@@ -1,7 +1,10 @@
 # The key value pairs found below are available within the templates.
 
 
+# This line is modified by the Makefile. To change the version number,
+# edit the Autoconf version number at the top of configure.ac
 jq_version: 1.2
+
 root: '/jq'
 footer: |
   
@@ -11,4 +14,4 @@ footer: |
 
   jq is licensed under the MIT license (code) and the
   [CC-BY-3.0](http://creativecommons.org/licenses/by/3.0/) license
-  (docs).
\ No newline at end of file
+  (docs).

From 282667bbd408824af6c6fdac46cd16530f591983 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 9 May 2013 01:50:20 +0100
Subject: [PATCH 248/284] Script for cross-compiling jq binaries for other
 platforms.

---
 Makefile.am   |  6 +++++-
 Makefile.in   |  5 ++++-
 build/compile | 31 +++++++++++++++++++++++++++++++
 3 files changed, 40 insertions(+), 2 deletions(-)
 create mode 100755 build/compile

diff --git a/Makefile.am b/Makefile.am
index 58250496..f6fe3a6d 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -22,7 +22,7 @@ AM_CFLAGS = -Wextra -Wall -Wno-missing-field-initializers	\
 # header file creation so we'll use good old make
 BUILT_SOURCES = lexer.h lexer.c parser.h parser.c
 lexer.c: lexer.l
-	flex -o lexer.c --header-file=lexer.h lexer.l
+	flex -o lexer.c --header-file=lexer.h $<
 lexer.h: lexer.c
 
 # Tell YACC (bison) autoconf macros that you want a header file created.
@@ -54,6 +54,10 @@ docs/site.yml: configure.ac
 	sed 's/^jq_version: .*/jq_version: $(VERSION)/' $@ > $@.new
 	mv $@.new $@
 
+install-binaries: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) install-exec
+
+
 # setup is only used by distribution developers, not package developers.
 # Still, as a matter of allowing patching, its not a bad idea to distribute 
 # the developer setup script in the tarball.
diff --git a/Makefile.in b/Makefile.in
index 692cca20..01e011f7 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -1090,7 +1090,7 @@ uninstall-man: uninstall-man1
 	uninstall-man1
 
 lexer.c: lexer.l
-	flex -o lexer.c --header-file=lexer.h lexer.l
+	flex -o lexer.c --header-file=lexer.h $<
 lexer.h: lexer.c
 
 ### Building the jq binary
@@ -1103,6 +1103,9 @@ docs/site.yml: configure.ac
 	sed 's/^jq_version: .*/jq_version: $(VERSION)/' $@ > $@.new
 	mv $@.new $@
 
+install-binaries: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) install-exec
+
 jq.1 :
 	cd ${abs_srcdir}/docs; rake manpage > ${abs_builddir}/$@
 
diff --git a/build/compile b/build/compile
new file mode 100755
index 00000000..7cfa94de
--- /dev/null
+++ b/build/compile
@@ -0,0 +1,31 @@
+#!/bin/sh
+
+# This script is used to cross-compile binaries for 
+# platforms other than the current one
+
+# Usage: $0 <platformname> <configure options>
+# <platformname> is arbitrary, it is the name
+# of the directory which will be created to contain
+# the output binaries.
+
+# e.g. $0 win32 --host=i686-w64-mingw32
+
+set -e
+cd `dirname "$0"`
+
+plat="$1"
+[ -z "$plat" ] && exit 1
+shift
+
+[ -d "$plat" ] || mkdir "$plat"
+rm -rf "$plat/tmp"
+mkdir "$plat/tmp"
+cd "$plat/tmp"
+mkdir install_other
+../../../configure \
+    --prefix="`pwd`/install_other" \
+    --bindir="`pwd`/.." \
+    "$@"
+make install-binaries
+cd ..
+rm -rf tmp
\ No newline at end of file

From 7fbc50239c6906b562501ff62c53254fc8c979ef Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 9 May 2013 02:01:01 +0100
Subject: [PATCH 249/284] Minor docs fix to get rid of Bonsai warnings.

---
 docs/content/3.manual/manual.yml | 4 ++--
 docs/site.yml                    | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index c85fcd57..a2334efa 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -166,7 +166,7 @@ sections:
           You can also look up fields of an object using syntax like
           `.["foo"]` (.foo above is a shorthand version of this). This
           one works for arrays as well, if the key is an
-          integer. Arrays are zero-based (like javascript), so .[2]
+          integer. Arrays are zero-based (like javascript), so `.[2]`
           returns the third element of the array.
 
         examples:
@@ -271,7 +271,7 @@ sections:
           filter into an array (as in `[.items[].name]`)
         
           Once you understand the "," operator, you can look at jq's array
-          syntax in a different light: the expression [1,2,3] is not using a
+          syntax in a different light: the expression `[1,2,3]` is not using a
           built-in syntax for comma-separated arrays, but is instead applying
           the `[]` operator (collect results) to the expression 1,2,3 (which
           produces three different results).
diff --git a/docs/site.yml b/docs/site.yml
index ae66854f..37f82cf3 100644
--- a/docs/site.yml
+++ b/docs/site.yml
@@ -1,5 +1,6 @@
 # The key value pairs found below are available within the templates.
 
+:url: http://stedolan.github.io/jq
 
 # This line is modified by the Makefile. To change the version number,
 # edit the Autoconf version number at the top of configure.ac

From 124bda69937af09ea793787fba645cdb1fc1611e Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 9 May 2013 02:18:28 +0100
Subject: [PATCH 250/284] Add a "binaries" target to the website Rakefile.

---
 docs/Rakefile | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/docs/Rakefile b/docs/Rakefile
index 0caaeca8..356f7111 100644
--- a/docs/Rakefile
+++ b/docs/Rakefile
@@ -64,6 +64,28 @@ task :build do
   Bonsai::Exporter.publish!
 end
 
+$BINARIES = {
+  :osx32 => "--host=i686-apple-darwin10 CFLAGS='-m32 -g -O'",
+  :osx64 => "--host=i686-apple-darwin10 CFLAGS='-m64 -g -O'",
+  :win32 => "--host=i686-w64-mingw32 CFLAGS='-g -O'",
+  :win64 => "--host=x86_64-w64-mingw32 CFLAGS='-g -O'",
+  :linux32 => "--host=x86_64-linux-gnu CFLAGS='-m32 -g -O'",
+  :linux64 => "--host=x86_64-linux-gnu CFLAGS='-m64 -g -O'"
+}
+
+$BINARIES.each do |name, args|
+  file "../build/#{name}" do |t|
+    sh "MAKEFLAGS=-j4 ../build/compile #{name} #{args}"
+  end
+  task :binaries => ["../build/#{name}"]
+end
+
+task :binaries => ["output/download"] do
+  $BINARIES.each do |name, args|
+    FileUtils.cp_r "../build/#{name}", "output/download/"
+  end
+end
+
 def load_manual
   YAML::ENGINE.yamler = 'syck'
   YAML::load(File.open("content/3.manual/manual.yml"))

From d43084086b82a5fb1ef548dd1166f8640b0ef0f3 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 9 May 2013 02:38:57 +0100
Subject: [PATCH 251/284] Make manpage building more robust.

---
 Makefile.am | 7 ++-----
 Makefile.in | 7 ++-----
 2 files changed, 4 insertions(+), 10 deletions(-)

diff --git a/Makefile.am b/Makefile.am
index f6fe3a6d..7deffb3b 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -71,11 +71,8 @@ dist_doc_DATA = README.md COPYING AUTHORS README
 
 man_MANS = jq.1
 
-jq.1 :
-	cd ${abs_srcdir}/docs; rake manpage > ${abs_builddir}/$@
-
-ChangeLog:
-	git log --name-status > $@ || echo "no changelog" > $@
+jq.1: docs/content/3.manual/manual.yml
+	( cd ${abs_srcdir}/docs; rake manpage ) > $@ || rm -f $@
 
 releasetag:
 	git tag -s "jq-$$(cat VERSION)" -m "jq release $$(cat VERSION)"
diff --git a/Makefile.in b/Makefile.in
index 01e011f7..daedb879 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -1106,11 +1106,8 @@ docs/site.yml: configure.ac
 install-binaries: $(BUILT_SOURCES)
 	$(MAKE) $(AM_MAKEFLAGS) install-exec
 
-jq.1 :
-	cd ${abs_srcdir}/docs; rake manpage > ${abs_builddir}/$@
-
-ChangeLog:
-	git log --name-status > $@ || echo "no changelog" > $@
+jq.1: docs/content/3.manual/manual.yml
+	( cd ${abs_srcdir}/docs; rake manpage ) > $@ || rm -f $@
 
 releasetag:
 	git tag -s "jq-$$(cat VERSION)" -m "jq release $$(cat VERSION)"

From 898dc8978b546c3c67a5678cc6101643b160d710 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 9 May 2013 11:30:49 +0100
Subject: [PATCH 252/284] Add a redundant intialisation to squash a gcc
 warning.

---
 execute.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/execute.c b/execute.c
index ddca19ce..7deeb0ae 100644
--- a/execute.c
+++ b/execute.c
@@ -168,7 +168,7 @@ jv jq_next(jq_state *jq) {
       dump_operation(frame_current_bytecode(&jq->frame_stk), pc);
       printf("\t");
       const struct opcode_description* opdesc = opcode_describe(opcode);
-      data_stk_elem* param;
+      data_stk_elem* param = 0;
       int stack_in = opdesc->stack_in;
       if (stack_in == -1) stack_in = pc[1];
       for (int i=0; i<stack_in; i++) {

From f6089a627a932bad7cfd5c8030bf32fcc9888996 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 9 May 2013 11:31:17 +0100
Subject: [PATCH 253/284] Autotools hackery so that "make dist" builds lexer
 and parser.

---
 Makefile.am  |  23 ++---
 Makefile.in  |  52 +++++-----
 config.h.in  |   4 +
 configure    | 262 +++++++++++++++++++++++++++++++++++++++++----------
 configure.ac |  14 +--
 5 files changed, 267 insertions(+), 88 deletions(-)

diff --git a/Makefile.am b/Makefile.am
index 7deffb3b..274197f5 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -3,11 +3,11 @@
 JQ_INCS = jq_parser.h builtin.h bytecode.h compile.h execute.h		\
   forkable_stack.h frame_layout.h jv.h jv_alloc.h jv_aux.h jv_dtoa.h	\
   jv_parse.h jv_unicode.h locfile.h opcode.h opcode_list.h parser.y	\
-  jv_utf8_tables.h
+  jv_utf8_tables.h lexer.l
 
 JQ_SRC = opcode.c bytecode.c compile.c execute.c builtin.c jv.c		\
   jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c jv_aux.c jv_alloc.c	\
-  lexer.c jq_test.c ${JQ_INCS}
+  jq_test.c ${JQ_INCS}
 
 
 ### C build options
@@ -40,13 +40,19 @@ bin_PROGRAMS = jq
 jq_SOURCES = ${JQ_SRC} main.c
 
 
-### Tests
+### Tests (make check)
 
-# this is what gets "make check" to work
 TESTS = tests/all.test
 TEST_LOG_COMPILER = tests/run
 
 
+### Building the manpage
+
+man_MANS = jq.1
+jq.1: docs/content/3.manual/manual.yml
+	( cd ${abs_srcdir}/docs; rake manpage ) > $@ || rm -f $@
+
+
 
 ### Packaging
 
@@ -61,19 +67,14 @@ install-binaries: $(BUILT_SOURCES)
 # setup is only used by distribution developers, not package developers.
 # Still, as a matter of allowing patching, its not a bad idea to distribute 
 # the developer setup script in the tarball.
-EXTRA_DIST = setup.sh config.h.in ChangeLog lexer.l lexer.h	\
-  gen_utf8_tables.py jq.spec testdata
+EXTRA_DIST = config.h.in $(BUILT_SOURCES) $(man_MANS) $(TESTS)	\
+	$(TEST_LOG_COMPILER) gen_utf8_tables.py jq.spec
 
 # README.md is expected in Github projects, good stuff in it, so we'll 
 # distribute it and install it with the package in the doc directory.
 docdir = ${datadir}/doc/${PACKAGE}
 dist_doc_DATA = README.md COPYING AUTHORS README
 
-man_MANS = jq.1
-
-jq.1: docs/content/3.manual/manual.yml
-	( cd ${abs_srcdir}/docs; rake manpage ) > $@ || rm -f $@
-
 releasetag:
 	git tag -s "jq-$$(cat VERSION)" -m "jq release $$(cat VERSION)"
 
diff --git a/Makefile.in b/Makefile.in
index daedb879..9c1f39c7 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -57,8 +57,8 @@ subdir = .
 DIST_COMMON = README $(am__configure_deps) $(dist_doc_DATA) \
 	$(srcdir)/Makefile.am $(srcdir)/Makefile.in \
 	$(srcdir)/config.h.in $(top_srcdir)/configure AUTHORS COPYING \
-	ChangeLog config/compile config/depcomp config/install-sh \
-	config/missing config/ylwrap parser.c parser.h
+	config/compile config/depcomp config/install-sh config/missing \
+	config/ylwrap lexer.c parser.c parser.h
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
 am__aclocal_m4_deps = $(top_srcdir)/configure.ac
 am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
@@ -72,12 +72,12 @@ CONFIG_CLEAN_VPATH_FILES =
 am__installdirs = "$(DESTDIR)$(bindir)" "$(DESTDIR)$(man1dir)" \
 	"$(DESTDIR)$(docdir)"
 PROGRAMS = $(bin_PROGRAMS)
-am__objects_1 = parser.$(OBJEXT)
+am__objects_1 = parser.$(OBJEXT) lexer.$(OBJEXT)
 am__objects_2 = opcode.$(OBJEXT) bytecode.$(OBJEXT) compile.$(OBJEXT) \
 	execute.$(OBJEXT) builtin.$(OBJEXT) jv.$(OBJEXT) \
 	jv_parse.$(OBJEXT) jv_print.$(OBJEXT) jv_dtoa.$(OBJEXT) \
 	jv_unicode.$(OBJEXT) jv_aux.$(OBJEXT) jv_alloc.$(OBJEXT) \
-	lexer.$(OBJEXT) jq_test.$(OBJEXT) $(am__objects_1)
+	jq_test.$(OBJEXT) $(am__objects_1)
 am_jq_OBJECTS = $(am__objects_2) main.$(OBJEXT)
 jq_OBJECTS = $(am_jq_OBJECTS)
 jq_LDADD = $(LDADD)
@@ -98,11 +98,15 @@ LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
 AM_V_CCLD = $(am__v_CCLD_@AM_V@)
 am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
 am__v_CCLD_0 = @echo "  CCLD  " $@;
+LEXCOMPILE = $(LEX) $(AM_LFLAGS) $(LFLAGS)
+AM_V_LEX = $(am__v_LEX_@AM_V@)
+am__v_LEX_ = $(am__v_LEX_@AM_DEFAULT_V@)
+am__v_LEX_0 = @echo "  LEX   " $@;
+YLWRAP = $(top_srcdir)/config/ylwrap
 YACCCOMPILE = $(YACC) $(AM_YFLAGS) $(YFLAGS)
 AM_V_YACC = $(am__v_YACC_@AM_V@)
 am__v_YACC_ = $(am__v_YACC_@AM_DEFAULT_V@)
 am__v_YACC_0 = @echo "  YACC  " $@;
-YLWRAP = $(top_srcdir)/config/ylwrap
 AM_V_GEN = $(am__v_GEN_@AM_V@)
 am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
 am__v_GEN_0 = @echo "  GEN   " $@;
@@ -241,7 +245,7 @@ am__remove_distdir = \
       && rm -rf "$(distdir)" \
       || { sleep 5 && rm -rf "$(distdir)"; }; \
   else :; fi
-DIST_ARCHIVES = $(distdir).tar.gz $(distdir).tar.bz2 $(distdir).zip
+DIST_ARCHIVES = $(distdir).tar.gz
 GZIP_ENV = --best
 distuninstallcheck_listfiles = find . -type f -print
 am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \
@@ -272,6 +276,9 @@ INSTALL_PROGRAM = @INSTALL_PROGRAM@
 INSTALL_SCRIPT = @INSTALL_SCRIPT@
 INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
 LDFLAGS = @LDFLAGS@
+LEX = @LEX@
+LEXLIB = @LEXLIB@
+LEX_OUTPUT_ROOT = @LEX_OUTPUT_ROOT@
 LIBOBJS = @LIBOBJS@
 LIBS = @LIBS@
 LTLIBOBJS = @LTLIBOBJS@
@@ -303,7 +310,6 @@ am__quote = @am__quote@
 am__tar = @am__tar@
 am__untar = @am__untar@
 bindir = @bindir@
-bison_cmd = @bison_cmd@
 build_alias = @build_alias@
 builddir = @builddir@
 datadir = @datadir@
@@ -343,11 +349,11 @@ valgrind_cmd = @valgrind_cmd@
 JQ_INCS = jq_parser.h builtin.h bytecode.h compile.h execute.h		\
   forkable_stack.h frame_layout.h jv.h jv_alloc.h jv_aux.h jv_dtoa.h	\
   jv_parse.h jv_unicode.h locfile.h opcode.h opcode_list.h parser.y	\
-  jv_utf8_tables.h
+  jv_utf8_tables.h lexer.l
 
 JQ_SRC = opcode.c bytecode.c compile.c execute.c builtin.c jv.c		\
   jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c jv_aux.c jv_alloc.c	\
-  lexer.c jq_test.c ${JQ_INCS}
+  jq_test.c ${JQ_INCS}
 
 
 ### C build options
@@ -367,25 +373,25 @@ BUILT_SOURCES = lexer.h lexer.c parser.h parser.c
 AM_YFLAGS = --warnings=all -d
 jq_SOURCES = ${JQ_SRC} main.c
 
-### Tests
-
-# this is what gets "make check" to work
+### Tests (make check)
 TESTS = tests/all.test
 TEST_LOG_COMPILER = tests/run
 
+### Building the manpage
+man_MANS = jq.1
+
 # setup is only used by distribution developers, not package developers.
 # Still, as a matter of allowing patching, its not a bad idea to distribute 
 # the developer setup script in the tarball.
-EXTRA_DIST = setup.sh config.h.in ChangeLog lexer.l lexer.h	\
-  gen_utf8_tables.py jq.spec testdata
+EXTRA_DIST = config.h.in $(BUILT_SOURCES) $(man_MANS) $(TESTS)	\
+	$(TEST_LOG_COMPILER) gen_utf8_tables.py jq.spec
 
 dist_doc_DATA = README.md COPYING AUTHORS README
-man_MANS = jq.1
 all: $(BUILT_SOURCES) config.h
 	$(MAKE) $(AM_MAKEFLAGS) all-am
 
 .SUFFIXES:
-.SUFFIXES: .c .html .log .o .obj .test .test$(EXEEXT) .y
+.SUFFIXES: .c .html .l .log .o .obj .test .test$(EXEEXT) .y
 am--refresh: Makefile
 	@:
 $(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
@@ -519,6 +525,9 @@ distclean-compile:
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c `$(CYGPATH_W) '$<'`
 
+.l.c:
+	$(AM_V_LEX)$(am__skiplex) $(SHELL) $(YLWRAP) $< $(LEX_OUTPUT_ROOT).c $@ -- $(LEXCOMPILE)
+
 .y.c:
 	$(AM_V_YACC)$(am__skipyacc) $(SHELL) $(YLWRAP) $< y.tab.c $@ y.tab.h $*.h y.output $*.output -- $(YACCCOMPILE)
 install-man1: $(man_MANS)
@@ -824,6 +833,7 @@ distdir: $(DISTFILES)
 dist-gzip: distdir
 	tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
 	$(am__remove_distdir)
+
 dist-bzip2: distdir
 	tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2
 	$(am__remove_distdir)
@@ -847,6 +857,7 @@ dist-tarZ: distdir
 dist-shar: distdir
 	shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz
 	$(am__remove_distdir)
+
 dist-zip: distdir
 	-rm -f $(distdir).zip
 	zip -rq $(distdir).zip $(distdir)
@@ -854,9 +865,6 @@ dist-zip: distdir
 
 dist dist-all: distdir
 	tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
-	tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2
-	-rm -f $(distdir).zip
-	zip -rq $(distdir).zip $(distdir)
 	$(am__remove_distdir)
 
 # This target untars the dist file and tries a VPATH configuration.  Then
@@ -988,6 +996,7 @@ distclean-generic:
 maintainer-clean-generic:
 	@echo "This command is intended for maintainers to use"
 	@echo "it deletes files that may require special tools to rebuild."
+	-rm -f lexer.c
 	-rm -f parser.c
 	-rm -f parser.h
 	-test -z "$(BUILT_SOURCES)" || rm -f $(BUILT_SOURCES)
@@ -1096,6 +1105,8 @@ lexer.h: lexer.c
 ### Building the jq binary
 
 main.c: config.h
+jq.1: docs/content/3.manual/manual.yml
+	( cd ${abs_srcdir}/docs; rake manpage ) > $@ || rm -f $@
 
 ### Packaging
 
@@ -1106,9 +1117,6 @@ docs/site.yml: configure.ac
 install-binaries: $(BUILT_SOURCES)
 	$(MAKE) $(AM_MAKEFLAGS) install-exec
 
-jq.1: docs/content/3.manual/manual.yml
-	( cd ${abs_srcdir}/docs; rake manpage ) > $@ || rm -f $@
-
 releasetag:
 	git tag -s "jq-$$(cat VERSION)" -m "jq release $$(cat VERSION)"
 
diff --git a/config.h.in b/config.h.in
index dbfa12bc..46b33c08 100644
--- a/config.h.in
+++ b/config.h.in
@@ -26,3 +26,7 @@
 
 /* Version number of package */
 #undef VERSION
+
+/* Define to 1 if `lex' declares `yytext' as a `char *' by default, not a
+   `char[]'. */
+#undef YYTEXT_POINTER
diff --git a/configure b/configure
index 7170e4a2..9520197a 100755
--- a/configure
+++ b/configure
@@ -589,8 +589,10 @@ am__EXEEXT_TRUE
 LTLIBOBJS
 LIBOBJS
 valgrind_cmd
-bison_cmd
 flex_cmd
+LEXLIB
+LEX_OUTPUT_ROOT
+LEX
 YFLAGS
 YACC
 CPP
@@ -1483,6 +1485,52 @@ fi
   as_fn_set_status $ac_retval
 
 } # ac_fn_c_try_cpp
+
+# ac_fn_c_try_link LINENO
+# -----------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_link ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext conftest$ac_exeext
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest$ac_exeext && {
+	 test "$cross_compiling" = yes ||
+	 test -x conftest$ac_exeext
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
+  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
+  # interfere with the next link command; also delete a directory that is
+  # left behind by Apple's compiler.  We do this before executing the actions.
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_link
 cat >config.log <<_ACEOF
 This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
@@ -3966,6 +4014,171 @@ fi
 
 
 
+
+for ac_prog in flex lex
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_LEX+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$LEX"; then
+  ac_cv_prog_LEX="$LEX" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_LEX="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+LEX=$ac_cv_prog_LEX
+if test -n "$LEX"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LEX" >&5
+$as_echo "$LEX" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$LEX" && break
+done
+test -n "$LEX" || LEX=":"
+
+if test "x$LEX" != "x:"; then
+  cat >conftest.l <<_ACEOF
+%%
+a { ECHO; }
+b { REJECT; }
+c { yymore (); }
+d { yyless (1); }
+e { /* IRIX 6.5 flex 2.5.4 underquotes its yyless argument.  */
+    yyless ((input () != 0)); }
+f { unput (yytext[0]); }
+. { BEGIN INITIAL; }
+%%
+#ifdef YYTEXT_POINTER
+extern char *yytext;
+#endif
+int
+main (void)
+{
+  return ! yylex () + ! yywrap ();
+}
+_ACEOF
+{ { ac_try="$LEX conftest.l"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$LEX conftest.l") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking lex output file root" >&5
+$as_echo_n "checking lex output file root... " >&6; }
+if ${ac_cv_prog_lex_root+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+
+if test -f lex.yy.c; then
+  ac_cv_prog_lex_root=lex.yy
+elif test -f lexyy.c; then
+  ac_cv_prog_lex_root=lexyy
+else
+  as_fn_error $? "cannot find output from $LEX; giving up" "$LINENO" 5
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_lex_root" >&5
+$as_echo "$ac_cv_prog_lex_root" >&6; }
+LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
+
+if test -z "${LEXLIB+set}"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking lex library" >&5
+$as_echo_n "checking lex library... " >&6; }
+if ${ac_cv_lib_lex+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+
+    ac_save_LIBS=$LIBS
+    ac_cv_lib_lex='none needed'
+    for ac_lib in '' -lfl -ll; do
+      LIBS="$ac_lib $ac_save_LIBS"
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+`cat $LEX_OUTPUT_ROOT.c`
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_lex=$ac_lib
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+      test "$ac_cv_lib_lex" != 'none needed' && break
+    done
+    LIBS=$ac_save_LIBS
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_lex" >&5
+$as_echo "$ac_cv_lib_lex" >&6; }
+  test "$ac_cv_lib_lex" != 'none needed' && LEXLIB=$ac_cv_lib_lex
+fi
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether yytext is a pointer" >&5
+$as_echo_n "checking whether yytext is a pointer... " >&6; }
+if ${ac_cv_prog_lex_yytext_pointer+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  # POSIX says lex can declare yytext either as a pointer or an array; the
+# default is implementation-dependent.  Figure out which it is, since
+# not all implementations provide the %pointer and %array declarations.
+ac_cv_prog_lex_yytext_pointer=no
+ac_save_LIBS=$LIBS
+LIBS="$LEXLIB $ac_save_LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+  #define YYTEXT_POINTER 1
+`cat $LEX_OUTPUT_ROOT.c`
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_prog_lex_yytext_pointer=yes
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_save_LIBS
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_lex_yytext_pointer" >&5
+$as_echo "$ac_cv_prog_lex_yytext_pointer" >&6; }
+if test $ac_cv_prog_lex_yytext_pointer = yes; then
+
+$as_echo "#define YYTEXT_POINTER 1" >>confdefs.h
+
+fi
+rm -f conftest.l $LEX_OUTPUT_ROOT.c
+
+fi
+if test "x$LEX" != xflex; then
+  LEX="$SHELL $missing_dir/missing flex"
+fi
+
+
 for ac_prog in flex
 do
   # Extract the first word of "$ac_prog", so it can be a program name with args.
@@ -4013,53 +4226,6 @@ if test x$flex_cmd = "x" ; then
 $as_echo "$as_me: flex is required to patch jq." >&6;}
 fi
 
-for ac_prog in bison
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_bison_cmd+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$bison_cmd"; then
-  ac_cv_prog_bison_cmd="$bison_cmd" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_bison_cmd="$ac_prog"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-bison_cmd=$ac_cv_prog_bison_cmd
-if test -n "$bison_cmd"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $bison_cmd" >&5
-$as_echo "$bison_cmd" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-  test -n "$bison_cmd" && break
-done
-
-if test x$bison_cmd = "x" ; then
-    { $as_echo "$as_me:${as_lineno-$LINENO}: bison is required to patch jq." >&5
-$as_echo "$as_me: bison is required to patch jq." >&6;}
-fi
-
 for ac_prog in valgrind
 do
   # Extract the first word of "$ac_prog", so it can be a program name with args.
diff --git a/configure.ac b/configure.ac
index 5bbc0b55..503ceaa0 100644
--- a/configure.ac
+++ b/configure.ac
@@ -20,18 +20,18 @@ dnl
 dnl these program checks should probably be deleted
 dnl
 
+AC_PROG_LEX
+if test "x$LEX" != xflex; then
+  LEX="$SHELL $missing_dir/missing flex"
+fi
+
+
 dnl Check for flex
 AC_CHECK_PROGS(flex_cmd, flex)
 if test x$flex_cmd = "x" ; then
     AC_MSG_NOTICE([flex is required to patch jq.])
 fi
 
-dnl Check for bison
-AC_CHECK_PROGS(bison_cmd, bison)
-if test x$bison_cmd = "x" ; then
-    AC_MSG_NOTICE([bison is required to patch jq.])
-fi
-
 dnl Check for valgrind
 AC_CHECK_PROGS(valgrind_cmd, valgrind)
 if test x$valgrind_cmd = "x" ; then
@@ -40,7 +40,7 @@ fi
 
 dnl AC_CONFIG_MACRO_DIR([m4])
 AC_CONFIG_HEADERS(config.h)
-AM_INIT_AUTOMAKE([-Wall dist-bzip2 dist-zip])
+AM_INIT_AUTOMAKE([-Wall])
 AC_CONFIG_FILES([Makefile])
 AC_OUTPUT
 

From a592c98461728e22423a5c6ecfd5cebf0150adf0 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 9 May 2013 13:10:09 +0100
Subject: [PATCH 254/284] Fail properly when attempting to build manpage
 without rake

---
 Makefile.am | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile.am b/Makefile.am
index 274197f5..b077842f 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -50,7 +50,7 @@ TEST_LOG_COMPILER = tests/run
 
 man_MANS = jq.1
 jq.1: docs/content/3.manual/manual.yml
-	( cd ${abs_srcdir}/docs; rake manpage ) > $@ || rm -f $@
+	( cd ${abs_srcdir}/docs; rake manpage ) > $@ || { rm -f $@; false; }
 
 
 

From d75414bc94ee1e9ba74336350755df60330edbe7 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 9 May 2013 13:40:00 +0100
Subject: [PATCH 255/284] support for out-of-tree tests

---
 Makefile.am | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Makefile.am b/Makefile.am
index b077842f..abf32376 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -43,13 +43,13 @@ jq_SOURCES = ${JQ_SRC} main.c
 ### Tests (make check)
 
 TESTS = tests/all.test
-TEST_LOG_COMPILER = tests/run
+TEST_LOG_COMPILER = ${srcdir}/tests/run
 
 
 ### Building the manpage
 
 man_MANS = jq.1
-jq.1: docs/content/3.manual/manual.yml
+jq.1: $(srcdir)/docs/content/3.manual/manual.yml
 	( cd ${abs_srcdir}/docs; rake manpage ) > $@ || { rm -f $@; false; }
 
 

From 12d2d4d1f53f7f1c6d53d0eb82672cdbd75a6df9 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 9 May 2013 15:22:38 +0100
Subject: [PATCH 256/284] Don't build the manpage unless there's a working Ruby
 setup.

---
 Makefile.am  | 13 +++++++++++++
 configure.ac | 26 ++++++++++++++++++--------
 jq.1.default |  0
 3 files changed, 31 insertions(+), 8 deletions(-)
 create mode 100644 jq.1.default

diff --git a/Makefile.am b/Makefile.am
index abf32376..96a885c1 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -49,8 +49,19 @@ TEST_LOG_COMPILER = ${srcdir}/tests/run
 ### Building the manpage
 
 man_MANS = jq.1
+.PHONY: real_docs
+if ENABLE_DOCS
 jq.1: $(srcdir)/docs/content/3.manual/manual.yml
 	( cd ${abs_srcdir}/docs; rake manpage ) > $@ || { rm -f $@; false; }
+real_docs:
+	true
+else
+jq.1: jq.1.default
+	cp $^ $@
+real_docs:
+	@echo "Cannot build full manpage" > /dev/stderr
+	false
+endif
 
 
 
@@ -63,6 +74,8 @@ docs/site.yml: configure.ac
 install-binaries: $(BUILT_SOURCES)
 	$(MAKE) $(AM_MAKEFLAGS) install-exec
 
+# Ensure "make dist" fails when we can't build the real manpage
+dist-hook: real_docs
 
 # setup is only used by distribution developers, not package developers.
 # Still, as a matter of allowing patching, its not a bad idea to distribute 
diff --git a/configure.ac b/configure.ac
index 503ceaa0..32ecdf7b 100644
--- a/configure.ac
+++ b/configure.ac
@@ -26,18 +26,28 @@ if test "x$LEX" != xflex; then
 fi
 
 
-dnl Check for flex
-AC_CHECK_PROGS(flex_cmd, flex)
-if test x$flex_cmd = "x" ; then
-    AC_MSG_NOTICE([flex is required to patch jq.])
-fi
-
 dnl Check for valgrind
 AC_CHECK_PROGS(valgrind_cmd, valgrind)
-if test x$valgrind_cmd = "x" ; then
-    AC_MSG_NOTICE([valgrind is required to test jq.])
+if test "x$valgrind_cmd" = "x" ; then
+    AC_MSG_WARN([valgrind is required to test jq.])
 fi
 
+
+dnl Don't attempt to build docs if there's no Ruby lying around
+AC_ARG_ENABLE([docs], 
+   AC_HELP_STRING([--disable-docs], [don't build docs]))
+
+AS_IF([test "x$enable_docs" != "xno"],[
+   AC_CHECK_PROG(bundle_cmd, bundle)
+   AS_IF([test "x$bundle_cmd" = "x" || \
+      ! ( cd ${srcdir}/docs; bundle check 2>/dev/null )],[
+         AC_MSG_WARN([no bundler])
+         enable_docs=no
+   ])
+])
+
+AM_CONDITIONAL([ENABLE_DOCS], [test "x$enable_docs" != xno])
+
 dnl AC_CONFIG_MACRO_DIR([m4])
 AC_CONFIG_HEADERS(config.h)
 AM_INIT_AUTOMAKE([-Wall])
diff --git a/jq.1.default b/jq.1.default
new file mode 100644
index 00000000..e69de29b

From e6494857fc188f50808fcf64e4f43188a455f264 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 9 May 2013 20:27:12 +0100
Subject: [PATCH 257/284] Add some build instructions for how to install doc
 dependencies.

jq can now build without Ruby, but you won't get a nice manpage.
---
 Makefile.am             | 23 +++++++++++++++--------
 configure.ac            | 15 ++++++++++++---
 docs/README.md          | 25 +++++++++++++++++++++++++
 docs/Rakefile           |  5 +++++
 docs/default_manpage.md | 22 ++++++++++++++++++++++
 jq.1.default            | 39 +++++++++++++++++++++++++++++++++++++++
 6 files changed, 118 insertions(+), 11 deletions(-)
 create mode 100644 docs/README.md
 create mode 100644 docs/default_manpage.md

diff --git a/Makefile.am b/Makefile.am
index 96a885c1..33175cd1 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,4 +1,4 @@
-### C source files to be built
+### C source files to be built and distributed.
 
 JQ_INCS = jq_parser.h builtin.h bytecode.h compile.h execute.h		\
   forkable_stack.h frame_layout.h jv.h jv_alloc.h jv_aux.h jv_dtoa.h	\
@@ -31,7 +31,6 @@ lexer.h: lexer.c
 AM_YFLAGS = --warnings=all -d
 
 
-
 ### Building the jq binary
 
 main.c: config.h
@@ -48,23 +47,31 @@ TEST_LOG_COMPILER = ${srcdir}/tests/run
 
 ### Building the manpage
 
+# If ENABLE_DOCS is not set, just copy jq.1.default to jq.1
+# The real_docs target succeeds (possibly after building jq.1) only if ENABLE_DOCS is set
+# Thus, making "dist" depend on "real_docs" ensures that we never build a tarball with
+# a stub manpage.
+
 man_MANS = jq.1
 .PHONY: real_docs
 if ENABLE_DOCS
 jq.1: $(srcdir)/docs/content/3.manual/manual.yml
-	( cd ${abs_srcdir}/docs; rake manpage ) > $@ || { rm -f $@; false; }
-real_docs:
-	true
+	( cd ${abs_srcdir}/docs; '$(BUNDLER)' exec rake manpage ) > $@ || { rm -f $@; false; }
+jq.1.default: $(srcdir)/docs/default_manpage.md
+	( cd ${abs_srcdir}/docs; '$(BUNDLER)' exec rake manpage_default ) > $@ || { rm -f $@; false; }
+real_docs: jq.1
+	cmp jq.1 $(srcdir)/jq.1.default > /dev/null && { rm -f jq.1; $(MAKE) $(AM_MAKEFLAGS) jq.1; }
 else
-jq.1: jq.1.default
+jq.1: $(srcdir)/jq.1.default
 	cp $^ $@
 real_docs:
-	@echo "Cannot build full manpage" > /dev/stderr
+	@echo "Ruby dependencies not found, cannot build manpage." > /dev/stderr
+	@echo "Follow the instructions in docs/README.md to install them" > /dev/stderr
+	@echo "and then rerun ./configure" > /dev/stderr
 	false
 endif
 
 
-
 ### Packaging
 
 docs/site.yml: configure.ac
diff --git a/configure.ac b/configure.ac
index 32ecdf7b..0ad893af 100644
--- a/configure.ac
+++ b/configure.ac
@@ -34,19 +34,28 @@ fi
 
 
 dnl Don't attempt to build docs if there's no Ruby lying around
-AC_ARG_ENABLE([docs], 
+AC_ARG_ENABLE([docs],
    AC_HELP_STRING([--disable-docs], [don't build docs]))
 
 AS_IF([test "x$enable_docs" != "xno"],[
-   AC_CHECK_PROG(bundle_cmd, bundle)
+   AC_CHECK_PROGS(bundle_cmd, bundle)
    AS_IF([test "x$bundle_cmd" = "x" || \
-      ! ( cd ${srcdir}/docs; bundle check 2>/dev/null )],[
+      ! ( cd ${srcdir}/docs; "$bundle_cmd" check 2>/dev/null )],[
          AC_MSG_WARN([no bundler])
+         cat <<EOF
+*****************************************************************
+*  Ruby dependencies for building jq documentation not found.   *
+*  You can still build, install and hack on jq, but the manpage *
+*  will not be rebuilt and some of the tests won't run.         *
+*  See docs/README.md for how to install the docs dependencies. *
+*****************************************************************
+EOF
          enable_docs=no
    ])
 ])
 
 AM_CONDITIONAL([ENABLE_DOCS], [test "x$enable_docs" != xno])
+AC_SUBST([BUNDLER], ["$bundle_cmd"])
 
 dnl AC_CONFIG_MACRO_DIR([m4])
 AC_CONFIG_HEADERS(config.h)
diff --git a/docs/README.md b/docs/README.md
new file mode 100644
index 00000000..58e7dca7
--- /dev/null
+++ b/docs/README.md
@@ -0,0 +1,25 @@
+Documentation
+=============
+
+The jq website, manpages and some of the tests are generated from this
+directory. The directory holds a [Bonsai](http://tinytree.info)
+website, and the manual is a YAML file in `content/3.manual`.
+
+To build the documentation (including building the jq manpage), you'll
+need a working Ruby setup. The easiest way to get one is to install
+RVM and Ruby 1.9.3 like so:
+
+    \curl -L https://get.rvm.io | bash -s stable --ruby=1.9.3
+
+After that finishes installing, you'll need to make sure RVM is on
+your path by doing `source $HOME/.rvm/scripts/rvm`, or just opening a
+new shell. See <http://rvm.io> for more info on RVM.
+
+Once RVM is installed, you can install all the dependencies for jq's
+documentation build by running this from the `docs` directory:
+
+    bundle install
+
+When bundle manages to install the dependencies, rerun `./configure`
+in the jq root directory and then the Makefile will be able to
+generate the jq manpage.
diff --git a/docs/Rakefile b/docs/Rakefile
index 356f7111..f8072072 100644
--- a/docs/Rakefile
+++ b/docs/Rakefile
@@ -120,6 +120,10 @@ task :manpage do
   end  
 end
 
+task :manpage_default => ["default_manpage.md"] do
+  puts Ronn::Document.new("default_manpage.md").convert('roff').gsub(/<\/?code>/,"")
+end
+
 task :mantests do
   load_manual['sections'].each do |section|
     (section['entries'] || []).each do |entry|
@@ -132,3 +136,4 @@ task :mantests do
     end
   end
 end
+
diff --git a/docs/default_manpage.md b/docs/default_manpage.md
new file mode 100644
index 00000000..f1a29a72
--- /dev/null
+++ b/docs/default_manpage.md
@@ -0,0 +1,22 @@
+jq(1) -- Command-line JSON processor
+====================================
+
+## DESCRIPTION
+
+`jq` can transform JSON in various ways, by selecting, iterating,
+reducing and otherwise mangling JSON documents. 
+
+This version of `jq` was built without a manual, so this manpage is a
+stub. For full documentation of the `jq` language, see:
+
+    http://stedolan.github.com/jq
+    
+## BUGS
+
+Presumably. Report them or discuss them at:
+
+    https://github.com/stedolan/jq/issues
+
+## AUTHOR
+
+Stephen Dolan `<mu@netsoc.tcd.ie>`
diff --git a/jq.1.default b/jq.1.default
index e69de29b..c556f794 100644
--- a/jq.1.default
+++ b/jq.1.default
@@ -0,0 +1,39 @@
+.\" generated with Ronn/v0.7.3
+.\" http://github.com/rtomayko/ronn/tree/0.7.3
+.
+.TH "JQ" "1" "May 2013" "" ""
+.
+.SH "NAME"
+\fBjq\fR \- Command\-line JSON processor
+.
+.SH "DESCRIPTION"
+\fBjq\fR can transform JSON in various ways, by selecting, iterating, reducing and otherwise mangling JSON documents\.
+.
+.P
+This version of \fBjq\fR was built without a manual, so this manpage is a stub\. For full documentation of the \fBjq\fR language, see:
+.
+.IP "" 4
+.
+.nf
+
+http://stedolan\.github\.com/jq
+.
+.fi
+.
+.IP "" 0
+.
+.SH "BUGS"
+Presumably\. Report them or discuss them at:
+.
+.IP "" 4
+.
+.nf
+
+https://github\.com/stedolan/jq/issues
+.
+.fi
+.
+.IP "" 0
+.
+.SH "AUTHOR"
+Stephen Dolan \fB<mu@netsoc\.tcd\.ie>\fR

From ba4bb136bbe371d96388fc505d036327581d7f2d Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 9 May 2013 20:43:26 +0100
Subject: [PATCH 258/284] Fix manpage build.

---
 Makefile.am | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Makefile.am b/Makefile.am
index 33175cd1..fb9aee03 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -60,7 +60,9 @@ jq.1: $(srcdir)/docs/content/3.manual/manual.yml
 jq.1.default: $(srcdir)/docs/default_manpage.md
 	( cd ${abs_srcdir}/docs; '$(BUNDLER)' exec rake manpage_default ) > $@ || { rm -f $@; false; }
 real_docs: jq.1
-	cmp jq.1 $(srcdir)/jq.1.default > /dev/null && { rm -f jq.1; $(MAKE) $(AM_MAKEFLAGS) jq.1; }
+	if cmp jq.1 $(srcdir)/jq.1.default > /dev/null; then\
+	  rm -f jq.1; $(MAKE) $(AM_MAKEFLAGS) jq.1;\
+	fi
 else
 jq.1: $(srcdir)/jq.1.default
 	cp $^ $@

From 18cf4ad4750fdd79eaabb2d4f5281db1d56a1bfa Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 9 May 2013 20:53:51 +0100
Subject: [PATCH 259/284] Add the docs to the distributed tarballs

---
 Makefile.am | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/Makefile.am b/Makefile.am
index fb9aee03..be8e9140 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -86,11 +86,16 @@ install-binaries: $(BUILT_SOURCES)
 # Ensure "make dist" fails when we can't build the real manpage
 dist-hook: real_docs
 
+DOC_FILES = docs/content docs/public docs/templates docs/site.yml	\
+            docs/Gemfile docs/Gemfile.lock docs/Rakefile docs/README.md \
+            docs/default_manpage.md jq.1.default
+
 # setup is only used by distribution developers, not package developers.
 # Still, as a matter of allowing patching, its not a bad idea to distribute 
 # the developer setup script in the tarball.
 EXTRA_DIST = config.h.in $(BUILT_SOURCES) $(man_MANS) $(TESTS)	\
-	$(TEST_LOG_COMPILER) gen_utf8_tables.py jq.spec
+	$(TEST_LOG_COMPILER) gen_utf8_tables.py jq.spec \
+	$(DOC_FILES)
 
 # README.md is expected in Github projects, good stuff in it, so we'll 
 # distribute it and install it with the package in the doc directory.

From d03149f4df5c91c16c77d5bda89cdcf724113544 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sat, 11 May 2013 14:48:39 +0100
Subject: [PATCH 260/284] Rake task to build source distribution for website

---
 docs/Rakefile | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/docs/Rakefile b/docs/Rakefile
index f8072072..6ef83d01 100644
--- a/docs/Rakefile
+++ b/docs/Rakefile
@@ -137,3 +137,10 @@ task :mantests do
   end
 end
 
+directory "output/download/source"
+task :tarball => ["output/download/source"] do
+  sh "cd ..; make dist"
+  sh "cp ../jq-*.tar.gz output/download/source"
+end
+
+task :dist => [:build, :binaries, :tarball]

From 4a5405e4b824b9f935f3f398c53fb83b8d07a15c Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sat, 11 May 2013 14:57:58 +0100
Subject: [PATCH 261/284] Rake task to build website including source dist and
 binaries.

---
 .gitignore                            | 4 ++--
 build/.gitignore                      | 1 +
 docs/Rakefile                         | 4 ++--
 build/compile => scripts/crosscompile | 2 +-
 4 files changed, 6 insertions(+), 5 deletions(-)
 create mode 100644 build/.gitignore
 rename build/compile => scripts/crosscompile (95%)

diff --git a/.gitignore b/.gitignore
index 96cd2892..06c87dda 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,7 +1,6 @@
 *.o
 *~
 
-build
 jq
 jq.1
 
@@ -22,4 +21,5 @@ config.log
 config.status
 autom4te.cache
 config.h
-Makefile
\ No newline at end of file
+Makefile
+jq-*.tar.gz
\ No newline at end of file
diff --git a/build/.gitignore b/build/.gitignore
new file mode 100644
index 00000000..f59ec20a
--- /dev/null
+++ b/build/.gitignore
@@ -0,0 +1 @@
+*
\ No newline at end of file
diff --git a/docs/Rakefile b/docs/Rakefile
index 6ef83d01..4ca5752f 100644
--- a/docs/Rakefile
+++ b/docs/Rakefile
@@ -75,7 +75,7 @@ $BINARIES = {
 
 $BINARIES.each do |name, args|
   file "../build/#{name}" do |t|
-    sh "MAKEFLAGS=-j4 ../build/compile #{name} #{args}"
+    sh "MAKEFLAGS=-j4 ../scripts/crosscompile #{name} #{args}"
   end
   task :binaries => ["../build/#{name}"]
 end
@@ -139,7 +139,7 @@ end
 
 directory "output/download/source"
 task :tarball => ["output/download/source"] do
-  sh "cd ..; make dist"
+  sh "cd ..; ./configure && make dist && make distclean"
   sh "cp ../jq-*.tar.gz output/download/source"
 end
 
diff --git a/build/compile b/scripts/crosscompile
similarity index 95%
rename from build/compile
rename to scripts/crosscompile
index 7cfa94de..7ee086b7 100755
--- a/build/compile
+++ b/scripts/crosscompile
@@ -11,7 +11,7 @@
 # e.g. $0 win32 --host=i686-w64-mingw32
 
 set -e
-cd `dirname "$0"`
+cd `dirname "$0"`/../build
 
 plat="$1"
 [ -z "$plat" ] && exit 1

From 4b1b9c219a37488e4b113e87216da121671b2297 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sat, 11 May 2013 15:15:56 +0100
Subject: [PATCH 262/284] Delete some Autotools junk and update README.

Autotools autogenerated files that change frequently have been
removed, those that don't are still checked in.
---
 .gitignore  |    5 +-
 Makefile.in | 1142 ----------
 README.md   |   15 +-
 aclocal.m4  | 1063 ---------
 configure   | 5932 ---------------------------------------------------
 5 files changed, 16 insertions(+), 8141 deletions(-)
 delete mode 100644 Makefile.in
 delete mode 100644 aclocal.m4
 delete mode 100755 configure

diff --git a/.gitignore b/.gitignore
index 06c87dda..a8250a50 100644
--- a/.gitignore
+++ b/.gitignore
@@ -22,4 +22,7 @@ config.status
 autom4te.cache
 config.h
 Makefile
-jq-*.tar.gz
\ No newline at end of file
+jq-*.tar.gz
+configure
+aclocal.m4
+Makefile.in
diff --git a/Makefile.in b/Makefile.in
deleted file mode 100644
index 9c1f39c7..00000000
--- a/Makefile.in
+++ /dev/null
@@ -1,1142 +0,0 @@
-# Makefile.in generated by automake 1.11.6 from Makefile.am.
-# @configure_input@
-
-# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
-# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
-# Foundation, Inc.
-# This Makefile.in is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
-# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-# PARTICULAR PURPOSE.
-
-@SET_MAKE@
-
-### C source files to be built
-
-
-VPATH = @srcdir@
-am__make_dryrun = \
-  { \
-    am__dry=no; \
-    case $$MAKEFLAGS in \
-      *\\[\ \	]*) \
-        echo 'am--echo: ; @echo "AM"  OK' | $(MAKE) -f - 2>/dev/null \
-          | grep '^AM OK$$' >/dev/null || am__dry=yes;; \
-      *) \
-        for am__flg in $$MAKEFLAGS; do \
-          case $$am__flg in \
-            *=*|--*) ;; \
-            *n*) am__dry=yes; break;; \
-          esac; \
-        done;; \
-    esac; \
-    test $$am__dry = yes; \
-  }
-pkgdatadir = $(datadir)/@PACKAGE@
-pkgincludedir = $(includedir)/@PACKAGE@
-pkglibdir = $(libdir)/@PACKAGE@
-pkglibexecdir = $(libexecdir)/@PACKAGE@
-am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
-install_sh_DATA = $(install_sh) -c -m 644
-install_sh_PROGRAM = $(install_sh) -c
-install_sh_SCRIPT = $(install_sh) -c
-INSTALL_HEADER = $(INSTALL_DATA)
-transform = $(program_transform_name)
-NORMAL_INSTALL = :
-PRE_INSTALL = :
-POST_INSTALL = :
-NORMAL_UNINSTALL = :
-PRE_UNINSTALL = :
-POST_UNINSTALL = :
-bin_PROGRAMS = jq$(EXEEXT)
-subdir = .
-DIST_COMMON = README $(am__configure_deps) $(dist_doc_DATA) \
-	$(srcdir)/Makefile.am $(srcdir)/Makefile.in \
-	$(srcdir)/config.h.in $(top_srcdir)/configure AUTHORS COPYING \
-	config/compile config/depcomp config/install-sh config/missing \
-	config/ylwrap lexer.c parser.c parser.h
-ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
-am__aclocal_m4_deps = $(top_srcdir)/configure.ac
-am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
-	$(ACLOCAL_M4)
-am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \
- configure.lineno config.status.lineno
-mkinstalldirs = $(install_sh) -d
-CONFIG_HEADER = config.h
-CONFIG_CLEAN_FILES =
-CONFIG_CLEAN_VPATH_FILES =
-am__installdirs = "$(DESTDIR)$(bindir)" "$(DESTDIR)$(man1dir)" \
-	"$(DESTDIR)$(docdir)"
-PROGRAMS = $(bin_PROGRAMS)
-am__objects_1 = parser.$(OBJEXT) lexer.$(OBJEXT)
-am__objects_2 = opcode.$(OBJEXT) bytecode.$(OBJEXT) compile.$(OBJEXT) \
-	execute.$(OBJEXT) builtin.$(OBJEXT) jv.$(OBJEXT) \
-	jv_parse.$(OBJEXT) jv_print.$(OBJEXT) jv_dtoa.$(OBJEXT) \
-	jv_unicode.$(OBJEXT) jv_aux.$(OBJEXT) jv_alloc.$(OBJEXT) \
-	jq_test.$(OBJEXT) $(am__objects_1)
-am_jq_OBJECTS = $(am__objects_2) main.$(OBJEXT)
-jq_OBJECTS = $(am_jq_OBJECTS)
-jq_LDADD = $(LDADD)
-DEFAULT_INCLUDES = -I.@am__isrc@
-depcomp = $(SHELL) $(top_srcdir)/config/depcomp
-am__depfiles_maybe = depfiles
-am__mv = mv -f
-COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
-	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
-AM_V_CC = $(am__v_CC_@AM_V@)
-am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
-am__v_CC_0 = @echo "  CC    " $@;
-AM_V_at = $(am__v_at_@AM_V@)
-am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
-am__v_at_0 = @
-CCLD = $(CC)
-LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
-AM_V_CCLD = $(am__v_CCLD_@AM_V@)
-am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
-am__v_CCLD_0 = @echo "  CCLD  " $@;
-LEXCOMPILE = $(LEX) $(AM_LFLAGS) $(LFLAGS)
-AM_V_LEX = $(am__v_LEX_@AM_V@)
-am__v_LEX_ = $(am__v_LEX_@AM_DEFAULT_V@)
-am__v_LEX_0 = @echo "  LEX   " $@;
-YLWRAP = $(top_srcdir)/config/ylwrap
-YACCCOMPILE = $(YACC) $(AM_YFLAGS) $(YFLAGS)
-AM_V_YACC = $(am__v_YACC_@AM_V@)
-am__v_YACC_ = $(am__v_YACC_@AM_DEFAULT_V@)
-am__v_YACC_0 = @echo "  YACC  " $@;
-AM_V_GEN = $(am__v_GEN_@AM_V@)
-am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
-am__v_GEN_0 = @echo "  GEN   " $@;
-SOURCES = $(jq_SOURCES)
-DIST_SOURCES = $(jq_SOURCES)
-am__can_run_installinfo = \
-  case $$AM_UPDATE_INFO_DIR in \
-    n|no|NO) false;; \
-    *) (install-info --version) >/dev/null 2>&1;; \
-  esac
-am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
-am__vpath_adj = case $$p in \
-    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
-    *) f=$$p;; \
-  esac;
-am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
-am__install_max = 40
-am__nobase_strip_setup = \
-  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
-am__nobase_strip = \
-  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
-am__nobase_list = $(am__nobase_strip_setup); \
-  for p in $$list; do echo "$$p $$p"; done | \
-  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
-  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
-    if (++n[$$2] == $(am__install_max)) \
-      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
-    END { for (dir in files) print dir, files[dir] }'
-am__base_list = \
-  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
-  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
-am__uninstall_files_from_dir = { \
-  test -z "$$files" \
-    || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
-    || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
-         $(am__cd) "$$dir" && rm -f $$files; }; \
-  }
-man1dir = $(mandir)/man1
-NROFF = nroff
-MANS = $(man_MANS)
-DATA = $(dist_doc_DATA)
-ETAGS = etags
-CTAGS = ctags
-am__tty_colors = \
-red=; grn=; lgn=; blu=; std=
-# Restructured Text title and section.
-am__rst_title = sed 's/.*/   &   /;h;s/./=/g;p;x;p;g;p;s/.*//'
-am__rst_section = sed 'p;s/./=/g;p;g'
-# Put stdin (possibly several lines separated by ".  ") in a box.
-# Prefix each line by 'col' and terminate each with 'std', for coloring.
-# Multi line coloring is problematic with "less -R", so we really need
-# to color each line individually.
-am__text_box = $(AWK) '{			\
-  n = split($$0, lines, "\\.  "); max = 0;	\
-  for (i = 1; i <= n; ++i)			\
-    if (max < length(lines[i]))			\
-      max = length(lines[i]);			\
-  for (i = 0; i < max; ++i)			\
-    line = line "=";				\
-  print col line std;				\
-  for (i = 1; i <= n; ++i)			\
-    if (lines[i])				\
-      print col lines[i] std;			\
-  print col line std;				\
-}'
-# Solaris 10 'make', and several other traditional 'make' implementations,
-# pass "-e" to $(SHELL), and POSIX 2008 even requires this.  Work around it
-# by disabling -e (using the XSI extension "set +e") if it's set.
-am__sh_e_setup = case $$- in *e*) set +e;; esac
-# To be inserted before the command running the test.  Creates the
-# directory for the log if needed.  Stores in $dir the directory
-# containing $f, in $tst the test, in $log the log, and passes
-# TESTS_ENVIRONMENT.  Save and restore TERM around use of
-# TESTS_ENVIRONMENT, in case that unsets it.
-am__check_pre = \
-$(am__sh_e_setup);					\
-$(am__vpath_adj_setup) $(am__vpath_adj)			\
-srcdir=$(srcdir); export srcdir;			\
-rm -f $@-t;						\
-am__trap='rm -f '\''$(abs_builddir)/$@-t'\''; (exit $$st); exit $$st'; \
-trap "st=129; $$am__trap" 1; trap "st=130; $$am__trap" 2;	\
-trap "st=141; $$am__trap" 13; trap "st=143; $$am__trap" 15; \
-am__odir=`echo "./$@" | sed 's|/[^/]*$$||'`;		\
-test "x$$am__odir" = x. || $(MKDIR_P) "$$am__odir" || exit $$?;	\
-if test -f "./$$f"; then dir=./;			\
-elif test -f "$$f"; then dir=;				\
-else dir="$(srcdir)/"; fi;				\
-tst=$$dir$$f; log='$@'; __SAVED_TERM=$$TERM;		\
-$(TESTS_ENVIRONMENT)
-# To be appended to the command running the test.  Handle the stdout
-# and stderr redirection, and catch the exit status.
-am__check_post = \
->$@-t 2>&1;						\
-estatus=$$?;						\
-if test -n '$(DISABLE_HARD_ERRORS)'			\
-   && test $$estatus -eq 99; then			\
-  estatus=1;						\
-fi;							\
-TERM=$$__SAVED_TERM; export TERM;			\
-$(am__tty_colors);					\
-xfailed=PASS;						\
-case " $(XFAIL_TESTS) " in				\
-  *[\ \	]$$f[\ \	]* | *[\ \	]$$dir$$f[\ \	]*) \
-    xfailed=XFAIL;;					\
-esac;							\
-case $$estatus.$$xfailed in				\
-    0.XFAIL) col=$$red; res=XPASS;;			\
-    0.*)     col=$$grn; res=PASS ;;			\
-    77.*)    col=$$blu; res=SKIP ;;			\
-    99.*)    col=$$red; res=FAIL ;;			\
-    *.XFAIL) col=$$lgn; res=XFAIL;;			\
-    *.*)     col=$$red; res=FAIL ;;			\
-esac;							\
-echo "$${col}$$res$${std}: $$f";			\
-echo "$$res: $$f (exit: $$estatus)" |			\
-  $(am__rst_section) >$@;				\
-cat $@-t >>$@;						\
-rm -f $@-t
-RECHECK_LOGS = $(TEST_LOGS)
-AM_RECURSIVE_TARGETS = check recheck check-html recheck-html
-TEST_SUITE_HTML = $(TEST_SUITE_LOG:.log=.html)
-TEST_SUITE_LOG = test-suite.log
-TEST_EXTENSIONS = @EXEEXT@ .test
-am__test_logs1 = $(TESTS:=.log)
-am__test_logs2 = $(am__test_logs1:@EXEEXT@.log=.log)
-TEST_LOGS = $(am__test_logs2:.test.log=.log)
-TEST_LOG_COMPILE = $(TEST_LOG_COMPILER) $(AM_TEST_LOG_FLAGS) \
-	$(TEST_LOG_FLAGS)
-TEST_LOGS_TMP = $(TEST_LOGS:.log=.log-t)
-DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
-distdir = $(PACKAGE)-$(VERSION)
-top_distdir = $(distdir)
-am__remove_distdir = \
-  if test -d "$(distdir)"; then \
-    find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \
-      && rm -rf "$(distdir)" \
-      || { sleep 5 && rm -rf "$(distdir)"; }; \
-  else :; fi
-DIST_ARCHIVES = $(distdir).tar.gz
-GZIP_ENV = --best
-distuninstallcheck_listfiles = find . -type f -print
-am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \
-  | sed 's|^\./|$(prefix)/|' | grep -v '$(infodir)/dir$$'
-distcleancheck_listfiles = find . -type f -print
-ACLOCAL = @ACLOCAL@
-AMTAR = @AMTAR@
-AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
-AUTOCONF = @AUTOCONF@
-AUTOHEADER = @AUTOHEADER@
-AUTOMAKE = @AUTOMAKE@
-AWK = @AWK@
-CC = @CC@
-CCDEPMODE = @CCDEPMODE@
-CFLAGS = @CFLAGS@
-CPP = @CPP@
-CPPFLAGS = @CPPFLAGS@
-CYGPATH_W = @CYGPATH_W@
-DEFS = @DEFS@
-DEPDIR = @DEPDIR@
-ECHO_C = @ECHO_C@
-ECHO_N = @ECHO_N@
-ECHO_T = @ECHO_T@
-EXEEXT = @EXEEXT@
-INSTALL = @INSTALL@
-INSTALL_DATA = @INSTALL_DATA@
-INSTALL_PROGRAM = @INSTALL_PROGRAM@
-INSTALL_SCRIPT = @INSTALL_SCRIPT@
-INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
-LDFLAGS = @LDFLAGS@
-LEX = @LEX@
-LEXLIB = @LEXLIB@
-LEX_OUTPUT_ROOT = @LEX_OUTPUT_ROOT@
-LIBOBJS = @LIBOBJS@
-LIBS = @LIBS@
-LTLIBOBJS = @LTLIBOBJS@
-MAKEINFO = @MAKEINFO@
-MKDIR_P = @MKDIR_P@
-OBJEXT = @OBJEXT@
-PACKAGE = @PACKAGE@
-PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
-PACKAGE_NAME = @PACKAGE_NAME@
-PACKAGE_STRING = @PACKAGE_STRING@
-PACKAGE_TARNAME = @PACKAGE_TARNAME@
-PACKAGE_URL = @PACKAGE_URL@
-PACKAGE_VERSION = @PACKAGE_VERSION@
-PATH_SEPARATOR = @PATH_SEPARATOR@
-SET_MAKE = @SET_MAKE@
-SHELL = @SHELL@
-STRIP = @STRIP@
-VERSION = @VERSION@
-YACC = @YACC@
-YFLAGS = @YFLAGS@
-abs_builddir = @abs_builddir@
-abs_srcdir = @abs_srcdir@
-abs_top_builddir = @abs_top_builddir@
-abs_top_srcdir = @abs_top_srcdir@
-ac_ct_CC = @ac_ct_CC@
-am__include = @am__include@
-am__leading_dot = @am__leading_dot@
-am__quote = @am__quote@
-am__tar = @am__tar@
-am__untar = @am__untar@
-bindir = @bindir@
-build_alias = @build_alias@
-builddir = @builddir@
-datadir = @datadir@
-datarootdir = @datarootdir@
-
-# README.md is expected in Github projects, good stuff in it, so we'll 
-# distribute it and install it with the package in the doc directory.
-docdir = ${datadir}/doc/${PACKAGE}
-dvidir = @dvidir@
-exec_prefix = @exec_prefix@
-flex_cmd = @flex_cmd@
-host_alias = @host_alias@
-htmldir = @htmldir@
-includedir = @includedir@
-infodir = @infodir@
-install_sh = @install_sh@
-libdir = @libdir@
-libexecdir = @libexecdir@
-localedir = @localedir@
-localstatedir = @localstatedir@
-mandir = @mandir@
-mkdir_p = @mkdir_p@
-oldincludedir = @oldincludedir@
-pdfdir = @pdfdir@
-prefix = @prefix@
-program_transform_name = @program_transform_name@
-psdir = @psdir@
-sbindir = @sbindir@
-sharedstatedir = @sharedstatedir@
-srcdir = @srcdir@
-sysconfdir = @sysconfdir@
-target_alias = @target_alias@
-top_build_prefix = @top_build_prefix@
-top_builddir = @top_builddir@
-top_srcdir = @top_srcdir@
-valgrind_cmd = @valgrind_cmd@
-JQ_INCS = jq_parser.h builtin.h bytecode.h compile.h execute.h		\
-  forkable_stack.h frame_layout.h jv.h jv_alloc.h jv_aux.h jv_dtoa.h	\
-  jv_parse.h jv_unicode.h locfile.h opcode.h opcode_list.h parser.y	\
-  jv_utf8_tables.h lexer.l
-
-JQ_SRC = opcode.c bytecode.c compile.c execute.c builtin.c jv.c		\
-  jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c jv_aux.c jv_alloc.c	\
-  jq_test.c ${JQ_INCS}
-
-
-### C build options
-AM_CFLAGS = -Wextra -Wall -Wno-missing-field-initializers	\
-  -Wno-unused-parameter -Wno-unused-function
-
-
-### Generating the lexer and parser
-
-# While there is some autoconf macro support for lex/flex, it doesn't support
-# header file creation so we'll use good old make
-BUILT_SOURCES = lexer.h lexer.c parser.h parser.c
-
-# Tell YACC (bison) autoconf macros that you want a header file created.
-# If the --warnings=all fails, you probably have an old version of bison
-# OSX ships an old bison, so update with homebrew or macports
-AM_YFLAGS = --warnings=all -d
-jq_SOURCES = ${JQ_SRC} main.c
-
-### Tests (make check)
-TESTS = tests/all.test
-TEST_LOG_COMPILER = tests/run
-
-### Building the manpage
-man_MANS = jq.1
-
-# setup is only used by distribution developers, not package developers.
-# Still, as a matter of allowing patching, its not a bad idea to distribute 
-# the developer setup script in the tarball.
-EXTRA_DIST = config.h.in $(BUILT_SOURCES) $(man_MANS) $(TESTS)	\
-	$(TEST_LOG_COMPILER) gen_utf8_tables.py jq.spec
-
-dist_doc_DATA = README.md COPYING AUTHORS README
-all: $(BUILT_SOURCES) config.h
-	$(MAKE) $(AM_MAKEFLAGS) all-am
-
-.SUFFIXES:
-.SUFFIXES: .c .html .l .log .o .obj .test .test$(EXEEXT) .y
-am--refresh: Makefile
-	@:
-$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
-	@for dep in $?; do \
-	  case '$(am__configure_deps)' in \
-	    *$$dep*) \
-	      echo ' cd $(srcdir) && $(AUTOMAKE) --foreign'; \
-	      $(am__cd) $(srcdir) && $(AUTOMAKE) --foreign \
-		&& exit 0; \
-	      exit 1;; \
-	  esac; \
-	done; \
-	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \
-	$(am__cd) $(top_srcdir) && \
-	  $(AUTOMAKE) --foreign Makefile
-.PRECIOUS: Makefile
-Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
-	@case '$?' in \
-	  *config.status*) \
-	    echo ' $(SHELL) ./config.status'; \
-	    $(SHELL) ./config.status;; \
-	  *) \
-	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe)'; \
-	    cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe);; \
-	esac;
-
-$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
-	$(SHELL) ./config.status --recheck
-
-$(top_srcdir)/configure:  $(am__configure_deps)
-	$(am__cd) $(srcdir) && $(AUTOCONF)
-$(ACLOCAL_M4):  $(am__aclocal_m4_deps)
-	$(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS)
-$(am__aclocal_m4_deps):
-
-config.h: stamp-h1
-	@if test ! -f $@; then rm -f stamp-h1; else :; fi
-	@if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) stamp-h1; else :; fi
-
-stamp-h1: $(srcdir)/config.h.in $(top_builddir)/config.status
-	@rm -f stamp-h1
-	cd $(top_builddir) && $(SHELL) ./config.status config.h
-$(srcdir)/config.h.in:  $(am__configure_deps) 
-	($(am__cd) $(top_srcdir) && $(AUTOHEADER))
-	rm -f stamp-h1
-	touch $@
-
-distclean-hdr:
-	-rm -f config.h stamp-h1
-install-binPROGRAMS: $(bin_PROGRAMS)
-	@$(NORMAL_INSTALL)
-	@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
-	if test -n "$$list"; then \
-	  echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \
-	  $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \
-	fi; \
-	for p in $$list; do echo "$$p $$p"; done | \
-	sed 's/$(EXEEXT)$$//' | \
-	while read p p1; do if test -f $$p; \
-	  then echo "$$p"; echo "$$p"; else :; fi; \
-	done | \
-	sed -e 'p;s,.*/,,;n;h' -e 's|.*|.|' \
-	    -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
-	sed 'N;N;N;s,\n, ,g' | \
-	$(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
-	  { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
-	    if ($$2 == $$4) files[d] = files[d] " " $$1; \
-	    else { print "f", $$3 "/" $$4, $$1; } } \
-	  END { for (d in files) print "f", d, files[d] }' | \
-	while read type dir files; do \
-	    if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
-	    test -z "$$files" || { \
-	      echo " $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
-	      $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
-	    } \
-	; done
-
-uninstall-binPROGRAMS:
-	@$(NORMAL_UNINSTALL)
-	@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
-	files=`for p in $$list; do echo "$$p"; done | \
-	  sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
-	      -e 's/$$/$(EXEEXT)/' `; \
-	test -n "$$list" || exit 0; \
-	echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
-	cd "$(DESTDIR)$(bindir)" && rm -f $$files
-
-clean-binPROGRAMS:
-	-test -z "$(bin_PROGRAMS)" || rm -f $(bin_PROGRAMS)
-parser.h: parser.c
-	@if test ! -f $@; then rm -f parser.c; else :; fi
-	@if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) parser.c; else :; fi
-jq$(EXEEXT): $(jq_OBJECTS) $(jq_DEPENDENCIES) $(EXTRA_jq_DEPENDENCIES) 
-	@rm -f jq$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(jq_OBJECTS) $(jq_LDADD) $(LIBS)
-
-mostlyclean-compile:
-	-rm -f *.$(OBJEXT)
-
-distclean-compile:
-	-rm -f *.tab.c
-
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/builtin.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bytecode.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compile.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/execute.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/jq_test.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/jv.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/jv_alloc.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/jv_aux.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/jv_dtoa.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/jv_parse.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/jv_print.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/jv_unicode.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/lexer.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/main.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/opcode.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/parser.Po@am__quote@
-
-.c.o:
-@am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
-@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c $<
-
-.c.obj:
-@am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
-@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c `$(CYGPATH_W) '$<'`
-
-.l.c:
-	$(AM_V_LEX)$(am__skiplex) $(SHELL) $(YLWRAP) $< $(LEX_OUTPUT_ROOT).c $@ -- $(LEXCOMPILE)
-
-.y.c:
-	$(AM_V_YACC)$(am__skipyacc) $(SHELL) $(YLWRAP) $< y.tab.c $@ y.tab.h $*.h y.output $*.output -- $(YACCCOMPILE)
-install-man1: $(man_MANS)
-	@$(NORMAL_INSTALL)
-	@list1=''; \
-	list2='$(man_MANS)'; \
-	test -n "$(man1dir)" \
-	  && test -n "`echo $$list1$$list2`" \
-	  || exit 0; \
-	echo " $(MKDIR_P) '$(DESTDIR)$(man1dir)'"; \
-	$(MKDIR_P) "$(DESTDIR)$(man1dir)" || exit 1; \
-	{ for i in $$list1; do echo "$$i"; done;  \
-	if test -n "$$list2"; then \
-	  for i in $$list2; do echo "$$i"; done \
-	    | sed -n '/\.1[a-z]*$$/p'; \
-	fi; \
-	} | while read p; do \
-	  if test -f $$p; then d=; else d="$(srcdir)/"; fi; \
-	  echo "$$d$$p"; echo "$$p"; \
-	done | \
-	sed -e 'n;s,.*/,,;p;h;s,.*\.,,;s,^[^1][0-9a-z]*$$,1,;x' \
-	      -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,' | \
-	sed 'N;N;s,\n, ,g' | { \
-	list=; while read file base inst; do \
-	  if test "$$base" = "$$inst"; then list="$$list $$file"; else \
-	    echo " $(INSTALL_DATA) '$$file' '$(DESTDIR)$(man1dir)/$$inst'"; \
-	    $(INSTALL_DATA) "$$file" "$(DESTDIR)$(man1dir)/$$inst" || exit $$?; \
-	  fi; \
-	done; \
-	for i in $$list; do echo "$$i"; done | $(am__base_list) | \
-	while read files; do \
-	  test -z "$$files" || { \
-	    echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(man1dir)'"; \
-	    $(INSTALL_DATA) $$files "$(DESTDIR)$(man1dir)" || exit $$?; }; \
-	done; }
-
-uninstall-man1:
-	@$(NORMAL_UNINSTALL)
-	@list=''; test -n "$(man1dir)" || exit 0; \
-	files=`{ for i in $$list; do echo "$$i"; done; \
-	l2='$(man_MANS)'; for i in $$l2; do echo "$$i"; done | \
-	  sed -n '/\.1[a-z]*$$/p'; \
-	} | sed -e 's,.*/,,;h;s,.*\.,,;s,^[^1][0-9a-z]*$$,1,;x' \
-	      -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,'`; \
-	dir='$(DESTDIR)$(man1dir)'; $(am__uninstall_files_from_dir)
-install-dist_docDATA: $(dist_doc_DATA)
-	@$(NORMAL_INSTALL)
-	@list='$(dist_doc_DATA)'; test -n "$(docdir)" || list=; \
-	if test -n "$$list"; then \
-	  echo " $(MKDIR_P) '$(DESTDIR)$(docdir)'"; \
-	  $(MKDIR_P) "$(DESTDIR)$(docdir)" || exit 1; \
-	fi; \
-	for p in $$list; do \
-	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
-	  echo "$$d$$p"; \
-	done | $(am__base_list) | \
-	while read files; do \
-	  echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(docdir)'"; \
-	  $(INSTALL_DATA) $$files "$(DESTDIR)$(docdir)" || exit $$?; \
-	done
-
-uninstall-dist_docDATA:
-	@$(NORMAL_UNINSTALL)
-	@list='$(dist_doc_DATA)'; test -n "$(docdir)" || list=; \
-	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
-	dir='$(DESTDIR)$(docdir)'; $(am__uninstall_files_from_dir)
-
-ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
-	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
-	unique=`for i in $$list; do \
-	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
-	  done | \
-	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
-	      END { if (nonempty) { for (i in files) print i; }; }'`; \
-	mkid -fID $$unique
-tags: TAGS
-
-TAGS:  $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \
-		$(TAGS_FILES) $(LISP)
-	set x; \
-	here=`pwd`; \
-	list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \
-	unique=`for i in $$list; do \
-	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
-	  done | \
-	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
-	      END { if (nonempty) { for (i in files) print i; }; }'`; \
-	shift; \
-	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
-	  test -n "$$unique" || unique=$$empty_fix; \
-	  if test $$# -gt 0; then \
-	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
-	      "$$@" $$unique; \
-	  else \
-	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
-	      $$unique; \
-	  fi; \
-	fi
-ctags: CTAGS
-CTAGS:  $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \
-		$(TAGS_FILES) $(LISP)
-	list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \
-	unique=`for i in $$list; do \
-	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
-	  done | \
-	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
-	      END { if (nonempty) { for (i in files) print i; }; }'`; \
-	test -z "$(CTAGS_ARGS)$$unique" \
-	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
-	     $$unique
-
-GTAGS:
-	here=`$(am__cd) $(top_builddir) && pwd` \
-	  && $(am__cd) $(top_srcdir) \
-	  && gtags -i $(GTAGS_ARGS) "$$here"
-
-distclean-tags:
-	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
-
-$(TEST_SUITE_LOG): $(TEST_LOGS)
-	@$(am__sh_e_setup);						\
-	list='$(TEST_LOGS)';						\
-	results=`for f in $$list; do					\
-		   test -r $$f && read line < $$f && echo "$$line"	\
-		     || echo FAIL;					\
-		 done`;							\
-	all=`echo "$$results" | sed '/^$$/d' | wc -l | sed -e 's/^[	 ]*//'`; \
-	fail=`echo "$$results" | grep -c '^FAIL'`;			\
-	pass=`echo "$$results" | grep -c '^PASS'`;			\
-	skip=`echo "$$results" | grep -c '^SKIP'`;			\
-	xfail=`echo "$$results" | grep -c '^XFAIL'`;			\
-	xpass=`echo "$$results" | grep -c '^XPASS'`;			\
-	failures=`expr $$fail + $$xpass`;				\
-	all=`expr $$all - $$skip`;					\
-	if test "$$all" -eq 1; then tests=test; All=;			\
-	else tests=tests; All="All "; fi;				\
-	case fail=$$fail:xpass=$$xpass:xfail=$$xfail in			\
-	  fail=0:xpass=0:xfail=0)					\
-	    msg="$$All$$all $$tests passed.  ";				\
-	    exit=true;;							\
-	  fail=0:xpass=0:xfail=*)					\
-	    msg="$$All$$all $$tests behaved as expected";		\
-	    if test "$$xfail" -eq 1; then xfailures=failure;		\
-	    else xfailures=failures; fi;				\
-	    msg="$$msg ($$xfail expected $$xfailures).  ";		\
-	    exit=true;;							\
-	  fail=*:xpass=0:xfail=*)					\
-	    msg="$$fail of $$all $$tests failed.  ";			\
-	    exit=false;;						\
-	  fail=*:xpass=*:xfail=*)					\
-	    msg="$$failures of $$all $$tests did not behave as expected"; \
-	    if test "$$xpass" -eq 1; then xpasses=pass;			\
-	    else xpasses=passes; fi;					\
-	    msg="$$msg ($$xpass unexpected $$xpasses).  ";		\
-	    exit=false;;						\
-	  *)								\
-	    echo >&2 "incorrect case"; exit 4;;				\
-	esac;								\
-	if test "$$skip" -ne 0; then					\
-	  if test "$$skip" -eq 1; then					\
-	    msg="$$msg($$skip test was not run).  ";			\
-	  else								\
-	    msg="$$msg($$skip tests were not run).  ";			\
-	  fi;								\
-	fi;								\
-	{								\
-	  echo "$(PACKAGE_STRING): $(subdir)/$(TEST_SUITE_LOG)" |	\
-	    $(am__rst_title);						\
-	  echo "$$msg";							\
-	  echo;								\
-	  echo ".. contents:: :depth: 2";				\
-	  echo;								\
-	  for f in $$list; do						\
-	    test -r $$f && read line < $$f || line=;			\
-	    case $$line in						\
-	      PASS:*|XFAIL:*);;						\
-	      *) echo; cat $$f;;					\
-	    esac;							\
-	  done;								\
-	} >$(TEST_SUITE_LOG).tmp;					\
-	mv $(TEST_SUITE_LOG).tmp $(TEST_SUITE_LOG);			\
-	if test "$$failures" -ne 0; then				\
-	  msg="$${msg}See $(subdir)/$(TEST_SUITE_LOG).  ";		\
-	  if test -n "$(PACKAGE_BUGREPORT)"; then			\
-	    msg="$${msg}Please report to $(PACKAGE_BUGREPORT).  ";	\
-	  fi;								\
-	fi;								\
-	test x"$$VERBOSE" = x || $$exit || cat $(TEST_SUITE_LOG);	\
-	$(am__tty_colors);						\
-	if $$exit; then							\
-	  col="$$grn";							\
-	 else								\
-	  col="$$red";							\
-	fi;								\
-	echo "$$msg" | $(am__text_box) "col=$$col" "std=$$std";		\
-	$$exit || exit 1
-
-check-TESTS recheck:
-	@if test $@ != recheck; then \
-	   list='$(RECHECK_LOGS)'; test -z "$$list" || rm -f $$list; \
-	 fi
-	@test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
-	@list='' list2='$(TEST_LOGS)'; for f in $$list2; do \
-	  test .log = $$f && continue; \
-	  if test $@ = recheck; then \
-	    test -f $$f || continue; \
-	    if test -r $$f && read line < $$f; then \
-	      case $$line in FAIL*|XPASS*) : ;; *) continue;; esac; \
-	    fi; \
-	  fi; \
-	  if test -z "$$list"; then list=$$f; else list="$$list $$f"; fi; \
-	done; \
-	if test $@ = recheck && test -n "$$list"; then \
-	  $(am__make_dryrun) || rm -f $$list || exit 1; \
-	fi; \
-	$(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) TEST_LOGS="$$list"
-recheck: 
-
-am--mostlyclean-test-html:
-	list='$(TEST_LOGS:.log=.html)'; test -z "$$list" || rm -f $$list
-	rm -f $(TEST_SUITE_HTML)
-
-.log.html:
-	@list='$(RST2HTML) $$RST2HTML rst2html rst2html.py';		\
-	for r2h in $$list; do						\
-	  if ($$r2h --version) >/dev/null 2>&1; then			\
-	    R2H=$$r2h;							\
-	  fi;								\
-	done;								\
-	if test -z "$$R2H"; then					\
-	  echo >&2 "cannot find rst2html, cannot create $@";		\
-	  exit 2;							\
-	fi;								\
-	$$R2H $< >$@.tmp
-	@mv $@.tmp $@
-
-# Be sure to run check first, and then to convert the result.
-# Beware of concurrent executions.  Run "check" not "check-TESTS", as
-# check-SCRIPTS and other dependencies are rebuilt by the former only.
-# And expect check to fail.
-check-html recheck-html:
-	@target=`echo $@ | sed 's/-html$$//'`; \
-	rv=0; $(MAKE) $(AM_MAKEFLAGS) $$target || rv=$$?; \
-	$(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_HTML) TEST_LOGS= || exit 4; \
-	exit $$rv
-.test.log:
-	@p='$<'; $(am__check_pre) $(TEST_LOG_COMPILE) "$$tst" $(am__check_post)
-@am__EXEEXT_TRUE@.test$(EXEEXT).log:
-@am__EXEEXT_TRUE@	@p='$<'; $(am__check_pre) $(TEST_LOG_COMPILE) "$$tst" $(am__check_post)
-
-distdir: $(DISTFILES)
-	@list='$(MANS)'; if test -n "$$list"; then \
-	  list=`for p in $$list; do \
-	    if test -f $$p; then d=; else d="$(srcdir)/"; fi; \
-	    if test -f "$$d$$p"; then echo "$$d$$p"; else :; fi; done`; \
-	  if test -n "$$list" && \
-	    grep 'ab help2man is required to generate this page' $$list >/dev/null; then \
-	    echo "error: found man pages containing the \`missing help2man' replacement text:" >&2; \
-	    grep -l 'ab help2man is required to generate this page' $$list | sed 's/^/         /' >&2; \
-	    echo "       to fix them, install help2man, remove and regenerate the man pages;" >&2; \
-	    echo "       typically \`make maintainer-clean' will remove them" >&2; \
-	    exit 1; \
-	  else :; fi; \
-	else :; fi
-	$(am__remove_distdir)
-	test -d "$(distdir)" || mkdir "$(distdir)"
-	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
-	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
-	list='$(DISTFILES)'; \
-	  dist_files=`for file in $$list; do echo $$file; done | \
-	  sed -e "s|^$$srcdirstrip/||;t" \
-	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
-	case $$dist_files in \
-	  */*) $(MKDIR_P) `echo "$$dist_files" | \
-			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
-			   sort -u` ;; \
-	esac; \
-	for file in $$dist_files; do \
-	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
-	  if test -d $$d/$$file; then \
-	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
-	    if test -d "$(distdir)/$$file"; then \
-	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
-	    fi; \
-	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
-	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
-	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
-	    fi; \
-	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
-	  else \
-	    test -f "$(distdir)/$$file" \
-	    || cp -p $$d/$$file "$(distdir)/$$file" \
-	    || exit 1; \
-	  fi; \
-	done
-	-test -n "$(am__skip_mode_fix)" \
-	|| find "$(distdir)" -type d ! -perm -755 \
-		-exec chmod u+rwx,go+rx {} \; -o \
-	  ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \
-	  ! -type d ! -perm -400 -exec chmod a+r {} \; -o \
-	  ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \
-	|| chmod -R a+r "$(distdir)"
-dist-gzip: distdir
-	tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
-	$(am__remove_distdir)
-
-dist-bzip2: distdir
-	tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2
-	$(am__remove_distdir)
-
-dist-lzip: distdir
-	tardir=$(distdir) && $(am__tar) | lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz
-	$(am__remove_distdir)
-
-dist-lzma: distdir
-	tardir=$(distdir) && $(am__tar) | lzma -9 -c >$(distdir).tar.lzma
-	$(am__remove_distdir)
-
-dist-xz: distdir
-	tardir=$(distdir) && $(am__tar) | XZ_OPT=$${XZ_OPT--e} xz -c >$(distdir).tar.xz
-	$(am__remove_distdir)
-
-dist-tarZ: distdir
-	tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z
-	$(am__remove_distdir)
-
-dist-shar: distdir
-	shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz
-	$(am__remove_distdir)
-
-dist-zip: distdir
-	-rm -f $(distdir).zip
-	zip -rq $(distdir).zip $(distdir)
-	$(am__remove_distdir)
-
-dist dist-all: distdir
-	tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
-	$(am__remove_distdir)
-
-# This target untars the dist file and tries a VPATH configuration.  Then
-# it guarantees that the distribution is self-contained by making another
-# tarfile.
-distcheck: dist
-	case '$(DIST_ARCHIVES)' in \
-	*.tar.gz*) \
-	  GZIP=$(GZIP_ENV) gzip -dc $(distdir).tar.gz | $(am__untar) ;;\
-	*.tar.bz2*) \
-	  bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\
-	*.tar.lzma*) \
-	  lzma -dc $(distdir).tar.lzma | $(am__untar) ;;\
-	*.tar.lz*) \
-	  lzip -dc $(distdir).tar.lz | $(am__untar) ;;\
-	*.tar.xz*) \
-	  xz -dc $(distdir).tar.xz | $(am__untar) ;;\
-	*.tar.Z*) \
-	  uncompress -c $(distdir).tar.Z | $(am__untar) ;;\
-	*.shar.gz*) \
-	  GZIP=$(GZIP_ENV) gzip -dc $(distdir).shar.gz | unshar ;;\
-	*.zip*) \
-	  unzip $(distdir).zip ;;\
-	esac
-	chmod -R a-w $(distdir); chmod u+w $(distdir)
-	mkdir $(distdir)/_build
-	mkdir $(distdir)/_inst
-	chmod a-w $(distdir)
-	test -d $(distdir)/_build || exit 0; \
-	dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \
-	  && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \
-	  && am__cwd=`pwd` \
-	  && $(am__cd) $(distdir)/_build \
-	  && ../configure --srcdir=.. --prefix="$$dc_install_base" \
-	    $(AM_DISTCHECK_CONFIGURE_FLAGS) \
-	    $(DISTCHECK_CONFIGURE_FLAGS) \
-	  && $(MAKE) $(AM_MAKEFLAGS) \
-	  && $(MAKE) $(AM_MAKEFLAGS) dvi \
-	  && $(MAKE) $(AM_MAKEFLAGS) check \
-	  && $(MAKE) $(AM_MAKEFLAGS) install \
-	  && $(MAKE) $(AM_MAKEFLAGS) installcheck \
-	  && $(MAKE) $(AM_MAKEFLAGS) uninstall \
-	  && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \
-	        distuninstallcheck \
-	  && chmod -R a-w "$$dc_install_base" \
-	  && ({ \
-	       (cd ../.. && umask 077 && mkdir "$$dc_destdir") \
-	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \
-	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \
-	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \
-	            distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \
-	      } || { rm -rf "$$dc_destdir"; exit 1; }) \
-	  && rm -rf "$$dc_destdir" \
-	  && $(MAKE) $(AM_MAKEFLAGS) dist \
-	  && rm -rf $(DIST_ARCHIVES) \
-	  && $(MAKE) $(AM_MAKEFLAGS) distcleancheck \
-	  && cd "$$am__cwd" \
-	  || exit 1
-	$(am__remove_distdir)
-	@(echo "$(distdir) archives ready for distribution: "; \
-	  list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \
-	  sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x'
-distuninstallcheck:
-	@test -n '$(distuninstallcheck_dir)' || { \
-	  echo 'ERROR: trying to run $@ with an empty' \
-	       '$$(distuninstallcheck_dir)' >&2; \
-	  exit 1; \
-	}; \
-	$(am__cd) '$(distuninstallcheck_dir)' || { \
-	  echo 'ERROR: cannot chdir into $(distuninstallcheck_dir)' >&2; \
-	  exit 1; \
-	}; \
-	test `$(am__distuninstallcheck_listfiles) | wc -l` -eq 0 \
-	   || { echo "ERROR: files left after uninstall:" ; \
-	        if test -n "$(DESTDIR)"; then \
-	          echo "  (check DESTDIR support)"; \
-	        fi ; \
-	        $(distuninstallcheck_listfiles) ; \
-	        exit 1; } >&2
-distcleancheck: distclean
-	@if test '$(srcdir)' = . ; then \
-	  echo "ERROR: distcleancheck can only run from a VPATH build" ; \
-	  exit 1 ; \
-	fi
-	@test `$(distcleancheck_listfiles) | wc -l` -eq 0 \
-	  || { echo "ERROR: files left in build directory after distclean:" ; \
-	       $(distcleancheck_listfiles) ; \
-	       exit 1; } >&2
-check-am: all-am
-	$(MAKE) $(AM_MAKEFLAGS) check-TESTS
-check: $(BUILT_SOURCES)
-	$(MAKE) $(AM_MAKEFLAGS) check-am
-all-am: Makefile $(PROGRAMS) $(MANS) $(DATA) config.h
-installdirs:
-	for dir in "$(DESTDIR)$(bindir)" "$(DESTDIR)$(man1dir)" "$(DESTDIR)$(docdir)"; do \
-	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
-	done
-install: $(BUILT_SOURCES)
-	$(MAKE) $(AM_MAKEFLAGS) install-am
-install-exec: install-exec-am
-install-data: install-data-am
-uninstall: uninstall-am
-
-install-am: all-am
-	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
-
-installcheck: installcheck-am
-install-strip:
-	if test -z '$(STRIP)'; then \
-	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
-	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
-	      install; \
-	else \
-	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
-	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
-	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
-	fi
-mostlyclean-generic:
-	-test -z "$(TEST_LOGS)" || rm -f $(TEST_LOGS)
-	-test -z "$(TEST_LOGS_TMP)" || rm -f $(TEST_LOGS_TMP)
-	-test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
-
-clean-generic:
-
-distclean-generic:
-	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
-
-maintainer-clean-generic:
-	@echo "This command is intended for maintainers to use"
-	@echo "it deletes files that may require special tools to rebuild."
-	-rm -f lexer.c
-	-rm -f parser.c
-	-rm -f parser.h
-	-test -z "$(BUILT_SOURCES)" || rm -f $(BUILT_SOURCES)
-clean: clean-am
-
-clean-am: clean-binPROGRAMS clean-generic clean-local mostlyclean-am
-
-distclean: distclean-am
-	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
-	-rm -rf ./$(DEPDIR)
-	-rm -f Makefile
-distclean-am: clean-am distclean-compile distclean-generic \
-	distclean-hdr distclean-tags
-
-dvi: dvi-am
-
-dvi-am:
-
-html: html-am
-
-html-am:
-
-info: info-am
-
-info-am:
-
-install-data-am: install-dist_docDATA install-man
-
-install-dvi: install-dvi-am
-
-install-dvi-am:
-
-install-exec-am: install-binPROGRAMS
-
-install-html: install-html-am
-
-install-html-am:
-
-install-info: install-info-am
-
-install-info-am:
-
-install-man: install-man1
-
-install-pdf: install-pdf-am
-
-install-pdf-am:
-
-install-ps: install-ps-am
-
-install-ps-am:
-
-installcheck-am:
-
-maintainer-clean: maintainer-clean-am
-	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
-	-rm -rf $(top_srcdir)/autom4te.cache
-	-rm -rf ./$(DEPDIR)
-	-rm -f Makefile
-maintainer-clean-am: distclean-am maintainer-clean-generic
-
-mostlyclean: mostlyclean-am
-
-mostlyclean-am: am--mostlyclean-test-html mostlyclean-compile \
-	mostlyclean-generic
-
-pdf: pdf-am
-
-pdf-am:
-
-ps: ps-am
-
-ps-am:
-
-uninstall-am: uninstall-binPROGRAMS uninstall-dist_docDATA \
-	uninstall-man
-
-uninstall-man: uninstall-man1
-
-.MAKE: all check check-am check-html install install-am install-strip \
-	recheck-html
-
-.PHONY: CTAGS GTAGS all all-am am--mostlyclean-test-html am--refresh \
-	check check-TESTS check-am check-html clean clean-binPROGRAMS \
-	clean-generic clean-local ctags dist dist-all dist-bzip2 \
-	dist-gzip dist-lzip dist-lzma dist-shar dist-tarZ dist-xz \
-	dist-zip distcheck distclean distclean-compile \
-	distclean-generic distclean-hdr distclean-tags distcleancheck \
-	distdir distuninstallcheck dvi dvi-am html html-am info \
-	info-am install install-am install-binPROGRAMS install-data \
-	install-data-am install-dist_docDATA install-dvi \
-	install-dvi-am install-exec install-exec-am install-html \
-	install-html-am install-info install-info-am install-man \
-	install-man1 install-pdf install-pdf-am install-ps \
-	install-ps-am install-strip installcheck installcheck-am \
-	installdirs maintainer-clean maintainer-clean-generic \
-	mostlyclean mostlyclean-compile mostlyclean-generic pdf pdf-am \
-	ps ps-am recheck recheck-html tags uninstall uninstall-am \
-	uninstall-binPROGRAMS uninstall-dist_docDATA uninstall-man \
-	uninstall-man1
-
-lexer.c: lexer.l
-	flex -o lexer.c --header-file=lexer.h $<
-lexer.h: lexer.c
-
-### Building the jq binary
-
-main.c: config.h
-jq.1: docs/content/3.manual/manual.yml
-	( cd ${abs_srcdir}/docs; rake manpage ) > $@ || rm -f $@
-
-### Packaging
-
-docs/site.yml: configure.ac
-	sed 's/^jq_version: .*/jq_version: $(VERSION)/' $@ > $@.new
-	mv $@.new $@
-
-install-binaries: $(BUILT_SOURCES)
-	$(MAKE) $(AM_MAKEFLAGS) install-exec
-
-releasetag:
-	git tag -s "jq-$$(cat VERSION)" -m "jq release $$(cat VERSION)"
-
-RELEASE ?= 1
-rpm: jq
-	@echo "Packaging jq as an RPM ..."
-	mkdir -p rpm/SOURCES rpm/BUILD rpm/BUILDROOT rpm/RPMS rpm/SPECS
-	cp jq-$$(cat VERSION).tar.gz rpm/SOURCES/
-	rpmbuild -tb --define "_topdir ${PWD}/rpm" --define "_prefix /usr" --define "myver $$(cat VERSION)" --define "myrel ${RELEASE}" rpm/SOURCES/jq-$$(cat VERSION).tar.gz
-	find rpm/RPMS/ -name "*.rpm" -exec mv {} ./ \;
-	rm -rf rpm
-
-dist-clean-local:
-	rm -f ${BUILT_SOURCES}
-
-# Not sure why this doesn't get cleaned up automatically, guess
-# automake used to man pages which are hand coded?
-clean-local:
-	rm -f jq.1
-
-# Tell versions [3.59,3.63) of GNU make to not export all variables.
-# Otherwise a system limit (for SysV at least) may be exceeded.
-.NOEXPORT:
diff --git a/README.md b/README.md
index df9ac4dd..fa78e7a5 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,16 @@ If you want to learn to use jq, read the documentation at
 documentation is generated from the docs/ folder of this repository.
 
 If you want to hack on jq, feel free, but be warned that its internals
-are not well-documented at the moment. Bring a hard hat and a shovel.
+are not well-documented at the moment. Bring a hard hat and a
+shovel. Also, read the wiki: http://github.com/stedolan/jq/wiki
 
-You can find some basic build instructions at
-[http://stedolan.github.com/jq/download](http://stedolan.github.com/jq/download)
+To build jq, run
+
+    ./configure
+    make
+    sudo make install (optionally)
+
+If you've just checked out the latest version from git (rather than
+using a released source tarball) then you'll need to run this first:
+
+    autoreconf
diff --git a/aclocal.m4 b/aclocal.m4
deleted file mode 100644
index 81e394eb..00000000
--- a/aclocal.m4
+++ /dev/null
@@ -1,1063 +0,0 @@
-# generated automatically by aclocal 1.11.6 -*- Autoconf -*-
-
-# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
-# 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation,
-# Inc.
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
-# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-# PARTICULAR PURPOSE.
-
-m4_ifndef([AC_AUTOCONF_VERSION],
-  [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
-m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.69],,
-[m4_warning([this file was generated for autoconf 2.69.
-You have another version of autoconf.  It may work, but is not guaranteed to.
-If you have problems, you may need to regenerate the build system entirely.
-To do so, use the procedure documented by the package, typically `autoreconf'.])])
-
-# Copyright (C) 2002, 2003, 2005, 2006, 2007, 2008, 2011 Free Software
-# Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# serial 1
-
-# AM_AUTOMAKE_VERSION(VERSION)
-# ----------------------------
-# Automake X.Y traces this macro to ensure aclocal.m4 has been
-# generated from the m4 files accompanying Automake X.Y.
-# (This private macro should not be called outside this file.)
-AC_DEFUN([AM_AUTOMAKE_VERSION],
-[am__api_version='1.11'
-dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
-dnl require some minimum version.  Point them to the right macro.
-m4_if([$1], [1.11.6], [],
-      [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl
-])
-
-# _AM_AUTOCONF_VERSION(VERSION)
-# -----------------------------
-# aclocal traces this macro to find the Autoconf version.
-# This is a private macro too.  Using m4_define simplifies
-# the logic in aclocal, which can simply ignore this definition.
-m4_define([_AM_AUTOCONF_VERSION], [])
-
-# AM_SET_CURRENT_AUTOMAKE_VERSION
-# -------------------------------
-# Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced.
-# This function is AC_REQUIREd by AM_INIT_AUTOMAKE.
-AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
-[AM_AUTOMAKE_VERSION([1.11.6])dnl
-m4_ifndef([AC_AUTOCONF_VERSION],
-  [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
-_AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))])
-
-# AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-
-
-# Copyright (C) 2001, 2003, 2005, 2011 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# serial 1
-
-# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets
-# $ac_aux_dir to `$srcdir/foo'.  In other projects, it is set to
-# `$srcdir', `$srcdir/..', or `$srcdir/../..'.
-#
-# Of course, Automake must honor this variable whenever it calls a
-# tool from the auxiliary directory.  The problem is that $srcdir (and
-# therefore $ac_aux_dir as well) can be either absolute or relative,
-# depending on how configure is run.  This is pretty annoying, since
-# it makes $ac_aux_dir quite unusable in subdirectories: in the top
-# source directory, any form will work fine, but in subdirectories a
-# relative path needs to be adjusted first.
-#
-# $ac_aux_dir/missing
-#    fails when called from a subdirectory if $ac_aux_dir is relative
-# $top_srcdir/$ac_aux_dir/missing
-#    fails if $ac_aux_dir is absolute,
-#    fails when called from a subdirectory in a VPATH build with
-#          a relative $ac_aux_dir
-#
-# The reason of the latter failure is that $top_srcdir and $ac_aux_dir
-# are both prefixed by $srcdir.  In an in-source build this is usually
-# harmless because $srcdir is `.', but things will broke when you
-# start a VPATH build or use an absolute $srcdir.
-#
-# So we could use something similar to $top_srcdir/$ac_aux_dir/missing,
-# iff we strip the leading $srcdir from $ac_aux_dir.  That would be:
-#   am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"`
-# and then we would define $MISSING as
-#   MISSING="\${SHELL} $am_aux_dir/missing"
-# This will work as long as MISSING is not called from configure, because
-# unfortunately $(top_srcdir) has no meaning in configure.
-# However there are other variables, like CC, which are often used in
-# configure, and could therefore not use this "fixed" $ac_aux_dir.
-#
-# Another solution, used here, is to always expand $ac_aux_dir to an
-# absolute PATH.  The drawback is that using absolute paths prevent a
-# configured tree to be moved without reconfiguration.
-
-AC_DEFUN([AM_AUX_DIR_EXPAND],
-[dnl Rely on autoconf to set up CDPATH properly.
-AC_PREREQ([2.50])dnl
-# expand $ac_aux_dir to an absolute path
-am_aux_dir=`cd $ac_aux_dir && pwd`
-])
-
-# AM_CONDITIONAL                                            -*- Autoconf -*-
-
-# Copyright (C) 1997, 2000, 2001, 2003, 2004, 2005, 2006, 2008
-# Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# serial 9
-
-# AM_CONDITIONAL(NAME, SHELL-CONDITION)
-# -------------------------------------
-# Define a conditional.
-AC_DEFUN([AM_CONDITIONAL],
-[AC_PREREQ(2.52)dnl
- ifelse([$1], [TRUE],  [AC_FATAL([$0: invalid condition: $1])],
-	[$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl
-AC_SUBST([$1_TRUE])dnl
-AC_SUBST([$1_FALSE])dnl
-_AM_SUBST_NOTMAKE([$1_TRUE])dnl
-_AM_SUBST_NOTMAKE([$1_FALSE])dnl
-m4_define([_AM_COND_VALUE_$1], [$2])dnl
-if $2; then
-  $1_TRUE=
-  $1_FALSE='#'
-else
-  $1_TRUE='#'
-  $1_FALSE=
-fi
-AC_CONFIG_COMMANDS_PRE(
-[if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then
-  AC_MSG_ERROR([[conditional "$1" was never defined.
-Usually this means the macro was only invoked conditionally.]])
-fi])])
-
-# Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2009,
-# 2010, 2011 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# serial 12
-
-# There are a few dirty hacks below to avoid letting `AC_PROG_CC' be
-# written in clear, in which case automake, when reading aclocal.m4,
-# will think it sees a *use*, and therefore will trigger all it's
-# C support machinery.  Also note that it means that autoscan, seeing
-# CC etc. in the Makefile, will ask for an AC_PROG_CC use...
-
-
-# _AM_DEPENDENCIES(NAME)
-# ----------------------
-# See how the compiler implements dependency checking.
-# NAME is "CC", "CXX", "GCJ", or "OBJC".
-# We try a few techniques and use that to set a single cache variable.
-#
-# We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was
-# modified to invoke _AM_DEPENDENCIES(CC); we would have a circular
-# dependency, and given that the user is not expected to run this macro,
-# just rely on AC_PROG_CC.
-AC_DEFUN([_AM_DEPENDENCIES],
-[AC_REQUIRE([AM_SET_DEPDIR])dnl
-AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl
-AC_REQUIRE([AM_MAKE_INCLUDE])dnl
-AC_REQUIRE([AM_DEP_TRACK])dnl
-
-ifelse([$1], CC,   [depcc="$CC"   am_compiler_list=],
-       [$1], CXX,  [depcc="$CXX"  am_compiler_list=],
-       [$1], OBJC, [depcc="$OBJC" am_compiler_list='gcc3 gcc'],
-       [$1], UPC,  [depcc="$UPC"  am_compiler_list=],
-       [$1], GCJ,  [depcc="$GCJ"  am_compiler_list='gcc3 gcc'],
-                   [depcc="$$1"   am_compiler_list=])
-
-AC_CACHE_CHECK([dependency style of $depcc],
-               [am_cv_$1_dependencies_compiler_type],
-[if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
-  # We make a subdir and do the tests there.  Otherwise we can end up
-  # making bogus files that we don't know about and never remove.  For
-  # instance it was reported that on HP-UX the gcc test will end up
-  # making a dummy file named `D' -- because `-MD' means `put the output
-  # in D'.
-  rm -rf conftest.dir
-  mkdir conftest.dir
-  # Copy depcomp to subdir because otherwise we won't find it if we're
-  # using a relative directory.
-  cp "$am_depcomp" conftest.dir
-  cd conftest.dir
-  # We will build objects and dependencies in a subdirectory because
-  # it helps to detect inapplicable dependency modes.  For instance
-  # both Tru64's cc and ICC support -MD to output dependencies as a
-  # side effect of compilation, but ICC will put the dependencies in
-  # the current directory while Tru64 will put them in the object
-  # directory.
-  mkdir sub
-
-  am_cv_$1_dependencies_compiler_type=none
-  if test "$am_compiler_list" = ""; then
-     am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp`
-  fi
-  am__universal=false
-  m4_case([$1], [CC],
-    [case " $depcc " in #(
-     *\ -arch\ *\ -arch\ *) am__universal=true ;;
-     esac],
-    [CXX],
-    [case " $depcc " in #(
-     *\ -arch\ *\ -arch\ *) am__universal=true ;;
-     esac])
-
-  for depmode in $am_compiler_list; do
-    # Setup a source with many dependencies, because some compilers
-    # like to wrap large dependency lists on column 80 (with \), and
-    # we should not choose a depcomp mode which is confused by this.
-    #
-    # We need to recreate these files for each test, as the compiler may
-    # overwrite some of them when testing with obscure command lines.
-    # This happens at least with the AIX C compiler.
-    : > sub/conftest.c
-    for i in 1 2 3 4 5 6; do
-      echo '#include "conftst'$i'.h"' >> sub/conftest.c
-      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
-      # Solaris 8's {/usr,}/bin/sh.
-      touch sub/conftst$i.h
-    done
-    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
-
-    # We check with `-c' and `-o' for the sake of the "dashmstdout"
-    # mode.  It turns out that the SunPro C++ compiler does not properly
-    # handle `-M -o', and we need to detect this.  Also, some Intel
-    # versions had trouble with output in subdirs
-    am__obj=sub/conftest.${OBJEXT-o}
-    am__minus_obj="-o $am__obj"
-    case $depmode in
-    gcc)
-      # This depmode causes a compiler race in universal mode.
-      test "$am__universal" = false || continue
-      ;;
-    nosideeffect)
-      # after this tag, mechanisms are not by side-effect, so they'll
-      # only be used when explicitly requested
-      if test "x$enable_dependency_tracking" = xyes; then
-	continue
-      else
-	break
-      fi
-      ;;
-    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
-      # This compiler won't grok `-c -o', but also, the minuso test has
-      # not run yet.  These depmodes are late enough in the game, and
-      # so weak that their functioning should not be impacted.
-      am__obj=conftest.${OBJEXT-o}
-      am__minus_obj=
-      ;;
-    none) break ;;
-    esac
-    if depmode=$depmode \
-       source=sub/conftest.c object=$am__obj \
-       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
-       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
-         >/dev/null 2>conftest.err &&
-       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
-       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
-       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
-       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
-      # icc doesn't choke on unknown options, it will just issue warnings
-      # or remarks (even with -Werror).  So we grep stderr for any message
-      # that says an option was ignored or not supported.
-      # When given -MP, icc 7.0 and 7.1 complain thusly:
-      #   icc: Command line warning: ignoring option '-M'; no argument required
-      # The diagnosis changed in icc 8.0:
-      #   icc: Command line remark: option '-MP' not supported
-      if (grep 'ignoring option' conftest.err ||
-          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
-        am_cv_$1_dependencies_compiler_type=$depmode
-        break
-      fi
-    fi
-  done
-
-  cd ..
-  rm -rf conftest.dir
-else
-  am_cv_$1_dependencies_compiler_type=none
-fi
-])
-AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type])
-AM_CONDITIONAL([am__fastdep$1], [
-  test "x$enable_dependency_tracking" != xno \
-  && test "$am_cv_$1_dependencies_compiler_type" = gcc3])
-])
-
-
-# AM_SET_DEPDIR
-# -------------
-# Choose a directory name for dependency files.
-# This macro is AC_REQUIREd in _AM_DEPENDENCIES
-AC_DEFUN([AM_SET_DEPDIR],
-[AC_REQUIRE([AM_SET_LEADING_DOT])dnl
-AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl
-])
-
-
-# AM_DEP_TRACK
-# ------------
-AC_DEFUN([AM_DEP_TRACK],
-[AC_ARG_ENABLE(dependency-tracking,
-[  --disable-dependency-tracking  speeds up one-time build
-  --enable-dependency-tracking   do not reject slow dependency extractors])
-if test "x$enable_dependency_tracking" != xno; then
-  am_depcomp="$ac_aux_dir/depcomp"
-  AMDEPBACKSLASH='\'
-  am__nodep='_no'
-fi
-AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno])
-AC_SUBST([AMDEPBACKSLASH])dnl
-_AM_SUBST_NOTMAKE([AMDEPBACKSLASH])dnl
-AC_SUBST([am__nodep])dnl
-_AM_SUBST_NOTMAKE([am__nodep])dnl
-])
-
-# Generate code to set up dependency tracking.              -*- Autoconf -*-
-
-# Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2008
-# Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-#serial 5
-
-# _AM_OUTPUT_DEPENDENCY_COMMANDS
-# ------------------------------
-AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
-[{
-  # Autoconf 2.62 quotes --file arguments for eval, but not when files
-  # are listed without --file.  Let's play safe and only enable the eval
-  # if we detect the quoting.
-  case $CONFIG_FILES in
-  *\'*) eval set x "$CONFIG_FILES" ;;
-  *)   set x $CONFIG_FILES ;;
-  esac
-  shift
-  for mf
-  do
-    # Strip MF so we end up with the name of the file.
-    mf=`echo "$mf" | sed -e 's/:.*$//'`
-    # Check whether this is an Automake generated Makefile or not.
-    # We used to match only the files named `Makefile.in', but
-    # some people rename them; so instead we look at the file content.
-    # Grep'ing the first line is not enough: some people post-process
-    # each Makefile.in and add a new line on top of each file to say so.
-    # Grep'ing the whole file is not good either: AIX grep has a line
-    # limit of 2048, but all sed's we know have understand at least 4000.
-    if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
-      dirpart=`AS_DIRNAME("$mf")`
-    else
-      continue
-    fi
-    # Extract the definition of DEPDIR, am__include, and am__quote
-    # from the Makefile without running `make'.
-    DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
-    test -z "$DEPDIR" && continue
-    am__include=`sed -n 's/^am__include = //p' < "$mf"`
-    test -z "am__include" && continue
-    am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
-    # When using ansi2knr, U may be empty or an underscore; expand it
-    U=`sed -n 's/^U = //p' < "$mf"`
-    # Find all dependency output files, they are included files with
-    # $(DEPDIR) in their names.  We invoke sed twice because it is the
-    # simplest approach to changing $(DEPDIR) to its actual value in the
-    # expansion.
-    for file in `sed -n "
-      s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
-	 sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
-      # Make sure the directory exists.
-      test -f "$dirpart/$file" && continue
-      fdir=`AS_DIRNAME(["$file"])`
-      AS_MKDIR_P([$dirpart/$fdir])
-      # echo "creating $dirpart/$file"
-      echo '# dummy' > "$dirpart/$file"
-    done
-  done
-}
-])# _AM_OUTPUT_DEPENDENCY_COMMANDS
-
-
-# AM_OUTPUT_DEPENDENCY_COMMANDS
-# -----------------------------
-# This macro should only be invoked once -- use via AC_REQUIRE.
-#
-# This code is only required when automatic dependency tracking
-# is enabled.  FIXME.  This creates each `.P' file that we will
-# need in order to bootstrap the dependency handling code.
-AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],
-[AC_CONFIG_COMMANDS([depfiles],
-     [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS],
-     [AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"])
-])
-
-# Do all the work for Automake.                             -*- Autoconf -*-
-
-# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
-# 2005, 2006, 2008, 2009 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# serial 16
-
-# This macro actually does too much.  Some checks are only needed if
-# your package does certain things.  But this isn't really a big deal.
-
-# AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE])
-# AM_INIT_AUTOMAKE([OPTIONS])
-# -----------------------------------------------
-# The call with PACKAGE and VERSION arguments is the old style
-# call (pre autoconf-2.50), which is being phased out.  PACKAGE
-# and VERSION should now be passed to AC_INIT and removed from
-# the call to AM_INIT_AUTOMAKE.
-# We support both call styles for the transition.  After
-# the next Automake release, Autoconf can make the AC_INIT
-# arguments mandatory, and then we can depend on a new Autoconf
-# release and drop the old call support.
-AC_DEFUN([AM_INIT_AUTOMAKE],
-[AC_PREREQ([2.62])dnl
-dnl Autoconf wants to disallow AM_ names.  We explicitly allow
-dnl the ones we care about.
-m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl
-AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl
-AC_REQUIRE([AC_PROG_INSTALL])dnl
-if test "`cd $srcdir && pwd`" != "`pwd`"; then
-  # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
-  # is not polluted with repeated "-I."
-  AC_SUBST([am__isrc], [' -I$(srcdir)'])_AM_SUBST_NOTMAKE([am__isrc])dnl
-  # test to see if srcdir already configured
-  if test -f $srcdir/config.status; then
-    AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
-  fi
-fi
-
-# test whether we have cygpath
-if test -z "$CYGPATH_W"; then
-  if (cygpath --version) >/dev/null 2>/dev/null; then
-    CYGPATH_W='cygpath -w'
-  else
-    CYGPATH_W=echo
-  fi
-fi
-AC_SUBST([CYGPATH_W])
-
-# Define the identity of the package.
-dnl Distinguish between old-style and new-style calls.
-m4_ifval([$2],
-[m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl
- AC_SUBST([PACKAGE], [$1])dnl
- AC_SUBST([VERSION], [$2])],
-[_AM_SET_OPTIONS([$1])dnl
-dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT.
-m4_if(m4_ifdef([AC_PACKAGE_NAME], 1)m4_ifdef([AC_PACKAGE_VERSION], 1), 11,,
-  [m4_fatal([AC_INIT should be called with package and version arguments])])dnl
- AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl
- AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl
-
-_AM_IF_OPTION([no-define],,
-[AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package])
- AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package])])dnl
-
-# Some tools Automake needs.
-AC_REQUIRE([AM_SANITY_CHECK])dnl
-AC_REQUIRE([AC_ARG_PROGRAM])dnl
-AM_MISSING_PROG(ACLOCAL, aclocal-${am__api_version})
-AM_MISSING_PROG(AUTOCONF, autoconf)
-AM_MISSING_PROG(AUTOMAKE, automake-${am__api_version})
-AM_MISSING_PROG(AUTOHEADER, autoheader)
-AM_MISSING_PROG(MAKEINFO, makeinfo)
-AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
-AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl
-AC_REQUIRE([AM_PROG_MKDIR_P])dnl
-# We need awk for the "check" target.  The system "awk" is bad on
-# some platforms.
-AC_REQUIRE([AC_PROG_AWK])dnl
-AC_REQUIRE([AC_PROG_MAKE_SET])dnl
-AC_REQUIRE([AM_SET_LEADING_DOT])dnl
-_AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])],
-	      [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])],
-			     [_AM_PROG_TAR([v7])])])
-_AM_IF_OPTION([no-dependencies],,
-[AC_PROVIDE_IFELSE([AC_PROG_CC],
-		  [_AM_DEPENDENCIES(CC)],
-		  [define([AC_PROG_CC],
-			  defn([AC_PROG_CC])[_AM_DEPENDENCIES(CC)])])dnl
-AC_PROVIDE_IFELSE([AC_PROG_CXX],
-		  [_AM_DEPENDENCIES(CXX)],
-		  [define([AC_PROG_CXX],
-			  defn([AC_PROG_CXX])[_AM_DEPENDENCIES(CXX)])])dnl
-AC_PROVIDE_IFELSE([AC_PROG_OBJC],
-		  [_AM_DEPENDENCIES(OBJC)],
-		  [define([AC_PROG_OBJC],
-			  defn([AC_PROG_OBJC])[_AM_DEPENDENCIES(OBJC)])])dnl
-])
-_AM_IF_OPTION([silent-rules], [AC_REQUIRE([AM_SILENT_RULES])])dnl
-dnl The `parallel-tests' driver may need to know about EXEEXT, so add the
-dnl `am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen.  This macro
-dnl is hooked onto _AC_COMPILER_EXEEXT early, see below.
-AC_CONFIG_COMMANDS_PRE(dnl
-[m4_provide_if([_AM_COMPILER_EXEEXT],
-  [AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl
-])
-
-dnl Hook into `_AC_COMPILER_EXEEXT' early to learn its expansion.  Do not
-dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further
-dnl mangled by Autoconf and run in a shell conditional statement.
-m4_define([_AC_COMPILER_EXEEXT],
-m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])])
-
-
-# When config.status generates a header, we must update the stamp-h file.
-# This file resides in the same directory as the config header
-# that is generated.  The stamp files are numbered to have different names.
-
-# Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the
-# loop where config.status creates the headers, so we can generate
-# our stamp files there.
-AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK],
-[# Compute $1's index in $config_headers.
-_am_arg=$1
-_am_stamp_count=1
-for _am_header in $config_headers :; do
-  case $_am_header in
-    $_am_arg | $_am_arg:* )
-      break ;;
-    * )
-      _am_stamp_count=`expr $_am_stamp_count + 1` ;;
-  esac
-done
-echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count])
-
-# Copyright (C) 2001, 2003, 2005, 2008, 2011 Free Software Foundation,
-# Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# serial 1
-
-# AM_PROG_INSTALL_SH
-# ------------------
-# Define $install_sh.
-AC_DEFUN([AM_PROG_INSTALL_SH],
-[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
-if test x"${install_sh}" != xset; then
-  case $am_aux_dir in
-  *\ * | *\	*)
-    install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
-  *)
-    install_sh="\${SHELL} $am_aux_dir/install-sh"
-  esac
-fi
-AC_SUBST(install_sh)])
-
-# Copyright (C) 2003, 2005  Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# serial 2
-
-# Check whether the underlying file-system supports filenames
-# with a leading dot.  For instance MS-DOS doesn't.
-AC_DEFUN([AM_SET_LEADING_DOT],
-[rm -rf .tst 2>/dev/null
-mkdir .tst 2>/dev/null
-if test -d .tst; then
-  am__leading_dot=.
-else
-  am__leading_dot=_
-fi
-rmdir .tst 2>/dev/null
-AC_SUBST([am__leading_dot])])
-
-# Check to see how 'make' treats includes.	            -*- Autoconf -*-
-
-# Copyright (C) 2001, 2002, 2003, 2005, 2009  Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# serial 4
-
-# AM_MAKE_INCLUDE()
-# -----------------
-# Check to see how make treats includes.
-AC_DEFUN([AM_MAKE_INCLUDE],
-[am_make=${MAKE-make}
-cat > confinc << 'END'
-am__doit:
-	@echo this is the am__doit target
-.PHONY: am__doit
-END
-# If we don't find an include directive, just comment out the code.
-AC_MSG_CHECKING([for style of include used by $am_make])
-am__include="#"
-am__quote=
-_am_result=none
-# First try GNU make style include.
-echo "include confinc" > confmf
-# Ignore all kinds of additional output from `make'.
-case `$am_make -s -f confmf 2> /dev/null` in #(
-*the\ am__doit\ target*)
-  am__include=include
-  am__quote=
-  _am_result=GNU
-  ;;
-esac
-# Now try BSD make style include.
-if test "$am__include" = "#"; then
-   echo '.include "confinc"' > confmf
-   case `$am_make -s -f confmf 2> /dev/null` in #(
-   *the\ am__doit\ target*)
-     am__include=.include
-     am__quote="\""
-     _am_result=BSD
-     ;;
-   esac
-fi
-AC_SUBST([am__include])
-AC_SUBST([am__quote])
-AC_MSG_RESULT([$_am_result])
-rm -f confinc confmf
-])
-
-# Copyright (C) 1999, 2000, 2001, 2003, 2004, 2005, 2008
-# Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# serial 6
-
-# AM_PROG_CC_C_O
-# --------------
-# Like AC_PROG_CC_C_O, but changed for automake.
-AC_DEFUN([AM_PROG_CC_C_O],
-[AC_REQUIRE([AC_PROG_CC_C_O])dnl
-AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
-AC_REQUIRE_AUX_FILE([compile])dnl
-# FIXME: we rely on the cache variable name because
-# there is no other way.
-set dummy $CC
-am_cc=`echo $[2] | sed ['s/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/']`
-eval am_t=\$ac_cv_prog_cc_${am_cc}_c_o
-if test "$am_t" != yes; then
-   # Losing compiler, so override with the script.
-   # FIXME: It is wrong to rewrite CC.
-   # But if we don't then we get into trouble of one sort or another.
-   # A longer-term fix would be to have automake use am__CC in this case,
-   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
-   CC="$am_aux_dir/compile $CC"
-fi
-dnl Make sure AC_PROG_CC is never called again, or it will override our
-dnl setting of CC.
-m4_define([AC_PROG_CC],
-          [m4_fatal([AC_PROG_CC cannot be called after AM_PROG_CC_C_O])])
-])
-
-# Fake the existence of programs that GNU maintainers use.  -*- Autoconf -*-
-
-# Copyright (C) 1997, 1999, 2000, 2001, 2003, 2004, 2005, 2008
-# Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# serial 6
-
-# AM_MISSING_PROG(NAME, PROGRAM)
-# ------------------------------
-AC_DEFUN([AM_MISSING_PROG],
-[AC_REQUIRE([AM_MISSING_HAS_RUN])
-$1=${$1-"${am_missing_run}$2"}
-AC_SUBST($1)])
-
-
-# AM_MISSING_HAS_RUN
-# ------------------
-# Define MISSING if not defined so far and test if it supports --run.
-# If it does, set am_missing_run to use it, otherwise, to nothing.
-AC_DEFUN([AM_MISSING_HAS_RUN],
-[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
-AC_REQUIRE_AUX_FILE([missing])dnl
-if test x"${MISSING+set}" != xset; then
-  case $am_aux_dir in
-  *\ * | *\	*)
-    MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;;
-  *)
-    MISSING="\${SHELL} $am_aux_dir/missing" ;;
-  esac
-fi
-# Use eval to expand $SHELL
-if eval "$MISSING --run true"; then
-  am_missing_run="$MISSING --run "
-else
-  am_missing_run=
-  AC_MSG_WARN([`missing' script is too old or missing])
-fi
-])
-
-# Copyright (C) 2003, 2004, 2005, 2006, 2011 Free Software Foundation,
-# Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# serial 1
-
-# AM_PROG_MKDIR_P
-# ---------------
-# Check for `mkdir -p'.
-AC_DEFUN([AM_PROG_MKDIR_P],
-[AC_PREREQ([2.60])dnl
-AC_REQUIRE([AC_PROG_MKDIR_P])dnl
-dnl Automake 1.8 to 1.9.6 used to define mkdir_p.  We now use MKDIR_P,
-dnl while keeping a definition of mkdir_p for backward compatibility.
-dnl @MKDIR_P@ is magic: AC_OUTPUT adjusts its value for each Makefile.
-dnl However we cannot define mkdir_p as $(MKDIR_P) for the sake of
-dnl Makefile.ins that do not define MKDIR_P, so we do our own
-dnl adjustment using top_builddir (which is defined more often than
-dnl MKDIR_P).
-AC_SUBST([mkdir_p], ["$MKDIR_P"])dnl
-case $mkdir_p in
-  [[\\/$]]* | ?:[[\\/]]*) ;;
-  */*) mkdir_p="\$(top_builddir)/$mkdir_p" ;;
-esac
-])
-
-# Helper functions for option handling.                     -*- Autoconf -*-
-
-# Copyright (C) 2001, 2002, 2003, 2005, 2008, 2010 Free Software
-# Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# serial 5
-
-# _AM_MANGLE_OPTION(NAME)
-# -----------------------
-AC_DEFUN([_AM_MANGLE_OPTION],
-[[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])])
-
-# _AM_SET_OPTION(NAME)
-# --------------------
-# Set option NAME.  Presently that only means defining a flag for this option.
-AC_DEFUN([_AM_SET_OPTION],
-[m4_define(_AM_MANGLE_OPTION([$1]), 1)])
-
-# _AM_SET_OPTIONS(OPTIONS)
-# ------------------------
-# OPTIONS is a space-separated list of Automake options.
-AC_DEFUN([_AM_SET_OPTIONS],
-[m4_foreach_w([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])])
-
-# _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET])
-# -------------------------------------------
-# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
-AC_DEFUN([_AM_IF_OPTION],
-[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])
-
-# Check to make sure that the build environment is sane.    -*- Autoconf -*-
-
-# Copyright (C) 1996, 1997, 2000, 2001, 2003, 2005, 2008
-# Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# serial 5
-
-# AM_SANITY_CHECK
-# ---------------
-AC_DEFUN([AM_SANITY_CHECK],
-[AC_MSG_CHECKING([whether build environment is sane])
-# Just in case
-sleep 1
-echo timestamp > conftest.file
-# Reject unsafe characters in $srcdir or the absolute working directory
-# name.  Accept space and tab only in the latter.
-am_lf='
-'
-case `pwd` in
-  *[[\\\"\#\$\&\'\`$am_lf]]*)
-    AC_MSG_ERROR([unsafe absolute working directory name]);;
-esac
-case $srcdir in
-  *[[\\\"\#\$\&\'\`$am_lf\ \	]]*)
-    AC_MSG_ERROR([unsafe srcdir value: `$srcdir']);;
-esac
-
-# Do `set' in a subshell so we don't clobber the current shell's
-# arguments.  Must try -L first in case configure is actually a
-# symlink; some systems play weird games with the mod time of symlinks
-# (eg FreeBSD returns the mod time of the symlink's containing
-# directory).
-if (
-   set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
-   if test "$[*]" = "X"; then
-      # -L didn't work.
-      set X `ls -t "$srcdir/configure" conftest.file`
-   fi
-   rm -f conftest.file
-   if test "$[*]" != "X $srcdir/configure conftest.file" \
-      && test "$[*]" != "X conftest.file $srcdir/configure"; then
-
-      # If neither matched, then we have a broken ls.  This can happen
-      # if, for instance, CONFIG_SHELL is bash and it inherits a
-      # broken ls alias from the environment.  This has actually
-      # happened.  Such a system could not be considered "sane".
-      AC_MSG_ERROR([ls -t appears to fail.  Make sure there is not a broken
-alias in your environment])
-   fi
-
-   test "$[2]" = conftest.file
-   )
-then
-   # Ok.
-   :
-else
-   AC_MSG_ERROR([newly created file is older than distributed files!
-Check your system clock])
-fi
-AC_MSG_RESULT(yes)])
-
-# Copyright (C) 2009, 2011  Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# serial 2
-
-# AM_SILENT_RULES([DEFAULT])
-# --------------------------
-# Enable less verbose build rules; with the default set to DEFAULT
-# (`yes' being less verbose, `no' or empty being verbose).
-AC_DEFUN([AM_SILENT_RULES],
-[AC_ARG_ENABLE([silent-rules],
-[  --enable-silent-rules          less verbose build output (undo: `make V=1')
-  --disable-silent-rules         verbose build output (undo: `make V=0')])
-case $enable_silent_rules in
-yes) AM_DEFAULT_VERBOSITY=0;;
-no)  AM_DEFAULT_VERBOSITY=1;;
-*)   AM_DEFAULT_VERBOSITY=m4_if([$1], [yes], [0], [1]);;
-esac
-dnl
-dnl A few `make' implementations (e.g., NonStop OS and NextStep)
-dnl do not support nested variable expansions.
-dnl See automake bug#9928 and bug#10237.
-am_make=${MAKE-make}
-AC_CACHE_CHECK([whether $am_make supports nested variables],
-   [am_cv_make_support_nested_variables],
-   [if AS_ECHO([['TRUE=$(BAR$(V))
-BAR0=false
-BAR1=true
-V=1
-am__doit:
-	@$(TRUE)
-.PHONY: am__doit']]) | $am_make -f - >/dev/null 2>&1; then
-  am_cv_make_support_nested_variables=yes
-else
-  am_cv_make_support_nested_variables=no
-fi])
-if test $am_cv_make_support_nested_variables = yes; then
-  dnl Using `$V' instead of `$(V)' breaks IRIX make.
-  AM_V='$(V)'
-  AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
-else
-  AM_V=$AM_DEFAULT_VERBOSITY
-  AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
-fi
-AC_SUBST([AM_V])dnl
-AM_SUBST_NOTMAKE([AM_V])dnl
-AC_SUBST([AM_DEFAULT_V])dnl
-AM_SUBST_NOTMAKE([AM_DEFAULT_V])dnl
-AC_SUBST([AM_DEFAULT_VERBOSITY])dnl
-AM_BACKSLASH='\'
-AC_SUBST([AM_BACKSLASH])dnl
-_AM_SUBST_NOTMAKE([AM_BACKSLASH])dnl
-])
-
-# Copyright (C) 2001, 2003, 2005, 2011 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# serial 1
-
-# AM_PROG_INSTALL_STRIP
-# ---------------------
-# One issue with vendor `install' (even GNU) is that you can't
-# specify the program used to strip binaries.  This is especially
-# annoying in cross-compiling environments, where the build's strip
-# is unlikely to handle the host's binaries.
-# Fortunately install-sh will honor a STRIPPROG variable, so we
-# always use install-sh in `make install-strip', and initialize
-# STRIPPROG with the value of the STRIP variable (set by the user).
-AC_DEFUN([AM_PROG_INSTALL_STRIP],
-[AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
-# Installed binaries are usually stripped using `strip' when the user
-# run `make install-strip'.  However `strip' might not be the right
-# tool to use in cross-compilation environments, therefore Automake
-# will honor the `STRIP' environment variable to overrule this program.
-dnl Don't test for $cross_compiling = yes, because it might be `maybe'.
-if test "$cross_compiling" != no; then
-  AC_CHECK_TOOL([STRIP], [strip], :)
-fi
-INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
-AC_SUBST([INSTALL_STRIP_PROGRAM])])
-
-# Copyright (C) 2006, 2008, 2010 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# serial 3
-
-# _AM_SUBST_NOTMAKE(VARIABLE)
-# ---------------------------
-# Prevent Automake from outputting VARIABLE = @VARIABLE@ in Makefile.in.
-# This macro is traced by Automake.
-AC_DEFUN([_AM_SUBST_NOTMAKE])
-
-# AM_SUBST_NOTMAKE(VARIABLE)
-# --------------------------
-# Public sister of _AM_SUBST_NOTMAKE.
-AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)])
-
-# Check how to create a tarball.                            -*- Autoconf -*-
-
-# Copyright (C) 2004, 2005, 2012 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# serial 2
-
-# _AM_PROG_TAR(FORMAT)
-# --------------------
-# Check how to create a tarball in format FORMAT.
-# FORMAT should be one of `v7', `ustar', or `pax'.
-#
-# Substitute a variable $(am__tar) that is a command
-# writing to stdout a FORMAT-tarball containing the directory
-# $tardir.
-#     tardir=directory && $(am__tar) > result.tar
-#
-# Substitute a variable $(am__untar) that extract such
-# a tarball read from stdin.
-#     $(am__untar) < result.tar
-AC_DEFUN([_AM_PROG_TAR],
-[# Always define AMTAR for backward compatibility.  Yes, it's still used
-# in the wild :-(  We should find a proper way to deprecate it ...
-AC_SUBST([AMTAR], ['$${TAR-tar}'])
-m4_if([$1], [v7],
-     [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'],
-     [m4_case([$1], [ustar],, [pax],,
-              [m4_fatal([Unknown tar format])])
-AC_MSG_CHECKING([how to create a $1 tar archive])
-# Loop over all known methods to create a tar archive until one works.
-_am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none'
-_am_tools=${am_cv_prog_tar_$1-$_am_tools}
-# Do not fold the above two line into one, because Tru64 sh and
-# Solaris sh will not grok spaces in the rhs of `-'.
-for _am_tool in $_am_tools
-do
-  case $_am_tool in
-  gnutar)
-    for _am_tar in tar gnutar gtar;
-    do
-      AM_RUN_LOG([$_am_tar --version]) && break
-    done
-    am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"'
-    am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"'
-    am__untar="$_am_tar -xf -"
-    ;;
-  plaintar)
-    # Must skip GNU tar: if it does not support --format= it doesn't create
-    # ustar tarball either.
-    (tar --version) >/dev/null 2>&1 && continue
-    am__tar='tar chf - "$$tardir"'
-    am__tar_='tar chf - "$tardir"'
-    am__untar='tar xf -'
-    ;;
-  pax)
-    am__tar='pax -L -x $1 -w "$$tardir"'
-    am__tar_='pax -L -x $1 -w "$tardir"'
-    am__untar='pax -r'
-    ;;
-  cpio)
-    am__tar='find "$$tardir" -print | cpio -o -H $1 -L'
-    am__tar_='find "$tardir" -print | cpio -o -H $1 -L'
-    am__untar='cpio -i -H $1 -d'
-    ;;
-  none)
-    am__tar=false
-    am__tar_=false
-    am__untar=false
-    ;;
-  esac
-
-  # If the value was cached, stop now.  We just wanted to have am__tar
-  # and am__untar set.
-  test -n "${am_cv_prog_tar_$1}" && break
-
-  # tar/untar a dummy directory, and stop if the command works
-  rm -rf conftest.dir
-  mkdir conftest.dir
-  echo GrepMe > conftest.dir/file
-  AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar])
-  rm -rf conftest.dir
-  if test -s conftest.tar; then
-    AM_RUN_LOG([$am__untar <conftest.tar])
-    grep GrepMe conftest.dir/file >/dev/null 2>&1 && break
-  fi
-done
-rm -rf conftest.dir
-
-AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool])
-AC_MSG_RESULT([$am_cv_prog_tar_$1])])
-AC_SUBST([am__tar])
-AC_SUBST([am__untar])
-]) # _AM_PROG_TAR
-
diff --git a/configure b/configure
deleted file mode 100755
index 9520197a..00000000
--- a/configure
+++ /dev/null
@@ -1,5932 +0,0 @@
-#! /bin/sh
-# Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.69 for jq 1.2.
-#
-# Report bugs to <mu@netsoc.tcd.ie>.
-#
-#
-# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
-#
-#
-# This configure script is free software; the Free Software Foundation
-# gives unlimited permission to copy, distribute and modify it.
-## -------------------- ##
-## M4sh Initialization. ##
-## -------------------- ##
-
-# Be more Bourne compatible
-DUALCASE=1; export DUALCASE # for MKS sh
-if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
-  emulate sh
-  NULLCMD=:
-  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
-  # is contrary to our usage.  Disable this feature.
-  alias -g '${1+"$@"}'='"$@"'
-  setopt NO_GLOB_SUBST
-else
-  case `(set -o) 2>/dev/null` in #(
-  *posix*) :
-    set -o posix ;; #(
-  *) :
-     ;;
-esac
-fi
-
-
-as_nl='
-'
-export as_nl
-# Printing a long string crashes Solaris 7 /usr/bin/printf.
-as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
-# Prefer a ksh shell builtin over an external printf program on Solaris,
-# but without wasting forks for bash or zsh.
-if test -z "$BASH_VERSION$ZSH_VERSION" \
-    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
-  as_echo='print -r --'
-  as_echo_n='print -rn --'
-elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
-  as_echo='printf %s\n'
-  as_echo_n='printf %s'
-else
-  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
-    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
-    as_echo_n='/usr/ucb/echo -n'
-  else
-    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
-    as_echo_n_body='eval
-      arg=$1;
-      case $arg in #(
-      *"$as_nl"*)
-	expr "X$arg" : "X\\(.*\\)$as_nl";
-	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
-      esac;
-      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
-    '
-    export as_echo_n_body
-    as_echo_n='sh -c $as_echo_n_body as_echo'
-  fi
-  export as_echo_body
-  as_echo='sh -c $as_echo_body as_echo'
-fi
-
-# The user is always right.
-if test "${PATH_SEPARATOR+set}" != set; then
-  PATH_SEPARATOR=:
-  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
-    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
-      PATH_SEPARATOR=';'
-  }
-fi
-
-
-# IFS
-# We need space, tab and new line, in precisely that order.  Quoting is
-# there to prevent editors from complaining about space-tab.
-# (If _AS_PATH_WALK were called with IFS unset, it would disable word
-# splitting by setting IFS to empty value.)
-IFS=" ""	$as_nl"
-
-# Find who we are.  Look in the path if we contain no directory separator.
-as_myself=
-case $0 in #((
-  *[\\/]* ) as_myself=$0 ;;
-  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
-  done
-IFS=$as_save_IFS
-
-     ;;
-esac
-# We did not find ourselves, most probably we were run as `sh COMMAND'
-# in which case we are not to be found in the path.
-if test "x$as_myself" = x; then
-  as_myself=$0
-fi
-if test ! -f "$as_myself"; then
-  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
-  exit 1
-fi
-
-# Unset variables that we do not need and which cause bugs (e.g. in
-# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
-# suppresses any "Segmentation fault" message there.  '((' could
-# trigger a bug in pdksh 5.2.14.
-for as_var in BASH_ENV ENV MAIL MAILPATH
-do eval test x\${$as_var+set} = xset \
-  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
-done
-PS1='$ '
-PS2='> '
-PS4='+ '
-
-# NLS nuisances.
-LC_ALL=C
-export LC_ALL
-LANGUAGE=C
-export LANGUAGE
-
-# CDPATH.
-(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
-
-# Use a proper internal environment variable to ensure we don't fall
-  # into an infinite loop, continuously re-executing ourselves.
-  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
-    _as_can_reexec=no; export _as_can_reexec;
-    # We cannot yet assume a decent shell, so we have to provide a
-# neutralization value for shells without unset; and this also
-# works around shells that cannot unset nonexistent variables.
-# Preserve -v and -x to the replacement shell.
-BASH_ENV=/dev/null
-ENV=/dev/null
-(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
-case $- in # ((((
-  *v*x* | *x*v* ) as_opts=-vx ;;
-  *v* ) as_opts=-v ;;
-  *x* ) as_opts=-x ;;
-  * ) as_opts= ;;
-esac
-exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
-# Admittedly, this is quite paranoid, since all the known shells bail
-# out after a failed `exec'.
-$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
-as_fn_exit 255
-  fi
-  # We don't want this to propagate to other subprocesses.
-          { _as_can_reexec=; unset _as_can_reexec;}
-if test "x$CONFIG_SHELL" = x; then
-  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
-  emulate sh
-  NULLCMD=:
-  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
-  # is contrary to our usage.  Disable this feature.
-  alias -g '\${1+\"\$@\"}'='\"\$@\"'
-  setopt NO_GLOB_SUBST
-else
-  case \`(set -o) 2>/dev/null\` in #(
-  *posix*) :
-    set -o posix ;; #(
-  *) :
-     ;;
-esac
-fi
-"
-  as_required="as_fn_return () { (exit \$1); }
-as_fn_success () { as_fn_return 0; }
-as_fn_failure () { as_fn_return 1; }
-as_fn_ret_success () { return 0; }
-as_fn_ret_failure () { return 1; }
-
-exitcode=0
-as_fn_success || { exitcode=1; echo as_fn_success failed.; }
-as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
-as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
-as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
-if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
-
-else
-  exitcode=1; echo positional parameters were not saved.
-fi
-test x\$exitcode = x0 || exit 1
-test -x / || exit 1"
-  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
-  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
-  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
-  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1"
-  if (eval "$as_required") 2>/dev/null; then :
-  as_have_required=yes
-else
-  as_have_required=no
-fi
-  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
-
-else
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-as_found=false
-for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-  as_found=:
-  case $as_dir in #(
-	 /*)
-	   for as_base in sh bash ksh sh5; do
-	     # Try only shells that exist, to save several forks.
-	     as_shell=$as_dir/$as_base
-	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
-		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
-  CONFIG_SHELL=$as_shell as_have_required=yes
-		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
-  break 2
-fi
-fi
-	   done;;
-       esac
-  as_found=false
-done
-$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
-	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
-  CONFIG_SHELL=$SHELL as_have_required=yes
-fi; }
-IFS=$as_save_IFS
-
-
-      if test "x$CONFIG_SHELL" != x; then :
-  export CONFIG_SHELL
-             # We cannot yet assume a decent shell, so we have to provide a
-# neutralization value for shells without unset; and this also
-# works around shells that cannot unset nonexistent variables.
-# Preserve -v and -x to the replacement shell.
-BASH_ENV=/dev/null
-ENV=/dev/null
-(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
-case $- in # ((((
-  *v*x* | *x*v* ) as_opts=-vx ;;
-  *v* ) as_opts=-v ;;
-  *x* ) as_opts=-x ;;
-  * ) as_opts= ;;
-esac
-exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
-# Admittedly, this is quite paranoid, since all the known shells bail
-# out after a failed `exec'.
-$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
-exit 255
-fi
-
-    if test x$as_have_required = xno; then :
-  $as_echo "$0: This script requires a shell more modern than all"
-  $as_echo "$0: the shells that I found on your system."
-  if test x${ZSH_VERSION+set} = xset ; then
-    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
-    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
-  else
-    $as_echo "$0: Please tell bug-autoconf@gnu.org and mu@netsoc.tcd.ie
-$0: about your system, including any error possibly output
-$0: before this message. Then install a modern shell, or
-$0: manually run the script under such a shell if you do
-$0: have one."
-  fi
-  exit 1
-fi
-fi
-fi
-SHELL=${CONFIG_SHELL-/bin/sh}
-export SHELL
-# Unset more variables known to interfere with behavior of common tools.
-CLICOLOR_FORCE= GREP_OPTIONS=
-unset CLICOLOR_FORCE GREP_OPTIONS
-
-## --------------------- ##
-## M4sh Shell Functions. ##
-## --------------------- ##
-# as_fn_unset VAR
-# ---------------
-# Portably unset VAR.
-as_fn_unset ()
-{
-  { eval $1=; unset $1;}
-}
-as_unset=as_fn_unset
-
-# as_fn_set_status STATUS
-# -----------------------
-# Set $? to STATUS, without forking.
-as_fn_set_status ()
-{
-  return $1
-} # as_fn_set_status
-
-# as_fn_exit STATUS
-# -----------------
-# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
-as_fn_exit ()
-{
-  set +e
-  as_fn_set_status $1
-  exit $1
-} # as_fn_exit
-
-# as_fn_mkdir_p
-# -------------
-# Create "$as_dir" as a directory, including parents if necessary.
-as_fn_mkdir_p ()
-{
-
-  case $as_dir in #(
-  -*) as_dir=./$as_dir;;
-  esac
-  test -d "$as_dir" || eval $as_mkdir_p || {
-    as_dirs=
-    while :; do
-      case $as_dir in #(
-      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
-      *) as_qdir=$as_dir;;
-      esac
-      as_dirs="'$as_qdir' $as_dirs"
-      as_dir=`$as_dirname -- "$as_dir" ||
-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$as_dir" : 'X\(//\)[^/]' \| \
-	 X"$as_dir" : 'X\(//\)$' \| \
-	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X"$as_dir" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-      test -d "$as_dir" && break
-    done
-    test -z "$as_dirs" || eval "mkdir $as_dirs"
-  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
-
-
-} # as_fn_mkdir_p
-
-# as_fn_executable_p FILE
-# -----------------------
-# Test if FILE is an executable regular file.
-as_fn_executable_p ()
-{
-  test -f "$1" && test -x "$1"
-} # as_fn_executable_p
-# as_fn_append VAR VALUE
-# ----------------------
-# Append the text in VALUE to the end of the definition contained in VAR. Take
-# advantage of any shell optimizations that allow amortized linear growth over
-# repeated appends, instead of the typical quadratic growth present in naive
-# implementations.
-if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
-  eval 'as_fn_append ()
-  {
-    eval $1+=\$2
-  }'
-else
-  as_fn_append ()
-  {
-    eval $1=\$$1\$2
-  }
-fi # as_fn_append
-
-# as_fn_arith ARG...
-# ------------------
-# Perform arithmetic evaluation on the ARGs, and store the result in the
-# global $as_val. Take advantage of shells that can avoid forks. The arguments
-# must be portable across $(()) and expr.
-if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
-  eval 'as_fn_arith ()
-  {
-    as_val=$(( $* ))
-  }'
-else
-  as_fn_arith ()
-  {
-    as_val=`expr "$@" || test $? -eq 1`
-  }
-fi # as_fn_arith
-
-
-# as_fn_error STATUS ERROR [LINENO LOG_FD]
-# ----------------------------------------
-# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
-# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
-# script with STATUS, using 1 if that was 0.
-as_fn_error ()
-{
-  as_status=$1; test $as_status -eq 0 && as_status=1
-  if test "$4"; then
-    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
-  fi
-  $as_echo "$as_me: error: $2" >&2
-  as_fn_exit $as_status
-} # as_fn_error
-
-if expr a : '\(a\)' >/dev/null 2>&1 &&
-   test "X`expr 00001 : '.*\(...\)'`" = X001; then
-  as_expr=expr
-else
-  as_expr=false
-fi
-
-if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
-  as_basename=basename
-else
-  as_basename=false
-fi
-
-if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
-  as_dirname=dirname
-else
-  as_dirname=false
-fi
-
-as_me=`$as_basename -- "$0" ||
-$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
-	 X"$0" : 'X\(//\)$' \| \
-	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X/"$0" |
-    sed '/^.*\/\([^/][^/]*\)\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-
-# Avoid depending upon Character Ranges.
-as_cr_letters='abcdefghijklmnopqrstuvwxyz'
-as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-as_cr_Letters=$as_cr_letters$as_cr_LETTERS
-as_cr_digits='0123456789'
-as_cr_alnum=$as_cr_Letters$as_cr_digits
-
-
-  as_lineno_1=$LINENO as_lineno_1a=$LINENO
-  as_lineno_2=$LINENO as_lineno_2a=$LINENO
-  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
-  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
-  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
-  sed -n '
-    p
-    /[$]LINENO/=
-  ' <$as_myself |
-    sed '
-      s/[$]LINENO.*/&-/
-      t lineno
-      b
-      :lineno
-      N
-      :loop
-      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
-      t loop
-      s/-\n.*//
-    ' >$as_me.lineno &&
-  chmod +x "$as_me.lineno" ||
-    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
-
-  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
-  # already done that, so ensure we don't try to do so again and fall
-  # in an infinite loop.  This has already happened in practice.
-  _as_can_reexec=no; export _as_can_reexec
-  # Don't try to exec as it changes $[0], causing all sort of problems
-  # (the dirname of $[0] is not the place where we might find the
-  # original and so on.  Autoconf is especially sensitive to this).
-  . "./$as_me.lineno"
-  # Exit status is that of the last command.
-  exit
-}
-
-ECHO_C= ECHO_N= ECHO_T=
-case `echo -n x` in #(((((
--n*)
-  case `echo 'xy\c'` in
-  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
-  xy)  ECHO_C='\c';;
-  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
-       ECHO_T='	';;
-  esac;;
-*)
-  ECHO_N='-n';;
-esac
-
-rm -f conf$$ conf$$.exe conf$$.file
-if test -d conf$$.dir; then
-  rm -f conf$$.dir/conf$$.file
-else
-  rm -f conf$$.dir
-  mkdir conf$$.dir 2>/dev/null
-fi
-if (echo >conf$$.file) 2>/dev/null; then
-  if ln -s conf$$.file conf$$ 2>/dev/null; then
-    as_ln_s='ln -s'
-    # ... but there are two gotchas:
-    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
-    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
-    # In both cases, we have to default to `cp -pR'.
-    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
-      as_ln_s='cp -pR'
-  elif ln conf$$.file conf$$ 2>/dev/null; then
-    as_ln_s=ln
-  else
-    as_ln_s='cp -pR'
-  fi
-else
-  as_ln_s='cp -pR'
-fi
-rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
-rmdir conf$$.dir 2>/dev/null
-
-if mkdir -p . 2>/dev/null; then
-  as_mkdir_p='mkdir -p "$as_dir"'
-else
-  test -d ./-p && rmdir ./-p
-  as_mkdir_p=false
-fi
-
-as_test_x='test -x'
-as_executable_p=as_fn_executable_p
-
-# Sed expression to map a string onto a valid CPP name.
-as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
-
-# Sed expression to map a string onto a valid variable name.
-as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
-
-
-test -n "$DJDIR" || exec 7<&0 </dev/null
-exec 6>&1
-
-# Name of the host.
-# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
-# so uname gets run too.
-ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
-
-#
-# Initializations.
-#
-ac_default_prefix=/usr/local
-ac_clean_files=
-ac_config_libobj_dir=.
-LIBOBJS=
-cross_compiling=no
-subdirs=
-MFLAGS=
-MAKEFLAGS=
-
-# Identity of this package.
-PACKAGE_NAME='jq'
-PACKAGE_TARNAME='jq'
-PACKAGE_VERSION='1.2'
-PACKAGE_STRING='jq 1.2'
-PACKAGE_BUGREPORT='mu@netsoc.tcd.ie'
-PACKAGE_URL='http://stedolan.github.com/jq/'
-
-ac_subst_vars='am__EXEEXT_FALSE
-am__EXEEXT_TRUE
-LTLIBOBJS
-LIBOBJS
-valgrind_cmd
-flex_cmd
-LEXLIB
-LEX_OUTPUT_ROOT
-LEX
-YFLAGS
-YACC
-CPP
-am__fastdepCC_FALSE
-am__fastdepCC_TRUE
-CCDEPMODE
-am__nodep
-AMDEPBACKSLASH
-AMDEP_FALSE
-AMDEP_TRUE
-am__quote
-am__include
-DEPDIR
-OBJEXT
-EXEEXT
-ac_ct_CC
-CPPFLAGS
-LDFLAGS
-CFLAGS
-CC
-AM_BACKSLASH
-AM_DEFAULT_VERBOSITY
-AM_DEFAULT_V
-AM_V
-am__untar
-am__tar
-AMTAR
-am__leading_dot
-SET_MAKE
-AWK
-mkdir_p
-MKDIR_P
-INSTALL_STRIP_PROGRAM
-STRIP
-install_sh
-MAKEINFO
-AUTOHEADER
-AUTOMAKE
-AUTOCONF
-ACLOCAL
-VERSION
-PACKAGE
-CYGPATH_W
-am__isrc
-INSTALL_DATA
-INSTALL_SCRIPT
-INSTALL_PROGRAM
-target_alias
-host_alias
-build_alias
-LIBS
-ECHO_T
-ECHO_N
-ECHO_C
-DEFS
-mandir
-localedir
-libdir
-psdir
-pdfdir
-dvidir
-htmldir
-infodir
-docdir
-oldincludedir
-includedir
-localstatedir
-sharedstatedir
-sysconfdir
-datadir
-datarootdir
-libexecdir
-sbindir
-bindir
-program_transform_name
-prefix
-exec_prefix
-PACKAGE_URL
-PACKAGE_BUGREPORT
-PACKAGE_STRING
-PACKAGE_VERSION
-PACKAGE_TARNAME
-PACKAGE_NAME
-PATH_SEPARATOR
-SHELL'
-ac_subst_files=''
-ac_user_opts='
-enable_option_checking
-enable_silent_rules
-enable_dependency_tracking
-'
-      ac_precious_vars='build_alias
-host_alias
-target_alias
-CC
-CFLAGS
-LDFLAGS
-LIBS
-CPPFLAGS
-CPP
-YACC
-YFLAGS'
-
-
-# Initialize some variables set by options.
-ac_init_help=
-ac_init_version=false
-ac_unrecognized_opts=
-ac_unrecognized_sep=
-# The variables have the same names as the options, with
-# dashes changed to underlines.
-cache_file=/dev/null
-exec_prefix=NONE
-no_create=
-no_recursion=
-prefix=NONE
-program_prefix=NONE
-program_suffix=NONE
-program_transform_name=s,x,x,
-silent=
-site=
-srcdir=
-verbose=
-x_includes=NONE
-x_libraries=NONE
-
-# Installation directory options.
-# These are left unexpanded so users can "make install exec_prefix=/foo"
-# and all the variables that are supposed to be based on exec_prefix
-# by default will actually change.
-# Use braces instead of parens because sh, perl, etc. also accept them.
-# (The list follows the same order as the GNU Coding Standards.)
-bindir='${exec_prefix}/bin'
-sbindir='${exec_prefix}/sbin'
-libexecdir='${exec_prefix}/libexec'
-datarootdir='${prefix}/share'
-datadir='${datarootdir}'
-sysconfdir='${prefix}/etc'
-sharedstatedir='${prefix}/com'
-localstatedir='${prefix}/var'
-includedir='${prefix}/include'
-oldincludedir='/usr/include'
-docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
-infodir='${datarootdir}/info'
-htmldir='${docdir}'
-dvidir='${docdir}'
-pdfdir='${docdir}'
-psdir='${docdir}'
-libdir='${exec_prefix}/lib'
-localedir='${datarootdir}/locale'
-mandir='${datarootdir}/man'
-
-ac_prev=
-ac_dashdash=
-for ac_option
-do
-  # If the previous option needs an argument, assign it.
-  if test -n "$ac_prev"; then
-    eval $ac_prev=\$ac_option
-    ac_prev=
-    continue
-  fi
-
-  case $ac_option in
-  *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
-  *=)   ac_optarg= ;;
-  *)    ac_optarg=yes ;;
-  esac
-
-  # Accept the important Cygnus configure options, so we can diagnose typos.
-
-  case $ac_dashdash$ac_option in
-  --)
-    ac_dashdash=yes ;;
-
-  -bindir | --bindir | --bindi | --bind | --bin | --bi)
-    ac_prev=bindir ;;
-  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
-    bindir=$ac_optarg ;;
-
-  -build | --build | --buil | --bui | --bu)
-    ac_prev=build_alias ;;
-  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
-    build_alias=$ac_optarg ;;
-
-  -cache-file | --cache-file | --cache-fil | --cache-fi \
-  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
-    ac_prev=cache_file ;;
-  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
-  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
-    cache_file=$ac_optarg ;;
-
-  --config-cache | -C)
-    cache_file=config.cache ;;
-
-  -datadir | --datadir | --datadi | --datad)
-    ac_prev=datadir ;;
-  -datadir=* | --datadir=* | --datadi=* | --datad=*)
-    datadir=$ac_optarg ;;
-
-  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
-  | --dataroo | --dataro | --datar)
-    ac_prev=datarootdir ;;
-  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
-  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
-    datarootdir=$ac_optarg ;;
-
-  -disable-* | --disable-*)
-    ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
-    # Reject names that are not valid shell variable names.
-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid feature name: $ac_useropt"
-    ac_useropt_orig=$ac_useropt
-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
-    case $ac_user_opts in
-      *"
-"enable_$ac_useropt"
-"*) ;;
-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
-	 ac_unrecognized_sep=', ';;
-    esac
-    eval enable_$ac_useropt=no ;;
-
-  -docdir | --docdir | --docdi | --doc | --do)
-    ac_prev=docdir ;;
-  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
-    docdir=$ac_optarg ;;
-
-  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
-    ac_prev=dvidir ;;
-  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
-    dvidir=$ac_optarg ;;
-
-  -enable-* | --enable-*)
-    ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
-    # Reject names that are not valid shell variable names.
-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid feature name: $ac_useropt"
-    ac_useropt_orig=$ac_useropt
-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
-    case $ac_user_opts in
-      *"
-"enable_$ac_useropt"
-"*) ;;
-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
-	 ac_unrecognized_sep=', ';;
-    esac
-    eval enable_$ac_useropt=\$ac_optarg ;;
-
-  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
-  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
-  | --exec | --exe | --ex)
-    ac_prev=exec_prefix ;;
-  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
-  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
-  | --exec=* | --exe=* | --ex=*)
-    exec_prefix=$ac_optarg ;;
-
-  -gas | --gas | --ga | --g)
-    # Obsolete; use --with-gas.
-    with_gas=yes ;;
-
-  -help | --help | --hel | --he | -h)
-    ac_init_help=long ;;
-  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
-    ac_init_help=recursive ;;
-  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
-    ac_init_help=short ;;
-
-  -host | --host | --hos | --ho)
-    ac_prev=host_alias ;;
-  -host=* | --host=* | --hos=* | --ho=*)
-    host_alias=$ac_optarg ;;
-
-  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
-    ac_prev=htmldir ;;
-  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
-  | --ht=*)
-    htmldir=$ac_optarg ;;
-
-  -includedir | --includedir | --includedi | --included | --include \
-  | --includ | --inclu | --incl | --inc)
-    ac_prev=includedir ;;
-  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
-  | --includ=* | --inclu=* | --incl=* | --inc=*)
-    includedir=$ac_optarg ;;
-
-  -infodir | --infodir | --infodi | --infod | --info | --inf)
-    ac_prev=infodir ;;
-  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
-    infodir=$ac_optarg ;;
-
-  -libdir | --libdir | --libdi | --libd)
-    ac_prev=libdir ;;
-  -libdir=* | --libdir=* | --libdi=* | --libd=*)
-    libdir=$ac_optarg ;;
-
-  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
-  | --libexe | --libex | --libe)
-    ac_prev=libexecdir ;;
-  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
-  | --libexe=* | --libex=* | --libe=*)
-    libexecdir=$ac_optarg ;;
-
-  -localedir | --localedir | --localedi | --localed | --locale)
-    ac_prev=localedir ;;
-  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
-    localedir=$ac_optarg ;;
-
-  -localstatedir | --localstatedir | --localstatedi | --localstated \
-  | --localstate | --localstat | --localsta | --localst | --locals)
-    ac_prev=localstatedir ;;
-  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
-  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
-    localstatedir=$ac_optarg ;;
-
-  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
-    ac_prev=mandir ;;
-  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
-    mandir=$ac_optarg ;;
-
-  -nfp | --nfp | --nf)
-    # Obsolete; use --without-fp.
-    with_fp=no ;;
-
-  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
-  | --no-cr | --no-c | -n)
-    no_create=yes ;;
-
-  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
-  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
-    no_recursion=yes ;;
-
-  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
-  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
-  | --oldin | --oldi | --old | --ol | --o)
-    ac_prev=oldincludedir ;;
-  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
-  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
-  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
-    oldincludedir=$ac_optarg ;;
-
-  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
-    ac_prev=prefix ;;
-  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
-    prefix=$ac_optarg ;;
-
-  -program-prefix | --program-prefix | --program-prefi | --program-pref \
-  | --program-pre | --program-pr | --program-p)
-    ac_prev=program_prefix ;;
-  -program-prefix=* | --program-prefix=* | --program-prefi=* \
-  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
-    program_prefix=$ac_optarg ;;
-
-  -program-suffix | --program-suffix | --program-suffi | --program-suff \
-  | --program-suf | --program-su | --program-s)
-    ac_prev=program_suffix ;;
-  -program-suffix=* | --program-suffix=* | --program-suffi=* \
-  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
-    program_suffix=$ac_optarg ;;
-
-  -program-transform-name | --program-transform-name \
-  | --program-transform-nam | --program-transform-na \
-  | --program-transform-n | --program-transform- \
-  | --program-transform | --program-transfor \
-  | --program-transfo | --program-transf \
-  | --program-trans | --program-tran \
-  | --progr-tra | --program-tr | --program-t)
-    ac_prev=program_transform_name ;;
-  -program-transform-name=* | --program-transform-name=* \
-  | --program-transform-nam=* | --program-transform-na=* \
-  | --program-transform-n=* | --program-transform-=* \
-  | --program-transform=* | --program-transfor=* \
-  | --program-transfo=* | --program-transf=* \
-  | --program-trans=* | --program-tran=* \
-  | --progr-tra=* | --program-tr=* | --program-t=*)
-    program_transform_name=$ac_optarg ;;
-
-  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
-    ac_prev=pdfdir ;;
-  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
-    pdfdir=$ac_optarg ;;
-
-  -psdir | --psdir | --psdi | --psd | --ps)
-    ac_prev=psdir ;;
-  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
-    psdir=$ac_optarg ;;
-
-  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
-  | -silent | --silent | --silen | --sile | --sil)
-    silent=yes ;;
-
-  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
-    ac_prev=sbindir ;;
-  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
-  | --sbi=* | --sb=*)
-    sbindir=$ac_optarg ;;
-
-  -sharedstatedir | --sharedstatedir | --sharedstatedi \
-  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
-  | --sharedst | --shareds | --shared | --share | --shar \
-  | --sha | --sh)
-    ac_prev=sharedstatedir ;;
-  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
-  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
-  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
-  | --sha=* | --sh=*)
-    sharedstatedir=$ac_optarg ;;
-
-  -site | --site | --sit)
-    ac_prev=site ;;
-  -site=* | --site=* | --sit=*)
-    site=$ac_optarg ;;
-
-  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
-    ac_prev=srcdir ;;
-  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
-    srcdir=$ac_optarg ;;
-
-  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
-  | --syscon | --sysco | --sysc | --sys | --sy)
-    ac_prev=sysconfdir ;;
-  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
-  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
-    sysconfdir=$ac_optarg ;;
-
-  -target | --target | --targe | --targ | --tar | --ta | --t)
-    ac_prev=target_alias ;;
-  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
-    target_alias=$ac_optarg ;;
-
-  -v | -verbose | --verbose | --verbos | --verbo | --verb)
-    verbose=yes ;;
-
-  -version | --version | --versio | --versi | --vers | -V)
-    ac_init_version=: ;;
-
-  -with-* | --with-*)
-    ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
-    # Reject names that are not valid shell variable names.
-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid package name: $ac_useropt"
-    ac_useropt_orig=$ac_useropt
-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
-    case $ac_user_opts in
-      *"
-"with_$ac_useropt"
-"*) ;;
-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
-	 ac_unrecognized_sep=', ';;
-    esac
-    eval with_$ac_useropt=\$ac_optarg ;;
-
-  -without-* | --without-*)
-    ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
-    # Reject names that are not valid shell variable names.
-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid package name: $ac_useropt"
-    ac_useropt_orig=$ac_useropt
-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
-    case $ac_user_opts in
-      *"
-"with_$ac_useropt"
-"*) ;;
-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
-	 ac_unrecognized_sep=', ';;
-    esac
-    eval with_$ac_useropt=no ;;
-
-  --x)
-    # Obsolete; use --with-x.
-    with_x=yes ;;
-
-  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
-  | --x-incl | --x-inc | --x-in | --x-i)
-    ac_prev=x_includes ;;
-  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
-  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
-    x_includes=$ac_optarg ;;
-
-  -x-libraries | --x-libraries | --x-librarie | --x-librari \
-  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
-    ac_prev=x_libraries ;;
-  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
-  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
-    x_libraries=$ac_optarg ;;
-
-  -*) as_fn_error $? "unrecognized option: \`$ac_option'
-Try \`$0 --help' for more information"
-    ;;
-
-  *=*)
-    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
-    # Reject names that are not valid shell variable names.
-    case $ac_envvar in #(
-      '' | [0-9]* | *[!_$as_cr_alnum]* )
-      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
-    esac
-    eval $ac_envvar=\$ac_optarg
-    export $ac_envvar ;;
-
-  *)
-    # FIXME: should be removed in autoconf 3.0.
-    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
-    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
-      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
-    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
-    ;;
-
-  esac
-done
-
-if test -n "$ac_prev"; then
-  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
-  as_fn_error $? "missing argument to $ac_option"
-fi
-
-if test -n "$ac_unrecognized_opts"; then
-  case $enable_option_checking in
-    no) ;;
-    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
-    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
-  esac
-fi
-
-# Check all directory arguments for consistency.
-for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
-		datadir sysconfdir sharedstatedir localstatedir includedir \
-		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
-		libdir localedir mandir
-do
-  eval ac_val=\$$ac_var
-  # Remove trailing slashes.
-  case $ac_val in
-    */ )
-      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
-      eval $ac_var=\$ac_val;;
-  esac
-  # Be sure to have absolute directory names.
-  case $ac_val in
-    [\\/$]* | ?:[\\/]* )  continue;;
-    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
-  esac
-  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
-done
-
-# There might be people who depend on the old broken behavior: `$host'
-# used to hold the argument of --host etc.
-# FIXME: To remove some day.
-build=$build_alias
-host=$host_alias
-target=$target_alias
-
-# FIXME: To remove some day.
-if test "x$host_alias" != x; then
-  if test "x$build_alias" = x; then
-    cross_compiling=maybe
-  elif test "x$build_alias" != "x$host_alias"; then
-    cross_compiling=yes
-  fi
-fi
-
-ac_tool_prefix=
-test -n "$host_alias" && ac_tool_prefix=$host_alias-
-
-test "$silent" = yes && exec 6>/dev/null
-
-
-ac_pwd=`pwd` && test -n "$ac_pwd" &&
-ac_ls_di=`ls -di .` &&
-ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
-  as_fn_error $? "working directory cannot be determined"
-test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
-  as_fn_error $? "pwd does not report name of working directory"
-
-
-# Find the source files, if location was not specified.
-if test -z "$srcdir"; then
-  ac_srcdir_defaulted=yes
-  # Try the directory containing this script, then the parent directory.
-  ac_confdir=`$as_dirname -- "$as_myself" ||
-$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$as_myself" : 'X\(//\)[^/]' \| \
-	 X"$as_myself" : 'X\(//\)$' \| \
-	 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X"$as_myself" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-  srcdir=$ac_confdir
-  if test ! -r "$srcdir/$ac_unique_file"; then
-    srcdir=..
-  fi
-else
-  ac_srcdir_defaulted=no
-fi
-if test ! -r "$srcdir/$ac_unique_file"; then
-  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
-  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
-fi
-ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
-ac_abs_confdir=`(
-	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
-	pwd)`
-# When building in place, set srcdir=.
-if test "$ac_abs_confdir" = "$ac_pwd"; then
-  srcdir=.
-fi
-# Remove unnecessary trailing slashes from srcdir.
-# Double slashes in file names in object file debugging info
-# mess up M-x gdb in Emacs.
-case $srcdir in
-*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
-esac
-for ac_var in $ac_precious_vars; do
-  eval ac_env_${ac_var}_set=\${${ac_var}+set}
-  eval ac_env_${ac_var}_value=\$${ac_var}
-  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
-  eval ac_cv_env_${ac_var}_value=\$${ac_var}
-done
-
-#
-# Report the --help message.
-#
-if test "$ac_init_help" = "long"; then
-  # Omit some internal or obsolete options to make the list less imposing.
-  # This message is too long to be a string in the A/UX 3.1 sh.
-  cat <<_ACEOF
-\`configure' configures jq 1.2 to adapt to many kinds of systems.
-
-Usage: $0 [OPTION]... [VAR=VALUE]...
-
-To assign environment variables (e.g., CC, CFLAGS...), specify them as
-VAR=VALUE.  See below for descriptions of some of the useful variables.
-
-Defaults for the options are specified in brackets.
-
-Configuration:
-  -h, --help              display this help and exit
-      --help=short        display options specific to this package
-      --help=recursive    display the short help of all the included packages
-  -V, --version           display version information and exit
-  -q, --quiet, --silent   do not print \`checking ...' messages
-      --cache-file=FILE   cache test results in FILE [disabled]
-  -C, --config-cache      alias for \`--cache-file=config.cache'
-  -n, --no-create         do not create output files
-      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
-
-Installation directories:
-  --prefix=PREFIX         install architecture-independent files in PREFIX
-                          [$ac_default_prefix]
-  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
-                          [PREFIX]
-
-By default, \`make install' will install all the files in
-\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
-an installation prefix other than \`$ac_default_prefix' using \`--prefix',
-for instance \`--prefix=\$HOME'.
-
-For better control, use the options below.
-
-Fine tuning of the installation directories:
-  --bindir=DIR            user executables [EPREFIX/bin]
-  --sbindir=DIR           system admin executables [EPREFIX/sbin]
-  --libexecdir=DIR        program executables [EPREFIX/libexec]
-  --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
-  --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
-  --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
-  --libdir=DIR            object code libraries [EPREFIX/lib]
-  --includedir=DIR        C header files [PREFIX/include]
-  --oldincludedir=DIR     C header files for non-gcc [/usr/include]
-  --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
-  --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
-  --infodir=DIR           info documentation [DATAROOTDIR/info]
-  --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
-  --mandir=DIR            man documentation [DATAROOTDIR/man]
-  --docdir=DIR            documentation root [DATAROOTDIR/doc/jq]
-  --htmldir=DIR           html documentation [DOCDIR]
-  --dvidir=DIR            dvi documentation [DOCDIR]
-  --pdfdir=DIR            pdf documentation [DOCDIR]
-  --psdir=DIR             ps documentation [DOCDIR]
-_ACEOF
-
-  cat <<\_ACEOF
-
-Program names:
-  --program-prefix=PREFIX            prepend PREFIX to installed program names
-  --program-suffix=SUFFIX            append SUFFIX to installed program names
-  --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
-_ACEOF
-fi
-
-if test -n "$ac_init_help"; then
-  case $ac_init_help in
-     short | recursive ) echo "Configuration of jq 1.2:";;
-   esac
-  cat <<\_ACEOF
-
-Optional Features:
-  --disable-option-checking  ignore unrecognized --enable/--with options
-  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
-  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
-  --enable-silent-rules          less verbose build output (undo: `make V=1')
-  --disable-silent-rules         verbose build output (undo: `make V=0')
-  --disable-dependency-tracking  speeds up one-time build
-  --enable-dependency-tracking   do not reject slow dependency extractors
-
-Some influential environment variables:
-  CC          C compiler command
-  CFLAGS      C compiler flags
-  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
-              nonstandard directory <lib dir>
-  LIBS        libraries to pass to the linker, e.g. -l<library>
-  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
-              you have headers in a nonstandard directory <include dir>
-  CPP         C preprocessor
-  YACC        The `Yet Another Compiler Compiler' implementation to use.
-              Defaults to the first program found out of: `bison -y', `byacc',
-              `yacc'.
-  YFLAGS      The list of arguments that will be passed by default to $YACC.
-              This script will default YFLAGS to the empty string to avoid a
-              default value of `-d' given by some make applications.
-
-Use these variables to override the choices made by `configure' or to help
-it to find libraries and programs with nonstandard names/locations.
-
-Report bugs to <mu@netsoc.tcd.ie>.
-jq home page: <http://stedolan.github.com/jq/>.
-_ACEOF
-ac_status=$?
-fi
-
-if test "$ac_init_help" = "recursive"; then
-  # If there are subdirs, report their specific --help.
-  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
-    test -d "$ac_dir" ||
-      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
-      continue
-    ac_builddir=.
-
-case "$ac_dir" in
-.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
-*)
-  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
-  # A ".." for each directory in $ac_dir_suffix.
-  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
-  case $ac_top_builddir_sub in
-  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
-  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
-  esac ;;
-esac
-ac_abs_top_builddir=$ac_pwd
-ac_abs_builddir=$ac_pwd$ac_dir_suffix
-# for backward compatibility:
-ac_top_builddir=$ac_top_build_prefix
-
-case $srcdir in
-  .)  # We are building in place.
-    ac_srcdir=.
-    ac_top_srcdir=$ac_top_builddir_sub
-    ac_abs_top_srcdir=$ac_pwd ;;
-  [\\/]* | ?:[\\/]* )  # Absolute name.
-    ac_srcdir=$srcdir$ac_dir_suffix;
-    ac_top_srcdir=$srcdir
-    ac_abs_top_srcdir=$srcdir ;;
-  *) # Relative name.
-    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
-    ac_top_srcdir=$ac_top_build_prefix$srcdir
-    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
-esac
-ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
-
-    cd "$ac_dir" || { ac_status=$?; continue; }
-    # Check for guested configure.
-    if test -f "$ac_srcdir/configure.gnu"; then
-      echo &&
-      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
-    elif test -f "$ac_srcdir/configure"; then
-      echo &&
-      $SHELL "$ac_srcdir/configure" --help=recursive
-    else
-      $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
-    fi || ac_status=$?
-    cd "$ac_pwd" || { ac_status=$?; break; }
-  done
-fi
-
-test -n "$ac_init_help" && exit $ac_status
-if $ac_init_version; then
-  cat <<\_ACEOF
-jq configure 1.2
-generated by GNU Autoconf 2.69
-
-Copyright (C) 2012 Free Software Foundation, Inc.
-This configure script is free software; the Free Software Foundation
-gives unlimited permission to copy, distribute and modify it.
-_ACEOF
-  exit
-fi
-
-## ------------------------ ##
-## Autoconf initialization. ##
-## ------------------------ ##
-
-# ac_fn_c_try_compile LINENO
-# --------------------------
-# Try to compile conftest.$ac_ext, and return whether this succeeded.
-ac_fn_c_try_compile ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  rm -f conftest.$ac_objext
-  if { { ac_try="$ac_compile"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_compile") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    grep -v '^ *+' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-    mv -f conftest.er1 conftest.err
-  fi
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } && {
-	 test -z "$ac_c_werror_flag" ||
-	 test ! -s conftest.err
-       } && test -s conftest.$ac_objext; then :
-  ac_retval=0
-else
-  $as_echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-	ac_retval=1
-fi
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-  as_fn_set_status $ac_retval
-
-} # ac_fn_c_try_compile
-
-# ac_fn_c_try_cpp LINENO
-# ----------------------
-# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
-ac_fn_c_try_cpp ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  if { { ac_try="$ac_cpp conftest.$ac_ext"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    grep -v '^ *+' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-    mv -f conftest.er1 conftest.err
-  fi
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } > conftest.i && {
-	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
-	 test ! -s conftest.err
-       }; then :
-  ac_retval=0
-else
-  $as_echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-    ac_retval=1
-fi
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-  as_fn_set_status $ac_retval
-
-} # ac_fn_c_try_cpp
-
-# ac_fn_c_try_link LINENO
-# -----------------------
-# Try to link conftest.$ac_ext, and return whether this succeeded.
-ac_fn_c_try_link ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  rm -f conftest.$ac_objext conftest$ac_exeext
-  if { { ac_try="$ac_link"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_link") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    grep -v '^ *+' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-    mv -f conftest.er1 conftest.err
-  fi
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } && {
-	 test -z "$ac_c_werror_flag" ||
-	 test ! -s conftest.err
-       } && test -s conftest$ac_exeext && {
-	 test "$cross_compiling" = yes ||
-	 test -x conftest$ac_exeext
-       }; then :
-  ac_retval=0
-else
-  $as_echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-	ac_retval=1
-fi
-  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
-  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
-  # interfere with the next link command; also delete a directory that is
-  # left behind by Apple's compiler.  We do this before executing the actions.
-  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-  as_fn_set_status $ac_retval
-
-} # ac_fn_c_try_link
-cat >config.log <<_ACEOF
-This file contains any messages produced by compilers while
-running configure, to aid debugging if configure makes a mistake.
-
-It was created by jq $as_me 1.2, which was
-generated by GNU Autoconf 2.69.  Invocation command line was
-
-  $ $0 $@
-
-_ACEOF
-exec 5>>config.log
-{
-cat <<_ASUNAME
-## --------- ##
-## Platform. ##
-## --------- ##
-
-hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
-uname -m = `(uname -m) 2>/dev/null || echo unknown`
-uname -r = `(uname -r) 2>/dev/null || echo unknown`
-uname -s = `(uname -s) 2>/dev/null || echo unknown`
-uname -v = `(uname -v) 2>/dev/null || echo unknown`
-
-/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
-/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
-
-/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
-/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
-/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
-/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
-/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
-/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
-/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
-
-_ASUNAME
-
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    $as_echo "PATH: $as_dir"
-  done
-IFS=$as_save_IFS
-
-} >&5
-
-cat >&5 <<_ACEOF
-
-
-## ----------- ##
-## Core tests. ##
-## ----------- ##
-
-_ACEOF
-
-
-# Keep a trace of the command line.
-# Strip out --no-create and --no-recursion so they do not pile up.
-# Strip out --silent because we don't want to record it for future runs.
-# Also quote any args containing shell meta-characters.
-# Make two passes to allow for proper duplicate-argument suppression.
-ac_configure_args=
-ac_configure_args0=
-ac_configure_args1=
-ac_must_keep_next=false
-for ac_pass in 1 2
-do
-  for ac_arg
-  do
-    case $ac_arg in
-    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
-    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
-    | -silent | --silent | --silen | --sile | --sil)
-      continue ;;
-    *\'*)
-      ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
-    esac
-    case $ac_pass in
-    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
-    2)
-      as_fn_append ac_configure_args1 " '$ac_arg'"
-      if test $ac_must_keep_next = true; then
-	ac_must_keep_next=false # Got value, back to normal.
-      else
-	case $ac_arg in
-	  *=* | --config-cache | -C | -disable-* | --disable-* \
-	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
-	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
-	  | -with-* | --with-* | -without-* | --without-* | --x)
-	    case "$ac_configure_args0 " in
-	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
-	    esac
-	    ;;
-	  -* ) ac_must_keep_next=true ;;
-	esac
-      fi
-      as_fn_append ac_configure_args " '$ac_arg'"
-      ;;
-    esac
-  done
-done
-{ ac_configure_args0=; unset ac_configure_args0;}
-{ ac_configure_args1=; unset ac_configure_args1;}
-
-# When interrupted or exit'd, cleanup temporary files, and complete
-# config.log.  We remove comments because anyway the quotes in there
-# would cause problems or look ugly.
-# WARNING: Use '\'' to represent an apostrophe within the trap.
-# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
-trap 'exit_status=$?
-  # Save into config.log some information that might help in debugging.
-  {
-    echo
-
-    $as_echo "## ---------------- ##
-## Cache variables. ##
-## ---------------- ##"
-    echo
-    # The following way of writing the cache mishandles newlines in values,
-(
-  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
-    eval ac_val=\$$ac_var
-    case $ac_val in #(
-    *${as_nl}*)
-      case $ac_var in #(
-      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
-$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
-      esac
-      case $ac_var in #(
-      _ | IFS | as_nl) ;; #(
-      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
-      *) { eval $ac_var=; unset $ac_var;} ;;
-      esac ;;
-    esac
-  done
-  (set) 2>&1 |
-    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
-    *${as_nl}ac_space=\ *)
-      sed -n \
-	"s/'\''/'\''\\\\'\'''\''/g;
-	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
-      ;; #(
-    *)
-      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
-      ;;
-    esac |
-    sort
-)
-    echo
-
-    $as_echo "## ----------------- ##
-## Output variables. ##
-## ----------------- ##"
-    echo
-    for ac_var in $ac_subst_vars
-    do
-      eval ac_val=\$$ac_var
-      case $ac_val in
-      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
-      esac
-      $as_echo "$ac_var='\''$ac_val'\''"
-    done | sort
-    echo
-
-    if test -n "$ac_subst_files"; then
-      $as_echo "## ------------------- ##
-## File substitutions. ##
-## ------------------- ##"
-      echo
-      for ac_var in $ac_subst_files
-      do
-	eval ac_val=\$$ac_var
-	case $ac_val in
-	*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
-	esac
-	$as_echo "$ac_var='\''$ac_val'\''"
-      done | sort
-      echo
-    fi
-
-    if test -s confdefs.h; then
-      $as_echo "## ----------- ##
-## confdefs.h. ##
-## ----------- ##"
-      echo
-      cat confdefs.h
-      echo
-    fi
-    test "$ac_signal" != 0 &&
-      $as_echo "$as_me: caught signal $ac_signal"
-    $as_echo "$as_me: exit $exit_status"
-  } >&5
-  rm -f core *.core core.conftest.* &&
-    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
-    exit $exit_status
-' 0
-for ac_signal in 1 2 13 15; do
-  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
-done
-ac_signal=0
-
-# confdefs.h avoids OS command line length limits that DEFS can exceed.
-rm -f -r conftest* confdefs.h
-
-$as_echo "/* confdefs.h */" > confdefs.h
-
-# Predefined preprocessor variables.
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_NAME "$PACKAGE_NAME"
-_ACEOF
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
-_ACEOF
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_VERSION "$PACKAGE_VERSION"
-_ACEOF
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_STRING "$PACKAGE_STRING"
-_ACEOF
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
-_ACEOF
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_URL "$PACKAGE_URL"
-_ACEOF
-
-
-# Let the site file select an alternate cache file if it wants to.
-# Prefer an explicitly selected file to automatically selected ones.
-ac_site_file1=NONE
-ac_site_file2=NONE
-if test -n "$CONFIG_SITE"; then
-  # We do not want a PATH search for config.site.
-  case $CONFIG_SITE in #((
-    -*)  ac_site_file1=./$CONFIG_SITE;;
-    */*) ac_site_file1=$CONFIG_SITE;;
-    *)   ac_site_file1=./$CONFIG_SITE;;
-  esac
-elif test "x$prefix" != xNONE; then
-  ac_site_file1=$prefix/share/config.site
-  ac_site_file2=$prefix/etc/config.site
-else
-  ac_site_file1=$ac_default_prefix/share/config.site
-  ac_site_file2=$ac_default_prefix/etc/config.site
-fi
-for ac_site_file in "$ac_site_file1" "$ac_site_file2"
-do
-  test "x$ac_site_file" = xNONE && continue
-  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
-    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
-$as_echo "$as_me: loading site script $ac_site_file" >&6;}
-    sed 's/^/| /' "$ac_site_file" >&5
-    . "$ac_site_file" \
-      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "failed to load site script $ac_site_file
-See \`config.log' for more details" "$LINENO" 5; }
-  fi
-done
-
-if test -r "$cache_file"; then
-  # Some versions of bash will fail to source /dev/null (special files
-  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
-  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
-    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
-$as_echo "$as_me: loading cache $cache_file" >&6;}
-    case $cache_file in
-      [\\/]* | ?:[\\/]* ) . "$cache_file";;
-      *)                      . "./$cache_file";;
-    esac
-  fi
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
-$as_echo "$as_me: creating cache $cache_file" >&6;}
-  >$cache_file
-fi
-
-# Check that the precious variables saved in the cache have kept the same
-# value.
-ac_cache_corrupted=false
-for ac_var in $ac_precious_vars; do
-  eval ac_old_set=\$ac_cv_env_${ac_var}_set
-  eval ac_new_set=\$ac_env_${ac_var}_set
-  eval ac_old_val=\$ac_cv_env_${ac_var}_value
-  eval ac_new_val=\$ac_env_${ac_var}_value
-  case $ac_old_set,$ac_new_set in
-    set,)
-      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
-$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
-      ac_cache_corrupted=: ;;
-    ,set)
-      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
-$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
-      ac_cache_corrupted=: ;;
-    ,);;
-    *)
-      if test "x$ac_old_val" != "x$ac_new_val"; then
-	# differences in whitespace do not lead to failure.
-	ac_old_val_w=`echo x $ac_old_val`
-	ac_new_val_w=`echo x $ac_new_val`
-	if test "$ac_old_val_w" != "$ac_new_val_w"; then
-	  { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
-$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
-	  ac_cache_corrupted=:
-	else
-	  { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
-$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
-	  eval $ac_var=\$ac_old_val
-	fi
-	{ $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
-$as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
-	{ $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
-$as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
-      fi;;
-  esac
-  # Pass precious variables to config.status.
-  if test "$ac_new_set" = set; then
-    case $ac_new_val in
-    *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
-    *) ac_arg=$ac_var=$ac_new_val ;;
-    esac
-    case " $ac_configure_args " in
-      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
-      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
-    esac
-  fi
-done
-if $ac_cache_corrupted; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
-$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
-  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
-fi
-## -------------------- ##
-## Main body of script. ##
-## -------------------- ##
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-
-
-
-ac_aux_dir=
-for ac_dir in config "$srcdir"/config; do
-  if test -f "$ac_dir/install-sh"; then
-    ac_aux_dir=$ac_dir
-    ac_install_sh="$ac_aux_dir/install-sh -c"
-    break
-  elif test -f "$ac_dir/install.sh"; then
-    ac_aux_dir=$ac_dir
-    ac_install_sh="$ac_aux_dir/install.sh -c"
-    break
-  elif test -f "$ac_dir/shtool"; then
-    ac_aux_dir=$ac_dir
-    ac_install_sh="$ac_aux_dir/shtool install -c"
-    break
-  fi
-done
-if test -z "$ac_aux_dir"; then
-  as_fn_error $? "cannot find install-sh, install.sh, or shtool in config \"$srcdir\"/config" "$LINENO" 5
-fi
-
-# These three variables are undocumented and unsupported,
-# and are intended to be withdrawn in a future Autoconf release.
-# They can cause serious problems if a builder's source tree is in a directory
-# whose full name contains unusual characters.
-ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
-ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
-ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
-
-
-am__api_version='1.11'
-
-# Find a good install program.  We prefer a C program (faster),
-# so one script is as good as another.  But avoid the broken or
-# incompatible versions:
-# SysV /etc/install, /usr/sbin/install
-# SunOS /usr/etc/install
-# IRIX /sbin/install
-# AIX /bin/install
-# AmigaOS /C/install, which installs bootblocks on floppy discs
-# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
-# AFS /usr/afsws/bin/install, which mishandles nonexistent args
-# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
-# OS/2's system install, which has a completely different semantic
-# ./install, which can be erroneously created by make from ./install.sh.
-# Reject install programs that cannot install multiple files.
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
-$as_echo_n "checking for a BSD-compatible install... " >&6; }
-if test -z "$INSTALL"; then
-if ${ac_cv_path_install+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    # Account for people who put trailing slashes in PATH elements.
-case $as_dir/ in #((
-  ./ | .// | /[cC]/* | \
-  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
-  ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
-  /usr/ucb/* ) ;;
-  *)
-    # OSF1 and SCO ODT 3.0 have their own names for install.
-    # Don't use installbsd from OSF since it installs stuff as root
-    # by default.
-    for ac_prog in ginstall scoinst install; do
-      for ac_exec_ext in '' $ac_executable_extensions; do
-	if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
-	  if test $ac_prog = install &&
-	    grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
-	    # AIX install.  It has an incompatible calling convention.
-	    :
-	  elif test $ac_prog = install &&
-	    grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
-	    # program-specific install script used by HP pwplus--don't use.
-	    :
-	  else
-	    rm -rf conftest.one conftest.two conftest.dir
-	    echo one > conftest.one
-	    echo two > conftest.two
-	    mkdir conftest.dir
-	    if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
-	      test -s conftest.one && test -s conftest.two &&
-	      test -s conftest.dir/conftest.one &&
-	      test -s conftest.dir/conftest.two
-	    then
-	      ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
-	      break 3
-	    fi
-	  fi
-	fi
-      done
-    done
-    ;;
-esac
-
-  done
-IFS=$as_save_IFS
-
-rm -rf conftest.one conftest.two conftest.dir
-
-fi
-  if test "${ac_cv_path_install+set}" = set; then
-    INSTALL=$ac_cv_path_install
-  else
-    # As a last resort, use the slow shell script.  Don't cache a
-    # value for INSTALL within a source directory, because that will
-    # break other packages using the cache if that directory is
-    # removed, or if the value is a relative name.
-    INSTALL=$ac_install_sh
-  fi
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
-$as_echo "$INSTALL" >&6; }
-
-# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
-# It thinks the first close brace ends the variable substitution.
-test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
-
-test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
-
-test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5
-$as_echo_n "checking whether build environment is sane... " >&6; }
-# Just in case
-sleep 1
-echo timestamp > conftest.file
-# Reject unsafe characters in $srcdir or the absolute working directory
-# name.  Accept space and tab only in the latter.
-am_lf='
-'
-case `pwd` in
-  *[\\\"\#\$\&\'\`$am_lf]*)
-    as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;;
-esac
-case $srcdir in
-  *[\\\"\#\$\&\'\`$am_lf\ \	]*)
-    as_fn_error $? "unsafe srcdir value: \`$srcdir'" "$LINENO" 5;;
-esac
-
-# Do `set' in a subshell so we don't clobber the current shell's
-# arguments.  Must try -L first in case configure is actually a
-# symlink; some systems play weird games with the mod time of symlinks
-# (eg FreeBSD returns the mod time of the symlink's containing
-# directory).
-if (
-   set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
-   if test "$*" = "X"; then
-      # -L didn't work.
-      set X `ls -t "$srcdir/configure" conftest.file`
-   fi
-   rm -f conftest.file
-   if test "$*" != "X $srcdir/configure conftest.file" \
-      && test "$*" != "X conftest.file $srcdir/configure"; then
-
-      # If neither matched, then we have a broken ls.  This can happen
-      # if, for instance, CONFIG_SHELL is bash and it inherits a
-      # broken ls alias from the environment.  This has actually
-      # happened.  Such a system could not be considered "sane".
-      as_fn_error $? "ls -t appears to fail.  Make sure there is not a broken
-alias in your environment" "$LINENO" 5
-   fi
-
-   test "$2" = conftest.file
-   )
-then
-   # Ok.
-   :
-else
-   as_fn_error $? "newly created file is older than distributed files!
-Check your system clock" "$LINENO" 5
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-$as_echo "yes" >&6; }
-test "$program_prefix" != NONE &&
-  program_transform_name="s&^&$program_prefix&;$program_transform_name"
-# Use a double $ so make ignores it.
-test "$program_suffix" != NONE &&
-  program_transform_name="s&\$&$program_suffix&;$program_transform_name"
-# Double any \ or $.
-# By default was `s,x,x', remove it if useless.
-ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
-program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"`
-
-# expand $ac_aux_dir to an absolute path
-am_aux_dir=`cd $ac_aux_dir && pwd`
-
-if test x"${MISSING+set}" != xset; then
-  case $am_aux_dir in
-  *\ * | *\	*)
-    MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;;
-  *)
-    MISSING="\${SHELL} $am_aux_dir/missing" ;;
-  esac
-fi
-# Use eval to expand $SHELL
-if eval "$MISSING --run true"; then
-  am_missing_run="$MISSING --run "
-else
-  am_missing_run=
-  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`missing' script is too old or missing" >&5
-$as_echo "$as_me: WARNING: \`missing' script is too old or missing" >&2;}
-fi
-
-if test x"${install_sh}" != xset; then
-  case $am_aux_dir in
-  *\ * | *\	*)
-    install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
-  *)
-    install_sh="\${SHELL} $am_aux_dir/install-sh"
-  esac
-fi
-
-# Installed binaries are usually stripped using `strip' when the user
-# run `make install-strip'.  However `strip' might not be the right
-# tool to use in cross-compilation environments, therefore Automake
-# will honor the `STRIP' environment variable to overrule this program.
-if test "$cross_compiling" != no; then
-  if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
-set dummy ${ac_tool_prefix}strip; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_STRIP+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$STRIP"; then
-  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-STRIP=$ac_cv_prog_STRIP
-if test -n "$STRIP"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
-$as_echo "$STRIP" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_STRIP"; then
-  ac_ct_STRIP=$STRIP
-  # Extract the first word of "strip", so it can be a program name with args.
-set dummy strip; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$ac_ct_STRIP"; then
-  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_STRIP="strip"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
-if test -n "$ac_ct_STRIP"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
-$as_echo "$ac_ct_STRIP" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-  if test "x$ac_ct_STRIP" = x; then
-    STRIP=":"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    STRIP=$ac_ct_STRIP
-  fi
-else
-  STRIP="$ac_cv_prog_STRIP"
-fi
-
-fi
-INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a thread-safe mkdir -p" >&5
-$as_echo_n "checking for a thread-safe mkdir -p... " >&6; }
-if test -z "$MKDIR_P"; then
-  if ${ac_cv_path_mkdir+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_prog in mkdir gmkdir; do
-	 for ac_exec_ext in '' $ac_executable_extensions; do
-	   as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext" || continue
-	   case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #(
-	     'mkdir (GNU coreutils) '* | \
-	     'mkdir (coreutils) '* | \
-	     'mkdir (fileutils) '4.1*)
-	       ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext
-	       break 3;;
-	   esac
-	 done
-       done
-  done
-IFS=$as_save_IFS
-
-fi
-
-  test -d ./--version && rmdir ./--version
-  if test "${ac_cv_path_mkdir+set}" = set; then
-    MKDIR_P="$ac_cv_path_mkdir -p"
-  else
-    # As a last resort, use the slow shell script.  Don't cache a
-    # value for MKDIR_P within a source directory, because that will
-    # break other packages using the cache if that directory is
-    # removed, or if the value is a relative name.
-    MKDIR_P="$ac_install_sh -d"
-  fi
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5
-$as_echo "$MKDIR_P" >&6; }
-
-mkdir_p="$MKDIR_P"
-case $mkdir_p in
-  [\\/$]* | ?:[\\/]*) ;;
-  */*) mkdir_p="\$(top_builddir)/$mkdir_p" ;;
-esac
-
-for ac_prog in gawk mawk nawk awk
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_AWK+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$AWK"; then
-  ac_cv_prog_AWK="$AWK" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_AWK="$ac_prog"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-AWK=$ac_cv_prog_AWK
-if test -n "$AWK"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
-$as_echo "$AWK" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-  test -n "$AWK" && break
-done
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
-$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
-set x ${MAKE-make}
-ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
-if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  cat >conftest.make <<\_ACEOF
-SHELL = /bin/sh
-all:
-	@echo '@@@%%%=$(MAKE)=@@@%%%'
-_ACEOF
-# GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
-case `${MAKE-make} -f conftest.make 2>/dev/null` in
-  *@@@%%%=?*=@@@%%%*)
-    eval ac_cv_prog_make_${ac_make}_set=yes;;
-  *)
-    eval ac_cv_prog_make_${ac_make}_set=no;;
-esac
-rm -f conftest.make
-fi
-if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-$as_echo "yes" >&6; }
-  SET_MAKE=
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-  SET_MAKE="MAKE=${MAKE-make}"
-fi
-
-rm -rf .tst 2>/dev/null
-mkdir .tst 2>/dev/null
-if test -d .tst; then
-  am__leading_dot=.
-else
-  am__leading_dot=_
-fi
-rmdir .tst 2>/dev/null
-
-if test "`cd $srcdir && pwd`" != "`pwd`"; then
-  # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
-  # is not polluted with repeated "-I."
-  am__isrc=' -I$(srcdir)'
-  # test to see if srcdir already configured
-  if test -f $srcdir/config.status; then
-    as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5
-  fi
-fi
-
-# test whether we have cygpath
-if test -z "$CYGPATH_W"; then
-  if (cygpath --version) >/dev/null 2>/dev/null; then
-    CYGPATH_W='cygpath -w'
-  else
-    CYGPATH_W=echo
-  fi
-fi
-
-
-# Define the identity of the package.
- PACKAGE='jq'
- VERSION='1.2'
-
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE "$PACKAGE"
-_ACEOF
-
-
-cat >>confdefs.h <<_ACEOF
-#define VERSION "$VERSION"
-_ACEOF
-
-# Some tools Automake needs.
-
-ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}
-
-
-AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}
-
-
-AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}
-
-
-AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}
-
-
-MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
-
-# We need awk for the "check" target.  The system "awk" is bad on
-# some platforms.
-# Always define AMTAR for backward compatibility.  Yes, it's still used
-# in the wild :-(  We should find a proper way to deprecate it ...
-AMTAR='$${TAR-tar}'
-
-am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'
-
-
-
-
-
-# Check whether --enable-silent-rules was given.
-if test "${enable_silent_rules+set}" = set; then :
-  enableval=$enable_silent_rules;
-fi
-
-case $enable_silent_rules in
-yes) AM_DEFAULT_VERBOSITY=0;;
-no)  AM_DEFAULT_VERBOSITY=1;;
-*)   AM_DEFAULT_VERBOSITY=0;;
-esac
-am_make=${MAKE-make}
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5
-$as_echo_n "checking whether $am_make supports nested variables... " >&6; }
-if ${am_cv_make_support_nested_variables+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if $as_echo 'TRUE=$(BAR$(V))
-BAR0=false
-BAR1=true
-V=1
-am__doit:
-	@$(TRUE)
-.PHONY: am__doit' | $am_make -f - >/dev/null 2>&1; then
-  am_cv_make_support_nested_variables=yes
-else
-  am_cv_make_support_nested_variables=no
-fi
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5
-$as_echo "$am_cv_make_support_nested_variables" >&6; }
-if test $am_cv_make_support_nested_variables = yes; then
-    AM_V='$(V)'
-  AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
-else
-  AM_V=$AM_DEFAULT_VERBOSITY
-  AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
-fi
-AM_BACKSLASH='\'
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
-set dummy ${ac_tool_prefix}gcc; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_CC="${ac_tool_prefix}gcc"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-$as_echo "$CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_CC"; then
-  ac_ct_CC=$CC
-  # Extract the first word of "gcc", so it can be a program name with args.
-set dummy gcc; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_ac_ct_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$ac_ct_CC"; then
-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_CC="gcc"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_CC=$ac_cv_prog_ac_ct_CC
-if test -n "$ac_ct_CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
-$as_echo "$ac_ct_CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-  if test "x$ac_ct_CC" = x; then
-    CC=""
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    CC=$ac_ct_CC
-  fi
-else
-  CC="$ac_cv_prog_CC"
-fi
-
-if test -z "$CC"; then
-          if test -n "$ac_tool_prefix"; then
-    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
-set dummy ${ac_tool_prefix}cc; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_CC="${ac_tool_prefix}cc"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-$as_echo "$CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-  fi
-fi
-if test -z "$CC"; then
-  # Extract the first word of "cc", so it can be a program name with args.
-set dummy cc; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-  ac_prog_rejected=no
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
-       ac_prog_rejected=yes
-       continue
-     fi
-    ac_cv_prog_CC="cc"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-if test $ac_prog_rejected = yes; then
-  # We found a bogon in the path, so make sure we never use it.
-  set dummy $ac_cv_prog_CC
-  shift
-  if test $# != 0; then
-    # We chose a different compiler from the bogus one.
-    # However, it has the same basename, so the bogon will be chosen
-    # first if we set CC to just the basename; use the full file name.
-    shift
-    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
-  fi
-fi
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-$as_echo "$CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-fi
-if test -z "$CC"; then
-  if test -n "$ac_tool_prefix"; then
-  for ac_prog in cl.exe
-  do
-    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
-set dummy $ac_tool_prefix$ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-$as_echo "$CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-    test -n "$CC" && break
-  done
-fi
-if test -z "$CC"; then
-  ac_ct_CC=$CC
-  for ac_prog in cl.exe
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_ac_ct_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$ac_ct_CC"; then
-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_CC="$ac_prog"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_CC=$ac_cv_prog_ac_ct_CC
-if test -n "$ac_ct_CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
-$as_echo "$ac_ct_CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-  test -n "$ac_ct_CC" && break
-done
-
-  if test "x$ac_ct_CC" = x; then
-    CC=""
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    CC=$ac_ct_CC
-  fi
-fi
-
-fi
-
-
-test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "no acceptable C compiler found in \$PATH
-See \`config.log' for more details" "$LINENO" 5; }
-
-# Provide some information about the compiler.
-$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
-set X $ac_compile
-ac_compiler=$2
-for ac_option in --version -v -V -qversion; do
-  { { ac_try="$ac_compiler $ac_option >&5"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    sed '10a\
-... rest of stderr output deleted ...
-         10q' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-  fi
-  rm -f conftest.er1 conftest.err
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }
-done
-
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-ac_clean_files_save=$ac_clean_files
-ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
-# Try to create an executable without -o first, disregard a.out.
-# It will help us diagnose broken compilers, and finding out an intuition
-# of exeext.
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
-$as_echo_n "checking whether the C compiler works... " >&6; }
-ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
-
-# The possible output files:
-ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
-
-ac_rmfiles=
-for ac_file in $ac_files
-do
-  case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
-    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
-  esac
-done
-rm -f $ac_rmfiles
-
-if { { ac_try="$ac_link_default"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_link_default") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; then :
-  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
-# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
-# in a Makefile.  We should not override ac_cv_exeext if it was cached,
-# so that the user can short-circuit this test for compilers unknown to
-# Autoconf.
-for ac_file in $ac_files ''
-do
-  test -f "$ac_file" || continue
-  case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
-	;;
-    [ab].out )
-	# We found the default executable, but exeext='' is most
-	# certainly right.
-	break;;
-    *.* )
-	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
-	then :; else
-	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
-	fi
-	# We set ac_cv_exeext here because the later test for it is not
-	# safe: cross compilers may not add the suffix if given an `-o'
-	# argument, so we may need to know it at that point already.
-	# Even if this section looks crufty: it has the advantage of
-	# actually working.
-	break;;
-    * )
-	break;;
-  esac
-done
-test "$ac_cv_exeext" = no && ac_cv_exeext=
-
-else
-  ac_file=''
-fi
-if test -z "$ac_file"; then :
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-$as_echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error 77 "C compiler cannot create executables
-See \`config.log' for more details" "$LINENO" 5; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-$as_echo "yes" >&6; }
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
-$as_echo_n "checking for C compiler default output file name... " >&6; }
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
-$as_echo "$ac_file" >&6; }
-ac_exeext=$ac_cv_exeext
-
-rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
-ac_clean_files=$ac_clean_files_save
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
-$as_echo_n "checking for suffix of executables... " >&6; }
-if { { ac_try="$ac_link"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_link") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; then :
-  # If both `conftest.exe' and `conftest' are `present' (well, observable)
-# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
-# work properly (i.e., refer to `conftest.exe'), while it won't with
-# `rm'.
-for ac_file in conftest.exe conftest conftest.*; do
-  test -f "$ac_file" || continue
-  case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
-    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
-	  break;;
-    * ) break;;
-  esac
-done
-else
-  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "cannot compute suffix of executables: cannot compile and link
-See \`config.log' for more details" "$LINENO" 5; }
-fi
-rm -f conftest conftest$ac_cv_exeext
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
-$as_echo "$ac_cv_exeext" >&6; }
-
-rm -f conftest.$ac_ext
-EXEEXT=$ac_cv_exeext
-ac_exeext=$EXEEXT
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <stdio.h>
-int
-main ()
-{
-FILE *f = fopen ("conftest.out", "w");
- return ferror (f) || fclose (f) != 0;
-
-  ;
-  return 0;
-}
-_ACEOF
-ac_clean_files="$ac_clean_files conftest.out"
-# Check that the compiler produces executables we can run.  If not, either
-# the compiler is broken, or we cross compile.
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
-$as_echo_n "checking whether we are cross compiling... " >&6; }
-if test "$cross_compiling" != yes; then
-  { { ac_try="$ac_link"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_link") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }
-  if { ac_try='./conftest$ac_cv_exeext'
-  { { case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_try") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; }; then
-    cross_compiling=no
-  else
-    if test "$cross_compiling" = maybe; then
-	cross_compiling=yes
-    else
-	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "cannot run C compiled programs.
-If you meant to cross compile, use \`--host'.
-See \`config.log' for more details" "$LINENO" 5; }
-    fi
-  fi
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
-$as_echo "$cross_compiling" >&6; }
-
-rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
-ac_clean_files=$ac_clean_files_save
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
-$as_echo_n "checking for suffix of object files... " >&6; }
-if ${ac_cv_objext+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.o conftest.obj
-if { { ac_try="$ac_compile"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_compile") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; then :
-  for ac_file in conftest.o conftest.obj conftest.*; do
-  test -f "$ac_file" || continue;
-  case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
-    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
-       break;;
-  esac
-done
-else
-  $as_echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "cannot compute suffix of object files: cannot compile
-See \`config.log' for more details" "$LINENO" 5; }
-fi
-rm -f conftest.$ac_cv_objext conftest.$ac_ext
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
-$as_echo "$ac_cv_objext" >&6; }
-OBJEXT=$ac_cv_objext
-ac_objext=$OBJEXT
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
-$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
-if ${ac_cv_c_compiler_gnu+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-#ifndef __GNUC__
-       choke me
-#endif
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-  ac_compiler_gnu=yes
-else
-  ac_compiler_gnu=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-ac_cv_c_compiler_gnu=$ac_compiler_gnu
-
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
-$as_echo "$ac_cv_c_compiler_gnu" >&6; }
-if test $ac_compiler_gnu = yes; then
-  GCC=yes
-else
-  GCC=
-fi
-ac_test_CFLAGS=${CFLAGS+set}
-ac_save_CFLAGS=$CFLAGS
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
-$as_echo_n "checking whether $CC accepts -g... " >&6; }
-if ${ac_cv_prog_cc_g+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  ac_save_c_werror_flag=$ac_c_werror_flag
-   ac_c_werror_flag=yes
-   ac_cv_prog_cc_g=no
-   CFLAGS="-g"
-   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-  ac_cv_prog_cc_g=yes
-else
-  CFLAGS=""
-      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-
-else
-  ac_c_werror_flag=$ac_save_c_werror_flag
-	 CFLAGS="-g"
-	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-  ac_cv_prog_cc_g=yes
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-   ac_c_werror_flag=$ac_save_c_werror_flag
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
-$as_echo "$ac_cv_prog_cc_g" >&6; }
-if test "$ac_test_CFLAGS" = set; then
-  CFLAGS=$ac_save_CFLAGS
-elif test $ac_cv_prog_cc_g = yes; then
-  if test "$GCC" = yes; then
-    CFLAGS="-g -O2"
-  else
-    CFLAGS="-g"
-  fi
-else
-  if test "$GCC" = yes; then
-    CFLAGS="-O2"
-  else
-    CFLAGS=
-  fi
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
-$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
-if ${ac_cv_prog_cc_c89+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  ac_cv_prog_cc_c89=no
-ac_save_CC=$CC
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <stdarg.h>
-#include <stdio.h>
-struct stat;
-/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
-struct buf { int x; };
-FILE * (*rcsopen) (struct buf *, struct stat *, int);
-static char *e (p, i)
-     char **p;
-     int i;
-{
-  return p[i];
-}
-static char *f (char * (*g) (char **, int), char **p, ...)
-{
-  char *s;
-  va_list v;
-  va_start (v,p);
-  s = g (p, va_arg (v,int));
-  va_end (v);
-  return s;
-}
-
-/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
-   function prototypes and stuff, but not '\xHH' hex character constants.
-   These don't provoke an error unfortunately, instead are silently treated
-   as 'x'.  The following induces an error, until -std is added to get
-   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
-   array size at least.  It's necessary to write '\x00'==0 to get something
-   that's true only with -std.  */
-int osf4_cc_array ['\x00' == 0 ? 1 : -1];
-
-/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
-   inside strings and character constants.  */
-#define FOO(x) 'x'
-int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
-
-int test (int i, double x);
-struct s1 {int (*f) (int a);};
-struct s2 {int (*f) (double a);};
-int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
-int argc;
-char **argv;
-int
-main ()
-{
-return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
-  ;
-  return 0;
-}
-_ACEOF
-for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
-	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
-do
-  CC="$ac_save_CC $ac_arg"
-  if ac_fn_c_try_compile "$LINENO"; then :
-  ac_cv_prog_cc_c89=$ac_arg
-fi
-rm -f core conftest.err conftest.$ac_objext
-  test "x$ac_cv_prog_cc_c89" != "xno" && break
-done
-rm -f conftest.$ac_ext
-CC=$ac_save_CC
-
-fi
-# AC_CACHE_VAL
-case "x$ac_cv_prog_cc_c89" in
-  x)
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-$as_echo "none needed" >&6; } ;;
-  xno)
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-$as_echo "unsupported" >&6; } ;;
-  *)
-    CC="$CC $ac_cv_prog_cc_c89"
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
-$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
-esac
-if test "x$ac_cv_prog_cc_c89" != xno; then :
-
-fi
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-DEPDIR="${am__leading_dot}deps"
-
-ac_config_commands="$ac_config_commands depfiles"
-
-
-am_make=${MAKE-make}
-cat > confinc << 'END'
-am__doit:
-	@echo this is the am__doit target
-.PHONY: am__doit
-END
-# If we don't find an include directive, just comment out the code.
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5
-$as_echo_n "checking for style of include used by $am_make... " >&6; }
-am__include="#"
-am__quote=
-_am_result=none
-# First try GNU make style include.
-echo "include confinc" > confmf
-# Ignore all kinds of additional output from `make'.
-case `$am_make -s -f confmf 2> /dev/null` in #(
-*the\ am__doit\ target*)
-  am__include=include
-  am__quote=
-  _am_result=GNU
-  ;;
-esac
-# Now try BSD make style include.
-if test "$am__include" = "#"; then
-   echo '.include "confinc"' > confmf
-   case `$am_make -s -f confmf 2> /dev/null` in #(
-   *the\ am__doit\ target*)
-     am__include=.include
-     am__quote="\""
-     _am_result=BSD
-     ;;
-   esac
-fi
-
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5
-$as_echo "$_am_result" >&6; }
-rm -f confinc confmf
-
-# Check whether --enable-dependency-tracking was given.
-if test "${enable_dependency_tracking+set}" = set; then :
-  enableval=$enable_dependency_tracking;
-fi
-
-if test "x$enable_dependency_tracking" != xno; then
-  am_depcomp="$ac_aux_dir/depcomp"
-  AMDEPBACKSLASH='\'
-  am__nodep='_no'
-fi
- if test "x$enable_dependency_tracking" != xno; then
-  AMDEP_TRUE=
-  AMDEP_FALSE='#'
-else
-  AMDEP_TRUE='#'
-  AMDEP_FALSE=
-fi
-
-
-
-depcc="$CC"   am_compiler_list=
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
-$as_echo_n "checking dependency style of $depcc... " >&6; }
-if ${am_cv_CC_dependencies_compiler_type+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
-  # We make a subdir and do the tests there.  Otherwise we can end up
-  # making bogus files that we don't know about and never remove.  For
-  # instance it was reported that on HP-UX the gcc test will end up
-  # making a dummy file named `D' -- because `-MD' means `put the output
-  # in D'.
-  rm -rf conftest.dir
-  mkdir conftest.dir
-  # Copy depcomp to subdir because otherwise we won't find it if we're
-  # using a relative directory.
-  cp "$am_depcomp" conftest.dir
-  cd conftest.dir
-  # We will build objects and dependencies in a subdirectory because
-  # it helps to detect inapplicable dependency modes.  For instance
-  # both Tru64's cc and ICC support -MD to output dependencies as a
-  # side effect of compilation, but ICC will put the dependencies in
-  # the current directory while Tru64 will put them in the object
-  # directory.
-  mkdir sub
-
-  am_cv_CC_dependencies_compiler_type=none
-  if test "$am_compiler_list" = ""; then
-     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
-  fi
-  am__universal=false
-  case " $depcc " in #(
-     *\ -arch\ *\ -arch\ *) am__universal=true ;;
-     esac
-
-  for depmode in $am_compiler_list; do
-    # Setup a source with many dependencies, because some compilers
-    # like to wrap large dependency lists on column 80 (with \), and
-    # we should not choose a depcomp mode which is confused by this.
-    #
-    # We need to recreate these files for each test, as the compiler may
-    # overwrite some of them when testing with obscure command lines.
-    # This happens at least with the AIX C compiler.
-    : > sub/conftest.c
-    for i in 1 2 3 4 5 6; do
-      echo '#include "conftst'$i'.h"' >> sub/conftest.c
-      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
-      # Solaris 8's {/usr,}/bin/sh.
-      touch sub/conftst$i.h
-    done
-    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
-
-    # We check with `-c' and `-o' for the sake of the "dashmstdout"
-    # mode.  It turns out that the SunPro C++ compiler does not properly
-    # handle `-M -o', and we need to detect this.  Also, some Intel
-    # versions had trouble with output in subdirs
-    am__obj=sub/conftest.${OBJEXT-o}
-    am__minus_obj="-o $am__obj"
-    case $depmode in
-    gcc)
-      # This depmode causes a compiler race in universal mode.
-      test "$am__universal" = false || continue
-      ;;
-    nosideeffect)
-      # after this tag, mechanisms are not by side-effect, so they'll
-      # only be used when explicitly requested
-      if test "x$enable_dependency_tracking" = xyes; then
-	continue
-      else
-	break
-      fi
-      ;;
-    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
-      # This compiler won't grok `-c -o', but also, the minuso test has
-      # not run yet.  These depmodes are late enough in the game, and
-      # so weak that their functioning should not be impacted.
-      am__obj=conftest.${OBJEXT-o}
-      am__minus_obj=
-      ;;
-    none) break ;;
-    esac
-    if depmode=$depmode \
-       source=sub/conftest.c object=$am__obj \
-       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
-       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
-         >/dev/null 2>conftest.err &&
-       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
-       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
-       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
-       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
-      # icc doesn't choke on unknown options, it will just issue warnings
-      # or remarks (even with -Werror).  So we grep stderr for any message
-      # that says an option was ignored or not supported.
-      # When given -MP, icc 7.0 and 7.1 complain thusly:
-      #   icc: Command line warning: ignoring option '-M'; no argument required
-      # The diagnosis changed in icc 8.0:
-      #   icc: Command line remark: option '-MP' not supported
-      if (grep 'ignoring option' conftest.err ||
-          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
-        am_cv_CC_dependencies_compiler_type=$depmode
-        break
-      fi
-    fi
-  done
-
-  cd ..
-  rm -rf conftest.dir
-else
-  am_cv_CC_dependencies_compiler_type=none
-fi
-
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
-$as_echo "$am_cv_CC_dependencies_compiler_type" >&6; }
-CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
-
- if
-  test "x$enable_dependency_tracking" != xno \
-  && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
-  am__fastdepCC_TRUE=
-  am__fastdepCC_FALSE='#'
-else
-  am__fastdepCC_TRUE='#'
-  am__fastdepCC_FALSE=
-fi
-
-
-   case $ac_cv_prog_cc_stdc in #(
-  no) :
-    ac_cv_prog_cc_c99=no; ac_cv_prog_cc_c89=no ;; #(
-  *) :
-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C99" >&5
-$as_echo_n "checking for $CC option to accept ISO C99... " >&6; }
-if ${ac_cv_prog_cc_c99+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  ac_cv_prog_cc_c99=no
-ac_save_CC=$CC
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdlib.h>
-#include <wchar.h>
-#include <stdio.h>
-
-// Check varargs macros.  These examples are taken from C99 6.10.3.5.
-#define debug(...) fprintf (stderr, __VA_ARGS__)
-#define showlist(...) puts (#__VA_ARGS__)
-#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
-static void
-test_varargs_macros (void)
-{
-  int x = 1234;
-  int y = 5678;
-  debug ("Flag");
-  debug ("X = %d\n", x);
-  showlist (The first, second, and third items.);
-  report (x>y, "x is %d but y is %d", x, y);
-}
-
-// Check long long types.
-#define BIG64 18446744073709551615ull
-#define BIG32 4294967295ul
-#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
-#if !BIG_OK
-  your preprocessor is broken;
-#endif
-#if BIG_OK
-#else
-  your preprocessor is broken;
-#endif
-static long long int bignum = -9223372036854775807LL;
-static unsigned long long int ubignum = BIG64;
-
-struct incomplete_array
-{
-  int datasize;
-  double data[];
-};
-
-struct named_init {
-  int number;
-  const wchar_t *name;
-  double average;
-};
-
-typedef const char *ccp;
-
-static inline int
-test_restrict (ccp restrict text)
-{
-  // See if C++-style comments work.
-  // Iterate through items via the restricted pointer.
-  // Also check for declarations in for loops.
-  for (unsigned int i = 0; *(text+i) != '\0'; ++i)
-    continue;
-  return 0;
-}
-
-// Check varargs and va_copy.
-static void
-test_varargs (const char *format, ...)
-{
-  va_list args;
-  va_start (args, format);
-  va_list args_copy;
-  va_copy (args_copy, args);
-
-  const char *str;
-  int number;
-  float fnumber;
-
-  while (*format)
-    {
-      switch (*format++)
-	{
-	case 's': // string
-	  str = va_arg (args_copy, const char *);
-	  break;
-	case 'd': // int
-	  number = va_arg (args_copy, int);
-	  break;
-	case 'f': // float
-	  fnumber = va_arg (args_copy, double);
-	  break;
-	default:
-	  break;
-	}
-    }
-  va_end (args_copy);
-  va_end (args);
-}
-
-int
-main ()
-{
-
-  // Check bool.
-  _Bool success = false;
-
-  // Check restrict.
-  if (test_restrict ("String literal") == 0)
-    success = true;
-  char *restrict newvar = "Another string";
-
-  // Check varargs.
-  test_varargs ("s, d' f .", "string", 65, 34.234);
-  test_varargs_macros ();
-
-  // Check flexible array members.
-  struct incomplete_array *ia =
-    malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
-  ia->datasize = 10;
-  for (int i = 0; i < ia->datasize; ++i)
-    ia->data[i] = i * 1.234;
-
-  // Check named initializers.
-  struct named_init ni = {
-    .number = 34,
-    .name = L"Test wide string",
-    .average = 543.34343,
-  };
-
-  ni.number = 58;
-
-  int dynamic_array[ni.number];
-  dynamic_array[ni.number - 1] = 543;
-
-  // work around unused variable warnings
-  return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x'
-	  || dynamic_array[ni.number - 1] != 543);
-
-  ;
-  return 0;
-}
-_ACEOF
-for ac_arg in '' -std=gnu99 -std=c99 -c99 -AC99 -D_STDC_C99= -qlanglvl=extc99
-do
-  CC="$ac_save_CC $ac_arg"
-  if ac_fn_c_try_compile "$LINENO"; then :
-  ac_cv_prog_cc_c99=$ac_arg
-fi
-rm -f core conftest.err conftest.$ac_objext
-  test "x$ac_cv_prog_cc_c99" != "xno" && break
-done
-rm -f conftest.$ac_ext
-CC=$ac_save_CC
-
-fi
-# AC_CACHE_VAL
-case "x$ac_cv_prog_cc_c99" in
-  x)
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-$as_echo "none needed" >&6; } ;;
-  xno)
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-$as_echo "unsupported" >&6; } ;;
-  *)
-    CC="$CC $ac_cv_prog_cc_c99"
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5
-$as_echo "$ac_cv_prog_cc_c99" >&6; } ;;
-esac
-if test "x$ac_cv_prog_cc_c99" != xno; then :
-  ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
-$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
-if ${ac_cv_prog_cc_c89+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  ac_cv_prog_cc_c89=no
-ac_save_CC=$CC
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <stdarg.h>
-#include <stdio.h>
-struct stat;
-/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
-struct buf { int x; };
-FILE * (*rcsopen) (struct buf *, struct stat *, int);
-static char *e (p, i)
-     char **p;
-     int i;
-{
-  return p[i];
-}
-static char *f (char * (*g) (char **, int), char **p, ...)
-{
-  char *s;
-  va_list v;
-  va_start (v,p);
-  s = g (p, va_arg (v,int));
-  va_end (v);
-  return s;
-}
-
-/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
-   function prototypes and stuff, but not '\xHH' hex character constants.
-   These don't provoke an error unfortunately, instead are silently treated
-   as 'x'.  The following induces an error, until -std is added to get
-   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
-   array size at least.  It's necessary to write '\x00'==0 to get something
-   that's true only with -std.  */
-int osf4_cc_array ['\x00' == 0 ? 1 : -1];
-
-/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
-   inside strings and character constants.  */
-#define FOO(x) 'x'
-int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
-
-int test (int i, double x);
-struct s1 {int (*f) (int a);};
-struct s2 {int (*f) (double a);};
-int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
-int argc;
-char **argv;
-int
-main ()
-{
-return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
-  ;
-  return 0;
-}
-_ACEOF
-for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
-	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
-do
-  CC="$ac_save_CC $ac_arg"
-  if ac_fn_c_try_compile "$LINENO"; then :
-  ac_cv_prog_cc_c89=$ac_arg
-fi
-rm -f core conftest.err conftest.$ac_objext
-  test "x$ac_cv_prog_cc_c89" != "xno" && break
-done
-rm -f conftest.$ac_ext
-CC=$ac_save_CC
-
-fi
-# AC_CACHE_VAL
-case "x$ac_cv_prog_cc_c89" in
-  x)
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-$as_echo "none needed" >&6; } ;;
-  xno)
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-$as_echo "unsupported" >&6; } ;;
-  *)
-    CC="$CC $ac_cv_prog_cc_c89"
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
-$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
-esac
-if test "x$ac_cv_prog_cc_c89" != xno; then :
-  ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89
-else
-  ac_cv_prog_cc_stdc=no
-fi
-
-fi
- ;;
-esac
-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO Standard C" >&5
-$as_echo_n "checking for $CC option to accept ISO Standard C... " >&6; }
-  if ${ac_cv_prog_cc_stdc+:} false; then :
-  $as_echo_n "(cached) " >&6
-fi
-
-  case $ac_cv_prog_cc_stdc in #(
-  no) :
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-$as_echo "unsupported" >&6; } ;; #(
-  '') :
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-$as_echo "none needed" >&6; } ;; #(
-  *) :
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_stdc" >&5
-$as_echo "$ac_cv_prog_cc_stdc" >&6; } ;;
-esac
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
-$as_echo_n "checking how to run the C preprocessor... " >&6; }
-# On Suns, sometimes $CPP names a directory.
-if test -n "$CPP" && test -d "$CPP"; then
-  CPP=
-fi
-if test -z "$CPP"; then
-  if ${ac_cv_prog_CPP+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-      # Double quotes because CPP needs to be expanded
-    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
-    do
-      ac_preproc_ok=false
-for ac_c_preproc_warn_flag in '' yes
-do
-  # Use a header file that comes with gcc, so configuring glibc
-  # with a fresh cross-compiler works.
-  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-  # <limits.h> exists even on freestanding compilers.
-  # On the NeXT, cc -E runs the code through the compiler's parser,
-  # not just through cpp. "Syntax error" is here to catch this case.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-		     Syntax error
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"; then :
-
-else
-  # Broken: fails on valid input.
-continue
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
-
-  # OK, works on sane cases.  Now check whether nonexistent headers
-  # can be detected and how.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <ac_nonexistent.h>
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"; then :
-  # Broken: success on invalid input.
-continue
-else
-  # Passes both tests.
-ac_preproc_ok=:
-break
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
-
-done
-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
-rm -f conftest.i conftest.err conftest.$ac_ext
-if $ac_preproc_ok; then :
-  break
-fi
-
-    done
-    ac_cv_prog_CPP=$CPP
-
-fi
-  CPP=$ac_cv_prog_CPP
-else
-  ac_cv_prog_CPP=$CPP
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
-$as_echo "$CPP" >&6; }
-ac_preproc_ok=false
-for ac_c_preproc_warn_flag in '' yes
-do
-  # Use a header file that comes with gcc, so configuring glibc
-  # with a fresh cross-compiler works.
-  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-  # <limits.h> exists even on freestanding compilers.
-  # On the NeXT, cc -E runs the code through the compiler's parser,
-  # not just through cpp. "Syntax error" is here to catch this case.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-		     Syntax error
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"; then :
-
-else
-  # Broken: fails on valid input.
-continue
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
-
-  # OK, works on sane cases.  Now check whether nonexistent headers
-  # can be detected and how.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <ac_nonexistent.h>
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"; then :
-  # Broken: success on invalid input.
-continue
-else
-  # Passes both tests.
-ac_preproc_ok=:
-break
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
-
-done
-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
-rm -f conftest.i conftest.err conftest.$ac_ext
-if $ac_preproc_ok; then :
-
-else
-  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
-See \`config.log' for more details" "$LINENO" 5; }
-fi
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-ac_c_preproc_warn_flag=yes
-for ac_prog in 'bison -y' byacc
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_YACC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$YACC"; then
-  ac_cv_prog_YACC="$YACC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_YACC="$ac_prog"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-YACC=$ac_cv_prog_YACC
-if test -n "$YACC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $YACC" >&5
-$as_echo "$YACC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-  test -n "$YACC" && break
-done
-test -n "$YACC" || YACC="yacc"
-
-
-if test "x$CC" != xcc; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC and cc understand -c and -o together" >&5
-$as_echo_n "checking whether $CC and cc understand -c and -o together... " >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether cc understands -c and -o together" >&5
-$as_echo_n "checking whether cc understands -c and -o together... " >&6; }
-fi
-set dummy $CC; ac_cc=`$as_echo "$2" |
-		      sed 's/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/'`
-if eval \${ac_cv_prog_cc_${ac_cc}_c_o+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-# Make sure it works both with $CC and with simple cc.
-# We do the test twice because some compilers refuse to overwrite an
-# existing .o file with -o, though they will create one.
-ac_try='$CC -c conftest.$ac_ext -o conftest2.$ac_objext >&5'
-rm -f conftest2.*
-if { { case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_try") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } &&
-   test -f conftest2.$ac_objext && { { case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_try") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; };
-then
-  eval ac_cv_prog_cc_${ac_cc}_c_o=yes
-  if test "x$CC" != xcc; then
-    # Test first that cc exists at all.
-    if { ac_try='cc -c conftest.$ac_ext >&5'
-  { { case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_try") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; }; then
-      ac_try='cc -c conftest.$ac_ext -o conftest2.$ac_objext >&5'
-      rm -f conftest2.*
-      if { { case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_try") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } &&
-	 test -f conftest2.$ac_objext && { { case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_try") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; };
-      then
-	# cc works too.
-	:
-      else
-	# cc exists but doesn't like -o.
-	eval ac_cv_prog_cc_${ac_cc}_c_o=no
-      fi
-    fi
-  fi
-else
-  eval ac_cv_prog_cc_${ac_cc}_c_o=no
-fi
-rm -f core conftest*
-
-fi
-if eval test \$ac_cv_prog_cc_${ac_cc}_c_o = yes; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-$as_echo "yes" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-
-$as_echo "#define NO_MINUS_C_MINUS_O 1" >>confdefs.h
-
-fi
-
-# FIXME: we rely on the cache variable name because
-# there is no other way.
-set dummy $CC
-am_cc=`echo $2 | sed 's/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/'`
-eval am_t=\$ac_cv_prog_cc_${am_cc}_c_o
-if test "$am_t" != yes; then
-   # Losing compiler, so override with the script.
-   # FIXME: It is wrong to rewrite CC.
-   # But if we don't then we get into trouble of one sort or another.
-   # A longer-term fix would be to have automake use am__CC in this case,
-   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
-   CC="$am_aux_dir/compile $CC"
-fi
-
-
-
-
-
-
-for ac_prog in flex lex
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_LEX+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$LEX"; then
-  ac_cv_prog_LEX="$LEX" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_LEX="$ac_prog"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-LEX=$ac_cv_prog_LEX
-if test -n "$LEX"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LEX" >&5
-$as_echo "$LEX" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-  test -n "$LEX" && break
-done
-test -n "$LEX" || LEX=":"
-
-if test "x$LEX" != "x:"; then
-  cat >conftest.l <<_ACEOF
-%%
-a { ECHO; }
-b { REJECT; }
-c { yymore (); }
-d { yyless (1); }
-e { /* IRIX 6.5 flex 2.5.4 underquotes its yyless argument.  */
-    yyless ((input () != 0)); }
-f { unput (yytext[0]); }
-. { BEGIN INITIAL; }
-%%
-#ifdef YYTEXT_POINTER
-extern char *yytext;
-#endif
-int
-main (void)
-{
-  return ! yylex () + ! yywrap ();
-}
-_ACEOF
-{ { ac_try="$LEX conftest.l"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$LEX conftest.l") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking lex output file root" >&5
-$as_echo_n "checking lex output file root... " >&6; }
-if ${ac_cv_prog_lex_root+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-
-if test -f lex.yy.c; then
-  ac_cv_prog_lex_root=lex.yy
-elif test -f lexyy.c; then
-  ac_cv_prog_lex_root=lexyy
-else
-  as_fn_error $? "cannot find output from $LEX; giving up" "$LINENO" 5
-fi
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_lex_root" >&5
-$as_echo "$ac_cv_prog_lex_root" >&6; }
-LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
-
-if test -z "${LEXLIB+set}"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking lex library" >&5
-$as_echo_n "checking lex library... " >&6; }
-if ${ac_cv_lib_lex+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-
-    ac_save_LIBS=$LIBS
-    ac_cv_lib_lex='none needed'
-    for ac_lib in '' -lfl -ll; do
-      LIBS="$ac_lib $ac_save_LIBS"
-      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-`cat $LEX_OUTPUT_ROOT.c`
-_ACEOF
-if ac_fn_c_try_link "$LINENO"; then :
-  ac_cv_lib_lex=$ac_lib
-fi
-rm -f core conftest.err conftest.$ac_objext \
-    conftest$ac_exeext conftest.$ac_ext
-      test "$ac_cv_lib_lex" != 'none needed' && break
-    done
-    LIBS=$ac_save_LIBS
-
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_lex" >&5
-$as_echo "$ac_cv_lib_lex" >&6; }
-  test "$ac_cv_lib_lex" != 'none needed' && LEXLIB=$ac_cv_lib_lex
-fi
-
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether yytext is a pointer" >&5
-$as_echo_n "checking whether yytext is a pointer... " >&6; }
-if ${ac_cv_prog_lex_yytext_pointer+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  # POSIX says lex can declare yytext either as a pointer or an array; the
-# default is implementation-dependent.  Figure out which it is, since
-# not all implementations provide the %pointer and %array declarations.
-ac_cv_prog_lex_yytext_pointer=no
-ac_save_LIBS=$LIBS
-LIBS="$LEXLIB $ac_save_LIBS"
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-  #define YYTEXT_POINTER 1
-`cat $LEX_OUTPUT_ROOT.c`
-_ACEOF
-if ac_fn_c_try_link "$LINENO"; then :
-  ac_cv_prog_lex_yytext_pointer=yes
-fi
-rm -f core conftest.err conftest.$ac_objext \
-    conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_save_LIBS
-
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_lex_yytext_pointer" >&5
-$as_echo "$ac_cv_prog_lex_yytext_pointer" >&6; }
-if test $ac_cv_prog_lex_yytext_pointer = yes; then
-
-$as_echo "#define YYTEXT_POINTER 1" >>confdefs.h
-
-fi
-rm -f conftest.l $LEX_OUTPUT_ROOT.c
-
-fi
-if test "x$LEX" != xflex; then
-  LEX="$SHELL $missing_dir/missing flex"
-fi
-
-
-for ac_prog in flex
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_flex_cmd+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$flex_cmd"; then
-  ac_cv_prog_flex_cmd="$flex_cmd" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_flex_cmd="$ac_prog"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-flex_cmd=$ac_cv_prog_flex_cmd
-if test -n "$flex_cmd"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $flex_cmd" >&5
-$as_echo "$flex_cmd" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-  test -n "$flex_cmd" && break
-done
-
-if test x$flex_cmd = "x" ; then
-    { $as_echo "$as_me:${as_lineno-$LINENO}: flex is required to patch jq." >&5
-$as_echo "$as_me: flex is required to patch jq." >&6;}
-fi
-
-for ac_prog in valgrind
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_valgrind_cmd+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$valgrind_cmd"; then
-  ac_cv_prog_valgrind_cmd="$valgrind_cmd" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_valgrind_cmd="$ac_prog"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-valgrind_cmd=$ac_cv_prog_valgrind_cmd
-if test -n "$valgrind_cmd"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $valgrind_cmd" >&5
-$as_echo "$valgrind_cmd" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-  test -n "$valgrind_cmd" && break
-done
-
-if test x$valgrind_cmd = "x" ; then
-    { $as_echo "$as_me:${as_lineno-$LINENO}: valgrind is required to test jq." >&5
-$as_echo "$as_me: valgrind is required to test jq." >&6;}
-fi
-
-ac_config_headers="$ac_config_headers config.h"
-
-if test "`cd $srcdir && pwd`" != "`pwd`"; then
-  # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
-  # is not polluted with repeated "-I."
-  am__isrc=' -I$(srcdir)'
-  # test to see if srcdir already configured
-  if test -f $srcdir/config.status; then
-    as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5
-  fi
-fi
-
-# test whether we have cygpath
-if test -z "$CYGPATH_W"; then
-  if (cygpath --version) >/dev/null 2>/dev/null; then
-    CYGPATH_W='cygpath -w'
-  else
-    CYGPATH_W=echo
-  fi
-fi
-
-
-# Define the identity of the package.
- PACKAGE='jq'
- VERSION='1.2'
-
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE "$PACKAGE"
-_ACEOF
-
-
-cat >>confdefs.h <<_ACEOF
-#define VERSION "$VERSION"
-_ACEOF
-
-# Some tools Automake needs.
-
-ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}
-
-
-AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}
-
-
-AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}
-
-
-AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}
-
-
-MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
-
-# We need awk for the "check" target.  The system "awk" is bad on
-# some platforms.
-# Always define AMTAR for backward compatibility.  Yes, it's still used
-# in the wild :-(  We should find a proper way to deprecate it ...
-AMTAR='$${TAR-tar}'
-
-am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'
-
-
-
-
-depcc="$CC"   am_compiler_list=
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
-$as_echo_n "checking dependency style of $depcc... " >&6; }
-if ${am_cv_CC_dependencies_compiler_type+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
-  # We make a subdir and do the tests there.  Otherwise we can end up
-  # making bogus files that we don't know about and never remove.  For
-  # instance it was reported that on HP-UX the gcc test will end up
-  # making a dummy file named `D' -- because `-MD' means `put the output
-  # in D'.
-  rm -rf conftest.dir
-  mkdir conftest.dir
-  # Copy depcomp to subdir because otherwise we won't find it if we're
-  # using a relative directory.
-  cp "$am_depcomp" conftest.dir
-  cd conftest.dir
-  # We will build objects and dependencies in a subdirectory because
-  # it helps to detect inapplicable dependency modes.  For instance
-  # both Tru64's cc and ICC support -MD to output dependencies as a
-  # side effect of compilation, but ICC will put the dependencies in
-  # the current directory while Tru64 will put them in the object
-  # directory.
-  mkdir sub
-
-  am_cv_CC_dependencies_compiler_type=none
-  if test "$am_compiler_list" = ""; then
-     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
-  fi
-  am__universal=false
-  case " $depcc " in #(
-     *\ -arch\ *\ -arch\ *) am__universal=true ;;
-     esac
-
-  for depmode in $am_compiler_list; do
-    # Setup a source with many dependencies, because some compilers
-    # like to wrap large dependency lists on column 80 (with \), and
-    # we should not choose a depcomp mode which is confused by this.
-    #
-    # We need to recreate these files for each test, as the compiler may
-    # overwrite some of them when testing with obscure command lines.
-    # This happens at least with the AIX C compiler.
-    : > sub/conftest.c
-    for i in 1 2 3 4 5 6; do
-      echo '#include "conftst'$i'.h"' >> sub/conftest.c
-      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
-      # Solaris 8's {/usr,}/bin/sh.
-      touch sub/conftst$i.h
-    done
-    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
-
-    # We check with `-c' and `-o' for the sake of the "dashmstdout"
-    # mode.  It turns out that the SunPro C++ compiler does not properly
-    # handle `-M -o', and we need to detect this.  Also, some Intel
-    # versions had trouble with output in subdirs
-    am__obj=sub/conftest.${OBJEXT-o}
-    am__minus_obj="-o $am__obj"
-    case $depmode in
-    gcc)
-      # This depmode causes a compiler race in universal mode.
-      test "$am__universal" = false || continue
-      ;;
-    nosideeffect)
-      # after this tag, mechanisms are not by side-effect, so they'll
-      # only be used when explicitly requested
-      if test "x$enable_dependency_tracking" = xyes; then
-	continue
-      else
-	break
-      fi
-      ;;
-    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
-      # This compiler won't grok `-c -o', but also, the minuso test has
-      # not run yet.  These depmodes are late enough in the game, and
-      # so weak that their functioning should not be impacted.
-      am__obj=conftest.${OBJEXT-o}
-      am__minus_obj=
-      ;;
-    none) break ;;
-    esac
-    if depmode=$depmode \
-       source=sub/conftest.c object=$am__obj \
-       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
-       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
-         >/dev/null 2>conftest.err &&
-       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
-       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
-       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
-       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
-      # icc doesn't choke on unknown options, it will just issue warnings
-      # or remarks (even with -Werror).  So we grep stderr for any message
-      # that says an option was ignored or not supported.
-      # When given -MP, icc 7.0 and 7.1 complain thusly:
-      #   icc: Command line warning: ignoring option '-M'; no argument required
-      # The diagnosis changed in icc 8.0:
-      #   icc: Command line remark: option '-MP' not supported
-      if (grep 'ignoring option' conftest.err ||
-          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
-        am_cv_CC_dependencies_compiler_type=$depmode
-        break
-      fi
-    fi
-  done
-
-  cd ..
-  rm -rf conftest.dir
-else
-  am_cv_CC_dependencies_compiler_type=none
-fi
-
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
-$as_echo "$am_cv_CC_dependencies_compiler_type" >&6; }
-CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
-
- if
-  test "x$enable_dependency_tracking" != xno \
-  && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
-  am__fastdepCC_TRUE=
-  am__fastdepCC_FALSE='#'
-else
-  am__fastdepCC_TRUE='#'
-  am__fastdepCC_FALSE=
-fi
-
-
-
-ac_config_files="$ac_config_files Makefile"
-
-cat >confcache <<\_ACEOF
-# This file is a shell script that caches the results of configure
-# tests run on this system so they can be shared between configure
-# scripts and configure runs, see configure's option --config-cache.
-# It is not useful on other systems.  If it contains results you don't
-# want to keep, you may remove or edit it.
-#
-# config.status only pays attention to the cache file if you give it
-# the --recheck option to rerun configure.
-#
-# `ac_cv_env_foo' variables (set or unset) will be overridden when
-# loading this file, other *unset* `ac_cv_foo' will be assigned the
-# following values.
-
-_ACEOF
-
-# The following way of writing the cache mishandles newlines in values,
-# but we know of no workaround that is simple, portable, and efficient.
-# So, we kill variables containing newlines.
-# Ultrix sh set writes to stderr and can't be redirected directly,
-# and sets the high bit in the cache file unless we assign to the vars.
-(
-  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
-    eval ac_val=\$$ac_var
-    case $ac_val in #(
-    *${as_nl}*)
-      case $ac_var in #(
-      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
-$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
-      esac
-      case $ac_var in #(
-      _ | IFS | as_nl) ;; #(
-      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
-      *) { eval $ac_var=; unset $ac_var;} ;;
-      esac ;;
-    esac
-  done
-
-  (set) 2>&1 |
-    case $as_nl`(ac_space=' '; set) 2>&1` in #(
-    *${as_nl}ac_space=\ *)
-      # `set' does not quote correctly, so add quotes: double-quote
-      # substitution turns \\\\ into \\, and sed turns \\ into \.
-      sed -n \
-	"s/'/'\\\\''/g;
-	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
-      ;; #(
-    *)
-      # `set' quotes correctly as required by POSIX, so do not add quotes.
-      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
-      ;;
-    esac |
-    sort
-) |
-  sed '
-     /^ac_cv_env_/b end
-     t clear
-     :clear
-     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
-     t end
-     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
-     :end' >>confcache
-if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
-  if test -w "$cache_file"; then
-    if test "x$cache_file" != "x/dev/null"; then
-      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
-$as_echo "$as_me: updating cache $cache_file" >&6;}
-      if test ! -f "$cache_file" || test -h "$cache_file"; then
-	cat confcache >"$cache_file"
-      else
-        case $cache_file in #(
-        */* | ?:*)
-	  mv -f confcache "$cache_file"$$ &&
-	  mv -f "$cache_file"$$ "$cache_file" ;; #(
-        *)
-	  mv -f confcache "$cache_file" ;;
-	esac
-      fi
-    fi
-  else
-    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
-$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
-  fi
-fi
-rm -f confcache
-
-test "x$prefix" = xNONE && prefix=$ac_default_prefix
-# Let make expand exec_prefix.
-test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
-
-DEFS=-DHAVE_CONFIG_H
-
-ac_libobjs=
-ac_ltlibobjs=
-U=
-for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
-  # 1. Remove the extension, and $U if already installed.
-  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
-  ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
-  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
-  #    will be set to the directory where LIBOBJS objects are built.
-  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
-  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
-done
-LIBOBJS=$ac_libobjs
-
-LTLIBOBJS=$ac_ltlibobjs
-
-
- if test -n "$EXEEXT"; then
-  am__EXEEXT_TRUE=
-  am__EXEEXT_FALSE='#'
-else
-  am__EXEEXT_TRUE='#'
-  am__EXEEXT_FALSE=
-fi
-
-if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
-  as_fn_error $? "conditional \"AMDEP\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
-if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
-  as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
-if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
-  as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
- if test -n "$EXEEXT"; then
-  am__EXEEXT_TRUE=
-  am__EXEEXT_FALSE='#'
-else
-  am__EXEEXT_TRUE='#'
-  am__EXEEXT_FALSE=
-fi
-
-
-: "${CONFIG_STATUS=./config.status}"
-ac_write_fail=0
-ac_clean_files_save=$ac_clean_files
-ac_clean_files="$ac_clean_files $CONFIG_STATUS"
-{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
-$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
-as_write_fail=0
-cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
-#! $SHELL
-# Generated by $as_me.
-# Run this file to recreate the current configuration.
-# Compiler output produced by configure, useful for debugging
-# configure, is in config.log if it exists.
-
-debug=false
-ac_cs_recheck=false
-ac_cs_silent=false
-
-SHELL=\${CONFIG_SHELL-$SHELL}
-export SHELL
-_ASEOF
-cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
-## -------------------- ##
-## M4sh Initialization. ##
-## -------------------- ##
-
-# Be more Bourne compatible
-DUALCASE=1; export DUALCASE # for MKS sh
-if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
-  emulate sh
-  NULLCMD=:
-  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
-  # is contrary to our usage.  Disable this feature.
-  alias -g '${1+"$@"}'='"$@"'
-  setopt NO_GLOB_SUBST
-else
-  case `(set -o) 2>/dev/null` in #(
-  *posix*) :
-    set -o posix ;; #(
-  *) :
-     ;;
-esac
-fi
-
-
-as_nl='
-'
-export as_nl
-# Printing a long string crashes Solaris 7 /usr/bin/printf.
-as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
-# Prefer a ksh shell builtin over an external printf program on Solaris,
-# but without wasting forks for bash or zsh.
-if test -z "$BASH_VERSION$ZSH_VERSION" \
-    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
-  as_echo='print -r --'
-  as_echo_n='print -rn --'
-elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
-  as_echo='printf %s\n'
-  as_echo_n='printf %s'
-else
-  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
-    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
-    as_echo_n='/usr/ucb/echo -n'
-  else
-    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
-    as_echo_n_body='eval
-      arg=$1;
-      case $arg in #(
-      *"$as_nl"*)
-	expr "X$arg" : "X\\(.*\\)$as_nl";
-	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
-      esac;
-      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
-    '
-    export as_echo_n_body
-    as_echo_n='sh -c $as_echo_n_body as_echo'
-  fi
-  export as_echo_body
-  as_echo='sh -c $as_echo_body as_echo'
-fi
-
-# The user is always right.
-if test "${PATH_SEPARATOR+set}" != set; then
-  PATH_SEPARATOR=:
-  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
-    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
-      PATH_SEPARATOR=';'
-  }
-fi
-
-
-# IFS
-# We need space, tab and new line, in precisely that order.  Quoting is
-# there to prevent editors from complaining about space-tab.
-# (If _AS_PATH_WALK were called with IFS unset, it would disable word
-# splitting by setting IFS to empty value.)
-IFS=" ""	$as_nl"
-
-# Find who we are.  Look in the path if we contain no directory separator.
-as_myself=
-case $0 in #((
-  *[\\/]* ) as_myself=$0 ;;
-  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
-  done
-IFS=$as_save_IFS
-
-     ;;
-esac
-# We did not find ourselves, most probably we were run as `sh COMMAND'
-# in which case we are not to be found in the path.
-if test "x$as_myself" = x; then
-  as_myself=$0
-fi
-if test ! -f "$as_myself"; then
-  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
-  exit 1
-fi
-
-# Unset variables that we do not need and which cause bugs (e.g. in
-# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
-# suppresses any "Segmentation fault" message there.  '((' could
-# trigger a bug in pdksh 5.2.14.
-for as_var in BASH_ENV ENV MAIL MAILPATH
-do eval test x\${$as_var+set} = xset \
-  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
-done
-PS1='$ '
-PS2='> '
-PS4='+ '
-
-# NLS nuisances.
-LC_ALL=C
-export LC_ALL
-LANGUAGE=C
-export LANGUAGE
-
-# CDPATH.
-(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
-
-
-# as_fn_error STATUS ERROR [LINENO LOG_FD]
-# ----------------------------------------
-# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
-# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
-# script with STATUS, using 1 if that was 0.
-as_fn_error ()
-{
-  as_status=$1; test $as_status -eq 0 && as_status=1
-  if test "$4"; then
-    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
-  fi
-  $as_echo "$as_me: error: $2" >&2
-  as_fn_exit $as_status
-} # as_fn_error
-
-
-# as_fn_set_status STATUS
-# -----------------------
-# Set $? to STATUS, without forking.
-as_fn_set_status ()
-{
-  return $1
-} # as_fn_set_status
-
-# as_fn_exit STATUS
-# -----------------
-# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
-as_fn_exit ()
-{
-  set +e
-  as_fn_set_status $1
-  exit $1
-} # as_fn_exit
-
-# as_fn_unset VAR
-# ---------------
-# Portably unset VAR.
-as_fn_unset ()
-{
-  { eval $1=; unset $1;}
-}
-as_unset=as_fn_unset
-# as_fn_append VAR VALUE
-# ----------------------
-# Append the text in VALUE to the end of the definition contained in VAR. Take
-# advantage of any shell optimizations that allow amortized linear growth over
-# repeated appends, instead of the typical quadratic growth present in naive
-# implementations.
-if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
-  eval 'as_fn_append ()
-  {
-    eval $1+=\$2
-  }'
-else
-  as_fn_append ()
-  {
-    eval $1=\$$1\$2
-  }
-fi # as_fn_append
-
-# as_fn_arith ARG...
-# ------------------
-# Perform arithmetic evaluation on the ARGs, and store the result in the
-# global $as_val. Take advantage of shells that can avoid forks. The arguments
-# must be portable across $(()) and expr.
-if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
-  eval 'as_fn_arith ()
-  {
-    as_val=$(( $* ))
-  }'
-else
-  as_fn_arith ()
-  {
-    as_val=`expr "$@" || test $? -eq 1`
-  }
-fi # as_fn_arith
-
-
-if expr a : '\(a\)' >/dev/null 2>&1 &&
-   test "X`expr 00001 : '.*\(...\)'`" = X001; then
-  as_expr=expr
-else
-  as_expr=false
-fi
-
-if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
-  as_basename=basename
-else
-  as_basename=false
-fi
-
-if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
-  as_dirname=dirname
-else
-  as_dirname=false
-fi
-
-as_me=`$as_basename -- "$0" ||
-$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
-	 X"$0" : 'X\(//\)$' \| \
-	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X/"$0" |
-    sed '/^.*\/\([^/][^/]*\)\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-
-# Avoid depending upon Character Ranges.
-as_cr_letters='abcdefghijklmnopqrstuvwxyz'
-as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-as_cr_Letters=$as_cr_letters$as_cr_LETTERS
-as_cr_digits='0123456789'
-as_cr_alnum=$as_cr_Letters$as_cr_digits
-
-ECHO_C= ECHO_N= ECHO_T=
-case `echo -n x` in #(((((
--n*)
-  case `echo 'xy\c'` in
-  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
-  xy)  ECHO_C='\c';;
-  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
-       ECHO_T='	';;
-  esac;;
-*)
-  ECHO_N='-n';;
-esac
-
-rm -f conf$$ conf$$.exe conf$$.file
-if test -d conf$$.dir; then
-  rm -f conf$$.dir/conf$$.file
-else
-  rm -f conf$$.dir
-  mkdir conf$$.dir 2>/dev/null
-fi
-if (echo >conf$$.file) 2>/dev/null; then
-  if ln -s conf$$.file conf$$ 2>/dev/null; then
-    as_ln_s='ln -s'
-    # ... but there are two gotchas:
-    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
-    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
-    # In both cases, we have to default to `cp -pR'.
-    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
-      as_ln_s='cp -pR'
-  elif ln conf$$.file conf$$ 2>/dev/null; then
-    as_ln_s=ln
-  else
-    as_ln_s='cp -pR'
-  fi
-else
-  as_ln_s='cp -pR'
-fi
-rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
-rmdir conf$$.dir 2>/dev/null
-
-
-# as_fn_mkdir_p
-# -------------
-# Create "$as_dir" as a directory, including parents if necessary.
-as_fn_mkdir_p ()
-{
-
-  case $as_dir in #(
-  -*) as_dir=./$as_dir;;
-  esac
-  test -d "$as_dir" || eval $as_mkdir_p || {
-    as_dirs=
-    while :; do
-      case $as_dir in #(
-      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
-      *) as_qdir=$as_dir;;
-      esac
-      as_dirs="'$as_qdir' $as_dirs"
-      as_dir=`$as_dirname -- "$as_dir" ||
-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$as_dir" : 'X\(//\)[^/]' \| \
-	 X"$as_dir" : 'X\(//\)$' \| \
-	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X"$as_dir" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-      test -d "$as_dir" && break
-    done
-    test -z "$as_dirs" || eval "mkdir $as_dirs"
-  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
-
-
-} # as_fn_mkdir_p
-if mkdir -p . 2>/dev/null; then
-  as_mkdir_p='mkdir -p "$as_dir"'
-else
-  test -d ./-p && rmdir ./-p
-  as_mkdir_p=false
-fi
-
-
-# as_fn_executable_p FILE
-# -----------------------
-# Test if FILE is an executable regular file.
-as_fn_executable_p ()
-{
-  test -f "$1" && test -x "$1"
-} # as_fn_executable_p
-as_test_x='test -x'
-as_executable_p=as_fn_executable_p
-
-# Sed expression to map a string onto a valid CPP name.
-as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
-
-# Sed expression to map a string onto a valid variable name.
-as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
-
-
-exec 6>&1
-## ----------------------------------- ##
-## Main body of $CONFIG_STATUS script. ##
-## ----------------------------------- ##
-_ASEOF
-test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-# Save the log message, to keep $0 and so on meaningful, and to
-# report actual input values of CONFIG_FILES etc. instead of their
-# values after options handling.
-ac_log="
-This file was extended by jq $as_me 1.2, which was
-generated by GNU Autoconf 2.69.  Invocation command line was
-
-  CONFIG_FILES    = $CONFIG_FILES
-  CONFIG_HEADERS  = $CONFIG_HEADERS
-  CONFIG_LINKS    = $CONFIG_LINKS
-  CONFIG_COMMANDS = $CONFIG_COMMANDS
-  $ $0 $@
-
-on `(hostname || uname -n) 2>/dev/null | sed 1q`
-"
-
-_ACEOF
-
-case $ac_config_files in *"
-"*) set x $ac_config_files; shift; ac_config_files=$*;;
-esac
-
-case $ac_config_headers in *"
-"*) set x $ac_config_headers; shift; ac_config_headers=$*;;
-esac
-
-
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-# Files that config.status was made for.
-config_files="$ac_config_files"
-config_headers="$ac_config_headers"
-config_commands="$ac_config_commands"
-
-_ACEOF
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-ac_cs_usage="\
-\`$as_me' instantiates files and other configuration actions
-from templates according to the current configuration.  Unless the files
-and actions are specified as TAGs, all are instantiated by default.
-
-Usage: $0 [OPTION]... [TAG]...
-
-  -h, --help       print this help, then exit
-  -V, --version    print version number and configuration settings, then exit
-      --config     print configuration, then exit
-  -q, --quiet, --silent
-                   do not print progress messages
-  -d, --debug      don't remove temporary files
-      --recheck    update $as_me by reconfiguring in the same conditions
-      --file=FILE[:TEMPLATE]
-                   instantiate the configuration file FILE
-      --header=FILE[:TEMPLATE]
-                   instantiate the configuration header FILE
-
-Configuration files:
-$config_files
-
-Configuration headers:
-$config_headers
-
-Configuration commands:
-$config_commands
-
-Report bugs to <mu@netsoc.tcd.ie>.
-jq home page: <http://stedolan.github.com/jq/>."
-
-_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
-ac_cs_version="\\
-jq config.status 1.2
-configured by $0, generated by GNU Autoconf 2.69,
-  with options \\"\$ac_cs_config\\"
-
-Copyright (C) 2012 Free Software Foundation, Inc.
-This config.status script is free software; the Free Software Foundation
-gives unlimited permission to copy, distribute and modify it."
-
-ac_pwd='$ac_pwd'
-srcdir='$srcdir'
-INSTALL='$INSTALL'
-MKDIR_P='$MKDIR_P'
-AWK='$AWK'
-test -n "\$AWK" || AWK=awk
-_ACEOF
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-# The default lists apply if the user does not specify any file.
-ac_need_defaults=:
-while test $# != 0
-do
-  case $1 in
-  --*=?*)
-    ac_option=`expr "X$1" : 'X\([^=]*\)='`
-    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
-    ac_shift=:
-    ;;
-  --*=)
-    ac_option=`expr "X$1" : 'X\([^=]*\)='`
-    ac_optarg=
-    ac_shift=:
-    ;;
-  *)
-    ac_option=$1
-    ac_optarg=$2
-    ac_shift=shift
-    ;;
-  esac
-
-  case $ac_option in
-  # Handling of the options.
-  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
-    ac_cs_recheck=: ;;
-  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
-    $as_echo "$ac_cs_version"; exit ;;
-  --config | --confi | --conf | --con | --co | --c )
-    $as_echo "$ac_cs_config"; exit ;;
-  --debug | --debu | --deb | --de | --d | -d )
-    debug=: ;;
-  --file | --fil | --fi | --f )
-    $ac_shift
-    case $ac_optarg in
-    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
-    '') as_fn_error $? "missing file argument" ;;
-    esac
-    as_fn_append CONFIG_FILES " '$ac_optarg'"
-    ac_need_defaults=false;;
-  --header | --heade | --head | --hea )
-    $ac_shift
-    case $ac_optarg in
-    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
-    esac
-    as_fn_append CONFIG_HEADERS " '$ac_optarg'"
-    ac_need_defaults=false;;
-  --he | --h)
-    # Conflict between --help and --header
-    as_fn_error $? "ambiguous option: \`$1'
-Try \`$0 --help' for more information.";;
-  --help | --hel | -h )
-    $as_echo "$ac_cs_usage"; exit ;;
-  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
-  | -silent | --silent | --silen | --sile | --sil | --si | --s)
-    ac_cs_silent=: ;;
-
-  # This is an error.
-  -*) as_fn_error $? "unrecognized option: \`$1'
-Try \`$0 --help' for more information." ;;
-
-  *) as_fn_append ac_config_targets " $1"
-     ac_need_defaults=false ;;
-
-  esac
-  shift
-done
-
-ac_configure_extra_args=
-
-if $ac_cs_silent; then
-  exec 6>/dev/null
-  ac_configure_extra_args="$ac_configure_extra_args --silent"
-fi
-
-_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-if \$ac_cs_recheck; then
-  set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
-  shift
-  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
-  CONFIG_SHELL='$SHELL'
-  export CONFIG_SHELL
-  exec "\$@"
-fi
-
-_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-exec 5>>config.log
-{
-  echo
-  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
-## Running $as_me. ##
-_ASBOX
-  $as_echo "$ac_log"
-} >&5
-
-_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-#
-# INIT-COMMANDS
-#
-AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
-
-_ACEOF
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-
-# Handling of arguments.
-for ac_config_target in $ac_config_targets
-do
-  case $ac_config_target in
-    "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
-    "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
-    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
-
-  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
-  esac
-done
-
-
-# If the user did not use the arguments to specify the items to instantiate,
-# then the envvar interface is used.  Set only those that are not.
-# We use the long form for the default assignment because of an extremely
-# bizarre bug on SunOS 4.1.3.
-if $ac_need_defaults; then
-  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
-  test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
-  test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
-fi
-
-# Have a temporary directory for convenience.  Make it in the build tree
-# simply because there is no reason against having it here, and in addition,
-# creating and moving files from /tmp can sometimes cause problems.
-# Hook for its removal unless debugging.
-# Note that there is a small window in which the directory will not be cleaned:
-# after its creation but before its name has been assigned to `$tmp'.
-$debug ||
-{
-  tmp= ac_tmp=
-  trap 'exit_status=$?
-  : "${ac_tmp:=$tmp}"
-  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
-' 0
-  trap 'as_fn_exit 1' 1 2 13 15
-}
-# Create a (secure) tmp directory for tmp files.
-
-{
-  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
-  test -d "$tmp"
-}  ||
-{
-  tmp=./conf$$-$RANDOM
-  (umask 077 && mkdir "$tmp")
-} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
-ac_tmp=$tmp
-
-# Set up the scripts for CONFIG_FILES section.
-# No need to generate them if there are no CONFIG_FILES.
-# This happens for instance with `./config.status config.h'.
-if test -n "$CONFIG_FILES"; then
-
-
-ac_cr=`echo X | tr X '\015'`
-# On cygwin, bash can eat \r inside `` if the user requested igncr.
-# But we know of no other shell where ac_cr would be empty at this
-# point, so we can use a bashism as a fallback.
-if test "x$ac_cr" = x; then
-  eval ac_cr=\$\'\\r\'
-fi
-ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
-if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
-  ac_cs_awk_cr='\\r'
-else
-  ac_cs_awk_cr=$ac_cr
-fi
-
-echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
-_ACEOF
-
-
-{
-  echo "cat >conf$$subs.awk <<_ACEOF" &&
-  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
-  echo "_ACEOF"
-} >conf$$subs.sh ||
-  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
-ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
-ac_delim='%!_!# '
-for ac_last_try in false false false false false :; do
-  . ./conf$$subs.sh ||
-    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
-
-  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
-  if test $ac_delim_n = $ac_delim_num; then
-    break
-  elif $ac_last_try; then
-    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
-  else
-    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
-  fi
-done
-rm -f conf$$subs.sh
-
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
-_ACEOF
-sed -n '
-h
-s/^/S["/; s/!.*/"]=/
-p
-g
-s/^[^!]*!//
-:repl
-t repl
-s/'"$ac_delim"'$//
-t delim
-:nl
-h
-s/\(.\{148\}\)..*/\1/
-t more1
-s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
-p
-n
-b repl
-:more1
-s/["\\]/\\&/g; s/^/"/; s/$/"\\/
-p
-g
-s/.\{148\}//
-t nl
-:delim
-h
-s/\(.\{148\}\)..*/\1/
-t more2
-s/["\\]/\\&/g; s/^/"/; s/$/"/
-p
-b
-:more2
-s/["\\]/\\&/g; s/^/"/; s/$/"\\/
-p
-g
-s/.\{148\}//
-t delim
-' <conf$$subs.awk | sed '
-/^[^""]/{
-  N
-  s/\n//
-}
-' >>$CONFIG_STATUS || ac_write_fail=1
-rm -f conf$$subs.awk
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-_ACAWK
-cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
-  for (key in S) S_is_set[key] = 1
-  FS = ""
-
-}
-{
-  line = $ 0
-  nfields = split(line, field, "@")
-  substed = 0
-  len = length(field[1])
-  for (i = 2; i < nfields; i++) {
-    key = field[i]
-    keylen = length(key)
-    if (S_is_set[key]) {
-      value = S[key]
-      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
-      len += length(value) + length(field[++i])
-      substed = 1
-    } else
-      len += 1 + keylen
-  }
-
-  print line
-}
-
-_ACAWK
-_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
-  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
-else
-  cat
-fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
-  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
-_ACEOF
-
-# VPATH may cause trouble with some makes, so we remove sole $(srcdir),
-# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
-# trailing colons and then remove the whole line if VPATH becomes empty
-# (actually we leave an empty line to preserve line numbers).
-if test "x$srcdir" = x.; then
-  ac_vpsub='/^[	 ]*VPATH[	 ]*=[	 ]*/{
-h
-s///
-s/^/:/
-s/[	 ]*$/:/
-s/:\$(srcdir):/:/g
-s/:\${srcdir}:/:/g
-s/:@srcdir@:/:/g
-s/^:*//
-s/:*$//
-x
-s/\(=[	 ]*\).*/\1/
-G
-s/\n//
-s/^[^=]*=[	 ]*$//
-}'
-fi
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-fi # test -n "$CONFIG_FILES"
-
-# Set up the scripts for CONFIG_HEADERS section.
-# No need to generate them if there are no CONFIG_HEADERS.
-# This happens for instance with `./config.status Makefile'.
-if test -n "$CONFIG_HEADERS"; then
-cat >"$ac_tmp/defines.awk" <<\_ACAWK ||
-BEGIN {
-_ACEOF
-
-# Transform confdefs.h into an awk script `defines.awk', embedded as
-# here-document in config.status, that substitutes the proper values into
-# config.h.in to produce config.h.
-
-# Create a delimiter string that does not exist in confdefs.h, to ease
-# handling of long lines.
-ac_delim='%!_!# '
-for ac_last_try in false false :; do
-  ac_tt=`sed -n "/$ac_delim/p" confdefs.h`
-  if test -z "$ac_tt"; then
-    break
-  elif $ac_last_try; then
-    as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5
-  else
-    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
-  fi
-done
-
-# For the awk script, D is an array of macro values keyed by name,
-# likewise P contains macro parameters if any.  Preserve backslash
-# newline sequences.
-
-ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
-sed -n '
-s/.\{148\}/&'"$ac_delim"'/g
-t rset
-:rset
-s/^[	 ]*#[	 ]*define[	 ][	 ]*/ /
-t def
-d
-:def
-s/\\$//
-t bsnl
-s/["\\]/\\&/g
-s/^ \('"$ac_word_re"'\)\(([^()]*)\)[	 ]*\(.*\)/P["\1"]="\2"\
-D["\1"]=" \3"/p
-s/^ \('"$ac_word_re"'\)[	 ]*\(.*\)/D["\1"]=" \2"/p
-d
-:bsnl
-s/["\\]/\\&/g
-s/^ \('"$ac_word_re"'\)\(([^()]*)\)[	 ]*\(.*\)/P["\1"]="\2"\
-D["\1"]=" \3\\\\\\n"\\/p
-t cont
-s/^ \('"$ac_word_re"'\)[	 ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p
-t cont
-d
-:cont
-n
-s/.\{148\}/&'"$ac_delim"'/g
-t clear
-:clear
-s/\\$//
-t bsnlc
-s/["\\]/\\&/g; s/^/"/; s/$/"/p
-d
-:bsnlc
-s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p
-b cont
-' <confdefs.h | sed '
-s/'"$ac_delim"'/"\\\
-"/g' >>$CONFIG_STATUS || ac_write_fail=1
-
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-  for (key in D) D_is_set[key] = 1
-  FS = ""
-}
-/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ {
-  line = \$ 0
-  split(line, arg, " ")
-  if (arg[1] == "#") {
-    defundef = arg[2]
-    mac1 = arg[3]
-  } else {
-    defundef = substr(arg[1], 2)
-    mac1 = arg[2]
-  }
-  split(mac1, mac2, "(") #)
-  macro = mac2[1]
-  prefix = substr(line, 1, index(line, defundef) - 1)
-  if (D_is_set[macro]) {
-    # Preserve the white space surrounding the "#".
-    print prefix "define", macro P[macro] D[macro]
-    next
-  } else {
-    # Replace #undef with comments.  This is necessary, for example,
-    # in the case of _POSIX_SOURCE, which is predefined and required
-    # on some systems where configure will not decide to define it.
-    if (defundef == "undef") {
-      print "/*", prefix defundef, macro, "*/"
-      next
-    }
-  }
-}
-{ print }
-_ACAWK
-_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-  as_fn_error $? "could not setup config headers machinery" "$LINENO" 5
-fi # test -n "$CONFIG_HEADERS"
-
-
-eval set X "  :F $CONFIG_FILES  :H $CONFIG_HEADERS    :C $CONFIG_COMMANDS"
-shift
-for ac_tag
-do
-  case $ac_tag in
-  :[FHLC]) ac_mode=$ac_tag; continue;;
-  esac
-  case $ac_mode$ac_tag in
-  :[FHL]*:*);;
-  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
-  :[FH]-) ac_tag=-:-;;
-  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
-  esac
-  ac_save_IFS=$IFS
-  IFS=:
-  set x $ac_tag
-  IFS=$ac_save_IFS
-  shift
-  ac_file=$1
-  shift
-
-  case $ac_mode in
-  :L) ac_source=$1;;
-  :[FH])
-    ac_file_inputs=
-    for ac_f
-    do
-      case $ac_f in
-      -) ac_f="$ac_tmp/stdin";;
-      *) # Look for the file first in the build tree, then in the source tree
-	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
-	 # because $ac_f cannot contain `:'.
-	 test -f "$ac_f" ||
-	   case $ac_f in
-	   [\\/$]*) false;;
-	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
-	   esac ||
-	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
-      esac
-      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
-      as_fn_append ac_file_inputs " '$ac_f'"
-    done
-
-    # Let's still pretend it is `configure' which instantiates (i.e., don't
-    # use $as_me), people would be surprised to read:
-    #    /* config.h.  Generated by config.status.  */
-    configure_input='Generated from '`
-	  $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
-	`' by configure.'
-    if test x"$ac_file" != x-; then
-      configure_input="$ac_file.  $configure_input"
-      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
-$as_echo "$as_me: creating $ac_file" >&6;}
-    fi
-    # Neutralize special characters interpreted by sed in replacement strings.
-    case $configure_input in #(
-    *\&* | *\|* | *\\* )
-       ac_sed_conf_input=`$as_echo "$configure_input" |
-       sed 's/[\\\\&|]/\\\\&/g'`;; #(
-    *) ac_sed_conf_input=$configure_input;;
-    esac
-
-    case $ac_tag in
-    *:-:* | *:-) cat >"$ac_tmp/stdin" \
-      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
-    esac
-    ;;
-  esac
-
-  ac_dir=`$as_dirname -- "$ac_file" ||
-$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$ac_file" : 'X\(//\)[^/]' \| \
-	 X"$ac_file" : 'X\(//\)$' \| \
-	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X"$ac_file" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-  as_dir="$ac_dir"; as_fn_mkdir_p
-  ac_builddir=.
-
-case "$ac_dir" in
-.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
-*)
-  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
-  # A ".." for each directory in $ac_dir_suffix.
-  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
-  case $ac_top_builddir_sub in
-  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
-  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
-  esac ;;
-esac
-ac_abs_top_builddir=$ac_pwd
-ac_abs_builddir=$ac_pwd$ac_dir_suffix
-# for backward compatibility:
-ac_top_builddir=$ac_top_build_prefix
-
-case $srcdir in
-  .)  # We are building in place.
-    ac_srcdir=.
-    ac_top_srcdir=$ac_top_builddir_sub
-    ac_abs_top_srcdir=$ac_pwd ;;
-  [\\/]* | ?:[\\/]* )  # Absolute name.
-    ac_srcdir=$srcdir$ac_dir_suffix;
-    ac_top_srcdir=$srcdir
-    ac_abs_top_srcdir=$srcdir ;;
-  *) # Relative name.
-    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
-    ac_top_srcdir=$ac_top_build_prefix$srcdir
-    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
-esac
-ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
-
-
-  case $ac_mode in
-  :F)
-  #
-  # CONFIG_FILE
-  #
-
-  case $INSTALL in
-  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
-  *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
-  esac
-  ac_MKDIR_P=$MKDIR_P
-  case $MKDIR_P in
-  [\\/$]* | ?:[\\/]* ) ;;
-  */*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;;
-  esac
-_ACEOF
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-# If the template does not know about datarootdir, expand it.
-# FIXME: This hack should be removed a few years after 2.60.
-ac_datarootdir_hack=; ac_datarootdir_seen=
-ac_sed_dataroot='
-/datarootdir/ {
-  p
-  q
-}
-/@datadir@/p
-/@docdir@/p
-/@infodir@/p
-/@localedir@/p
-/@mandir@/p'
-case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
-*datarootdir*) ac_datarootdir_seen=yes;;
-*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
-  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
-$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
-_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-  ac_datarootdir_hack='
-  s&@datadir@&$datadir&g
-  s&@docdir@&$docdir&g
-  s&@infodir@&$infodir&g
-  s&@localedir@&$localedir&g
-  s&@mandir@&$mandir&g
-  s&\\\${datarootdir}&$datarootdir&g' ;;
-esac
-_ACEOF
-
-# Neutralize VPATH when `$srcdir' = `.'.
-# Shell code in configure.ac might set extrasub.
-# FIXME: do we really want to maintain this feature?
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-ac_sed_extra="$ac_vpsub
-$extrasub
-_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-:t
-/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
-s|@configure_input@|$ac_sed_conf_input|;t t
-s&@top_builddir@&$ac_top_builddir_sub&;t t
-s&@top_build_prefix@&$ac_top_build_prefix&;t t
-s&@srcdir@&$ac_srcdir&;t t
-s&@abs_srcdir@&$ac_abs_srcdir&;t t
-s&@top_srcdir@&$ac_top_srcdir&;t t
-s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
-s&@builddir@&$ac_builddir&;t t
-s&@abs_builddir@&$ac_abs_builddir&;t t
-s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
-s&@INSTALL@&$ac_INSTALL&;t t
-s&@MKDIR_P@&$ac_MKDIR_P&;t t
-$ac_datarootdir_hack
-"
-eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
-  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
-
-test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
-  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
-  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \
-      "$ac_tmp/out"`; test -z "$ac_out"; } &&
-  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
-which seems to be undefined.  Please make sure it is defined" >&5
-$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
-which seems to be undefined.  Please make sure it is defined" >&2;}
-
-  rm -f "$ac_tmp/stdin"
-  case $ac_file in
-  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
-  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
-  esac \
-  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
- ;;
-  :H)
-  #
-  # CONFIG_HEADER
-  #
-  if test x"$ac_file" != x-; then
-    {
-      $as_echo "/* $configure_input  */" \
-      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs"
-    } >"$ac_tmp/config.h" \
-      || as_fn_error $? "could not create $ac_file" "$LINENO" 5
-    if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then
-      { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
-$as_echo "$as_me: $ac_file is unchanged" >&6;}
-    else
-      rm -f "$ac_file"
-      mv "$ac_tmp/config.h" "$ac_file" \
-	|| as_fn_error $? "could not create $ac_file" "$LINENO" 5
-    fi
-  else
-    $as_echo "/* $configure_input  */" \
-      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \
-      || as_fn_error $? "could not create -" "$LINENO" 5
-  fi
-# Compute "$ac_file"'s index in $config_headers.
-_am_arg="$ac_file"
-_am_stamp_count=1
-for _am_header in $config_headers :; do
-  case $_am_header in
-    $_am_arg | $_am_arg:* )
-      break ;;
-    * )
-      _am_stamp_count=`expr $_am_stamp_count + 1` ;;
-  esac
-done
-echo "timestamp for $_am_arg" >`$as_dirname -- "$_am_arg" ||
-$as_expr X"$_am_arg" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$_am_arg" : 'X\(//\)[^/]' \| \
-	 X"$_am_arg" : 'X\(//\)$' \| \
-	 X"$_am_arg" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X"$_am_arg" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`/stamp-h$_am_stamp_count
- ;;
-
-  :C)  { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5
-$as_echo "$as_me: executing $ac_file commands" >&6;}
- ;;
-  esac
-
-
-  case $ac_file$ac_mode in
-    "depfiles":C) test x"$AMDEP_TRUE" != x"" || {
-  # Autoconf 2.62 quotes --file arguments for eval, but not when files
-  # are listed without --file.  Let's play safe and only enable the eval
-  # if we detect the quoting.
-  case $CONFIG_FILES in
-  *\'*) eval set x "$CONFIG_FILES" ;;
-  *)   set x $CONFIG_FILES ;;
-  esac
-  shift
-  for mf
-  do
-    # Strip MF so we end up with the name of the file.
-    mf=`echo "$mf" | sed -e 's/:.*$//'`
-    # Check whether this is an Automake generated Makefile or not.
-    # We used to match only the files named `Makefile.in', but
-    # some people rename them; so instead we look at the file content.
-    # Grep'ing the first line is not enough: some people post-process
-    # each Makefile.in and add a new line on top of each file to say so.
-    # Grep'ing the whole file is not good either: AIX grep has a line
-    # limit of 2048, but all sed's we know have understand at least 4000.
-    if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
-      dirpart=`$as_dirname -- "$mf" ||
-$as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$mf" : 'X\(//\)[^/]' \| \
-	 X"$mf" : 'X\(//\)$' \| \
-	 X"$mf" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X"$mf" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-    else
-      continue
-    fi
-    # Extract the definition of DEPDIR, am__include, and am__quote
-    # from the Makefile without running `make'.
-    DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
-    test -z "$DEPDIR" && continue
-    am__include=`sed -n 's/^am__include = //p' < "$mf"`
-    test -z "am__include" && continue
-    am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
-    # When using ansi2knr, U may be empty or an underscore; expand it
-    U=`sed -n 's/^U = //p' < "$mf"`
-    # Find all dependency output files, they are included files with
-    # $(DEPDIR) in their names.  We invoke sed twice because it is the
-    # simplest approach to changing $(DEPDIR) to its actual value in the
-    # expansion.
-    for file in `sed -n "
-      s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
-	 sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
-      # Make sure the directory exists.
-      test -f "$dirpart/$file" && continue
-      fdir=`$as_dirname -- "$file" ||
-$as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$file" : 'X\(//\)[^/]' \| \
-	 X"$file" : 'X\(//\)$' \| \
-	 X"$file" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X"$file" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-      as_dir=$dirpart/$fdir; as_fn_mkdir_p
-      # echo "creating $dirpart/$file"
-      echo '# dummy' > "$dirpart/$file"
-    done
-  done
-}
- ;;
-
-  esac
-done # for ac_tag
-
-
-as_fn_exit 0
-_ACEOF
-ac_clean_files=$ac_clean_files_save
-
-test $ac_write_fail = 0 ||
-  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
-
-
-# configure is writing to config.log, and then calls config.status.
-# config.status does its own redirection, appending to config.log.
-# Unfortunately, on DOS this fails, as config.log is still kept open
-# by configure, so config.status won't be able to write to it; its
-# output is simply discarded.  So we exec the FD to /dev/null,
-# effectively closing config.log, so it can be properly (re)opened and
-# appended to by config.status.  When coming back to configure, we
-# need to make the FD available again.
-if test "$no_create" != yes; then
-  ac_cs_success=:
-  ac_config_status_args=
-  test "$silent" = yes &&
-    ac_config_status_args="$ac_config_status_args --quiet"
-  exec 5>/dev/null
-  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
-  exec 5>>config.log
-  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
-  # would make configure fail if this is the last instruction.
-  $ac_cs_success || as_fn_exit 1
-fi
-if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
-$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
-fi
-
-
-

From e29db8d272eff570071d84d735fcbfc9f6fbcdd8 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sat, 11 May 2013 18:10:21 +0100
Subject: [PATCH 263/284] Fix bug with path handling (used in assignments).

Closes #67
---
 execute.c      | 5 +++--
 tests/all.test | 8 ++++++++
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/execute.c b/execute.c
index 7deeb0ae..e424ed8c 100644
--- a/execute.c
+++ b/execute.c
@@ -180,7 +180,8 @@ jv jq_next(jq_state *jq) {
         }
         if (!param) break;
         jv_dump(jv_copy(param->sv.value), 0);
-        printf("<%d>", jv_get_refcnt(param->sv.value));
+        //printf("<%d>", jv_get_refcnt(param->sv.value));
+        printf("<%d>", param->sv.pathidx);
       }
 
       if (backtracking) printf("\t<backtracking>");
@@ -298,7 +299,7 @@ jv jq_next(jq_state *jq) {
       jv_free(path_end.value);
       jv path = jv_array();
       for (int i=path_start.pathidx; i<path_end.pathidx; i++) {
-        path = jv_array_set(path, i, jv_copy(jq->pathbuf[i]));
+        path = jv_array_append(path, jv_copy(jq->pathbuf[i]));
       }
       stack_push(jq, stackval_replace(path_start, path));
       break;
diff --git a/tests/all.test b/tests/all.test
index 83f91dae..97af7e55 100644
--- a/tests/all.test
+++ b/tests/all.test
@@ -574,3 +574,11 @@ unique
 .foo[.baz]
 {"foo":{"bar":4},"baz":"bar"}
 4
+
+.[] | .error = "no, it's OK"
+[{"error":true}]
+{"error": "no, it's OK"}
+
+[{a:1}] | .[] | .a=999
+null
+{"a": 999}

From b0e65d149f76c081d5840b4156b9a13516429732 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 13 May 2013 14:10:39 +0100
Subject: [PATCH 264/284] Fix a bug triggered by jv_array_slice.

---
 jq_test.c | 12 ++++++++++++
 jv.c      |  2 +-
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/jq_test.c b/jq_test.c
index 19dccc22..c71fdc66 100644
--- a/jq_test.c
+++ b/jq_test.c
@@ -164,6 +164,18 @@ static void jv_test() {
     jv_free(a3);
 
 
+    jv a4 = jv_array();
+    a4 = jv_array_append(a4, jv_number(1));
+    a4 = jv_array_append(a4, jv_number(2));
+    jv a5 = jv_copy(a4);
+    a4 = jv_array_append(a4, jv_number(3));
+    a4 = jv_array_slice(a4, 0, 1);
+    assert(jv_array_length(jv_copy(a4)) == 1);
+    a4 = jv_array_append(a4, jv_number(4));
+    assert(jv_array_length(a4) == 2);
+    assert(jv_array_length(a5) == 2);
+
+
     assert(jv_array_length(jv_copy(a)) == 2);
     assert(jv_number_value(jv_array_get(jv_copy(a), 0)) == 42);
     assert(jv_array_length(jv_array_get(jv_copy(a), 1)) == 1);
diff --git a/jv.c b/jv.c
index 4ed623f0..b03c024c 100644
--- a/jv.c
+++ b/jv.c
@@ -214,7 +214,7 @@ static jv* jvp_array_write(jv_nontrivial* a, int i) {
         array->elements[j] = JV_NULL;
       }
       array->length = imax(pos + 1, array->length);
-      a->i[1] = imax(pos + 1, array->length);
+      a->i[1] = imax(pos + 1, a->i[1]);
       return &array->elements[pos];
     }
   }

From 8c708f3c7aece2429adb626c9031b3e2de5051c3 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 13 May 2013 15:00:05 +0100
Subject: [PATCH 265/284] Refactor path logic.

---
 builtin.c     |   4 +-
 compile.c     |   2 +-
 execute.c     | 291 +++++++++++++++++++++++++++-----------------------
 jv_print.c    |   1 +
 opcode_list.h |   7 +-
 5 files changed, 164 insertions(+), 141 deletions(-)

diff --git a/builtin.c b/builtin.c
index 4fb14dc7..1516c6c6 100644
--- a/builtin.c
+++ b/builtin.c
@@ -520,9 +520,9 @@ static block bind_bytecoded_builtins(block b) {
   }
   {
     struct bytecoded_builtin builtin_def_1arg[] = {
-      {"path", BLOCK(gen_op_simple(DUP), 
+      {"path", BLOCK(gen_op_simple(PATH_BEGIN), 
                      gen_call("arg", gen_noop()),
-                     gen_op_simple(GETPATH))},
+                     gen_op_simple(PATH_END))},
     };
     for (unsigned i=0; i<sizeof(builtin_def_1arg)/sizeof(builtin_def_1arg[0]); i++) {
       builtins = BLOCK(builtins, gen_function(builtin_def_1arg[i].name,
diff --git a/compile.c b/compile.c
index 77dfd904..de9c14c3 100644
--- a/compile.c
+++ b/compile.c
@@ -275,7 +275,7 @@ block gen_call(const char* name, block args) {
 
 
 block gen_subexp(block a) {
-  return BLOCK(gen_op_simple(DUP), a, gen_op_simple(SWAP));
+  return BLOCK(gen_op_simple(SUBEXP_BEGIN), a, gen_op_simple(SUBEXP_END));
 }
 
 block gen_both(block a, block b) {
diff --git a/execute.c b/execute.c
index e424ed8c..77b8574d 100644
--- a/execute.c
+++ b/execute.c
@@ -19,78 +19,43 @@
 #include "parser.h"
 #include "builtin.h"
 
-typedef struct {
-  jv value;
-  int pathidx;
-} stackval;
-
 struct jq_state {
   struct forkable_stack data_stk;
   struct forkable_stack frame_stk;
   struct forkable_stack fork_stk;
-  jv* pathbuf;
-  int pathsize; // number of allocated elements
+  jv path;
+  int subexp_nest;
   int debug_trace_enabled;
 };
 
-int path_push(jq_state *jq, stackval sv, jv val) {
-  int pos = sv.pathidx;
-  assert(pos <= jq->pathsize);
-  assert(pos >= 0);
-  if (pos == jq->pathsize) {
-    int oldpathsize = jq->pathsize;
-    jq->pathsize = oldpathsize ? oldpathsize * 2 : 100;
-    jq->pathbuf = jv_mem_realloc(jq->pathbuf, sizeof(jq->pathbuf[0]) * jq->pathsize);
-    for (int i=oldpathsize; i<jq->pathsize; i++) {
-      jq->pathbuf[i] = jv_invalid();
-    }
-  }
-  jv_free(jq->pathbuf[pos]);
-  jq->pathbuf[pos] = val;
-  return pos + 1;
-}
-
-stackval stackval_replace(stackval value, jv newjs) {
-  jv_free(value.value);
-  stackval s = {newjs, value.pathidx};
-  return s;
-}
-
-
-// Probably all uses of this function are bugs
-stackval stackval_root(jv v) {
-  stackval s = {v, 0};
-  return s;
-}
-
 typedef struct {
   FORKABLE_STACK_HEADER;
-  stackval sv;
+  jv val;
 } data_stk_elem;
 
-void stack_push(jq_state *jq, stackval val) {
-  assert(jv_is_valid(val.value));
+void stack_push(jq_state *jq, jv val) {
+  assert(jv_is_valid(val));
   data_stk_elem* s = forkable_stack_push(&jq->data_stk, sizeof(data_stk_elem));
-  s->sv = val;
+  s->val = val;
 }
 
-stackval stack_pop(jq_state *jq) {
+jv stack_pop(jq_state *jq) {
   data_stk_elem* s = forkable_stack_peek(&jq->data_stk);
-  stackval sv = s->sv;
+  jv val = s->val;
   if (!forkable_stack_pop_will_free(&jq->data_stk)) {
-    sv.value = jv_copy(sv.value);
+    val = jv_copy(val);
   }
   forkable_stack_pop(&jq->data_stk);
-  assert(jv_is_valid(sv.value));
-  return sv;
+  assert(jv_is_valid(val));
+  return val;
 }
 
 
-
 struct forkpoint {
   FORKABLE_STACK_HEADER;
   struct forkable_stack_state saved_data_stack;
   struct forkable_stack_state saved_call_stack;
+  int path_len, subexp_nest;
 };
 
 
@@ -98,6 +63,9 @@ void stack_save(jq_state *jq){
   struct forkpoint* fork = forkable_stack_push(&jq->fork_stk, sizeof(struct forkpoint));
   forkable_stack_save(&jq->data_stk, &fork->saved_data_stack);
   forkable_stack_save(&jq->frame_stk, &fork->saved_call_stack);
+  fork->path_len = 
+    jv_get_kind(jq->path) == JV_KIND_ARRAY ? jv_array_length(jv_copy(jq->path)) : 0;
+  fork->subexp_nest = jq->subexp_nest;
 }
 
 void stack_switch(jq_state *jq) {
@@ -106,26 +74,47 @@ void stack_switch(jq_state *jq) {
   forkable_stack_switch(&jq->frame_stk, &fork->saved_call_stack);
 }
 
+void path_append(jq_state* jq, jv component) {
+  if (jq->subexp_nest == 0 && jv_get_kind(jq->path) == JV_KIND_ARRAY) {
+    int n1 = jv_array_length(jv_copy(jq->path));
+    jq->path = jv_array_append(jq->path, component);
+    int n2 = jv_array_length(jv_copy(jq->path));
+    assert(n2 == n1 + 1);
+  } else {
+    jv_free(component);
+  }
+}
+
 int stack_restore(jq_state *jq){
   while (!forkable_stack_empty(&jq->data_stk) && 
          forkable_stack_pop_will_free(&jq->data_stk)) {
-    jv_free(stack_pop(jq).value);
+    jv_free(stack_pop(jq));
   }
   while (!forkable_stack_empty(&jq->frame_stk) && 
          forkable_stack_pop_will_free(&jq->frame_stk)) {
     frame_pop(&jq->frame_stk);
   }
+
   if (forkable_stack_empty(&jq->fork_stk)) {
     return 0;
-  } else {
-    struct forkpoint* fork = forkable_stack_peek(&jq->fork_stk);
-    forkable_stack_restore(&jq->data_stk, &fork->saved_data_stack);
-    forkable_stack_restore(&jq->frame_stk, &fork->saved_call_stack);
-    forkable_stack_pop(&jq->fork_stk);
-    return 1;
   }
+
+  struct forkpoint* fork = forkable_stack_peek(&jq->fork_stk);
+  forkable_stack_restore(&jq->data_stk, &fork->saved_data_stack);
+  forkable_stack_restore(&jq->frame_stk, &fork->saved_call_stack);
+  int path_len = fork->path_len;
+  if (jv_get_kind(jq->path) == JV_KIND_ARRAY) {
+    assert(path_len >= 0);
+    jq->path = jv_array_slice(jq->path, 0, path_len);
+  } else {
+    assert(path_len == 0);
+  }
+  jq->subexp_nest = fork->subexp_nest;
+  forkable_stack_pop(&jq->fork_stk);
+  return 1;
 }
 
+
 static struct closure make_closure(struct forkable_stack* stk, frame_ptr fr, uint16_t* pc) {
   uint16_t level = *pc++;
   uint16_t idx = *pc++;
@@ -179,9 +168,10 @@ jv jq_next(jq_state *jq) {
           param = forkable_stack_peek_next(&jq->data_stk, param);
         }
         if (!param) break;
-        jv_dump(jv_copy(param->sv.value), 0);
-        //printf("<%d>", jv_get_refcnt(param->sv.value));
-        printf("<%d>", param->sv.pathidx);
+        jv_dump(jv_copy(param->val), 0);
+        //printf("<%d>", jv_get_refcnt(param->val));
+        //printf(" -- ");
+        //jv_dump(jv_copy(jq->path), 0);
       }
 
       if (backtracking) printf("\t<backtracking>");
@@ -200,46 +190,52 @@ jv jq_next(jq_state *jq) {
     case LOADK: {
       jv v = jv_array_get(jv_copy(frame_current_bytecode(&jq->frame_stk)->constants), *pc++);
       assert(jv_is_valid(v));
-      stack_push(jq, stackval_replace(stack_pop(jq), v));
+      jv_free(stack_pop(jq));
+      stack_push(jq, v);
       break;
     }
 
     case DUP: {
-      stackval v = stack_pop(jq);
-      stackval v2 = v;
-      v2.value = jv_copy(v.value);
+      jv v = stack_pop(jq);
+      stack_push(jq, jv_copy(v));
       stack_push(jq, v);
-      stack_push(jq, v2);
       break;
     }
 
     case DUP2: {
-      stackval keep = stack_pop(jq);
-      stackval v = stack_pop(jq);
-      stackval v2 = v;
-      v2.value = jv_copy(v.value);
-      stack_push(jq, v);
+      jv keep = stack_pop(jq);
+      jv v = stack_pop(jq);
+      stack_push(jq, jv_copy(v));
       stack_push(jq, keep);
-      stack_push(jq, v2);
+      stack_push(jq, v);
       break;
     }
 
-    case SWAP: {
-      stackval a = stack_pop(jq);
-      stackval b = stack_pop(jq);
+    case SUBEXP_BEGIN: {
+      jv v = stack_pop(jq);
+      stack_push(jq, jv_copy(v));
+      stack_push(jq, v);
+      jq->subexp_nest++;
+      break;
+    }
+
+    case SUBEXP_END: {
+      assert(jq->subexp_nest > 0);
+      jq->subexp_nest--;
+      jv a = stack_pop(jq);
+      jv b = stack_pop(jq);
       stack_push(jq, a);
       stack_push(jq, b);
       break;
     }
       
     case POP: {
-      jv_free(stack_pop(jq).value);
+      jv_free(stack_pop(jq));
       break;
     }
 
     case APPEND: {
-      // FIXME paths
-      jv v = stack_pop(jq).value;
+      jv v = stack_pop(jq);
       uint16_t level = *pc++;
       uint16_t vidx = *pc++;
       frame_ptr fp = frame_get_level(&jq->frame_stk, frame_current(&jq->frame_stk), level);
@@ -250,14 +246,13 @@ jv jq_next(jq_state *jq) {
     }
 
     case INSERT: {
-      stackval stktop = stack_pop(jq);
-      jv v = stack_pop(jq).value;
-      jv k = stack_pop(jq).value;
-      stackval objv = stack_pop(jq);
+      jv stktop = stack_pop(jq);
+      jv v = stack_pop(jq);
+      jv k = stack_pop(jq);
+      jv objv = stack_pop(jq);
       assert(jv_get_kind(k) == JV_KIND_STRING);
-      assert(jv_get_kind(objv.value) == JV_KIND_OBJECT);
-      objv.value = jv_object_set(objv.value, k, v);
-      stack_push(jq, objv);
+      assert(jv_get_kind(objv) == JV_KIND_OBJECT);
+      stack_push(jq, jv_object_set(objv, k, v));
       stack_push(jq, stktop);
       break;
     }
@@ -273,7 +268,8 @@ jv jq_next(jq_state *jq) {
         jv_dump(jv_copy(*var), 0);
         printf("\n");
       }
-      stack_push(jq, stackval_replace(stack_pop(jq), jv_copy(*var)));
+      jv_free(stack_pop(jq));
+      stack_push(jq, jv_copy(*var));
       break;
     }
 
@@ -282,39 +278,66 @@ jv jq_next(jq_state *jq) {
       uint16_t v = *pc++;
       frame_ptr fp = frame_get_level(&jq->frame_stk, frame_current(&jq->frame_stk), level);
       jv* var = frame_local_var(fp, v);
-      stackval val = stack_pop(jq);
+      jv val = stack_pop(jq);
       if (jq->debug_trace_enabled) {
         printf("V%d = ", v);
-        jv_dump(jv_copy(val.value), 0);
+        jv_dump(jv_copy(val), 0);
         printf("\n");
       }
       jv_free(*var);
-      *var = val.value;
+      *var = val;
       break;
     }
 
-    case GETPATH: {
-      stackval path_end = stack_pop(jq);
-      stackval path_start = stack_pop(jq);
-      jv_free(path_end.value);
-      jv path = jv_array();
-      for (int i=path_start.pathidx; i<path_end.pathidx; i++) {
-        path = jv_array_append(path, jv_copy(jq->pathbuf[i]));
-      }
-      stack_push(jq, stackval_replace(path_start, path));
+    case PATH_BEGIN: {
+      jv v = stack_pop(jq);
+      stack_push(jq, jq->path);
+
+      stack_save(jq);
+      frame_push_backtrack(&jq->frame_stk, pc - 1);
+      stack_switch(jq);
+
+      stack_push(jq, jv_number(jq->subexp_nest));
+      stack_push(jq, v);
+
+      jq->path = jv_array();
+      jq->subexp_nest = 0;
       break;
     }
 
+    case PATH_END: {
+      jv v = stack_pop(jq);
+      jv_free(v); // discard value, only keep path
+
+      int old_subexp_nest = (int)jv_number_value(stack_pop(jq));
+
+      jv path = jq->path;
+      jq->path = stack_pop(jq);
+
+      stack_save(jq);
+      stack_push(jq, jv_copy(path));
+      frame_push_backtrack(&jq->frame_stk, pc - 1);
+      stack_switch(jq);
+
+      stack_push(jq, path);
+      jq->subexp_nest = old_subexp_nest;
+      break;
+    }
+
+    case ON_BACKTRACK(PATH_BEGIN):
+    case ON_BACKTRACK(PATH_END): {
+      jv_free(jq->path);
+      jq->path = stack_pop(jq);
+      goto do_backtrack;
+    }
+
     case INDEX: {
-      stackval t = stack_pop(jq);
-      jv k = stack_pop(jq).value;
-      int pathidx = path_push(jq, t, jv_copy(k));
-      jv v = jv_get(t.value, k);
+      jv t = stack_pop(jq);
+      jv k = stack_pop(jq);
+      path_append(jq, jv_copy(k));
+      jv v = jv_get(t, k);
       if (jv_is_valid(v)) {
-        stackval sv;
-        sv.value = v;
-        sv.pathidx = pathidx;
-        stack_push(jq, sv);
+        stack_push(jq, v);
       } else {
         print_error(v);
         goto do_backtrack;
@@ -331,8 +354,8 @@ jv jq_next(jq_state *jq) {
 
     case JUMP_F: {
       uint16_t offset = *pc++;
-      stackval t = stack_pop(jq);
-      jv_kind kind = jv_get_kind(t.value);
+      jv t = stack_pop(jq);
+      jv_kind kind = jv_get_kind(t);
       if (kind == JV_KIND_FALSE || kind == JV_KIND_NULL) {
         pc += offset;
       }
@@ -341,50 +364,48 @@ jv jq_next(jq_state *jq) {
     }
 
     case EACH: 
-      stack_push(jq, stackval_root(jv_number(-1)));
+      stack_push(jq, jv_number(-1));
       // fallthrough
     case ON_BACKTRACK(EACH): {
-      int idx = jv_number_value(stack_pop(jq).value);
-      stackval container = stack_pop(jq);
+      int idx = jv_number_value(stack_pop(jq));
+      jv container = stack_pop(jq);
 
       int keep_going;
       jv key, value;
-      if (jv_get_kind(container.value) == JV_KIND_ARRAY) {
+      if (jv_get_kind(container) == JV_KIND_ARRAY) {
         if (opcode == EACH) idx = 0;
         else idx = idx + 1;
-        keep_going = idx < jv_array_length(jv_copy(container.value));
+        keep_going = idx < jv_array_length(jv_copy(container));
         if (keep_going) {
           key = jv_number(idx);
-          value = jv_array_get(jv_copy(container.value), idx);
+          value = jv_array_get(jv_copy(container), idx);
         }
-      } else if (jv_get_kind(container.value) == JV_KIND_OBJECT) {
-        if (opcode == EACH) idx = jv_object_iter(container.value);
-        else idx = jv_object_iter_next(container.value, idx);
-        keep_going = jv_object_iter_valid(container.value, idx);
+      } else if (jv_get_kind(container) == JV_KIND_OBJECT) {
+        if (opcode == EACH) idx = jv_object_iter(container);
+        else idx = jv_object_iter_next(container, idx);
+        keep_going = jv_object_iter_valid(container, idx);
         if (keep_going) {
-          key = jv_object_iter_key(container.value, idx);
-          value = jv_object_iter_value(container.value, idx);
+          key = jv_object_iter_key(container, idx);
+          value = jv_object_iter_value(container, idx);
         }
       } else {
         assert(opcode == EACH);
         print_error(jv_invalid_with_msg(jv_string_fmt("Cannot iterate over %s",
-                                                      jv_kind_name(jv_get_kind(container.value)))));
+                                                      jv_kind_name(jv_get_kind(container)))));
         keep_going = 0;
       }
 
       if (!keep_going) {
-        jv_free(container.value);
+        jv_free(container);
         goto do_backtrack;
       } else {
         stack_save(jq);
         stack_push(jq, container);
-        stack_push(jq, stackval_root(jv_number(idx)));
+        stack_push(jq, jv_number(idx));
         frame_push_backtrack(&jq->frame_stk, pc - 1);
         stack_switch(jq);
-        
-        stackval sv = {value,
-                       path_push(jq, container, key)};
-        stack_push(jq, sv);
+        path_append(jq, key);
+        stack_push(jq, value);
       }
       break;
     }
@@ -415,24 +436,24 @@ jv jq_next(jq_state *jq) {
     }
 
     case YIELD: {
-      jv value = stack_pop(jq).value;
+      jv value = stack_pop(jq);
       frame_push_backtrack(&jq->frame_stk, pc);
       return value;
     }
       
     case CALL_BUILTIN: {
       int nargs = *pc++;
-      stackval top = stack_pop(jq);
-      cfunc_input[0] = top.value;
+      jv top = stack_pop(jq);
+      cfunc_input[0] = top;
       for (int i = 1; i < nargs; i++) {
-        cfunc_input[i] = stack_pop(jq).value;
+        cfunc_input[i] = stack_pop(jq);
       }
       struct cfunction* func = &frame_current_bytecode(&jq->frame_stk)->globals->cfunctions[*pc++];
-      top.value = cfunction_invoke(func, cfunc_input);
-      if (jv_is_valid(top.value)) {
+      top = cfunction_invoke(func, cfunc_input);
+      if (jv_is_valid(top)) {
         stack_push(jq, top);
       } else {
-        print_error(top.value);
+        print_error(top);
         goto do_backtrack;
       }
       break;
@@ -470,11 +491,12 @@ void jq_init(struct bytecode* bc, jv input, jq_state **jq, int flags) {
   jq_state *new_jq;
   new_jq = jv_mem_alloc(sizeof(*new_jq));
   memset(new_jq, 0, sizeof(*new_jq));
-  forkable_stack_init(&new_jq->data_stk, sizeof(stackval) * 100);
+  new_jq->path = jv_null();
+  forkable_stack_init(&new_jq->data_stk, sizeof(data_stk_elem) * 100);
   forkable_stack_init(&new_jq->frame_stk, 1024);
   forkable_stack_init(&new_jq->fork_stk, 1024);
   
-  stack_push(new_jq, stackval_root(input));
+  stack_push(new_jq, input);
   struct closure top = {bc, -1};
   frame_push(&new_jq->frame_stk, top, 0);
   frame_push_backtrack(&new_jq->frame_stk, bc->code);
@@ -501,10 +523,7 @@ void jq_teardown(jq_state **jq) {
   forkable_stack_free(&old_jq->data_stk);
   forkable_stack_free(&old_jq->frame_stk);
 
-  for (int i=0; i<old_jq->pathsize; i++) {
-    jv_free(old_jq->pathbuf[i]);
-  }
-  jv_mem_free(old_jq->pathbuf);
+  jv_free(old_jq->path);
   jv_mem_free(old_jq);
 }
 
diff --git a/jv_print.c b/jv_print.c
index 6396d7c8..fc1370ed 100644
--- a/jv_print.c
+++ b/jv_print.c
@@ -124,6 +124,7 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
     }
   }
   switch (jv_get_kind(x)) {
+  default:
   case JV_KIND_INVALID:
     assert(0 && "Invalid value");
     break;
diff --git a/opcode_list.h b/opcode_list.h
index f384d715..91a6aba1 100644
--- a/opcode_list.h
+++ b/opcode_list.h
@@ -1,7 +1,6 @@
 OP(LOADK, CONSTANT, 1, 1)
 OP(DUP,   NONE,     1, 2)
 OP(DUP2,  NONE,     2, 3)
-OP(SWAP,  NONE,     2, 2)
 OP(POP,   NONE,     1, 0)
 OP(LOADV, VARIABLE, 1, 1)
 OP(STOREV, VARIABLE, 1, 0)
@@ -15,7 +14,11 @@ OP(BACKTRACK, NONE, 0, 0)
 OP(APPEND, VARIABLE,1, 0)
 OP(INSERT, NONE,    4, 2)
 
-OP(GETPATH, NONE,   2, 1)
+OP(SUBEXP_BEGIN,  NONE,     1, 2)
+OP(SUBEXP_END,    NONE,     2, 2)
+
+OP(PATH_BEGIN, NONE, 1, 2)
+OP(PATH_END,   NONE, 2, 1)
 
 OP(CALL_BUILTIN, CFUNC, -1, 1)
 

From 34a63246abe5116cc293490e8d1fcaba9a00e5d9 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 13 May 2013 15:37:57 +0100
Subject: [PATCH 266/284] Remove the is_backtrack_frame special case hack.

---
 execute.c      | 39 ++++++++++++++++++---------------------
 frame_layout.h | 16 +---------------
 2 files changed, 19 insertions(+), 36 deletions(-)

diff --git a/execute.c b/execute.c
index 77b8574d..9062f116 100644
--- a/execute.c
+++ b/execute.c
@@ -56,16 +56,18 @@ struct forkpoint {
   struct forkable_stack_state saved_data_stack;
   struct forkable_stack_state saved_call_stack;
   int path_len, subexp_nest;
+  uint16_t* return_address;
 };
 
 
-void stack_save(jq_state *jq){
+void stack_save(jq_state *jq, uint16_t* retaddr){
   struct forkpoint* fork = forkable_stack_push(&jq->fork_stk, sizeof(struct forkpoint));
   forkable_stack_save(&jq->data_stk, &fork->saved_data_stack);
   forkable_stack_save(&jq->frame_stk, &fork->saved_call_stack);
   fork->path_len = 
     jv_get_kind(jq->path) == JV_KIND_ARRAY ? jv_array_length(jv_copy(jq->path)) : 0;
   fork->subexp_nest = jq->subexp_nest;
+  fork->return_address = retaddr;
 }
 
 void stack_switch(jq_state *jq) {
@@ -85,7 +87,7 @@ void path_append(jq_state* jq, jv component) {
   }
 }
 
-int stack_restore(jq_state *jq){
+uint16_t* stack_restore(jq_state *jq){
   while (!forkable_stack_empty(&jq->data_stk) && 
          forkable_stack_pop_will_free(&jq->data_stk)) {
     jv_free(stack_pop(jq));
@@ -100,6 +102,7 @@ int stack_restore(jq_state *jq){
   }
 
   struct forkpoint* fork = forkable_stack_peek(&jq->fork_stk);
+  uint16_t* retaddr = fork->return_address;
   forkable_stack_restore(&jq->data_stk, &fork->saved_data_stack);
   forkable_stack_restore(&jq->frame_stk, &fork->saved_call_stack);
   int path_len = fork->path_len;
@@ -111,7 +114,7 @@ int stack_restore(jq_state *jq){
   }
   jq->subexp_nest = fork->subexp_nest;
   forkable_stack_pop(&jq->fork_stk);
-  return 1;
+  return retaddr;
 }
 
 
@@ -143,11 +146,8 @@ void print_error(jv value) {
 jv jq_next(jq_state *jq) {
   jv cfunc_input[MAX_CFUNCTION_ARGS];
 
-  assert(!forkable_stack_empty(&jq->frame_stk));
-  uint16_t* pc = *frame_current_retaddr(&jq->frame_stk);
-  frame_pop(&jq->frame_stk);
-  
-  assert(!forkable_stack_empty(&jq->frame_stk));
+  uint16_t* pc = stack_restore(jq);
+  assert(pc);
 
   int backtracking = 0;
   while (1) {
@@ -293,8 +293,7 @@ jv jq_next(jq_state *jq) {
       jv v = stack_pop(jq);
       stack_push(jq, jq->path);
 
-      stack_save(jq);
-      frame_push_backtrack(&jq->frame_stk, pc - 1);
+      stack_save(jq, pc - 1);
       stack_switch(jq);
 
       stack_push(jq, jv_number(jq->subexp_nest));
@@ -314,9 +313,8 @@ jv jq_next(jq_state *jq) {
       jv path = jq->path;
       jq->path = stack_pop(jq);
 
-      stack_save(jq);
+      stack_save(jq, pc - 1);
       stack_push(jq, jv_copy(path));
-      frame_push_backtrack(&jq->frame_stk, pc - 1);
       stack_switch(jq);
 
       stack_push(jq, path);
@@ -399,10 +397,9 @@ jv jq_next(jq_state *jq) {
         jv_free(container);
         goto do_backtrack;
       } else {
-        stack_save(jq);
+        stack_save(jq, pc - 1);
         stack_push(jq, container);
         stack_push(jq, jv_number(idx));
-        frame_push_backtrack(&jq->frame_stk, pc - 1);
         stack_switch(jq);
         path_append(jq, key);
         stack_push(jq, value);
@@ -412,18 +409,16 @@ jv jq_next(jq_state *jq) {
 
     do_backtrack:
     case BACKTRACK: {
-      if (!stack_restore(jq)) {
+      pc = stack_restore(jq);
+      if (!pc) {
         return jv_invalid();
       }
-      pc = *frame_current_retaddr(&jq->frame_stk);
-      frame_pop(&jq->frame_stk);
       backtracking = 1;
       break;
     }
 
     case FORK: {
-      stack_save(jq);
-      frame_push_backtrack(&jq->frame_stk, pc - 1);
+      stack_save(jq, pc - 1);
       stack_switch(jq);
       pc++; // skip offset this time
       break;
@@ -437,7 +432,8 @@ jv jq_next(jq_state *jq) {
 
     case YIELD: {
       jv value = stack_pop(jq);
-      frame_push_backtrack(&jq->frame_stk, pc);
+      stack_save(jq, pc);
+      stack_switch(jq);
       return value;
     }
       
@@ -499,7 +495,8 @@ void jq_init(struct bytecode* bc, jv input, jq_state **jq, int flags) {
   stack_push(new_jq, input);
   struct closure top = {bc, -1};
   frame_push(&new_jq->frame_stk, top, 0);
-  frame_push_backtrack(&new_jq->frame_stk, bc->code);
+  stack_save(new_jq, bc->code);
+  stack_switch(new_jq);
   if (flags & JQ_DEBUG_TRACE) {
     new_jq->debug_trace_enabled = 1;
   } else {
diff --git a/frame_layout.h b/frame_layout.h
index f098272e..dbbe3000 100644
--- a/frame_layout.h
+++ b/frame_layout.h
@@ -11,8 +11,6 @@ struct continuation {
   struct bytecode* bc;
   stack_idx env;
   uint16_t* retaddr;
-  // FIXME: probably not necessary as a separate field
-  int is_backtrack_frame;
 };
 
 typedef union frame_elem {
@@ -86,27 +84,15 @@ static frame_ptr frame_push(struct forkable_stack* stk, struct closure cl, uint1
   cc->bc = cl.bc;
   cc->env = cl.env;
   cc->retaddr = retaddr;
-  cc->is_backtrack_frame = 0;
   for (int i=0; i<cl.bc->nlocals; i++) {
     *frame_local_var(fp, i) = jv_invalid();
   }
   return fp;
 }
 
-static frame_ptr frame_push_backtrack(struct forkable_stack* stk, uint16_t* retaddr) {
-  struct continuation cc = *frame_self(frame_current(stk));
-  frame_ptr fp = forkable_stack_push(stk, sizeof(union frame_elem) * 2);
-  assert(!cc.is_backtrack_frame);
-  cc.is_backtrack_frame = 1;
-  cc.retaddr = retaddr;
-  *frame_self(fp) = cc;
-  return fp;
-}
-
 static void frame_pop(struct forkable_stack* stk) {
   frame_ptr fp = frame_current(stk);
-  if (forkable_stack_pop_will_free(stk) && 
-      !frame_self(fp)->is_backtrack_frame) {
+  if (forkable_stack_pop_will_free(stk)) {
     int nlocals = frame_self(fp)->bc->nlocals;
     for (int i=0; i<nlocals; i++) {
       jv_free(*frame_local_var(fp, i));

From e13f24ab45c2bc6fead9d698bdeaa84746761692 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 13 May 2013 15:42:57 +0100
Subject: [PATCH 267/284] Better error handling for INSERT opcode

jq 'null | {(.a): 1}' no longer crashes.
---
 execute.c | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/execute.c b/execute.c
index 9062f116..48262df8 100644
--- a/execute.c
+++ b/execute.c
@@ -250,10 +250,19 @@ jv jq_next(jq_state *jq) {
       jv v = stack_pop(jq);
       jv k = stack_pop(jq);
       jv objv = stack_pop(jq);
-      assert(jv_get_kind(k) == JV_KIND_STRING);
       assert(jv_get_kind(objv) == JV_KIND_OBJECT);
-      stack_push(jq, jv_object_set(objv, k, v));
-      stack_push(jq, stktop);
+      if (jv_get_kind(k) == JV_KIND_STRING) {
+        stack_push(jq, jv_object_set(objv, k, v));
+        stack_push(jq, stktop);
+      } else {
+        print_error(jv_invalid_with_msg(jv_string_fmt("Cannot use %s as object key",
+                                                      jv_kind_name(jv_get_kind(k)))));
+        jv_free(stktop);
+        jv_free(v);
+        jv_free(k);
+        jv_free(objv);
+        goto do_backtrack;
+      }
       break;
     }
 

From d8706fd4607ee1b5b56debd4da39e3314739f126 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 13 May 2013 16:04:30 +0100
Subject: [PATCH 268/284] Fix the //= operator.

Closes #62.
---
 parser.y       | 12 +++++++++++-
 tests/all.test |  7 +++----
 2 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/parser.y b/parser.y
index 2889977d..378c0740 100644
--- a/parser.y
+++ b/parser.y
@@ -163,6 +163,16 @@ static block gen_binop(block a, block b, int op) {
 static block gen_format(block a, jv fmt) {
   return BLOCK(a, gen_call("format", BLOCK(gen_lambda(gen_const(fmt)))));
 }
+
+static block gen_definedor_assign(block object, block val) {
+  block tmp = block_bind(gen_op_var_unbound(STOREV, "tmp"),
+                         gen_noop(), OP_HAS_VARIABLE);
+  return BLOCK(gen_op_simple(DUP),
+               val, tmp,
+               gen_call("_modify", BLOCK(gen_lambda(object),
+                                         gen_lambda(gen_definedor(gen_noop(), 
+                                                                  gen_op_var_bound(LOADV, tmp))))));
+}
  
 static block gen_update(block object, block val, int optype) {
   block tmp = block_bind(gen_op_var_unbound(STOREV, "tmp"),
@@ -235,7 +245,7 @@ Exp "//" Exp {
 } |
 
 Exp "//=" Exp {
-  $$ = gen_update($1, gen_definedor(gen_noop(), $3), 0);
+  $$ = gen_definedor_assign($1, $3);
 } |
 
 Exp "|=" Exp {
diff --git a/tests/all.test b/tests/all.test
index 97af7e55..5b38709b 100644
--- a/tests/all.test
+++ b/tests/all.test
@@ -475,10 +475,9 @@ def inc(x): x |= .+1; inc(.[].a)
 [{"foo":[1,2], "bar": 42}, {"foo":[1], "bar": null}, {"foo":[null,false,3], "bar": 18}, {"foo":[], "bar":42}, {"foo": [null,false,null], "bar": 41}]
 [[1,2], [1], [3], [42], [41]]
 
-# FIXME: behaviour of update operators
-# .[] //= .[0]
-# ["hello",true,false,[false],null]
-# ["hello",true,"hello",[false],"hello"]
+.[] //= .[0]
+["hello",true,false,[false],null]
+["hello",true,"hello",[false],"hello"]
 
 .[] | [.[0] and .[1], .[0] or .[1]]
 [[true,[]], [false,1], [42,null], [null,false]]

From a625d2821ecb27b87266762545f88d7d4aa59d31 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 13 May 2013 16:15:49 +0100
Subject: [PATCH 269/284] Add to_entries, from_entries and with_entries
 functions.

Closes #97.
---
 builtin.c                        |  3 +++
 docs/content/3.manual/manual.yml | 25 +++++++++++++++++++++++++
 2 files changed, 28 insertions(+)

diff --git a/builtin.c b/builtin.c
index 1516c6c6..2a48ba35 100644
--- a/builtin.c
+++ b/builtin.c
@@ -547,6 +547,9 @@ static const char* const jq_builtins[] = {
   "def _assign(paths; value): value as $v | fold . as $obj (path(paths) as $p | $obj | setpath($p; $v));",
   "def _modify(paths; update): fold . as $obj (path(paths) as $p | $obj | setpath($p; getpath($p) | update));",
   "def recurse(f): ., (f | select(. != null) | recurse(f));",
+  "def to_entries: [keys[] as $k | {key: $k, value: .[$k]}];",
+  "def from_entries: map({(.key): .value}) | add;",
+  "def with_entries(f): to_entries | map(f) | from_entries;",
 };
 
 
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 2f36392c..766fef7b 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -478,6 +478,31 @@ sections:
             input: '[[0,1], ["a","b","c"]]'
             output: ['[false, true]']
 
+      - title: `to_entries`, `from_entries`, `with_entries`
+        body: |
+          
+          These functions convert between an object and an array of
+          key-value pairs. If `to_entries` is passed an object, then
+          for each `k: v` entry in the input, the output array
+          includes `{"key": k, "value": v}`. 
+
+          `from_entries` does the opposite conversion, and
+          `with_entries(foo)` is a shorthand for `to_entries |
+          map(foo) | from_entries`, useful for doing some operation to
+          all keys and values of an object.
+
+        examples:
+          - program: 'to_entries'
+            input: '[{"a": 1}, {"b": 2}]'
+            output: ['[{"key":"a", "value":1}, {"key":"b", "value":2}]']
+          - program: 'from_entries'
+            input: '[{"key":"a", "value":1}, {"key":"b", "value":2}]'
+            output: ['[{"a": 1}, {"b": 2}]']
+          - program: 'with_entries(.key |= "KEY_" + .)'
+            input: '[{"a": 1}, {"b": 2}]'
+            output: ['[{"KEY_a": 1}, {"KEY_b": 2}]']
+
+
       - title: `select`
         body: |
           

From a47cfa475700469d0ea0e7a7c80c5fef8690ac3f Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 13 May 2013 16:41:11 +0100
Subject: [PATCH 270/284] Delete unnecessary _POSIX_SOURCE. Closes #89

---
 main.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/main.c b/main.c
index 774dc61e..77c76548 100644
--- a/main.c
+++ b/main.c
@@ -1,4 +1,3 @@
-#define _POSIX_SOURCE
 #include <stdio.h>
 #include <errno.h>
 #include <string.h>

From 33901b74b16ce037c732d7a33444862d93c91065 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 13 May 2013 20:16:19 +0100
Subject: [PATCH 271/284] Array slicing. Closes #2.

---
 docs/content/3.manual/manual.yml |  21 ++++-
 jv_aux.c                         | 136 +++++++++++++++++++++++++++----
 parser.y                         |  20 +++++
 tests/all.test                   |  19 +++++
 4 files changed, 180 insertions(+), 16 deletions(-)

diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 766fef7b..b88c4c22 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -160,7 +160,7 @@ sections:
             input: '{"notfoo": true, "alsonotfoo": false}'
             output: ['null']
 
-      - title: "`.[foo]`"
+      - title: "`.[foo]`, `.[2]`, `.[10:15]`"
         body: |
           
           You can also look up fields of an object using syntax like
@@ -169,6 +169,13 @@ sections:
           integer. Arrays are zero-based (like javascript), so `.[2]`
           returns the third element of the array.
 
+          The `.[10:15]` syntax can be used to return a subarray of an
+          array. The array returned by `.[10:15]` will be of length 5,
+          containing the elements from index 10 (inclusive) to index
+          15 (exclusive). Either index may be negative (in which case
+          it counts backwards from the end of the array), or omitted
+          (in which case it refers to the start or end of the array).
+
         examples:
           - program: '.[0]'
             input: '[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]'
@@ -178,6 +185,18 @@ sections:
             input: '[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]'
             output: ['null']
 
+          - program: '.[2:4]'
+            input: '["a","b","c","d","e"]'
+            output: ['["c", "d"]']
+          
+          - program: '.[:3]'
+            input: '["a","b","c","d","e"]'
+            output: ['["a", "b", "c"]']
+
+          - program: '.[-2:]'
+            input: '["a","b","c","d","e"]'
+            output: ['["d", "e"]']
+
       - title: "`.[]`"
         body: |
           
diff --git a/jv_aux.c b/jv_aux.c
index 1f40cc4b..28755644 100644
--- a/jv_aux.c
+++ b/jv_aux.c
@@ -3,6 +3,38 @@
 #include <stdlib.h>
 #include "jv_alloc.h"
 
+static int parse_slice(jv array, jv slice, int* pstart, int* pend) {
+  // Array slices
+  int len = jv_array_length(jv_copy(array));
+  jv start_jv = jv_object_get(jv_copy(slice), jv_string("start"));
+  jv end_jv = jv_object_get(slice, jv_string("end"));
+  if (jv_get_kind(start_jv) == JV_KIND_NULL) {
+    jv_free(start_jv);
+    start_jv = jv_number(0);
+  }
+  if (jv_get_kind(end_jv) == JV_KIND_NULL) {
+    jv_free(end_jv);
+    end_jv = jv_number(len);
+  }
+  if (jv_get_kind(start_jv) != JV_KIND_NUMBER ||
+      jv_get_kind(end_jv) != JV_KIND_NUMBER) {
+    jv_free(start_jv);
+    jv_free(end_jv);
+    return 0;
+  } else {
+    int start = (int)jv_number_value(start_jv);
+    int end = (int)jv_number_value(end_jv);
+    if (start < 0) start = len + start;
+    if (end < 0) end = len + end;
+    if (start < 0) start = 0;
+    if (end > len) end = len;
+    if (end < start) end = start;
+    *pstart = start;
+    *pend = end;
+    return 1;
+  }
+}
+
 jv jv_get(jv t, jv k) {
   jv v;
   if (jv_get_kind(t) == JV_KIND_OBJECT && jv_get_kind(k) == JV_KIND_STRING) {
@@ -18,8 +50,18 @@ jv jv_get(jv t, jv k) {
       jv_free(v);
       v = jv_null();
     }
+  } else if (jv_get_kind(t) == JV_KIND_ARRAY && jv_get_kind(k) == JV_KIND_OBJECT) {
+    int start, end;
+    if (parse_slice(t, k, &start, &end)) {
+      v = jv_array_slice(t, start, end);
+    } else {
+      v = jv_invalid_with_msg(jv_string_fmt("Start and end indices of an array slice must be numbers"));
+      jv_free(t);
+    }
   } else if (jv_get_kind(t) == JV_KIND_NULL && 
-             (jv_get_kind(k) == JV_KIND_STRING || jv_get_kind(k) == JV_KIND_NUMBER)) {
+             (jv_get_kind(k) == JV_KIND_STRING || 
+              jv_get_kind(k) == JV_KIND_NUMBER || 
+              jv_get_kind(k) == JV_KIND_OBJECT)) {
     jv_free(t);
     jv_free(k);
     v = jv_null();
@@ -48,10 +90,49 @@ jv jv_set(jv t, jv k, jv v) {
              (jv_get_kind(t) == JV_KIND_ARRAY || isnull)) {
     if (isnull) t = jv_array();
     t = jv_array_set(t, (int)jv_number_value(k), v);
+  } else if (jv_get_kind(k) == JV_KIND_OBJECT &&
+             (jv_get_kind(t) == JV_KIND_ARRAY || isnull)) {
+    if (isnull) t = jv_array();
+    int start, end;
+    if (parse_slice(t, k, &start, &end)) {
+      if (jv_get_kind(v) == JV_KIND_ARRAY) {
+        int array_len = jv_array_length(jv_copy(t));
+        assert(0 <= start && start <= end && end <= array_len);
+        int slice_len = end - start;
+        int insert_len = jv_array_length(jv_copy(v));
+        if (slice_len < insert_len) {
+          // array is growing
+          int shift = insert_len - slice_len;
+          for (int i = array_len - 1; i >= end; i--) {
+            t = jv_array_set(t, i + shift, jv_array_get(jv_copy(t), i));
+          }
+        } else if (slice_len > insert_len) {
+          // array is shrinking
+          int shift = slice_len - insert_len;
+          for (int i = end; i < array_len; i++) {
+            t = jv_array_set(t, i - shift, jv_array_get(jv_copy(t), i));
+          }
+          t = jv_array_slice(t, 0, array_len - shift);
+        }
+        for (int i=0; i < insert_len; i++) {
+          t = jv_array_set(t, start + i, jv_array_get(jv_copy(v), i));
+        }
+        jv_free(v);
+      } else {
+        jv_free(t);
+        jv_free(v);
+        t = jv_invalid_with_msg(jv_string_fmt("A slice of an array can only be assigned another array"));
+      }
+    } else {
+      jv_free(t);
+      jv_free(k);
+      jv_free(v);
+      t = jv_invalid_with_msg(jv_string_fmt("Start and end indices of an array slice must be numbers"));
+    }
   } else {
     jv err = jv_invalid_with_msg(jv_string_fmt("Cannot update field at %s index of %s",
-                                               jv_kind_name(jv_get_kind(t)),
-                                               jv_kind_name(jv_get_kind(v))));
+                                               jv_kind_name(jv_get_kind(k)),
+                                               jv_kind_name(jv_get_kind(t))));
     jv_free(t);
     jv_free(k);
     jv_free(v);
@@ -96,23 +177,39 @@ jv jv_dels(jv t, jv keys) {
   if (jv_get_kind(t) == JV_KIND_NULL || jv_array_length(jv_copy(keys)) == 0) {
     // no change
   } else if (jv_get_kind(t) == JV_KIND_ARRAY) {
+    // extract slices, they must be handled differently
+    jv orig_keys = keys;
+    keys = jv_array();
     jv new_array = jv_array();
+    jv starts = jv_array(), ends = jv_array();
+    jv_array_foreach(orig_keys, i, key) {
+      if (jv_get_kind(key) == JV_KIND_NUMBER) {
+        keys = jv_array_append(keys, key);
+      } else if (jv_get_kind(key) == JV_KIND_OBJECT) {
+        int start, end;
+        if (parse_slice(t, key, &start, &end)) {
+          starts = jv_array_append(starts, jv_number(start));
+          ends = jv_array_append(ends, jv_number(end));
+        } else {
+          jv_free(new_array);
+          jv_free(key);
+          new_array = jv_invalid_with_msg(jv_string_fmt("Start and end indices of an array slice must be numbers"));
+          goto arr_out;
+        }
+      } else {
+        jv_free(new_array);
+        new_array = jv_invalid_with_msg(jv_string_fmt("Cannot delete %s element of array",
+                                                      jv_kind_name(jv_get_kind(key))));
+        jv_free(key);
+        goto arr_out;
+      }
+    }
+
     int kidx = 0;
     jv_array_foreach(t, i, elem) {
       int del = 0;
       while (kidx < jv_array_length(jv_copy(keys))) {
-        jv nextdel = jv_array_get(jv_copy(keys), kidx);
-        if (jv_get_kind(nextdel) != JV_KIND_NUMBER) {
-          jv err = jv_invalid_with_msg(jv_string_fmt("Cannot delete %s element of array",
-                                                     jv_kind_name(jv_get_kind(nextdel))));
-          jv_free(nextdel);
-          jv_free(new_array);
-          jv_free(elem);
-          new_array = err;
-          goto arr_out; // break twice
-        }
-        int delidx = (int)jv_number_value(nextdel);
-        jv_free(nextdel);
+        int delidx = (int)jv_number_value(jv_array_get(jv_copy(keys), kidx));
         if (i == delidx) {
           del = 1;
         }
@@ -121,12 +218,21 @@ jv jv_dels(jv t, jv keys) {
         }
         kidx++;
       }
+      for (int sidx=0; !del && sidx<jv_array_length(jv_copy(starts)); sidx++) {
+        if ((int)jv_number_value(jv_array_get(jv_copy(starts), sidx)) <= i &&
+            i < (int)jv_number_value(jv_array_get(jv_copy(ends), sidx))) {
+          del = 1;
+        }
+      }
       if (!del)
         new_array = jv_array_append(new_array, elem);
       else
         jv_free(elem);
     }
   arr_out:
+    jv_free(starts);
+    jv_free(ends);
+    jv_free(orig_keys);
     jv_free(t);
     t = new_array;
   } else if (jv_get_kind(t) == JV_KIND_OBJECT) {
diff --git a/parser.y b/parser.y
index 378c0740..592a428b 100644
--- a/parser.y
+++ b/parser.y
@@ -141,6 +141,17 @@ static block gen_index(block obj, block key) {
   return BLOCK(gen_subexp(key), obj, gen_op_simple(INDEX));
 }
 
+static block gen_slice_index(block obj, block start, block end) {
+  block key = BLOCK(gen_subexp(gen_const(jv_object())),
+                    gen_subexp(gen_const(jv_string("start"))),
+                    gen_subexp(start),
+                    gen_op_simple(INSERT),
+                    gen_subexp(gen_const(jv_string("end"))),
+                    gen_subexp(end),
+                    gen_op_simple(INSERT));
+  return BLOCK(key, obj, gen_op_simple(INDEX));
+}
+
 static block gen_binop(block a, block b, int op) {
   const char* funcname = 0;
   switch (op) {
@@ -408,6 +419,15 @@ Term '[' Exp ']' {
 Term '[' ']' {
   $$ = block_join($1, gen_op_simple(EACH)); 
 } |
+Term '[' Exp ':' Exp ']' {
+  $$ = gen_slice_index($1, $3, $5);
+} |
+Term '[' Exp ':' ']' {
+  $$ = gen_slice_index($1, $3, gen_const(jv_null()));
+} |
+Term '[' ':' Exp ']' {
+  $$ = gen_slice_index($1, gen_const(jv_null()), $4);
+} |
 LITERAL {
   $$ = gen_const($1); 
 } |
diff --git a/tests/all.test b/tests/all.test
index 5b38709b..4eaa9b61 100644
--- a/tests/all.test
+++ b/tests/all.test
@@ -166,6 +166,25 @@ null
 2
 3
 
+#
+# Slices
+#
+
+[.[3:2], .[-5:4], .[:-2], .[-2:]]
+[0,1,2,3,4,5,6]
+[[], [2,3], [0,1,2,3,4], [5,6]]
+
+del(.[2:4],.[0],.[-2:])
+[0,1,2,3,4,5,6,7]
+[1,4,5]
+
+.[2:4] = ([], ["a","b"], ["a","b","c"])
+[0,1,2,3,4,5,6,7]
+[0,1,4,5,6,7]
+[0,1,"a","b",4,5,6,7]
+[0,1,"a","b","c",4,5,6,7]
+
+
 #
 # Variables
 #

From 4d540b7102cb3a63ea5b966b1bbe42ad275fbf25 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Mon, 13 May 2013 20:26:44 +0100
Subject: [PATCH 272/284] Fix some documentation bugs

---
 docs/content/3.manual/manual.yml | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index b88c4c22..94348ea7 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -221,8 +221,8 @@ sections:
             output: []
 
           - program: '.[]'
-            input: '{"a": 1, "b": 2}'
-            output: ['[1, 2]']
+            input: '{"a": 1, "b": 1}'
+            output: ['1', '1']
 
       - title: "`,`"
         body: |
@@ -512,14 +512,14 @@ sections:
 
         examples:
           - program: 'to_entries'
-            input: '[{"a": 1}, {"b": 2}]'
+            input: '{"a": 1, "b": 2}'
             output: ['[{"key":"a", "value":1}, {"key":"b", "value":2}]']
           - program: 'from_entries'
             input: '[{"key":"a", "value":1}, {"key":"b", "value":2}]'
-            output: ['[{"a": 1}, {"b": 2}]']
+            output: ['{"a": 1, "b": 2}']
           - program: 'with_entries(.key |= "KEY_" + .)'
-            input: '[{"a": 1}, {"b": 2}]'
-            output: ['[{"KEY_a": 1}, {"KEY_b": 2}]']
+            input: '{"a": 1, "b": 2}'
+            output: ['{"KEY_a": 1, "KEY_b": 2}']
 
 
       - title: `select`
@@ -845,7 +845,7 @@ sections:
 
           - program: '@sh "echo \(.)"'
             input: "\"O'Hara's Ale\""
-            output: ["\"echo 'O'\\''Hara'\\''s Ale\""]
+            output: ["\"echo 'O'\\\\''Hara'\\\\''s Ale'\""]
         
   - title: Conditionals and Comparisons
     entries:
@@ -942,9 +942,12 @@ sections:
           - program: '(true, false) or false'
             input: 'null'
             output: ['true', 'false']
-          - program: '(true, false) and (true, false)'
+#          - program: '(true, false) and (true, false)'
+#            input: 'null'
+#            output: ['true', 'false', 'false', 'false']
+          - program: '(true, true) and (true, false)'
             input: 'null'
-            output: ['true', 'false', 'false', 'false']
+            output: ['true', 'false', 'true', 'false']
           - program: '[true, false | not]'
             input: 'null'
             output: ['[false, true]']

From 81be37b23601a948164f0eb4a4f0331fa83ccf15 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Tue, 14 May 2013 16:09:10 +0100
Subject: [PATCH 273/284] Add the range function

---
 builtin.c                        | 12 ++++++++++++
 docs/content/3.manual/manual.yml | 16 ++++++++++++++++
 execute.c                        | 27 +++++++++++++++++++++++++++
 opcode_list.h                    |  1 +
 4 files changed, 56 insertions(+)

diff --git a/builtin.c b/builtin.c
index 2a48ba35..09ef9fcd 100644
--- a/builtin.c
+++ b/builtin.c
@@ -530,6 +530,18 @@ static block bind_bytecoded_builtins(block b) {
                                               builtin_def_1arg[i].code));
     }
   }
+  {
+    block rangevar = block_bind(gen_op_var_unbound(STOREV, "rangevar"),
+                                gen_noop(), OP_HAS_VARIABLE);
+    block init = BLOCK(gen_op_simple(DUP), gen_call("start", gen_noop()), rangevar);
+    block range = BLOCK(init, 
+                        gen_call("end", gen_noop()),
+                        gen_op_var_bound(RANGE, rangevar));
+    builtins = BLOCK(builtins, gen_function("range",
+                                            BLOCK(gen_op_block_unbound(CLOSURE_PARAM, "start"),
+                                                  gen_op_block_unbound(CLOSURE_PARAM, "end")),
+                                            range));
+  }
   
   return block_bind(builtins, b, OP_IS_CALL_PSEUDO);
 }
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 94348ea7..e5fff391 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -588,6 +588,22 @@ sections:
           - program: add
             input: '[]'
             output: ["null"]
+
+      - title: `range`
+        body: |
+          
+          The `range` function produces a range of numbers. `range(4;10)`
+          produces 6 numbers, from 4 (inclusive) to 10 (exclusive). The numbers
+          are produced as separate outputs. Use `[range(4;10)]` to get a range as 
+          an array.
+
+        examples:
+          - program: 'range(2;4)'
+            input: 'null'
+            output: ['2', '3']
+          - program: '[range(2;4)]'
+            input: 'null'
+            output: ['[2,3]']
             
       - title: `tonumber`
         body: |
diff --git a/execute.c b/execute.c
index 48262df8..b9d1d31d 100644
--- a/execute.c
+++ b/execute.c
@@ -266,6 +266,33 @@ jv jq_next(jq_state *jq) {
       break;
     }
 
+    case ON_BACKTRACK(RANGE):
+    case RANGE: {
+      uint16_t level = *pc++;
+      uint16_t v = *pc++;
+      frame_ptr fp = frame_get_level(&jq->frame_stk, frame_current(&jq->frame_stk), level);
+      jv* var = frame_local_var(fp, v);
+      jv max = stack_pop(jq);
+      if (jv_get_kind(*var) != JV_KIND_NUMBER ||
+          jv_get_kind(max) != JV_KIND_NUMBER) {
+        print_error(jv_invalid_with_msg(jv_string_fmt("Range bounds must be numeric")));
+        jv_free(max);
+        goto do_backtrack;
+      } else if (jv_number_value(jv_copy(*var)) >= jv_number_value(jv_copy(max))) {
+        /* finished iterating */
+        goto do_backtrack;
+      } else {
+        jv curr = jv_copy(*var);
+        *var = jv_number(jv_number_value(*var) + 1);
+
+        stack_save(jq, pc - 3);
+        stack_push(jq, jv_copy(max));
+        stack_switch(jq);
+        stack_push(jq, curr);
+      }
+      break;
+    }
+
       // FIXME: loadv/storev may do too much copying/freeing
     case LOADV: {
       uint16_t level = *pc++;
diff --git a/opcode_list.h b/opcode_list.h
index 91a6aba1..38206871 100644
--- a/opcode_list.h
+++ b/opcode_list.h
@@ -13,6 +13,7 @@ OP(JUMP_F,BRANCH,   1, 0)
 OP(BACKTRACK, NONE, 0, 0)
 OP(APPEND, VARIABLE,1, 0)
 OP(INSERT, NONE,    4, 2)
+OP(RANGE, VARIABLE, 1, 1)
 
 OP(SUBEXP_BEGIN,  NONE,     1, 2)
 OP(SUBEXP_END,    NONE,     2, 2)

From c496a924ce71317aa5560da0cbf5a4524bb8c226 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 15 May 2013 00:22:44 +0100
Subject: [PATCH 274/284] Bugfix for array slices.

---
 jv_aux.c       | 3 +++
 tests/all.test | 4 ++--
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/jv_aux.c b/jv_aux.c
index 28755644..68811cd0 100644
--- a/jv_aux.c
+++ b/jv_aux.c
@@ -26,9 +26,12 @@ static int parse_slice(jv array, jv slice, int* pstart, int* pend) {
     int end = (int)jv_number_value(end_jv);
     if (start < 0) start = len + start;
     if (end < 0) end = len + end;
+
     if (start < 0) start = 0;
+    if (start > len) start = len;
     if (end > len) end = len;
     if (end < start) end = start;
+    assert(0 <= start && start <= end && end <= len);
     *pstart = start;
     *pend = end;
     return 1;
diff --git a/tests/all.test b/tests/all.test
index 4eaa9b61..0119dad6 100644
--- a/tests/all.test
+++ b/tests/all.test
@@ -170,9 +170,9 @@ null
 # Slices
 #
 
-[.[3:2], .[-5:4], .[:-2], .[-2:]]
+[.[3:2], .[-5:4], .[:-2], .[-2:], .[3:3][1:], .[10:]]
 [0,1,2,3,4,5,6]
-[[], [2,3], [0,1,2,3,4], [5,6]]
+[[], [2,3], [0,1,2,3,4], [5,6], [], []]
 
 del(.[2:4],.[0],.[-2:])
 [0,1,2,3,4,5,6,7]

From e83e51eb56a1de6e627d346f027d3ceb09ae3807 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 15 May 2013 00:37:38 +0100
Subject: [PATCH 275/284] 'length' function now measures string length in
 codepoints, not bytes.

---
 builtin.c      |  8 ++++----
 jq_test.c      |  8 ++++----
 jv.c           | 13 ++++++++++++-
 jv.h           |  3 ++-
 jv_aux.c       |  4 ++--
 jv_print.c     |  2 +-
 lexer.l        |  2 +-
 main.c         |  2 +-
 tests/all.test |  4 ++--
 9 files changed, 29 insertions(+), 17 deletions(-)

diff --git a/builtin.c b/builtin.c
index 09ef9fcd..0b797142 100644
--- a/builtin.c
+++ b/builtin.c
@@ -187,7 +187,7 @@ static jv f_length(jv input) {
   } else if (jv_get_kind(input) == JV_KIND_OBJECT) {
     return jv_number(jv_object_length(input));
   } else if (jv_get_kind(input) == JV_KIND_STRING) {
-    return jv_number(jv_string_length(input));
+    return jv_number(jv_string_length_codepoints(input));
   } else if (jv_get_kind(input) == JV_KIND_NULL) {
     jv_free(input);
     return jv_number(0);
@@ -220,7 +220,7 @@ static jv escape_string(jv input, const char* escapings) {
 
   jv ret = jv_string("");
   const char* i = jv_string_value(input);
-  const char* end = i + jv_string_length(jv_copy(input));
+  const char* end = i + jv_string_length_bytes(jv_copy(input));
   const char* cstart;
   int c = 0;
   while ((i = jvp_utf8_next((cstart = i), end, &c))) {
@@ -299,7 +299,7 @@ static jv f_format(jv input, jv fmt) {
 
     jv line = jv_string("");
     const char* s = jv_string_value(input);
-    for (int i=0; i<jv_string_length(jv_copy(input)); i++) {
+    for (int i=0; i<jv_string_length_bytes(jv_copy(input)); i++) {
       unsigned ch = (unsigned)(unsigned char)*s;
       if (ch < 128 && unreserved[ch]) {
         line = jv_string_append_buf(line, s, 1);
@@ -346,7 +346,7 @@ static jv f_format(jv input, jv fmt) {
     jv line = jv_string("");
     const char b64[64 + 1] = CHARS_ALPHANUM "+/";
     const char* data = jv_string_value(input);
-    int len = jv_string_length(jv_copy(input));
+    int len = jv_string_length_bytes(jv_copy(input));
     for (int i=0; i<len; i+=3) {
       uint32_t code = 0;
       int n = len - i >= 3 ? 3 : len-i;
diff --git a/jq_test.c b/jq_test.c
index c71fdc66..25cea1c6 100644
--- a/jq_test.c
+++ b/jq_test.c
@@ -63,7 +63,7 @@ static void run_jq_tests(FILE *testdata) {
         pass = 0;
       }
       jv as_string = jv_dump_string(jv_copy(expected), rand() & ~JV_PRINT_COLOUR);
-      jv reparsed = jv_parse_sized(jv_string_value(as_string), jv_string_length(jv_copy(as_string)));
+      jv reparsed = jv_parse_sized(jv_string_value(as_string), jv_string_length_bytes(jv_copy(as_string)));
       assert(jv_equal(jv_copy(expected), jv_copy(reparsed)));
       jv_free(as_string);
       jv_free(reparsed);
@@ -191,8 +191,8 @@ static void jv_test() {
     assert(jv_equal(jv_string("foo"), jv_string_sized("foo", 3)));
     char nasty[] = "foo\0";
     jv shortstr = jv_string(nasty), longstr = jv_string_sized(nasty, sizeof(nasty));
-    assert(jv_string_length(shortstr) == (int)strlen(nasty));
-    assert(jv_string_length(longstr) == (int)sizeof(nasty));
+    assert(jv_string_length_bytes(shortstr) == (int)strlen(nasty));
+    assert(jv_string_length_bytes(longstr) == (int)sizeof(nasty));
 
   
     char a1s[] = "hello", a2s[] = "hello", bs[] = "goodbye";
@@ -213,7 +213,7 @@ static void jv_test() {
     for (int i=0; i<(int)sizeof(big); i++) big[i] = 'a';
     big[sizeof(big)-1] = 0;
     jv str = jv_string_fmt("%s", big);
-    assert(jv_string_length(jv_copy(str)) == sizeof(big) - 1);
+    assert(jv_string_length_bytes(jv_copy(str)) == sizeof(big) - 1);
     assert(!strcmp(big, jv_string_value(str)));
     jv_free(str);
   }
diff --git a/jv.c b/jv.c
index b03c024c..9316aec1 100644
--- a/jv.c
+++ b/jv.c
@@ -8,6 +8,7 @@
 
 #include "jv_alloc.h"
 #include "jv.h"
+#include "jv_unicode.h"
 
 /*
  * Internal refcounting helpers
@@ -530,13 +531,23 @@ jv jv_string(const char* str) {
   return jv_string_sized(str, strlen(str));
 }
 
-int jv_string_length(jv j) {
+int jv_string_length_bytes(jv j) {
   assert(jv_get_kind(j) == JV_KIND_STRING);
   int r = jvp_string_length(jvp_string_ptr(&j.val.nontrivial));
   jv_free(j);
   return r;
 }
 
+int jv_string_length_codepoints(jv j) {
+  assert(jv_get_kind(j) == JV_KIND_STRING);
+  const char* i = jv_string_value(j);
+  const char* end = i + jv_string_length_bytes(jv_copy(j));
+  int c = 0, len = 0;
+  while ((i = jvp_utf8_next(i, end, &c))) len++;
+  jv_free(j);
+  return len;
+}
+
 uint32_t jv_string_hash(jv j) {
   assert(jv_get_kind(j) == JV_KIND_STRING);
   uint32_t hash = jvp_string_hash(jvp_string_ptr(&j.val.nontrivial));
diff --git a/jv.h b/jv.h
index a64f3acc..d14e5d78 100644
--- a/jv.h
+++ b/jv.h
@@ -82,7 +82,8 @@ jv jv_array_slice(jv, int, int);
 
 jv jv_string(const char*);
 jv jv_string_sized(const char*, int);
-int jv_string_length(jv);
+int jv_string_length_bytes(jv);
+int jv_string_length_codepoints(jv);
 uint32_t jv_string_hash(jv);
 const char* jv_string_value(jv);
 jv jv_string_concat(jv, jv);
diff --git a/jv_aux.c b/jv_aux.c
index 68811cd0..0c8cd8b7 100644
--- a/jv_aux.c
+++ b/jv_aux.c
@@ -380,8 +380,8 @@ jv jv_delpaths(jv object, jv paths) {
 static int string_cmp(const void* pa, const void* pb){
   const jv* a = pa;
   const jv* b = pb;
-  int lena = jv_string_length(jv_copy(*a));
-  int lenb = jv_string_length(jv_copy(*b));
+  int lena = jv_string_length_bytes(jv_copy(*a));
+  int lenb = jv_string_length_bytes(jv_copy(*b));
   int minlen = lena < lenb ? lena : lenb;
   int r = memcmp(jv_string_value(*a), jv_string_value(*b), minlen);
   if (r == 0) r = lena - lenb;
diff --git a/jv_print.c b/jv_print.c
index fc1370ed..5784337e 100644
--- a/jv_print.c
+++ b/jv_print.c
@@ -45,7 +45,7 @@ static void put_space(int n, FILE* fout, jv* strout) {
 static void jvp_dump_string(jv str, int ascii_only, FILE* F, jv* S) {
   assert(jv_get_kind(str) == JV_KIND_STRING);
   const char* i = jv_string_value(str);
-  const char* end = i + jv_string_length(jv_copy(str));
+  const char* end = i + jv_string_length_bytes(jv_copy(str));
   const char* cstart;
   int c = 0;
   char buf[32];
diff --git a/lexer.l b/lexer.l
index 633b863a..59e527db 100644
--- a/lexer.l
+++ b/lexer.l
@@ -93,7 +93,7 @@ struct lexer_param;
   (\\[^u(]|\\u[a-zA-Z0-9]{0,4})+ {
     /* pass escapes to the json parser */
     jv escapes = jv_string_fmt("\"%.*s\"", yyleng, yytext);
-    yylval->literal = jv_parse_sized(jv_string_value(escapes), jv_string_length(jv_copy(escapes)));
+    yylval->literal = jv_parse_sized(jv_string_value(escapes), jv_string_length_bytes(jv_copy(escapes)));
     jv_free(escapes);
     return QQSTRING_TEXT;
   }
diff --git a/main.c b/main.c
index 77c76548..73359ffe 100644
--- a/main.c
+++ b/main.c
@@ -69,7 +69,7 @@ static void process(jv value, int flags) {
   jv result;
   while (jv_is_valid(result = jq_next(jq))) {
     if ((options & RAW_OUTPUT) && jv_get_kind(result) == JV_KIND_STRING) {
-      fwrite(jv_string_value(result), 1, jv_string_length(jv_copy(result)), stdout);
+      fwrite(jv_string_value(result), 1, jv_string_length_bytes(jv_copy(result)), stdout);
       jv_free(result);
     } else {
       int dumpopts;
diff --git a/tests/all.test b/tests/all.test
index 0119dad6..90ab7db7 100644
--- a/tests/all.test
+++ b/tests/all.test
@@ -302,8 +302,8 @@ null
 [false, false, false, false, false, false, false, false, true ]
 
 [.[] | length]
-[[], {}, [1,2], {"a":42}, "asdf"]
-[0, 0, 2, 1, 4]
+[[], {}, [1,2], {"a":42}, "asdf", "\u03bc"]
+[0, 0, 2, 1, 4, 1]
 
 map(keys)
 [{}, {"abcd":1,"abc":2,"abcde":3}, {"x":1, "z": 3, "y":2}]

From 1e2851cdb3add02948e28ba2e80594794bbcffb3 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 15 May 2013 01:23:06 +0100
Subject: [PATCH 276/284] Remove the YIELD opcode (use RET instead)

---
 compile.c     |  8 +-------
 execute.c     | 31 +++++++++++++++++++++----------
 opcode_list.h |  1 -
 3 files changed, 22 insertions(+), 18 deletions(-)

diff --git a/compile.c b/compile.c
index de9c14c3..d305c5c8 100644
--- a/compile.c
+++ b/compile.c
@@ -507,13 +507,7 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
   int var_frame_idx = 0;
   bc->nsubfunctions = 0;
   errors += expand_call_arglist(locations, &b);
-  if (bc->parent) {
-    // functions should end in a return
-    b = BLOCK(b, gen_op_simple(RET));
-  } else {
-    // the toplevel should YIELD;BACKTRACK; when it finds an answer
-    b = BLOCK(b, gen_op_simple(YIELD), gen_op_simple(BACKTRACK));
-  }
+  b = BLOCK(b, gen_op_simple(RET));
   for (inst* curr = b.first; curr; curr = curr->next) {
     if (!curr->next) assert(curr == b.last);
     int length = opcode_describe(curr->op)->length;
diff --git a/execute.c b/execute.c
index b9d1d31d..f5bd033e 100644
--- a/execute.c
+++ b/execute.c
@@ -26,6 +26,7 @@ struct jq_state {
   jv path;
   int subexp_nest;
   int debug_trace_enabled;
+  int initial_execution;
 };
 
 typedef struct {
@@ -149,7 +150,8 @@ jv jq_next(jq_state *jq) {
   uint16_t* pc = stack_restore(jq);
   assert(pc);
 
-  int backtracking = 0;
+  int backtracking = !jq->initial_execution;
+  jq->initial_execution = 0;
   while (1) {
     uint16_t opcode = *pc;
 
@@ -465,13 +467,6 @@ jv jq_next(jq_state *jq) {
       pc += offset;
       break;
     }
-
-    case YIELD: {
-      jv value = stack_pop(jq);
-      stack_save(jq, pc);
-      stack_switch(jq);
-      return value;
-    }
       
     case CALL_BUILTIN: {
       int nargs = *pc++;
@@ -510,10 +505,25 @@ jv jq_next(jq_state *jq) {
     }
 
     case RET: {
-      pc = *frame_current_retaddr(&jq->frame_stk);
-      frame_pop(&jq->frame_stk);
+      uint16_t* retaddr = *frame_current_retaddr(&jq->frame_stk);
+      if (retaddr) {
+        // function return
+        pc = retaddr;
+        frame_pop(&jq->frame_stk);
+      } else {
+        // top-level return, yielding value
+        jv value = stack_pop(jq);
+        stack_save(jq, pc - 1);
+        stack_push(jq, jv_null());
+        stack_switch(jq);
+        return value;
+      }
       break;
     }
+    case ON_BACKTRACK(RET): {
+      // resumed after top-level return
+      goto do_backtrack;
+    }
     }
   }
 }
@@ -538,6 +548,7 @@ void jq_init(struct bytecode* bc, jv input, jq_state **jq, int flags) {
   } else {
     new_jq->debug_trace_enabled = 0;
   }
+  new_jq->initial_execution = 1;
   *jq = new_jq;
 }
 
diff --git a/opcode_list.h b/opcode_list.h
index 38206871..14450c51 100644
--- a/opcode_list.h
+++ b/opcode_list.h
@@ -5,7 +5,6 @@ OP(POP,   NONE,     1, 0)
 OP(LOADV, VARIABLE, 1, 1)
 OP(STOREV, VARIABLE, 1, 0)
 OP(INDEX, NONE,     2, 1)
-OP(YIELD, NONE, 1, 0)
 OP(EACH,  NONE,     1, 1)
 OP(FORK,  BRANCH,   0, 0)
 OP(JUMP,  BRANCH,   0, 0)

From f8644c31a3e6f4c3d9a95837c22a18fd27155510 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Wed, 15 May 2013 01:37:15 +0100
Subject: [PATCH 277/284] Only generate code for those builtin functions
 actually used.

Makes output of --debug-dump-disasm much simpler.
---
 builtin.c |  4 ++--
 compile.c | 24 +++++++++++++++++++++---
 compile.h |  1 +
 3 files changed, 24 insertions(+), 5 deletions(-)

diff --git a/builtin.c b/builtin.c
index 0b797142..47c13865 100644
--- a/builtin.c
+++ b/builtin.c
@@ -543,7 +543,7 @@ static block bind_bytecoded_builtins(block b) {
                                             range));
   }
   
-  return block_bind(builtins, b, OP_IS_CALL_PSEUDO);
+  return block_bind_referenced(builtins, b, OP_IS_CALL_PSEUDO);
 }
 
 static const char* const jq_builtins[] = {
@@ -572,7 +572,7 @@ block builtins_bind(block b) {
     block funcs;
     int nerrors = jq_parse_library(&src, &funcs);
     assert(!nerrors);
-    b = block_bind(funcs, b, OP_IS_CALL_PSEUDO);
+    b = block_bind_referenced(funcs, b, OP_IS_CALL_PSEUDO);
     locfile_free(&src);
   }
   b = bind_bytecoded_builtins(b);
diff --git a/compile.c b/compile.c
index d305c5c8..6c1e8f87 100644
--- a/compile.c
+++ b/compile.c
@@ -216,13 +216,14 @@ int block_has_only_binders(block binders, int bindflags) {
   return 1;
 }
 
-static void block_bind_subblock(block binder, block body, int bindflags) {
+static int block_bind_subblock(block binder, block body, int bindflags) {
   assert(block_is_single(binder));
   assert((opcode_describe(binder.first->op)->flags & bindflags) == bindflags);
   assert(binder.first->symbol);
   assert(binder.first->bound_by == 0 || binder.first->bound_by == binder.first);
 
   binder.first->bound_by = binder.first;
+  int nrefs = 0;
   for (inst* i = body.first; i; i = i->next) {
     int flags = opcode_describe(i->op)->flags;
     if ((flags & bindflags) == bindflags &&
@@ -230,12 +231,14 @@ static void block_bind_subblock(block binder, block body, int bindflags) {
         !strcmp(i->symbol, binder.first->symbol)) {
       // bind this instruction
       i->bound_by = binder.first;
+      nrefs++;
     }
     // binding recurses into closures
-    block_bind_subblock(binder, i->subfn, bindflags);
+    nrefs += block_bind_subblock(binder, i->subfn, bindflags);
     // binding recurses into argument list
-    block_bind_subblock(binder, i->arglist, bindflags);
+    nrefs += block_bind_subblock(binder, i->arglist, bindflags);
   }
+  return nrefs;
 }
 
 static void block_bind_each(block binder, block body, int bindflags) {
@@ -251,6 +254,21 @@ block block_bind(block binder, block body, int bindflags) {
   return block_join(binder, body);
 }
 
+block block_bind_referenced(block binder, block body, int bindflags) {
+  assert(block_has_only_binders(binder, bindflags));
+  bindflags |= OP_HAS_BINDING;
+  block refd = gen_noop();
+  for (inst* curr; (curr = block_take(&binder));) {
+    block b = inst_block(curr);
+    if (block_bind_subblock(b, body, bindflags)) {
+      refd = BLOCK(refd, b);
+    } else {
+      block_free(b);
+    }
+  }
+  return block_join(refd, body);
+}
+
 block gen_function(const char* name, block formals, block body) {
   block_bind_each(formals, body, OP_IS_CALL_PSEUDO);
   inst* i = inst_new(CLOSURE_CREATE);
diff --git a/compile.h b/compile.h
index 00a863c6..f3f70b44 100644
--- a/compile.h
+++ b/compile.h
@@ -50,6 +50,7 @@ void block_append(block* b, block b2);
 block block_join(block a, block b);
 int block_has_only_binders(block, int bindflags);
 block block_bind(block binder, block body, int bindflags);
+block block_bind_referenced(block binder, block body, int bindflags);
 
 int block_compile(block, struct locfile*, struct bytecode**);
 

From a1e4dfa32412457e03dd0e4e4c2ac17eca02c4f8 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 16 May 2013 00:51:17 +0100
Subject: [PATCH 278/284] Better debug info for struct bytecode.

--debug-dump-disasm produces more comprehensible output now.
---
 bytecode.c | 51 +++++++++++++++++++++++++++++++++++++++++++++------
 bytecode.h |  3 +++
 compile.c  | 11 +++++++++++
 3 files changed, 59 insertions(+), 6 deletions(-)

diff --git a/bytecode.c b/bytecode.c
index 39381204..b5703a9a 100644
--- a/bytecode.c
+++ b/bytecode.c
@@ -16,12 +16,24 @@ static int bytecode_operation_length(uint16_t* codeptr) {
 
 void dump_disassembly(int indent, struct bytecode* bc) {
   if (bc->nclosures > 0) {
-    printf("%*s[params: %d]\n", indent, "", bc->nclosures);
+    printf("%*s[params: ", indent, "");
+    jv params = jv_object_get(jv_copy(bc->debuginfo), jv_string("params"));
+    for (int i=0; i<bc->nclosures; i++) {
+      if (i) printf(", ");
+      jv name = jv_array_get(jv_copy(params), i);
+      printf("%s", jv_string_value(name));
+      jv_free(name);
+    }
+    jv_free(params);
+    printf("]\n");
   }
   dump_code(indent, bc);
   for (int i=0; i<bc->nsubfunctions; i++) {
-    printf("%*ssubfn[%d]:\n", indent, "", i);
-    dump_disassembly(indent+2, bc->subfunctions[i]);
+    struct bytecode* subfn = bc->subfunctions[i];
+    jv name = jv_object_get(jv_copy(subfn->debuginfo), jv_string("name"));
+    printf("%*s%s:%d:\n", indent, "", jv_string_value(name), i);
+    jv_free(name);
+    dump_disassembly(indent+2, subfn);
   }
 }
 
@@ -35,6 +47,14 @@ void dump_code(int indent, struct bytecode* bc) {
   }
 }
 
+static struct bytecode* getlevel(struct bytecode* bc, int level) {
+  while (level > 0) {
+    bc = bc->parent;
+    level--;
+  }
+  return bc;
+}
+
 void dump_operation(struct bytecode* bc, uint16_t* codeptr) {
   int pc = codeptr - bc->code;
   printf("%04d ", pc);
@@ -46,15 +66,28 @@ void dump_operation(struct bytecode* bc, uint16_t* codeptr) {
       for (int i=0; i<imm+1; i++) {
         uint16_t level = bc->code[pc++];
         uint16_t idx = bc->code[pc++];
+        jv name;
         if (idx & ARG_NEWCLOSURE) {
-          printf(" subfn[%d]", idx & ~ARG_NEWCLOSURE);
+          idx &= ~ARG_NEWCLOSURE;
+          name = jv_object_get(jv_copy(getlevel(bc,level)->subfunctions[idx]->debuginfo), 
+                               jv_string("name"));
         } else {
-          printf(" param[%d]", idx);
+          name = jv_array_get(jv_object_get(jv_copy(getlevel(bc,level)->debuginfo), 
+                                            jv_string("params")), idx);
         }
+        printf(" %s:%d",
+               jv_string_value(name),
+               idx);
+        jv_free(name);
         if (level) {
           printf("^%d", level);
         }
       }
+    } else if (op->op == CALL_BUILTIN) {
+      int func = bc->code[pc++];
+      jv name = jv_array_get(jv_copy(bc->globals->cfunc_names), func);
+      printf(" %s", jv_string_value(name));
+      jv_free(name);
     } else if (op->flags & OP_HAS_BRANCH) {
       printf(" %04d", pc + imm);
     } else if (op->flags & OP_HAS_CONSTANT) {
@@ -62,7 +95,11 @@ void dump_operation(struct bytecode* bc, uint16_t* codeptr) {
       jv_dump(jv_array_get(jv_copy(bc->constants), imm), 0);
     } else if (op->flags & OP_HAS_VARIABLE) {
       uint16_t v = bc->code[pc++];
-      printf(" v%d", v);
+      jv name = jv_array_get(jv_object_get(jv_copy(getlevel(bc,imm)->debuginfo), jv_string("locals")), v);
+      printf(" $%s:%d", 
+             jv_string_value(name), 
+             v);
+      jv_free(name);
       if (imm) {
         printf("^%d", imm);
       }
@@ -74,6 +111,7 @@ void dump_operation(struct bytecode* bc, uint16_t* codeptr) {
 
 void symbol_table_free(struct symbol_table* syms) {
   jv_mem_free(syms->cfunctions);
+  jv_free(syms->cfunc_names);
   jv_mem_free(syms);
 }
 
@@ -85,5 +123,6 @@ void bytecode_free(struct bytecode* bc) {
   if (!bc->parent)
     symbol_table_free(bc->globals);
   jv_mem_free(bc->subfunctions);
+  jv_free(bc->debuginfo);
   jv_mem_free(bc);
 }
diff --git a/bytecode.h b/bytecode.h
index e84f1387..c742cdd9 100644
--- a/bytecode.h
+++ b/bytecode.h
@@ -10,6 +10,7 @@
 struct symbol_table {
   struct cfunction* cfunctions;
   int ncfunctions;
+  jv cfunc_names;
 };
 
 // The bytecode format matters in:
@@ -33,6 +34,8 @@ struct bytecode {
   int nsubfunctions;
 
   struct bytecode* parent;
+
+  jv debuginfo;
 };
 
 void dump_disassembly(int, struct bytecode* code);
diff --git a/compile.c b/compile.c
index 6c1e8f87..1f8be905 100644
--- a/compile.c
+++ b/compile.c
@@ -526,6 +526,7 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
   bc->nsubfunctions = 0;
   errors += expand_call_arglist(locations, &b);
   b = BLOCK(b, gen_op_simple(RET));
+  jv localnames = jv_array();
   for (inst* curr = b.first; curr; curr = curr->next) {
     if (!curr->next) assert(curr == b.last);
     int length = opcode_describe(curr->op)->length;
@@ -543,6 +544,7 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
     if ((opcode_describe(curr->op)->flags & OP_HAS_VARIABLE) &&
         curr->bound_by == curr) {
       curr->imm.intval = var_frame_idx++;
+      localnames = jv_array_append(localnames, jv_string(curr->symbol));
     }
 
     if (curr->op == CLOSURE_CREATE) {
@@ -552,10 +554,13 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
     if (curr->op == CLOSURE_CREATE_C) {
       assert(curr->bound_by == curr);
       int idx = bc->globals->ncfunctions++;
+      bc->globals->cfunc_names = jv_array_append(bc->globals->cfunc_names,
+                                                 jv_string(curr->symbol));
       bc->globals->cfunctions[idx] = *curr->imm.cfunc;
       curr->imm.intval = idx;
     }
   }
+  bc->debuginfo = jv_object_set(bc->debuginfo, jv_string("locals"), localnames);
   if (bc->nsubfunctions) {
     bc->subfunctions = jv_mem_alloc(sizeof(struct bytecode*) * bc->nsubfunctions);
     for (inst* curr = b.first; curr; curr = curr->next) {
@@ -565,12 +570,16 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
         subfn->globals = bc->globals;
         subfn->parent = bc;
         subfn->nclosures = 0;
+        subfn->debuginfo = jv_object_set(jv_object(), jv_string("name"), jv_string(curr->symbol));
+        jv params = jv_array();
         for (inst* param = curr->arglist.first; param; param = param->next) {
           assert(param->op == CLOSURE_PARAM);
           assert(param->bound_by == param);
           param->imm.intval = subfn->nclosures++;
           param->compiled = subfn;
+          params = jv_array_append(params, jv_string(param->symbol));
         }
+        subfn->debuginfo = jv_object_set(subfn->debuginfo, jv_string("params"), params);
         errors += compile(locations, subfn, curr->subfn);
         curr->subfn = gen_noop();
       }
@@ -638,6 +647,8 @@ int block_compile(block b, struct locfile* locations, struct bytecode** out) {
   int ncfunc = count_cfunctions(b);
   bc->globals->ncfunctions = 0;
   bc->globals->cfunctions = jv_mem_alloc(sizeof(struct cfunction) * ncfunc);
+  bc->globals->cfunc_names = jv_array();
+  bc->debuginfo = jv_object_set(jv_object(), jv_string("name"), jv_null());
   int nerrors = compile(locations, bc, b);
   assert(bc->globals->ncfunctions == ncfunc);
   if (nerrors > 0) {

From 919292764a1ba57507ab4c93e732d2037a2ffa14 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 16 May 2013 14:25:28 +0100
Subject: [PATCH 279/284] Reverse function. Closes #94.

---
 builtin.c                        |  1 +
 docs/content/3.manual/manual.yml | 10 ++++++++++
 2 files changed, 11 insertions(+)

diff --git a/builtin.c b/builtin.c
index 47c13865..48d71109 100644
--- a/builtin.c
+++ b/builtin.c
@@ -562,6 +562,7 @@ static const char* const jq_builtins[] = {
   "def to_entries: [keys[] as $k | {key: $k, value: .[$k]}];",
   "def from_entries: map({(.key): .value}) | add;",
   "def with_entries(f): to_entries | map(f) | from_entries;",
+  "def reverse: [.[length - 1 - range(0;length)]];",
 };
 
 
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index e5fff391..7038b5fc 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -718,6 +718,16 @@ sections:
             input: '[1,2,5,3,5,3,1,3]'
             output: ['[1,2,3,5]']
 
+      - title: `reverse`
+        body: |
+          
+          This function reverses an array.
+
+        examples:
+          - program: 'reverse'
+            input: '[1,2,3,4]'
+            output: ['[4,3,2,1]']
+
       - title: `contains`
         body: |
 

From 8fbee891b305180bdce956fde177604782c3cdc0 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 16 May 2013 14:32:18 +0100
Subject: [PATCH 280/284] Add LOADVN opcode.

Does a variable load, but sets the variable to be null afterwards.
---
 execute.c     | 17 +++++++++++++++++
 opcode_list.h |  1 +
 2 files changed, 18 insertions(+)

diff --git a/execute.c b/execute.c
index f5bd033e..8d6e76a9 100644
--- a/execute.c
+++ b/execute.c
@@ -311,6 +311,23 @@ jv jq_next(jq_state *jq) {
       break;
     }
 
+      // Does a load but replaces the variable with null
+    case LOADVN: {
+      uint16_t level = *pc++;
+      uint16_t v = *pc++;
+      frame_ptr fp = frame_get_level(&jq->frame_stk, frame_current(&jq->frame_stk), level);
+      jv* var = frame_local_var(fp, v);
+      if (jq->debug_trace_enabled) {
+        printf("V%d = ", v);
+        jv_dump(jv_copy(*var), 0);
+        printf("\n");
+      }
+      jv_free(stack_pop(jq));
+      stack_push(jq, *var);
+      *var = jv_null();
+      break;
+    }
+
     case STOREV: {
       uint16_t level = *pc++;
       uint16_t v = *pc++;
diff --git a/opcode_list.h b/opcode_list.h
index 14450c51..c9730bae 100644
--- a/opcode_list.h
+++ b/opcode_list.h
@@ -3,6 +3,7 @@ OP(DUP,   NONE,     1, 2)
 OP(DUP2,  NONE,     2, 3)
 OP(POP,   NONE,     1, 0)
 OP(LOADV, VARIABLE, 1, 1)
+OP(LOADVN, VARIABLE, 1, 1)
 OP(STOREV, VARIABLE, 1, 0)
 OP(INDEX, NONE,     2, 1)
 OP(EACH,  NONE,     1, 1)

From bc42812715fb56e72717bf18809dd9ba59771b3a Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 16 May 2013 15:07:53 +0100
Subject: [PATCH 281/284] Remove the insane "fold" operation, replace with
 saner "reduce".

---
 builtin.c                        |  6 +++---
 compile.c                        | 23 ++++++++++++++-------
 compile.h                        |  2 +-
 docs/content/3.manual/manual.yml | 34 +++++++++++---------------------
 lexer.l                          |  2 +-
 parser.y                         |  6 +++---
 tests/all.test                   |  2 +-
 7 files changed, 37 insertions(+), 38 deletions(-)

diff --git a/builtin.c b/builtin.c
index 48d71109..071cb564 100644
--- a/builtin.c
+++ b/builtin.c
@@ -554,10 +554,10 @@ static const char* const jq_builtins[] = {
   "def unique: group_by(.) | map(.[0]);",
   "def max_by(f): _max_by_impl(map([f]));",
   "def min_by(f): _min_by_impl(map([f]));",
-  "def add: fold null as $sum (.[] | $sum + .);",
+  "def add: reduce .[] as $x (null; . + $x);",
   "def del(f): delpaths([path(f)]);",
-  "def _assign(paths; value): value as $v | fold . as $obj (path(paths) as $p | $obj | setpath($p; $v));",
-  "def _modify(paths; update): fold . as $obj (path(paths) as $p | $obj | setpath($p; getpath($p) | update));",
+  "def _assign(paths; value): value as $v | reduce path(paths) as $p (.; setpath($p; $v));",
+  "def _modify(paths; update): reduce path(paths) as $p (.; setpath($p; getpath($p) | update));",
   "def recurse(f): ., (f | select(. != null) | recurse(f));",
   "def to_entries: [keys[] as $k | {key: $k, value: .[$k]}];",
   "def from_entries: map({(.key): .value}) | add;",
diff --git a/compile.c b/compile.c
index 1f8be905..95cd59e5 100644
--- a/compile.c
+++ b/compile.c
@@ -320,15 +320,24 @@ block gen_collect(block expr) {
                gen_op_var_bound(LOADV, array_var));
 }
 
-block gen_fold(const char* varname, block init, block fold) {
-  block loop = BLOCK(fold, gen_op_var_unbound(STOREV, varname), gen_op_simple(BACKTRACK));
+block gen_reduce(const char* varname, block source, block init, block body) {
+  block res_var = block_bind(gen_op_var_unbound(STOREV, "reduce"),
+                             gen_noop(), OP_HAS_VARIABLE);
+
+  block loop = BLOCK(gen_op_simple(DUP),
+                     source,
+                     block_bind(gen_op_var_unbound(STOREV, varname),
+                                BLOCK(gen_op_var_bound(LOADVN, res_var),
+                                      body,
+                                      gen_op_var_bound(STOREV, res_var)),
+                                OP_HAS_VARIABLE),
+                     gen_op_simple(BACKTRACK));
   return BLOCK(gen_op_simple(DUP),
                init,
-               block_bind(gen_op_var_unbound(STOREV, varname),
-                          BLOCK(gen_op_target(FORK, loop),
-                                loop,
-                                gen_op_var_unbound(LOADV, varname)),
-                          OP_HAS_VARIABLE));
+               res_var,
+               gen_op_target(FORK, loop),
+               loop,
+               gen_op_var_bound(LOADVN, res_var));
 }
 
 block gen_definedor(block a, block b) {
diff --git a/compile.h b/compile.h
index f3f70b44..152384a7 100644
--- a/compile.h
+++ b/compile.h
@@ -34,7 +34,7 @@ block gen_call(const char* name, block body);
 block gen_subexp(block a);
 block gen_both(block a, block b);
 block gen_collect(block expr);
-block gen_fold(const char* varname, block init, block body);
+block gen_reduce(const char* varname, block source, block init, block body);
 block gen_definedor(block a, block b);
 block gen_condbranch(block iftrue, block iffalse);
 block gen_and(block a, block b);
diff --git a/docs/content/3.manual/manual.yml b/docs/content/3.manual/manual.yml
index 7038b5fc..9b8a7b4a 100644
--- a/docs/content/3.manual/manual.yml
+++ b/docs/content/3.manual/manual.yml
@@ -1016,7 +1016,7 @@ sections:
       (many jq functions such as `map` and `find` are in fact written
       in jq).
 
-      Finally, jq has a `fold` operation, which is very powerful but a
+      Finally, jq has a `reduce` operation, which is very powerful but a
       bit tricky. Again, it's mostly used internally, to define some
       useful bits of jq's standard library.
 
@@ -1126,36 +1126,26 @@ sections:
             input: '[[1,2],[10,20]]'
             output: ['[[1,2,1,2], [10,20,1,2]]']
 
-      - title: Fold
+      - title: Reduce
         body: |
         
-          The `fold` syntax in jq allows you to combine all of the
+          The `reduce` syntax in jq allows you to combine all of the
           results of an expression by accumulating them into a single
           answer. As an example, we'll pass `[3,2,1]` to this expression:
 
-              fold 0 as $sum (.[] | $sum + .)
+              reduce .[] as $item (0; . + $item)
           
-          The variable `$sum` is first given the value `0`. The body
-          of the fold (i.e. `.[] | $sum + .`) is evaluated. `.[]`
-          produces three results, `3`, `2`, and `1`. For the first
-          one, `$sum + .` gives `3`.
+          For each result that `.[]` produces, `. + $item` is run to
+          accumulate a running total, starting from 0. In this
+          example, `.[]` produces the results 3, 2, and 1, so the
+          effect is similar to running something like this:
 
-          Having produced this answer, jq backtracks to find the next
-          result as per usual. However, this time, `$sum` is set to
-          the previous value of the body, so `$sum + .` gives
-          `5`. After the final backtracking, `$sum + .` gives
-          `6`. This final value is used as the value of the entire
-          `fold` expression, so the above filter returns `6`.
-
-          More formally, in order to evaluate `fold INIT as $VAR
-          (BODY)`, jq first sets `$VAR` to the value of `INIT`. It
-          then runs through `BODY`. Each time `BODY` produces a value,
-          `$VAR` is set to that value and jq backtracks to find the
-          next one. When `BODY` stops producing values, the final
-          value of `$VAR` is the result of the entire expression.
+              0 | (3 as $item | . + $item) | 
+                  (2 as $item | . + $item) |
+                  (1 as $item | . + $item)
 
         examples:
-          - program: 'fold 0 as $sum (.[] | $sum + .)'
+          - program: 'reduce .[] as $item (0; . + $item)'
             input: '[10,2,5,3]'
             output: ['20']
       
diff --git a/lexer.l b/lexer.l
index 59e527db..3000bafa 100644
--- a/lexer.l
+++ b/lexer.l
@@ -49,7 +49,7 @@ struct lexer_param;
 "and" { return AND; }
 "or" { return OR; }
 "end" { return END; }
-"fold" { return FOLD; }
+"reduce" { return REDUCE; }
 "//" { return DEFINEDOR; }
 "|=" { return SETPIPE; }
 "+=" { return SETPLUS; }
diff --git a/parser.y b/parser.y
index 592a428b..bc703e92 100644
--- a/parser.y
+++ b/parser.y
@@ -58,7 +58,7 @@ struct lexer_param;
 %token THEN "then"
 %token ELSE "else"
 %token ELSE_IF "elif"
-%token FOLD "fold"
+%token REDUCE "reduce"
 %token END "end"
 %token AND "and"
 %token OR "or"
@@ -226,8 +226,8 @@ Term "as" '$' IDENT '|' Exp {
   jv_free($4);
 } |
 
-"fold" Term "as" '$' IDENT '(' Exp ')' {
-  $$ = gen_fold(jv_string_value($5), $2, $7);
+"reduce" Term "as" '$' IDENT '(' Exp ';' Exp ')' {
+  $$ = gen_reduce(jv_string_value($5), $2, $7, $9);
   jv_free($5);
 } |
 
diff --git a/tests/all.test b/tests/all.test
index 90ab7db7..cc97961f 100644
--- a/tests/all.test
+++ b/tests/all.test
@@ -379,7 +379,7 @@ def fac: if . == 1 then 1 else . * (. - 1 | fac) end; [.[] | fac]
 # []
 # 1001
 
-fold 0 as $s (.[] | $s + .)
+reduce .[] as $x (0; . + $x)
 [1,2,4]
 7
 

From 9b91eafac4df406e48348e2cb0baf6fcb998a6fa Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Thu, 16 May 2013 15:09:59 +0100
Subject: [PATCH 282/284] Make array construction use LOADVN (slightly faster)

---
 compile.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compile.c b/compile.c
index 95cd59e5..bf4f92fd 100644
--- a/compile.c
+++ b/compile.c
@@ -317,7 +317,7 @@ block gen_collect(block expr) {
                gen_op_target(FORK, tail),
                expr, 
                tail,
-               gen_op_var_bound(LOADV, array_var));
+               gen_op_var_bound(LOADVN, array_var));
 }
 
 block gen_reduce(const char* varname, block source, block init, block body) {

From fd1ac5dd791f5a9ec618b8a0eba5c39cec13b6de Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Fri, 17 May 2013 22:49:08 +0100
Subject: [PATCH 283/284] EACH need not make a backtrack point on the last
 iteration

---
 execute.c | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/execute.c b/execute.c
index 8d6e76a9..fe8e6985 100644
--- a/execute.c
+++ b/execute.c
@@ -423,12 +423,14 @@ jv jq_next(jq_state *jq) {
       int idx = jv_number_value(stack_pop(jq));
       jv container = stack_pop(jq);
 
-      int keep_going;
+      int keep_going, is_last = 0;
       jv key, value;
       if (jv_get_kind(container) == JV_KIND_ARRAY) {
         if (opcode == EACH) idx = 0;
         else idx = idx + 1;
-        keep_going = idx < jv_array_length(jv_copy(container));
+        int len = jv_array_length(jv_copy(container));
+        keep_going = idx < len;
+        is_last = idx == len - 1;
         if (keep_going) {
           key = jv_number(idx);
           value = jv_array_get(jv_copy(container), idx);
@@ -451,6 +453,11 @@ jv jq_next(jq_state *jq) {
       if (!keep_going) {
         jv_free(container);
         goto do_backtrack;
+      } else if (is_last) {
+        // we don't need to make a backtrack point
+        jv_free(container);
+        path_append(jq, key);
+        stack_push(jq, value);
       } else {
         stack_save(jq, pc - 1);
         stack_push(jq, container);

From 0535e724a274818f0ef7fab74d5a59a32fd78ac9 Mon Sep 17 00:00:00 2001
From: Stephen Dolan <mu@netsoc.tcd.ie>
Date: Sun, 19 May 2013 10:48:25 +0100
Subject: [PATCH 284/284] jq 1.3 release

---
 Makefile.am                         |  2 +-
 configure.ac                        |  2 +-
 docs/content/2.download/default.yml | 20 ++++++++++++++++----
 docs/content/index/index.yml        |  9 ++++++++-
 docs/public/css/base.scss           |  7 +++++++
 docs/site.yml                       |  2 +-
 docs/templates/default.liquid       |  2 +-
 docs/templates/index.liquid         | 10 ++++++++++
 8 files changed, 45 insertions(+), 9 deletions(-)

diff --git a/Makefile.am b/Makefile.am
index be8e9140..34152056 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -77,7 +77,7 @@ endif
 ### Packaging
 
 docs/site.yml: configure.ac
-	sed 's/^jq_version: .*/jq_version: $(VERSION)/' $@ > $@.new
+	sed 's/^jq_version: .*/jq_version: "$(VERSION)"/' $@ > $@.new
 	mv $@.new $@
 
 install-binaries: $(BUILT_SOURCES)
diff --git a/configure.ac b/configure.ac
index 0ad893af..1ee3ad7d 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1,4 +1,4 @@
-AC_INIT([jq], [1.2], [mu@netsoc.tcd.ie],
+AC_INIT([jq], [1.3], [mu@netsoc.tcd.ie],
              [jq], [http://stedolan.github.com/jq/])
 
 dnl Created autoconf implementation thompson@dtosolutions, 26NOV12
diff --git a/docs/content/2.download/default.yml b/docs/content/2.download/default.yml
index 502ef0b4..c7faa1e9 100644
--- a/docs/content/2.download/default.yml
+++ b/docs/content/2.download/default.yml
@@ -27,7 +27,7 @@ body:
          manually by following instructions on [Arch Linux's
          Wiki](https://wiki.archlinux.org/index.php/Arch_UseRepository).
 
-       * Debian/Ubuntu packages are coming Real Soon Now.
+       * jq 1.2 is [in Debian](http://packages.debian.org/jq)
 
       ### OS X
 
@@ -42,18 +42,28 @@ body:
 
       ### From source on Linux or OS X
 
+       * [Source tarball for jq $JQ_VERSION](source/jq-$JQ_VERSION.tar.gz)
+
+      You can build it using the usual `./configure && make && sudo
+      make install` rigmarole.
+
+      If you're interested in using the lastest development version, try:
+
           git clone https://github.com/stedolan/jq.git
           cd jq
-          make && sudo make install
+          autoreconf
+          ./configure
+          make
+          sudo make install
 
       To build it from a git clone, you'll need to install a few
       packages first:
 
        * [Flex](http://www.gnu.org/software/flex/)
        * [Bison](http://www.gnu.org/software/bison/)
-       * [Python](http://www.python.org)
        * [GCC](http://gcc.gnu.org)
        * [Make](http://www.gnu.org/software/make)
+       * [Autotools](http://www.gnu.org/software/automake)
 
       For Linux systems, these will all be in your system's package
       manager, and if you do development on the machine they're most
@@ -73,6 +83,8 @@ body:
 
       jq's documentation is compiled into static HTML using
       [Bonsai](http://www.tinytree.info). To view the documentation
-      locally, run `rake serve` from the docs/ subdirectory.
+      locally, run `rake serve` from the docs/ subdirectory. You'll
+      need a few Ruby dependencies, which can be installed by
+      following the instructions in `docs/README.md`.
 
 
diff --git a/docs/content/index/index.yml b/docs/content/index/index.yml
index 6b6faf35..096fbeda 100644
--- a/docs/content/index/index.yml
+++ b/docs/content/index/index.yml
@@ -24,4 +24,11 @@ body3: |
   
 tail: |
   Go read the [tutorial](tutorial/) for more, or the [manual](manual/)
-  for *way* more.
\ No newline at end of file
+  for *way* more.
+
+news:
+  - date: 2013-05-19
+    body: |
+      
+      jq 1.3 (finally) released! Get it on the [download](download/) page.
+
diff --git a/docs/public/css/base.scss b/docs/public/css/base.scss
index 260f8309..9f58d944 100644
--- a/docs/public/css/base.scss
+++ b/docs/public/css/base.scss
@@ -89,4 +89,11 @@ h3 code {
 
 footer {
     text-align: center;
+}
+
+#news {
+    font-size: 12pt;
+    .date {
+          font-style: italic;
+    }
 }
\ No newline at end of file
diff --git a/docs/site.yml b/docs/site.yml
index 37f82cf3..058bd4ce 100644
--- a/docs/site.yml
+++ b/docs/site.yml
@@ -4,7 +4,7 @@
 
 # This line is modified by the Makefile. To change the version number,
 # edit the Autoconf version number at the top of configure.ac
-jq_version: 1.2
+jq_version: "1.3"
 
 root: '/jq'
 footer: |
diff --git a/docs/templates/default.liquid b/docs/templates/default.liquid
index eb2ebbb8..c49de1c3 100644
--- a/docs/templates/default.liquid
+++ b/docs/templates/default.liquid
@@ -10,7 +10,7 @@
         <h1>{{headline}}</h1>
         {% for item in body %}
           {% if item.text %}
-            {{ item.text | markdownify }}
+            {{ item.text | replace: '$JQ_VERSION', jq_version | markdownify }}
           {% endif %}
         
           {% if item.command %}
diff --git a/docs/templates/index.liquid b/docs/templates/index.liquid
index 4165c766..6ee88bbf 100644
--- a/docs/templates/index.liquid
+++ b/docs/templates/index.liquid
@@ -35,6 +35,16 @@
       <div class="row" style="text-align:center; margin-top: 30px">
         {{tail | markdownify}}
       </div>
+      <div class="row">
+        <h2>News</h2>
+        <div id="news">
+          <ul>
+            {% for item in news %}
+            <li><span class="date">{{ item.date | date: '%m %B %Y' }}</span>{{item.body | markdownify}}</li>
+            {% endfor %}
+          </ul>
+        </div>
+      </div>
     </div>
     {% include "shared/footer" %}    
   </body>