HPDA_review.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Demo of Myria as a Federated Database\n",
    "\n",
    "\n",
    "### Setup steps:\n",
    "* Install Raco:\n",
    "    * Follow the steps listed on https://github.com/uwescience/raco/tree/SPJA_federation#setup to set up RACO.\n",
    "* Install SPARK:\n",
    "    * Download the prebuilt HADOOP version from http://spark.apache.org/downloads.html and follow the setup steps on SPARK website to verify if it works. (Make sure you have all the dependencies listed on the page installed)\n",
    "    * Set the SPARK_HOME environment variable to the downloaded SPARK folder and add it to PATH\n",
    "        * On mac, this can be done by adding the following lines to bash_profile or bashrc file:\n",
    "`\n",
    "export SPARK_HOME=</path/to/spark>\n",
    "export PATH=$SPARK_HOME/bin:$PATH\n",
    "`\n",
    "\n",
    "* Install jupyter:\n",
    "    * on mac, this can be done via: `pip install jupyter`\n",
    "    \n",
    "* Run `ipython notebook` command. And browse to this notebook. \n",
    "\n",
    "* Update the path to the input dataset in the code below^: \n",
    "`\n",
    "matA = scan('/path/to/datafile');\n",
    "`\n",
    "\n",
    "^ (As a sample, you can download and use https://github.com/uwescience/raco/blob/SPJA_federation/demo/sample.dat)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import time\n",
    "import os\n",
    "import raco.viz\n",
    "\n",
    "import findspark\n",
    "findspark.init()\n",
    "findspark.add_packages('com.databricks:spark-csv_2.10:1.4.0')\n",
    "\n",
    "from raco.backends.spark.connection import SparkConnection\n",
    "from raco.backends.spark.catalog import SparkCatalog\n",
    "from raco.backends.spark.algebra import SparkAlgebra\n",
    "\n",
    "from raco.backends.logical import OptLogicalAlgebra\n",
    "from raco.catalog import FromFileCatalog\n",
    "import raco.myrial.interpreter as interpreter\n",
    "import raco.myrial.parser as myrialparser\n",
    "\n",
    "from raco.backends.myria import MyriaLeftDeepTreeAlgebra\n",
    "from raco.backends.myria.connection import MyriaConnection\n",
    "from raco.backends.myria.catalog import MyriaCatalog\n",
    "\n",
    "from raco.backends.federated.connection import FederatedConnection\n",
    "from raco.backends.federated.catalog import FederatedCatalog\n",
    "from raco.backends.federated.algebra import FederatedAlgebra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "masterHostname = os.environ.get('sparkurl', 'localhost')\n",
    "def get_myria_connection():\n",
    "    execution_url = os.environ.get('MYRIAX_REST_HOST', 'localhost')\n",
    "    connection = MyriaConnection(hostname=execution_url, port=8753)\n",
    "    return connection\n",
    "\n",
    "def get_spark_connection():\n",
    "    masterHostname = os.environ.get('sparkurl', 'localhost')\n",
    "    if masterHostname == 'localhost':\n",
    "        return SparkConnection(masterHostname)\n",
    "    return SparkConnection(\"spark://{masterHostname}:7077\".format(masterHostname=masterHostname))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "##Initialize Backend 1\n",
    "myriaconn = get_myria_connection()\n",
    "myriacatalog = MyriaCatalog(myriaconn)\n",
    "\n",
    "##Initialize Backend 2\n",
    "sparkconn = get_spark_connection()\n",
    "sparkcatalog = SparkCatalog.load_from_file(os.path.join(os.path.abspath('./examples/'), 'catalog.py'))\n",
    "\n",
    "##Initialize Federated Backend\n",
    "fed_conn = FederatedConnection([myriaconn, sparkconn])\n",
    "fed_catalog = FederatedCatalog([myriacatalog, sparkcatalog])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "##The Jaccard Computation expressed as MyriaL query\n",
    "program_fquery=\"\"\"\n",
    "-- Scan netflow data (this resides in Accumulo)\n",
    "NF = scan(netflow);\n",
    "-- Filter the dataset (runs on Accumulo)\n",
    "NFSUB = select SrcAddr as src_ip, DstAddr as dst_ip, 1.0 as value from NF where TotBytes > 100;\n",
    "-- Scan DNS dataset (this is accessible to Spark)\n",
    "DNS = scan('/Users/shrainik/Dropbox/raco/examples/fed_accumulo_spark_c/dnssample_parsed.txt');\n",
    "-- Perform a Join (Automatically move the datasets as necessary)\n",
    "graph = select d1.dns as row, d2.dns as col, n.value\n",
    "\t\tfrom NFSUB n, DNS d1, DNS d2\n",
    "\t    where n.src_ip = d1.ip and n.dst_ip = d2.ip;\n",
    "\n",
    "--Begin Jaccard\n",
    "-- Calculate common neighbours\n",
    "gammas = select a.row as u, b.row as v, count(b.value) as gamma\n",
    "\t\t from graph a, graph b\n",
    "         where a.col == b.col;\n",
    "\n",
    "-- Calculate the out_degree of each vertex\n",
    "out_d = select row, count(value) as od from graph;\n",
    "\n",
    "-- Calculate the Jaccard Coefficients for all pairs (u,v);\n",
    "J = select a.u as src_name, a.v as dst_name, a.gamma/(b.od + c.od - a.gamma) as jaccard_coeff\n",
    "\tfrom gammas a, out_d b, out_d c\n",
    "    where a.u = b.row and a.v = c.row;\n",
    "\n",
    "-- Store the result\n",
    "store(J, nameJaccard);\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "##Parse the query\n",
    "parser = myrialparser.Parser()\n",
    "processor = interpreter.StatementProcessor(fed_catalog, True)\n",
    "statement_list = parser.parse(program_fquery)\n",
    "processor.evaluate(statement_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Digraph.gv.pdf'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "##Lets Visualize the query\n",
    "logical_plan = processor.get_logical_plan()\n",
    "dot_logical = raco.viz.operator_to_dot_object(logical_plan)\n",
    "dot_logical.view()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FileStore('/Users/shrainik/Dropbox/raco/V5153686634', 'CSV', {}, Apply([('src_ip', NamedAttributeRef('SrcAddr')), ('dst_ip', NamedAttributeRef('DstAddr')), ('value', NumericLiteral(1.0))], Select(GT(UnnamedAttributeRef(0, None), NumericLiteral(100)), Scan(RelationKey('public','adhoc','netflow'), Scheme([(u'TotBytes', 'LONG_TYPE'), (u'StartTime', 'STRING_TYPE'), (u'SrcAddr', 'STRING_TYPE'), (u'DstAddr', 'STRING_TYPE'), (u'RATE', 'DOUBLE_TYPE'), (u'Dur', 'DOUBLE_TYPE'), (u'Dir', 'STRING_TYPE'), (u'Proto', 'STRING_TYPE'), (u'Sport', 'STRING_TYPE'), (u'Dport', 'STRING_TYPE'), (u'State', 'STRING_TYPE'), (u'sTos', 'LONG_TYPE'), (u'dTos', 'LONG_TYPE'), (u'TotPkts', 'LONG_TYPE'), (u'SrcBytes', 'LONG_TYPE'), (u'Label', 'STRING_TYPE')]), (<raco.backends.myria.catalog.MyriaCatalog object at 0x112825290>, 7), RepresentationProperties(frozenset([UnnamedAttributeRef(0, None), UnnamedAttributeRef(1, None)]), None, None)))))\n",
      "FileStore('/Users/shrainik/Dropbox/raco/V4374434844', 'CSV', {}, Apply([('src_ip', NamedAttributeRef('SrcAddr')), ('dst_ip', NamedAttributeRef('DstAddr')), ('value', NumericLiteral(1.0))], Select(GT(UnnamedAttributeRef(0, None), NumericLiteral(100)), Scan(RelationKey('public','adhoc','netflow'), Scheme([(u'TotBytes', 'LONG_TYPE'), (u'StartTime', 'STRING_TYPE'), (u'SrcAddr', 'STRING_TYPE'), (u'DstAddr', 'STRING_TYPE'), (u'RATE', 'DOUBLE_TYPE'), (u'Dur', 'DOUBLE_TYPE'), (u'Dir', 'STRING_TYPE'), (u'Proto', 'STRING_TYPE'), (u'Sport', 'STRING_TYPE'), (u'Dport', 'STRING_TYPE'), (u'State', 'STRING_TYPE'), (u'sTos', 'LONG_TYPE'), (u'dTos', 'LONG_TYPE'), (u'TotPkts', 'LONG_TYPE'), (u'SrcBytes', 'LONG_TYPE'), (u'Label', 'STRING_TYPE')]), (<raco.backends.myria.catalog.MyriaCatalog object at 0x112afd7d0>, 7), RepresentationProperties(frozenset([UnnamedAttributeRef(0, None), UnnamedAttributeRef(1, None)]), None, None)))))\n",
      "FileStore('/Users/shrainik/Dropbox/raco/V771274108', 'CSV', {}, Apply([('src_ip', NamedAttributeRef('SrcAddr')), ('dst_ip', NamedAttributeRef('DstAddr')), ('value', NumericLiteral(1.0))], Select(GT(UnnamedAttributeRef(0, None), NumericLiteral(100)), Scan(RelationKey('public','adhoc','netflow'), Scheme([(u'TotBytes', 'LONG_TYPE'), (u'StartTime', 'STRING_TYPE'), (u'SrcAddr', 'STRING_TYPE'), (u'DstAddr', 'STRING_TYPE'), (u'RATE', 'DOUBLE_TYPE'), (u'Dur', 'DOUBLE_TYPE'), (u'Dir', 'STRING_TYPE'), (u'Proto', 'STRING_TYPE'), (u'Sport', 'STRING_TYPE'), (u'Dport', 'STRING_TYPE'), (u'State', 'STRING_TYPE'), (u'sTos', 'LONG_TYPE'), (u'dTos', 'LONG_TYPE'), (u'TotPkts', 'LONG_TYPE'), (u'SrcBytes', 'LONG_TYPE'), (u'Label', 'STRING_TYPE')]), (<raco.backends.myria.catalog.MyriaCatalog object at 0x112afe050>, 7), RepresentationProperties(frozenset([UnnamedAttributeRef(0, None), UnnamedAttributeRef(1, None)]), None, None)))))\n",
      "FileStore('/Users/shrainik/Dropbox/raco/V8892656962', 'CSV', {}, Apply([('src_ip', NamedAttributeRef('SrcAddr')), ('dst_ip', NamedAttributeRef('DstAddr')), ('value', NumericLiteral(1.0))], Select(GT(UnnamedAttributeRef(0, None), NumericLiteral(100)), Scan(RelationKey('public','adhoc','netflow'), Scheme([(u'TotBytes', 'LONG_TYPE'), (u'StartTime', 'STRING_TYPE'), (u'SrcAddr', 'STRING_TYPE'), (u'DstAddr', 'STRING_TYPE'), (u'RATE', 'DOUBLE_TYPE'), (u'Dur', 'DOUBLE_TYPE'), (u'Dir', 'STRING_TYPE'), (u'Proto', 'STRING_TYPE'), (u'Sport', 'STRING_TYPE'), (u'Dport', 'STRING_TYPE'), (u'State', 'STRING_TYPE'), (u'sTos', 'LONG_TYPE'), (u'dTos', 'LONG_TYPE'), (u'TotPkts', 'LONG_TYPE'), (u'SrcBytes', 'LONG_TYPE'), (u'Label', 'STRING_TYPE')]), (<raco.backends.myria.catalog.MyriaCatalog object at 0x112afe650>, 7), RepresentationProperties(frozenset([UnnamedAttributeRef(0, None), UnnamedAttributeRef(1, None)]), None, None)))))\n"
     ]
    }
   ],
   "source": [
    "##Lets optimize the query and let the federation figure out the right backends\n",
    "algebras = [OptLogicalAlgebra(), MyriaLeftDeepTreeAlgebra(), SparkAlgebra()]\n",
    "falg = FederatedAlgebra(algebras, fed_catalog)\n",
    "federated_plan = processor.get_physical_plan(target_alg=falg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Digraph.gv.pdf'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "##Visualizing the physical plan\n",
    "raco.viz.operator_to_dot_object(federated_plan).view()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------------+--------------------+-------------+\n",
      "|            src_name|            dst_name|jaccard_coeff|\n",
      "+--------------------+--------------------+-------------+\n",
      "|adsl-69-235-227-1...|adsl-69-235-227-1...|          1.0|\n",
      "|178.111.dsl.mel.i...|adsl-69-235-227-1...|         0.25|\n",
      "|ip65-47-243-178.z...|adsl-69-235-227-1...|          1.0|\n",
      "|smtp179.emergency...|adsl-69-235-227-1...|         0.25|\n",
      "|adsl-69-235-227-1...|178.111.dsl.mel.i...|         0.25|\n",
      "|178.111.dsl.mel.i...|178.111.dsl.mel.i...|          1.0|\n",
      "|ip65-47-243-178.z...|178.111.dsl.mel.i...|         0.25|\n",
      "|smtp179.emergency...|178.111.dsl.mel.i...|          0.5|\n",
      "|adsl-69-235-227-1...|ip65-47-243-178.z...|          1.0|\n",
      "|178.111.dsl.mel.i...|ip65-47-243-178.z...|         0.25|\n",
      "|ip65-47-243-178.z...|ip65-47-243-178.z...|          1.0|\n",
      "|smtp179.emergency...|ip65-47-243-178.z...|         0.25|\n",
      "|adsl-69-235-227-1...|smtp179.emergency...|         0.25|\n",
      "|178.111.dsl.mel.i...|smtp179.emergency...|          0.5|\n",
      "|ip65-47-243-178.z...|smtp179.emergency...|         0.25|\n",
      "|smtp179.emergency...|smtp179.emergency...|          1.0|\n",
      "+--------------------+--------------------+-------------+\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(16, 'nameJaccard')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "##Submit the plan for federated execution\n",
    "fed_conn.execute_query(federated_plan)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FileStore('/Users/shrainik/Dropbox/raco/V5614044245', 'CSV', {}, Apply([('src_ip', NamedAttributeRef('SrcAddr')), ('dst_ip', NamedAttributeRef('DstAddr')), ('value', NumericLiteral(1.0))], Select(GT(UnnamedAttributeRef(0, None), NumericLiteral(100)), Scan(RelationKey('public','adhoc','netflow'), Scheme([(u'TotBytes', 'LONG_TYPE'), (u'StartTime', 'STRING_TYPE'), (u'SrcAddr', 'STRING_TYPE'), (u'DstAddr', 'STRING_TYPE'), (u'RATE', 'DOUBLE_TYPE'), (u'Dur', 'DOUBLE_TYPE'), (u'Dir', 'STRING_TYPE'), (u'Proto', 'STRING_TYPE'), (u'Sport', 'STRING_TYPE'), (u'Dport', 'STRING_TYPE'), (u'State', 'STRING_TYPE'), (u'sTos', 'LONG_TYPE'), (u'dTos', 'LONG_TYPE'), (u'TotPkts', 'LONG_TYPE'), (u'SrcBytes', 'LONG_TYPE'), (u'Label', 'STRING_TYPE')]), (<raco.backends.myria.catalog.MyriaCatalog object at 0x112825290>, 7), RepresentationProperties(frozenset([UnnamedAttributeRef(0, None), UnnamedAttributeRef(1, None)]), None, None)))))\n",
      "FileStore('/Users/shrainik/Dropbox/raco/V7434941858', 'CSV', {}, Apply([('src_ip', NamedAttributeRef('SrcAddr')), ('dst_ip', NamedAttributeRef('DstAddr')), ('value', NumericLiteral(1.0))], Select(GT(UnnamedAttributeRef(0, None), NumericLiteral(100)), Scan(RelationKey('public','adhoc','netflow'), Scheme([(u'TotBytes', 'LONG_TYPE'), (u'StartTime', 'STRING_TYPE'), (u'SrcAddr', 'STRING_TYPE'), (u'DstAddr', 'STRING_TYPE'), (u'RATE', 'DOUBLE_TYPE'), (u'Dur', 'DOUBLE_TYPE'), (u'Dir', 'STRING_TYPE'), (u'Proto', 'STRING_TYPE'), (u'Sport', 'STRING_TYPE'), (u'Dport', 'STRING_TYPE'), (u'State', 'STRING_TYPE'), (u'sTos', 'LONG_TYPE'), (u'dTos', 'LONG_TYPE'), (u'TotPkts', 'LONG_TYPE'), (u'SrcBytes', 'LONG_TYPE'), (u'Label', 'STRING_TYPE')]), (<raco.backends.myria.catalog.MyriaCatalog object at 0x112b76b90>, 7), RepresentationProperties(frozenset([UnnamedAttributeRef(0, None), UnnamedAttributeRef(1, None)]), None, None)))))\n",
      "FileStore('/Users/shrainik/Dropbox/raco/V6957298498', 'CSV', {}, Apply([('src_ip', NamedAttributeRef('SrcAddr')), ('dst_ip', NamedAttributeRef('DstAddr')), ('value', NumericLiteral(1.0))], Select(GT(UnnamedAttributeRef(0, None), NumericLiteral(100)), Scan(RelationKey('public','adhoc','netflow'), Scheme([(u'TotBytes', 'LONG_TYPE'), (u'StartTime', 'STRING_TYPE'), (u'SrcAddr', 'STRING_TYPE'), (u'DstAddr', 'STRING_TYPE'), (u'RATE', 'DOUBLE_TYPE'), (u'Dur', 'DOUBLE_TYPE'), (u'Dir', 'STRING_TYPE'), (u'Proto', 'STRING_TYPE'), (u'Sport', 'STRING_TYPE'), (u'Dport', 'STRING_TYPE'), (u'State', 'STRING_TYPE'), (u'sTos', 'LONG_TYPE'), (u'dTos', 'LONG_TYPE'), (u'TotPkts', 'LONG_TYPE'), (u'SrcBytes', 'LONG_TYPE'), (u'Label', 'STRING_TYPE')]), (<raco.backends.myria.catalog.MyriaCatalog object at 0x112b753d0>, 7), RepresentationProperties(frozenset([UnnamedAttributeRef(0, None), UnnamedAttributeRef(1, None)]), None, None)))))\n",
      "FileStore('/Users/shrainik/Dropbox/raco/V7341013414', 'CSV', {}, Apply([('src_ip', NamedAttributeRef('SrcAddr')), ('dst_ip', NamedAttributeRef('DstAddr')), ('value', NumericLiteral(1.0))], Select(GT(UnnamedAttributeRef(0, None), NumericLiteral(100)), Scan(RelationKey('public','adhoc','netflow'), Scheme([(u'TotBytes', 'LONG_TYPE'), (u'StartTime', 'STRING_TYPE'), (u'SrcAddr', 'STRING_TYPE'), (u'DstAddr', 'STRING_TYPE'), (u'RATE', 'DOUBLE_TYPE'), (u'Dur', 'DOUBLE_TYPE'), (u'Dir', 'STRING_TYPE'), (u'Proto', 'STRING_TYPE'), (u'Sport', 'STRING_TYPE'), (u'Dport', 'STRING_TYPE'), (u'State', 'STRING_TYPE'), (u'sTos', 'LONG_TYPE'), (u'dTos', 'LONG_TYPE'), (u'TotPkts', 'LONG_TYPE'), (u'SrcBytes', 'LONG_TYPE'), (u'Label', 'STRING_TYPE')]), (<raco.backends.myria.catalog.MyriaCatalog object at 0x112b759d0>, 7), RepresentationProperties(frozenset([UnnamedAttributeRef(0, None), UnnamedAttributeRef(1, None)]), None, None)))))\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Digraph.gv.pdf'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from raco.backends.cpp.cpp import CCAlgebra\n",
    "\n",
    "##Initialize C Backend Catalog\n",
    "c_catalog = FromFileCatalog.load_from_file(os.path.join(\n",
    "                                                os.path.dirname('/Users/shrainik/Dropbox/raco/examples/'), \n",
    "                                                'catalog.py'))\n",
    "\n",
    "##Initialize Federated Backend -- With the C catalog\n",
    "fed_conn = FederatedConnection([myriaconn])\n",
    "fed_catalog = FederatedCatalog([myriacatalog, c_catalog])\n",
    "\n",
    "##Parse the query -- SAME AS BEFORE\n",
    "parser = myrialparser.Parser()\n",
    "processor = interpreter.StatementProcessor(fed_catalog, True)\n",
    "statement_list = parser.parse(program_fquery)\n",
    "processor.evaluate(statement_list)\n",
    "\n",
    "##Change to C Algebra \n",
    "algebras = [OptLogicalAlgebra(), MyriaLeftDeepTreeAlgebra(), CCAlgebra()]\n",
    "falg = FederatedAlgebra(algebras, fed_catalog, crossproducts=False)\n",
    "federated_plan = processor.get_physical_plan(target_alg=falg)\n",
    "##Visualizing the physical plan\n",
    "raco.viz.operator_to_dot_object(federated_plan).view()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "// Precount_select: Use buckets to track the number of matches\n",
      "// Use buckets to copy into the result array\n",
      "#include <cstdio>\n",
      "#include <cstdlib>     // for exit()\n",
      "#include <fcntl.h>      // for open()\n",
      "#include <unistd.h>     // for close()\n",
      "#include <sys/stat.h>   // for fstat()\n",
      "#include <ctype.h>      // for isdigit()\n",
      "#include <cstring>\n",
      "#include <errno.h>\n",
      "#include <algorithm>\n",
      "#include <sys/types.h>\n",
      "#include <sys/stat.h>\n",
      "#include <sys/file.h>\n",
      "\n",
      "#ifdef __MTA__\n",
      "#include <machine/runtime.h>\n",
      "#include <luc/luc_common.h>\n",
      "#include <snapshot/client.h>\n",
      "#include <sys/mta_task.h>\n",
      "\n",
      "\n",
      "typedef int int64;\n",
      "typedef unsigned uint64;\n",
      "#else\n",
      "#include <sys/time.h>\n",
      "\n",
      "#include <iomanip>\n",
      "#include <cstdint>\n",
      "#include <iostream>\n",
      "#include <fstream>\n",
      "typedef int64_t int64;\n",
      "typedef uint64_t uint64;\n",
      "\n",
      "#include <unordered_map>\n",
      "#include <vector>\n",
      "#include <limits>\n",
      "#endif\n",
      "\n",
      "#include \"io_util.h\"\n",
      "#include \"hash.h\"\n",
      "#include \"radish_utils.h\"\n",
      "#include \"strings.h\"\n",
      "#include \"timing.h\"\n",
      "\n",
      "// ------------------------------------------------------------------\n",
      "\n",
      "\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V2340303319_0_1_2 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "        double f2;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 3;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V2340303319_0_1_2 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f2) + sizeof(_t.f2) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V2340303319_0_1_2 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f1) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V2340303319_0_1_2 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V2340303319_0_1_2 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V2340303319_0_1_2));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V2340303319_0_1_2 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a2\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V2340303319_0_1_2(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V2340303319_0_1_2 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V2340303319_0_1_2 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V2340303319_0_1_2 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f2;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V2340303319_0_1_2 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V2340303319_0_1_2::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V2340303319_0_1_2 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V2340303319_0_1_2::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V2340303319_0_1_2 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V2340303319_0_1_2 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(double*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V2340303319_0_1_2& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V4104807128_0_1_2_3_4 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "        int64_t f2;\n",
      "    \n",
      "        int64_t f3;\n",
      "    \n",
      "        int64_t f4;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 5;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V4104807128_0_1_2_3_4 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f4) + sizeof(_t.f4) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V4104807128_0_1_2_3_4 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f3) - ((char*)&_t.f2)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f4) - ((char*)&_t.f3)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f3) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V4104807128_0_1_2_3_4 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V4104807128_0_1_2_3_4 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V4104807128_0_1_2_3_4));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V4104807128_0_1_2_3_4 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const int64_t& a2\n",
      "                               ,\n",
      "                       \n",
      "                               const int64_t& a3\n",
      "                               ,\n",
      "                       \n",
      "                               const int64_t& a4\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "            f3 = a3;\n",
      "        \n",
      "            f4 = a4;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V4104807128_0_1_2_3_4(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "            f3 = std::get<3>(o);\n",
      "        \n",
      "            f4 = std::get<4>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "            std::get<3>(r) = f3;\n",
      "        \n",
      "            std::get<4>(r) = f4;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V4104807128_0_1_2_3_4 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //        f3 = vals[3];\n",
      "    //    \n",
      "    //        f4 = vals[4];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V4104807128_0_1_2_3_4 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V4104807128_0_1_2_3_4 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f2;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f3;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f4;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 << \" \"\n",
      "        \n",
      "        << f3 << \" \"\n",
      "        \n",
      "        << f4 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V4104807128_0_1_2_3_4 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V4104807128_0_1_2_3_4::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V4104807128_0_1_2_3_4 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V4104807128_0_1_2_3_4::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "        o << f3 << \",\";\n",
      "      \n",
      "        o << f4 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V4104807128_0_1_2_3_4 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V4104807128_0_1_2_3_4 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(int64_t*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "         _t.f3 = *(int64_t*)(&(rel->relation[row*rel->fields+3]));\n",
      "      \n",
      "         _t.f4 = *(int64_t*)(&(rel->relation[row*rel->fields+4]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V4104807128_0_1_2_3_4& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V4839141921_0_1 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        int64_t f1;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 2;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V4839141921_0_1 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f1) + sizeof(_t.f1) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V4839141921_0_1 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f0) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V4839141921_0_1 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V4839141921_0_1 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V4839141921_0_1));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V4839141921_0_1 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const int64_t& a1\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V4839141921_0_1(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V4839141921_0_1 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V4839141921_0_1 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V4839141921_0_1 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f1;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V4839141921_0_1 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V4839141921_0_1::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V4839141921_0_1 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V4839141921_0_1::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V4839141921_0_1 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V4839141921_0_1 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(int64_t*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V4839141921_0_1& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "std::unordered_map<std::array<char, MAX_STR_LEN>,int64_t> group_hash_000;\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V9458626130_0_1 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        double f1;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 2;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V9458626130_0_1 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f1) + sizeof(_t.f1) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V9458626130_0_1 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f0) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V9458626130_0_1 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V9458626130_0_1 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V9458626130_0_1));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V9458626130_0_1 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a1\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V9458626130_0_1(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V9458626130_0_1 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V9458626130_0_1 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V9458626130_0_1 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f1;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V9458626130_0_1 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V9458626130_0_1::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V9458626130_0_1 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V9458626130_0_1::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V9458626130_0_1 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V9458626130_0_1 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(double*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V9458626130_0_1& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V7687329561_0_1 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        double f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 2;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V7687329561_0_1 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f1) + sizeof(_t.f1) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V7687329561_0_1 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f0) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V7687329561_0_1 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V7687329561_0_1 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V7687329561_0_1));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V7687329561_0_1 (\n",
      "                               const double& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V7687329561_0_1(const std::tuple<\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V7687329561_0_1 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V7687329561_0_1 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V7687329561_0_1 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f0;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V7687329561_0_1 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V7687329561_0_1::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V7687329561_0_1 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V7687329561_0_1::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V7687329561_0_1 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V7687329561_0_1 _t;\n",
      "      \n",
      "         _t.f0 = *(double*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V7687329561_0_1& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V7324074249_0 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 1;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V7324074249_0 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            sizeof(_t.f0);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V7324074249_0 _t;\n",
      "\n",
      "        \n",
      "        std::cout << _t.fieldsSize() << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V7324074249_0 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V7324074249_0 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V7324074249_0));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V7324074249_0 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V7324074249_0(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V7324074249_0 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V7324074249_0 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V7324074249_0 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V7324074249_0 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V7324074249_0::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V7324074249_0 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V7324074249_0::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V7324074249_0 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V7324074249_0 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V7324074249_0& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V5630118086_0_1_2 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f2;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 3;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V5630118086_0_1_2 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f2) + sizeof(_t.f2) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V5630118086_0_1_2 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f1) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V5630118086_0_1_2 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V5630118086_0_1_2 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V5630118086_0_1_2));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V5630118086_0_1_2 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a2\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V5630118086_0_1_2(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V5630118086_0_1_2 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V5630118086_0_1_2 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V5630118086_0_1_2 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f2 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V5630118086_0_1_2 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V5630118086_0_1_2::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V5630118086_0_1_2 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V5630118086_0_1_2::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V5630118086_0_1_2 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V5630118086_0_1_2 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V5630118086_0_1_2& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "std::vector<MaterializedTupleRef_V5630118086_0_1_2> V5630118086;\n",
      "std::unordered_map<std::array<char, MAX_STR_LEN>, std::vector<MaterializedTupleRef_V7324074249_0> > hash_001;\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V7965580226_0_1_2 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        double f1;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f2;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 3;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V7965580226_0_1_2 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f2) + sizeof(_t.f2) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V7965580226_0_1_2 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f1) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V7965580226_0_1_2 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V7965580226_0_1_2 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V7965580226_0_1_2));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V7965580226_0_1_2 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a2\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V7965580226_0_1_2(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V7965580226_0_1_2 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V7965580226_0_1_2 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V7965580226_0_1_2 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f1;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f2 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V7965580226_0_1_2 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V7965580226_0_1_2::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V7965580226_0_1_2 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V7965580226_0_1_2::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V7965580226_0_1_2 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V7965580226_0_1_2 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(double*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V7965580226_0_1_2& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V4184513601_0_1 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 2;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V4184513601_0_1 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f1) + sizeof(_t.f1) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V4184513601_0_1 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f0) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V4184513601_0_1 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V4184513601_0_1 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V4184513601_0_1));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V4184513601_0_1 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V4184513601_0_1(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V4184513601_0_1 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V4184513601_0_1 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V4184513601_0_1 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V4184513601_0_1 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V4184513601_0_1::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V4184513601_0_1 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V4184513601_0_1::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V4184513601_0_1 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V4184513601_0_1 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V4184513601_0_1& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "std::unordered_map<std::array<char, MAX_STR_LEN>, std::vector<MaterializedTupleRef_V4184513601_0_1> > hash_002;\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V5039388092_0_1_2 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "        double f2;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 3;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V5039388092_0_1_2 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f2) + sizeof(_t.f2) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V5039388092_0_1_2 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f1) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V5039388092_0_1_2 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V5039388092_0_1_2 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V5039388092_0_1_2));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V5039388092_0_1_2 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a2\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V5039388092_0_1_2(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V5039388092_0_1_2 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V5039388092_0_1_2 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V5039388092_0_1_2 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f2;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V5039388092_0_1_2 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V5039388092_0_1_2::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V5039388092_0_1_2 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V5039388092_0_1_2::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V5039388092_0_1_2 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V5039388092_0_1_2 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(double*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V5039388092_0_1_2& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "std::vector<MaterializedTupleRef_V5039388092_0_1_2> V5039388092;\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V3928066836_0_1_2_3_4 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "        double f2;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f3;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f4;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 5;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V3928066836_0_1_2_3_4 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f4) + sizeof(_t.f4) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V3928066836_0_1_2_3_4 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f3) - ((char*)&_t.f2)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f4) - ((char*)&_t.f3)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f3) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V3928066836_0_1_2_3_4 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V3928066836_0_1_2_3_4 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V3928066836_0_1_2_3_4));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V3928066836_0_1_2_3_4 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a2\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a3\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a4\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "            f3 = a3;\n",
      "        \n",
      "            f4 = a4;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V3928066836_0_1_2_3_4(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "            f3 = std::get<3>(o);\n",
      "        \n",
      "            f4 = std::get<4>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "            std::get<3>(r) = f3;\n",
      "        \n",
      "            std::get<4>(r) = f4;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V3928066836_0_1_2_3_4 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //        f3 = vals[3];\n",
      "    //    \n",
      "    //        f4 = vals[4];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V3928066836_0_1_2_3_4 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V3928066836_0_1_2_3_4 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f2;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f3 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f4 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 << \" \"\n",
      "        \n",
      "        << f3 << \" \"\n",
      "        \n",
      "        << f4 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V3928066836_0_1_2_3_4 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V3928066836_0_1_2_3_4::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V3928066836_0_1_2_3_4 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V3928066836_0_1_2_3_4::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "        o << f3 << \",\";\n",
      "      \n",
      "        o << f4 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V3928066836_0_1_2_3_4 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V3928066836_0_1_2_3_4 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(double*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "         _t.f3 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+3]));\n",
      "      \n",
      "         _t.f4 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+4]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V3928066836_0_1_2_3_4& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "static MaterializedTupleRef_V3928066836_0_1_2_3_4 create_V2950028442(const MaterializedTupleRef_V5039388092_0_1_2& t1, const MaterializedTupleRef_V4184513601_0_1& t2) {\n",
      "    MaterializedTupleRef_V3928066836_0_1_2_3_4 t;\n",
      "    \n",
      "        t.f0 = t1.f0;\n",
      "    \n",
      "        t.f1 = t1.f1;\n",
      "    \n",
      "        t.f2 = t1.f2;\n",
      "    \n",
      "\n",
      "    \n",
      "        t.f3 = t2.f0;\n",
      "    \n",
      "        t.f4 = t2.f1;\n",
      "    \n",
      "\n",
      "    return t;\n",
      "}\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V8834168336_0_1_2_3 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        double f1;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f2;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f3;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 4;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V8834168336_0_1_2_3 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f3) + sizeof(_t.f3) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V8834168336_0_1_2_3 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f3) - ((char*)&_t.f2)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f2) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V8834168336_0_1_2_3 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V8834168336_0_1_2_3 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V8834168336_0_1_2_3));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V8834168336_0_1_2_3 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a2\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a3\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "            f3 = a3;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V8834168336_0_1_2_3(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "            f3 = std::get<3>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "            std::get<3>(r) = f3;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V8834168336_0_1_2_3 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //        f3 = vals[3];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V8834168336_0_1_2_3 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V8834168336_0_1_2_3 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f1;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f2 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f3 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 << \" \"\n",
      "        \n",
      "        << f3 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V8834168336_0_1_2_3 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V8834168336_0_1_2_3::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V8834168336_0_1_2_3 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V8834168336_0_1_2_3::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "        o << f3 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V8834168336_0_1_2_3 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V8834168336_0_1_2_3 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(double*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "         _t.f3 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+3]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V8834168336_0_1_2_3& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "static MaterializedTupleRef_V8834168336_0_1_2_3 create_V8766972874(const MaterializedTupleRef_V7965580226_0_1_2& t1, const MaterializedTupleRef_V7324074249_0& t2) {\n",
      "    MaterializedTupleRef_V8834168336_0_1_2_3 t;\n",
      "    \n",
      "        t.f0 = t1.f0;\n",
      "    \n",
      "        t.f1 = t1.f1;\n",
      "    \n",
      "        t.f2 = t1.f2;\n",
      "    \n",
      "\n",
      "    \n",
      "        t.f3 = t2.f0;\n",
      "    \n",
      "\n",
      "    return t;\n",
      "}\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V6852235585_0_1 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        int64_t f1;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 2;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V6852235585_0_1 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f1) + sizeof(_t.f1) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V6852235585_0_1 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f0) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V6852235585_0_1 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V6852235585_0_1 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V6852235585_0_1));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V6852235585_0_1 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const int64_t& a1\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V6852235585_0_1(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V6852235585_0_1 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V6852235585_0_1 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V6852235585_0_1 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f1;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V6852235585_0_1 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V6852235585_0_1::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V6852235585_0_1 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V6852235585_0_1::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V6852235585_0_1 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V6852235585_0_1 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(int64_t*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V6852235585_0_1& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "std::unordered_map<std::array<char, MAX_STR_LEN>, std::vector<MaterializedTupleRef_V4839141921_0_1> > hash_000;\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V4410861523_0_1_2_3 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "        int64_t f2;\n",
      "    \n",
      "        int64_t f3;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 4;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V4410861523_0_1_2_3 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f3) + sizeof(_t.f3) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V4410861523_0_1_2_3 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f3) - ((char*)&_t.f2)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f2) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V4410861523_0_1_2_3 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V4410861523_0_1_2_3 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V4410861523_0_1_2_3));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V4410861523_0_1_2_3 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const int64_t& a2\n",
      "                               ,\n",
      "                       \n",
      "                               const int64_t& a3\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "            f3 = a3;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V4410861523_0_1_2_3(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "            f3 = std::get<3>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "            std::get<3>(r) = f3;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V4410861523_0_1_2_3 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //        f3 = vals[3];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V4410861523_0_1_2_3 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V4410861523_0_1_2_3 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f2;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f3;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 << \" \"\n",
      "        \n",
      "        << f3 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V4410861523_0_1_2_3 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V4410861523_0_1_2_3::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V4410861523_0_1_2_3 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V4410861523_0_1_2_3::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "        o << f3 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V4410861523_0_1_2_3 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V4410861523_0_1_2_3 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(int64_t*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "         _t.f3 = *(int64_t*)(&(rel->relation[row*rel->fields+3]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V4410861523_0_1_2_3& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V8082870640_0_1 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        int64_t f1;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 2;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V8082870640_0_1 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f1) + sizeof(_t.f1) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V8082870640_0_1 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f0) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V8082870640_0_1 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V8082870640_0_1 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V8082870640_0_1));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V8082870640_0_1 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const int64_t& a1\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V8082870640_0_1(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V8082870640_0_1 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V8082870640_0_1 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V8082870640_0_1 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f1;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V8082870640_0_1 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V8082870640_0_1::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V8082870640_0_1 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V8082870640_0_1::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V8082870640_0_1 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V8082870640_0_1 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(int64_t*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V8082870640_0_1& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "std::unordered_map<std::array<char, MAX_STR_LEN>,int64_t> group_hash_001;\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V3087637349_0_1 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        double f1;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 2;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V3087637349_0_1 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f1) + sizeof(_t.f1) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V3087637349_0_1 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f0) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V3087637349_0_1 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V3087637349_0_1 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V3087637349_0_1));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V3087637349_0_1 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a1\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V3087637349_0_1(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V3087637349_0_1 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V3087637349_0_1 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V3087637349_0_1 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f1;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V3087637349_0_1 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V3087637349_0_1::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V3087637349_0_1 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V3087637349_0_1::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V3087637349_0_1 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V3087637349_0_1 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(double*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V3087637349_0_1& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V5287524902_0_1 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        double f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 2;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V5287524902_0_1 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f1) + sizeof(_t.f1) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V5287524902_0_1 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f0) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V5287524902_0_1 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V5287524902_0_1 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V5287524902_0_1));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V5287524902_0_1 (\n",
      "                               const double& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V5287524902_0_1(const std::tuple<\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V5287524902_0_1 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V5287524902_0_1 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V5287524902_0_1 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f0;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V5287524902_0_1 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V5287524902_0_1::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V5287524902_0_1 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V5287524902_0_1::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V5287524902_0_1 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V5287524902_0_1 _t;\n",
      "      \n",
      "         _t.f0 = *(double*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V5287524902_0_1& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V9774699966_0_1_2 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        double f1;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f2;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 3;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V9774699966_0_1_2 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f2) + sizeof(_t.f2) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V9774699966_0_1_2 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f1) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V9774699966_0_1_2 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V9774699966_0_1_2 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V9774699966_0_1_2));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V9774699966_0_1_2 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a2\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V9774699966_0_1_2(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V9774699966_0_1_2 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V9774699966_0_1_2 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V9774699966_0_1_2 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f1;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f2 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V9774699966_0_1_2 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V9774699966_0_1_2::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V9774699966_0_1_2 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V9774699966_0_1_2::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V9774699966_0_1_2 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V9774699966_0_1_2 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(double*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V9774699966_0_1_2& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V240378163_0_1_2 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "        double f2;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 3;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V240378163_0_1_2 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f2) + sizeof(_t.f2) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V240378163_0_1_2 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f1) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V240378163_0_1_2 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V240378163_0_1_2 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V240378163_0_1_2));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V240378163_0_1_2 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a2\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V240378163_0_1_2(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V240378163_0_1_2 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V240378163_0_1_2 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V240378163_0_1_2 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f2;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V240378163_0_1_2 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V240378163_0_1_2::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V240378163_0_1_2 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V240378163_0_1_2::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V240378163_0_1_2 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V240378163_0_1_2 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(double*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V240378163_0_1_2& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "std::vector<MaterializedTupleRef_V240378163_0_1_2> V240378163;\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V8415876346_0_1_2_3_4 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "        double f2;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f3;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f4;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 5;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V8415876346_0_1_2_3_4 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f4) + sizeof(_t.f4) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V8415876346_0_1_2_3_4 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f3) - ((char*)&_t.f2)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f4) - ((char*)&_t.f3)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f3) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V8415876346_0_1_2_3_4 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V8415876346_0_1_2_3_4 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V8415876346_0_1_2_3_4));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V8415876346_0_1_2_3_4 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a2\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a3\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a4\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "            f3 = a3;\n",
      "        \n",
      "            f4 = a4;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V8415876346_0_1_2_3_4(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "            f3 = std::get<3>(o);\n",
      "        \n",
      "            f4 = std::get<4>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "            std::get<3>(r) = f3;\n",
      "        \n",
      "            std::get<4>(r) = f4;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V8415876346_0_1_2_3_4 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //        f3 = vals[3];\n",
      "    //    \n",
      "    //        f4 = vals[4];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V8415876346_0_1_2_3_4 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V8415876346_0_1_2_3_4 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f2;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f3 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f4 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 << \" \"\n",
      "        \n",
      "        << f3 << \" \"\n",
      "        \n",
      "        << f4 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V8415876346_0_1_2_3_4 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V8415876346_0_1_2_3_4::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V8415876346_0_1_2_3_4 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V8415876346_0_1_2_3_4::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "        o << f3 << \",\";\n",
      "      \n",
      "        o << f4 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V8415876346_0_1_2_3_4 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V8415876346_0_1_2_3_4 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(double*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "         _t.f3 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+3]));\n",
      "      \n",
      "         _t.f4 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+4]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V8415876346_0_1_2_3_4& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "static MaterializedTupleRef_V8415876346_0_1_2_3_4 create_V9723642197(const MaterializedTupleRef_V240378163_0_1_2& t1, const MaterializedTupleRef_V4184513601_0_1& t2) {\n",
      "    MaterializedTupleRef_V8415876346_0_1_2_3_4 t;\n",
      "    \n",
      "        t.f0 = t1.f0;\n",
      "    \n",
      "        t.f1 = t1.f1;\n",
      "    \n",
      "        t.f2 = t1.f2;\n",
      "    \n",
      "\n",
      "    \n",
      "        t.f3 = t2.f0;\n",
      "    \n",
      "        t.f4 = t2.f1;\n",
      "    \n",
      "\n",
      "    return t;\n",
      "}\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V4742428694_0_1_2_3 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        double f1;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f2;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f3;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 4;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V4742428694_0_1_2_3 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f3) + sizeof(_t.f3) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V4742428694_0_1_2_3 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f3) - ((char*)&_t.f2)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f2) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V4742428694_0_1_2_3 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V4742428694_0_1_2_3 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V4742428694_0_1_2_3));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V4742428694_0_1_2_3 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a2\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a3\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "            f3 = a3;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V4742428694_0_1_2_3(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "            f3 = std::get<3>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "            std::get<3>(r) = f3;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V4742428694_0_1_2_3 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //        f3 = vals[3];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V4742428694_0_1_2_3 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V4742428694_0_1_2_3 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f1;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f2 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f3 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 << \" \"\n",
      "        \n",
      "        << f3 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V4742428694_0_1_2_3 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V4742428694_0_1_2_3::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V4742428694_0_1_2_3 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V4742428694_0_1_2_3::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "        o << f3 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V4742428694_0_1_2_3 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V4742428694_0_1_2_3 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(double*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "         _t.f3 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+3]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V4742428694_0_1_2_3& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "static MaterializedTupleRef_V4742428694_0_1_2_3 create_V7968469703(const MaterializedTupleRef_V9774699966_0_1_2& t1, const MaterializedTupleRef_V7324074249_0& t2) {\n",
      "    MaterializedTupleRef_V4742428694_0_1_2_3 t;\n",
      "    \n",
      "        t.f0 = t1.f0;\n",
      "    \n",
      "        t.f1 = t1.f1;\n",
      "    \n",
      "        t.f2 = t1.f2;\n",
      "    \n",
      "\n",
      "    \n",
      "        t.f3 = t2.f0;\n",
      "    \n",
      "\n",
      "    return t;\n",
      "}\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V1689264244_0_1 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        int64_t f1;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 2;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V1689264244_0_1 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f1) + sizeof(_t.f1) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V1689264244_0_1 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f0) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V1689264244_0_1 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V1689264244_0_1 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V1689264244_0_1));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V1689264244_0_1 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const int64_t& a1\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V1689264244_0_1(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V1689264244_0_1 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V1689264244_0_1 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V1689264244_0_1 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f1;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V1689264244_0_1 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V1689264244_0_1::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V1689264244_0_1 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V1689264244_0_1::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V1689264244_0_1 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V1689264244_0_1 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(int64_t*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V1689264244_0_1& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "std::unordered_map<std::array<char, MAX_STR_LEN>, std::vector<MaterializedTupleRef_V8082870640_0_1> > hash_003;\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V5812125899_0_1_2 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "        int64_t f2;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 3;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V5812125899_0_1_2 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f2) + sizeof(_t.f2) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V5812125899_0_1_2 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f1) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V5812125899_0_1_2 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V5812125899_0_1_2 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V5812125899_0_1_2));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V5812125899_0_1_2 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const int64_t& a2\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V5812125899_0_1_2(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V5812125899_0_1_2 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V5812125899_0_1_2 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V5812125899_0_1_2 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f2;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V5812125899_0_1_2 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V5812125899_0_1_2::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V5812125899_0_1_2 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V5812125899_0_1_2::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V5812125899_0_1_2 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V5812125899_0_1_2 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(int64_t*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V5812125899_0_1_2& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "std::unordered_map<std::pair<std::array<char, MAX_STR_LEN>,std::array<char, MAX_STR_LEN>>, int64_t, pairhash> group_hash_002;\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V9266923760_0_1_2 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "        double f2;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 3;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V9266923760_0_1_2 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f2) + sizeof(_t.f2) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V9266923760_0_1_2 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f1) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V9266923760_0_1_2 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V9266923760_0_1_2 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V9266923760_0_1_2));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V9266923760_0_1_2 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a2\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V9266923760_0_1_2(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V9266923760_0_1_2 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V9266923760_0_1_2 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V9266923760_0_1_2 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f2;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V9266923760_0_1_2 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V9266923760_0_1_2::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V9266923760_0_1_2 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V9266923760_0_1_2::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V9266923760_0_1_2 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V9266923760_0_1_2 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(double*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V9266923760_0_1_2& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V8887445041_0_1_2 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "        double f2;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 3;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V8887445041_0_1_2 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f2) + sizeof(_t.f2) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V8887445041_0_1_2 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f1) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V8887445041_0_1_2 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V8887445041_0_1_2 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V8887445041_0_1_2));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V8887445041_0_1_2 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a2\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V8887445041_0_1_2(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V8887445041_0_1_2 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V8887445041_0_1_2 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V8887445041_0_1_2 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f2;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V8887445041_0_1_2 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V8887445041_0_1_2::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V8887445041_0_1_2 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V8887445041_0_1_2::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V8887445041_0_1_2 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V8887445041_0_1_2 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(double*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V8887445041_0_1_2& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V5998582294_0_1_2 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "        double f2;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 3;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V5998582294_0_1_2 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f2) + sizeof(_t.f2) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V5998582294_0_1_2 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f1) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V5998582294_0_1_2 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V5998582294_0_1_2 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V5998582294_0_1_2));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V5998582294_0_1_2 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a2\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V5998582294_0_1_2(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V5998582294_0_1_2 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V5998582294_0_1_2 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V5998582294_0_1_2 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f2;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V5998582294_0_1_2 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V5998582294_0_1_2::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V5998582294_0_1_2 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V5998582294_0_1_2::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V5998582294_0_1_2 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V5998582294_0_1_2 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(double*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V5998582294_0_1_2& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V2352247948_0_1_2 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        double f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f2;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 3;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V2352247948_0_1_2 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f2) + sizeof(_t.f2) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V2352247948_0_1_2 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f1) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V2352247948_0_1_2 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V2352247948_0_1_2 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V2352247948_0_1_2));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V2352247948_0_1_2 (\n",
      "                               const double& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a2\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V2352247948_0_1_2(const std::tuple<\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V2352247948_0_1_2 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V2352247948_0_1_2 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V2352247948_0_1_2 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f0;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f2 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V2352247948_0_1_2 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V2352247948_0_1_2::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V2352247948_0_1_2 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V2352247948_0_1_2::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V2352247948_0_1_2 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V2352247948_0_1_2 _t;\n",
      "      \n",
      "         _t.f0 = *(double*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V2352247948_0_1_2& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V2650345716_0_1_2 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        double f1;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f2;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 3;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V2650345716_0_1_2 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f2) + sizeof(_t.f2) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V2650345716_0_1_2 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f1) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V2650345716_0_1_2 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V2650345716_0_1_2 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V2650345716_0_1_2));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V2650345716_0_1_2 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a2\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V2650345716_0_1_2(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V2650345716_0_1_2 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V2650345716_0_1_2 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V2650345716_0_1_2 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f1;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f2 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V2650345716_0_1_2 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V2650345716_0_1_2::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V2650345716_0_1_2 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V2650345716_0_1_2::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V2650345716_0_1_2 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V2650345716_0_1_2 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(double*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V2650345716_0_1_2& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V4244548386_0_1_2 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "        double f2;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 3;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V4244548386_0_1_2 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f2) + sizeof(_t.f2) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V4244548386_0_1_2 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f1) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V4244548386_0_1_2 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V4244548386_0_1_2 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V4244548386_0_1_2));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V4244548386_0_1_2 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a2\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V4244548386_0_1_2(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V4244548386_0_1_2 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V4244548386_0_1_2 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V4244548386_0_1_2 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f2;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V4244548386_0_1_2 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V4244548386_0_1_2::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V4244548386_0_1_2 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V4244548386_0_1_2::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V4244548386_0_1_2 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V4244548386_0_1_2 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(double*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V4244548386_0_1_2& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "std::vector<MaterializedTupleRef_V4244548386_0_1_2> V4244548386;\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V1533947543_0_1_2_3_4 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "        double f2;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f3;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f4;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 5;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V1533947543_0_1_2_3_4 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f4) + sizeof(_t.f4) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V1533947543_0_1_2_3_4 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f3) - ((char*)&_t.f2)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f4) - ((char*)&_t.f3)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f3) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V1533947543_0_1_2_3_4 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V1533947543_0_1_2_3_4 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V1533947543_0_1_2_3_4));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V1533947543_0_1_2_3_4 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a2\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a3\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a4\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "            f3 = a3;\n",
      "        \n",
      "            f4 = a4;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V1533947543_0_1_2_3_4(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "            f3 = std::get<3>(o);\n",
      "        \n",
      "            f4 = std::get<4>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "            std::get<3>(r) = f3;\n",
      "        \n",
      "            std::get<4>(r) = f4;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V1533947543_0_1_2_3_4 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //        f3 = vals[3];\n",
      "    //    \n",
      "    //        f4 = vals[4];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V1533947543_0_1_2_3_4 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V1533947543_0_1_2_3_4 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f2;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f3 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f4 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 << \" \"\n",
      "        \n",
      "        << f3 << \" \"\n",
      "        \n",
      "        << f4 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V1533947543_0_1_2_3_4 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V1533947543_0_1_2_3_4::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V1533947543_0_1_2_3_4 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V1533947543_0_1_2_3_4::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "        o << f3 << \",\";\n",
      "      \n",
      "        o << f4 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V1533947543_0_1_2_3_4 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V1533947543_0_1_2_3_4 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(double*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "         _t.f3 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+3]));\n",
      "      \n",
      "         _t.f4 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+4]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V1533947543_0_1_2_3_4& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "static MaterializedTupleRef_V1533947543_0_1_2_3_4 create_V8132519124(const MaterializedTupleRef_V4244548386_0_1_2& t1, const MaterializedTupleRef_V4184513601_0_1& t2) {\n",
      "    MaterializedTupleRef_V1533947543_0_1_2_3_4 t;\n",
      "    \n",
      "        t.f0 = t1.f0;\n",
      "    \n",
      "        t.f1 = t1.f1;\n",
      "    \n",
      "        t.f2 = t1.f2;\n",
      "    \n",
      "\n",
      "    \n",
      "        t.f3 = t2.f0;\n",
      "    \n",
      "        t.f4 = t2.f1;\n",
      "    \n",
      "\n",
      "    return t;\n",
      "}\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V1399935105_0_1_2_3_4 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        double f1;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f2;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f3;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f4;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 5;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V1399935105_0_1_2_3_4 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f4) + sizeof(_t.f4) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V1399935105_0_1_2_3_4 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f3) - ((char*)&_t.f2)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f4) - ((char*)&_t.f3)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f3) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V1399935105_0_1_2_3_4 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V1399935105_0_1_2_3_4 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V1399935105_0_1_2_3_4));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V1399935105_0_1_2_3_4 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a2\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a3\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a4\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "            f3 = a3;\n",
      "        \n",
      "            f4 = a4;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V1399935105_0_1_2_3_4(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "            f3 = std::get<3>(o);\n",
      "        \n",
      "            f4 = std::get<4>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "            std::get<3>(r) = f3;\n",
      "        \n",
      "            std::get<4>(r) = f4;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V1399935105_0_1_2_3_4 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //        f3 = vals[3];\n",
      "    //    \n",
      "    //        f4 = vals[4];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V1399935105_0_1_2_3_4 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V1399935105_0_1_2_3_4 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f1;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f2 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f3 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f4 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 << \" \"\n",
      "        \n",
      "        << f3 << \" \"\n",
      "        \n",
      "        << f4 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V1399935105_0_1_2_3_4 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V1399935105_0_1_2_3_4::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V1399935105_0_1_2_3_4 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V1399935105_0_1_2_3_4::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "        o << f3 << \",\";\n",
      "      \n",
      "        o << f4 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V1399935105_0_1_2_3_4 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V1399935105_0_1_2_3_4 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(double*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "         _t.f3 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+3]));\n",
      "      \n",
      "         _t.f4 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+4]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V1399935105_0_1_2_3_4& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "static MaterializedTupleRef_V1399935105_0_1_2_3_4 create_V2101838709(const MaterializedTupleRef_V2650345716_0_1_2& t1, const MaterializedTupleRef_V4184513601_0_1& t2) {\n",
      "    MaterializedTupleRef_V1399935105_0_1_2_3_4 t;\n",
      "    \n",
      "        t.f0 = t1.f0;\n",
      "    \n",
      "        t.f1 = t1.f1;\n",
      "    \n",
      "        t.f2 = t1.f2;\n",
      "    \n",
      "\n",
      "    \n",
      "        t.f3 = t2.f0;\n",
      "    \n",
      "        t.f4 = t2.f1;\n",
      "    \n",
      "\n",
      "    return t;\n",
      "}\n",
      "std::unordered_map<std::array<char, MAX_STR_LEN>, std::vector<MaterializedTupleRef_V5998582294_0_1_2> > hash_004;\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V538555819_0_1 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 2;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V538555819_0_1 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f1) + sizeof(_t.f1) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V538555819_0_1 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f0) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V538555819_0_1 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V538555819_0_1 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V538555819_0_1));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V538555819_0_1 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V538555819_0_1(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V538555819_0_1 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V538555819_0_1 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V538555819_0_1 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V538555819_0_1 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V538555819_0_1::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V538555819_0_1 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V538555819_0_1::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V538555819_0_1 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V538555819_0_1 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V538555819_0_1& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V1715756987_0_1 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 2;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V1715756987_0_1 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f1) + sizeof(_t.f1) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V1715756987_0_1 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f0) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V1715756987_0_1 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V1715756987_0_1 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V1715756987_0_1));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V1715756987_0_1 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V1715756987_0_1(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V1715756987_0_1 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V1715756987_0_1 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V1715756987_0_1 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V1715756987_0_1 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V1715756987_0_1::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V1715756987_0_1 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V1715756987_0_1::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V1715756987_0_1 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V1715756987_0_1 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V1715756987_0_1& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V7599661600_0_1_2 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        double f1;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f2;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 3;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V7599661600_0_1_2 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f2) + sizeof(_t.f2) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V7599661600_0_1_2 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f1) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V7599661600_0_1_2 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V7599661600_0_1_2 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V7599661600_0_1_2));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V7599661600_0_1_2 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a2\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V7599661600_0_1_2(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V7599661600_0_1_2 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V7599661600_0_1_2 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V7599661600_0_1_2 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f1;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f2 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V7599661600_0_1_2 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V7599661600_0_1_2::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V7599661600_0_1_2 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V7599661600_0_1_2::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V7599661600_0_1_2 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V7599661600_0_1_2 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(double*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V7599661600_0_1_2& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V2824441650_0_1_2 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "        double f2;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 3;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V2824441650_0_1_2 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f2) + sizeof(_t.f2) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V2824441650_0_1_2 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f1) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V2824441650_0_1_2 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V2824441650_0_1_2 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V2824441650_0_1_2));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V2824441650_0_1_2 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a2\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V2824441650_0_1_2(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V2824441650_0_1_2 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V2824441650_0_1_2 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V2824441650_0_1_2 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f2;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V2824441650_0_1_2 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V2824441650_0_1_2::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V2824441650_0_1_2 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V2824441650_0_1_2::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V2824441650_0_1_2 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V2824441650_0_1_2 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(double*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V2824441650_0_1_2& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "std::vector<MaterializedTupleRef_V2824441650_0_1_2> V2824441650;\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V9365257980_0_1_2_3_4 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "        double f2;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f3;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f4;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 5;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V9365257980_0_1_2_3_4 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f4) + sizeof(_t.f4) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V9365257980_0_1_2_3_4 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f3) - ((char*)&_t.f2)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f4) - ((char*)&_t.f3)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f3) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V9365257980_0_1_2_3_4 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V9365257980_0_1_2_3_4 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V9365257980_0_1_2_3_4));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V9365257980_0_1_2_3_4 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a2\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a3\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a4\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "            f3 = a3;\n",
      "        \n",
      "            f4 = a4;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V9365257980_0_1_2_3_4(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "            f3 = std::get<3>(o);\n",
      "        \n",
      "            f4 = std::get<4>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "            std::get<3>(r) = f3;\n",
      "        \n",
      "            std::get<4>(r) = f4;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V9365257980_0_1_2_3_4 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //        f3 = vals[3];\n",
      "    //    \n",
      "    //        f4 = vals[4];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V9365257980_0_1_2_3_4 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V9365257980_0_1_2_3_4 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f2;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f3 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f4 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 << \" \"\n",
      "        \n",
      "        << f3 << \" \"\n",
      "        \n",
      "        << f4 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V9365257980_0_1_2_3_4 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V9365257980_0_1_2_3_4::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V9365257980_0_1_2_3_4 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V9365257980_0_1_2_3_4::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "        o << f3 << \",\";\n",
      "      \n",
      "        o << f4 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V9365257980_0_1_2_3_4 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V9365257980_0_1_2_3_4 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(double*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "         _t.f3 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+3]));\n",
      "      \n",
      "         _t.f4 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+4]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V9365257980_0_1_2_3_4& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "static MaterializedTupleRef_V9365257980_0_1_2_3_4 create_V8572126959(const MaterializedTupleRef_V2824441650_0_1_2& t1, const MaterializedTupleRef_V4184513601_0_1& t2) {\n",
      "    MaterializedTupleRef_V9365257980_0_1_2_3_4 t;\n",
      "    \n",
      "        t.f0 = t1.f0;\n",
      "    \n",
      "        t.f1 = t1.f1;\n",
      "    \n",
      "        t.f2 = t1.f2;\n",
      "    \n",
      "\n",
      "    \n",
      "        t.f3 = t2.f0;\n",
      "    \n",
      "        t.f4 = t2.f1;\n",
      "    \n",
      "\n",
      "    return t;\n",
      "}\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V5980668088_0_1_2_3_4 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        double f1;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f2;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f3;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f4;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 5;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V5980668088_0_1_2_3_4 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f4) + sizeof(_t.f4) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V5980668088_0_1_2_3_4 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f3) - ((char*)&_t.f2)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f4) - ((char*)&_t.f3)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f3) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V5980668088_0_1_2_3_4 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V5980668088_0_1_2_3_4 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V5980668088_0_1_2_3_4));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V5980668088_0_1_2_3_4 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a2\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a3\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a4\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "            f3 = a3;\n",
      "        \n",
      "            f4 = a4;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V5980668088_0_1_2_3_4(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "            f3 = std::get<3>(o);\n",
      "        \n",
      "            f4 = std::get<4>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "            std::get<3>(r) = f3;\n",
      "        \n",
      "            std::get<4>(r) = f4;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V5980668088_0_1_2_3_4 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //        f3 = vals[3];\n",
      "    //    \n",
      "    //        f4 = vals[4];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V5980668088_0_1_2_3_4 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V5980668088_0_1_2_3_4 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f1;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f2 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f3 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f4 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 << \" \"\n",
      "        \n",
      "        << f3 << \" \"\n",
      "        \n",
      "        << f4 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V5980668088_0_1_2_3_4 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V5980668088_0_1_2_3_4::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V5980668088_0_1_2_3_4 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V5980668088_0_1_2_3_4::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "        o << f3 << \",\";\n",
      "      \n",
      "        o << f4 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V5980668088_0_1_2_3_4 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V5980668088_0_1_2_3_4 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(double*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "         _t.f3 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+3]));\n",
      "      \n",
      "         _t.f4 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+4]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V5980668088_0_1_2_3_4& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "static MaterializedTupleRef_V5980668088_0_1_2_3_4 create_V384261100(const MaterializedTupleRef_V7599661600_0_1_2& t1, const MaterializedTupleRef_V4184513601_0_1& t2) {\n",
      "    MaterializedTupleRef_V5980668088_0_1_2_3_4 t;\n",
      "    \n",
      "        t.f0 = t1.f0;\n",
      "    \n",
      "        t.f1 = t1.f1;\n",
      "    \n",
      "        t.f2 = t1.f2;\n",
      "    \n",
      "\n",
      "    \n",
      "        t.f3 = t2.f0;\n",
      "    \n",
      "        t.f4 = t2.f1;\n",
      "    \n",
      "\n",
      "    return t;\n",
      "}\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V3616665512_0_1_2_3_4 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f2;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f3;\n",
      "    \n",
      "        double f4;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 5;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V3616665512_0_1_2_3_4 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f4) + sizeof(_t.f4) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V3616665512_0_1_2_3_4 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f3) - ((char*)&_t.f2)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f4) - ((char*)&_t.f3)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f3) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V3616665512_0_1_2_3_4 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V3616665512_0_1_2_3_4 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V3616665512_0_1_2_3_4));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V3616665512_0_1_2_3_4 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a2\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a3\n",
      "                               ,\n",
      "                       \n",
      "                               const double& a4\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "            f3 = a3;\n",
      "        \n",
      "            f4 = a4;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V3616665512_0_1_2_3_4(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "            f3 = std::get<3>(o);\n",
      "        \n",
      "            f4 = std::get<4>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        double\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "            std::get<3>(r) = f3;\n",
      "        \n",
      "            std::get<4>(r) = f4;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V3616665512_0_1_2_3_4 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //        f3 = vals[3];\n",
      "    //    \n",
      "    //        f4 = vals[4];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V3616665512_0_1_2_3_4 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V3616665512_0_1_2_3_4 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f2 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f3 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f4;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 << \" \"\n",
      "        \n",
      "        << f3 << \" \"\n",
      "        \n",
      "        << f4 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V3616665512_0_1_2_3_4 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V3616665512_0_1_2_3_4::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V3616665512_0_1_2_3_4 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V3616665512_0_1_2_3_4::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "        o << f3 << \",\";\n",
      "      \n",
      "        o << f4 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V3616665512_0_1_2_3_4 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V3616665512_0_1_2_3_4 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "         _t.f3 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+3]));\n",
      "      \n",
      "         _t.f4 = *(double*)(&(rel->relation[row*rel->fields+4]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V3616665512_0_1_2_3_4& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "static MaterializedTupleRef_V3616665512_0_1_2_3_4 create_V4953929627(const MaterializedTupleRef_V538555819_0_1& t1, const MaterializedTupleRef_V5998582294_0_1_2& t2) {\n",
      "    MaterializedTupleRef_V3616665512_0_1_2_3_4 t;\n",
      "    \n",
      "        t.f0 = t1.f0;\n",
      "    \n",
      "        t.f1 = t1.f1;\n",
      "    \n",
      "\n",
      "    \n",
      "        t.f2 = t2.f0;\n",
      "    \n",
      "        t.f3 = t2.f1;\n",
      "    \n",
      "        t.f4 = t2.f2;\n",
      "    \n",
      "\n",
      "    return t;\n",
      "}\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V2392129956_0_1_2 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "        int64_t f2;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 3;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V2392129956_0_1_2 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f2) + sizeof(_t.f2) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V2392129956_0_1_2 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f1) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V2392129956_0_1_2 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V2392129956_0_1_2 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V2392129956_0_1_2));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V2392129956_0_1_2 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const int64_t& a2\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V2392129956_0_1_2(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V2392129956_0_1_2 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V2392129956_0_1_2 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V2392129956_0_1_2 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f2;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V2392129956_0_1_2 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V2392129956_0_1_2::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V2392129956_0_1_2 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V2392129956_0_1_2::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V2392129956_0_1_2 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V2392129956_0_1_2 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(int64_t*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V2392129956_0_1_2& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V863350317_0_1_2_3_4 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "        int64_t f2;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f3;\n",
      "    \n",
      "        int64_t f4;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 5;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V863350317_0_1_2_3_4 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f4) + sizeof(_t.f4) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V863350317_0_1_2_3_4 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f3) - ((char*)&_t.f2)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f4) - ((char*)&_t.f3)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f3) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V863350317_0_1_2_3_4 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V863350317_0_1_2_3_4 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V863350317_0_1_2_3_4));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V863350317_0_1_2_3_4 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const int64_t& a2\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a3\n",
      "                               ,\n",
      "                       \n",
      "                               const int64_t& a4\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "            f3 = a3;\n",
      "        \n",
      "            f4 = a4;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V863350317_0_1_2_3_4(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "            f3 = std::get<3>(o);\n",
      "        \n",
      "            f4 = std::get<4>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "            std::get<3>(r) = f3;\n",
      "        \n",
      "            std::get<4>(r) = f4;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V863350317_0_1_2_3_4 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //        f3 = vals[3];\n",
      "    //    \n",
      "    //        f4 = vals[4];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V863350317_0_1_2_3_4 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V863350317_0_1_2_3_4 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f2;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f3 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f4;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 << \" \"\n",
      "        \n",
      "        << f3 << \" \"\n",
      "        \n",
      "        << f4 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V863350317_0_1_2_3_4 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V863350317_0_1_2_3_4::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V863350317_0_1_2_3_4 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V863350317_0_1_2_3_4::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "        o << f3 << \",\";\n",
      "      \n",
      "        o << f4 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V863350317_0_1_2_3_4 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V863350317_0_1_2_3_4 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(int64_t*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "         _t.f3 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+3]));\n",
      "      \n",
      "         _t.f4 = *(int64_t*)(&(rel->relation[row*rel->fields+4]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V863350317_0_1_2_3_4& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "static MaterializedTupleRef_V863350317_0_1_2_3_4 create_V6789029498(const MaterializedTupleRef_V5812125899_0_1_2& t1, const MaterializedTupleRef_V8082870640_0_1& t2) {\n",
      "    MaterializedTupleRef_V863350317_0_1_2_3_4 t;\n",
      "    \n",
      "        t.f0 = t1.f0;\n",
      "    \n",
      "        t.f1 = t1.f1;\n",
      "    \n",
      "        t.f2 = t1.f2;\n",
      "    \n",
      "\n",
      "    \n",
      "        t.f3 = t2.f0;\n",
      "    \n",
      "        t.f4 = t2.f1;\n",
      "    \n",
      "\n",
      "    return t;\n",
      "}\n",
      "          // can be just the necessary schema\n",
      "  class MaterializedTupleRef_V6013932443_0_1_2_3_4_5 {\n",
      "    // Invariant: data stored in _fields is always in the representation\n",
      "    // specified by _scheme.\n",
      "\n",
      "    public:\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f0;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f1;\n",
      "    \n",
      "        int64_t f2;\n",
      "    \n",
      "        int64_t f3;\n",
      "    \n",
      "        std::array<char, MAX_STR_LEN> f4;\n",
      "    \n",
      "        int64_t f5;\n",
      "    \n",
      "\n",
      "    static constexpr int numFields() {\n",
      "      return 6;\n",
      "    }\n",
      "\n",
      "    // size of all fields in struct removing only end padding\n",
      "    static size_t fieldsSize() {\n",
      "        const MaterializedTupleRef_V6013932443_0_1_2_3_4_5 _t;\n",
      "        return\n",
      "\n",
      "        \n",
      "            ((char*)&_t.f5) + sizeof(_t.f5) - ((char*)&_t);\n",
      "         \n",
      "    }\n",
      "\n",
      "    // debugging function to get storage sizes\n",
      "    static void print_representation() {\n",
      "        const MaterializedTupleRef_V6013932443_0_1_2_3_4_5 _t;\n",
      "\n",
      "        \n",
      "        \n",
      "        std::cout << (((char*)&_t.f1) - ((char*)&_t.f0)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f2) - ((char*)&_t.f1)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f3) - ((char*)&_t.f2)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f4) - ((char*)&_t.f3)) << \",\";\n",
      "        \n",
      "        std::cout << (((char*)&_t.f5) - ((char*)&_t.f4)) << \",\";\n",
      "        \n",
      "        std::cout << (_t.fieldsSize() - (((char*)&_t.f4) - ((char*)&_t)));\n",
      "        std::cout << std::endl;\n",
      "        \n",
      "\n",
      "\n",
      "    }\n",
      "\n",
      "    MaterializedTupleRef_V6013932443_0_1_2_3_4_5 () {\n",
      "      // no-op\n",
      "    }\n",
      "\n",
      "    //template <typename OT>\n",
      "    //MaterializedTupleRef_V6013932443_0_1_2_3_4_5 (const OT& other) {\n",
      "    //  std::memcpy(this, &other, sizeof(MaterializedTupleRef_V6013932443_0_1_2_3_4_5));\n",
      "    //}\n",
      "    \n",
      "    MaterializedTupleRef_V6013932443_0_1_2_3_4_5 (\n",
      "                               const std::array<char, MAX_STR_LEN>& a0\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a1\n",
      "                               ,\n",
      "                       \n",
      "                               const int64_t& a2\n",
      "                               ,\n",
      "                       \n",
      "                               const int64_t& a3\n",
      "                               ,\n",
      "                       \n",
      "                               const std::array<char, MAX_STR_LEN>& a4\n",
      "                               ,\n",
      "                       \n",
      "                               const int64_t& a5\n",
      "                               \n",
      "                       \n",
      "                       ) {\n",
      "        \n",
      "            f0 = a0;\n",
      "        \n",
      "            f1 = a1;\n",
      "        \n",
      "            f2 = a2;\n",
      "        \n",
      "            f3 = a3;\n",
      "        \n",
      "            f4 = a4;\n",
      "        \n",
      "            f5 = a5;\n",
      "        \n",
      "    }\n",
      "\n",
      "    \n",
      "    \n",
      "    \n",
      "\n",
      "\n",
      "    MaterializedTupleRef_V6013932443_0_1_2_3_4_5(const std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "            >& o) {\n",
      "        \n",
      "            f0 = std::get<0>(o);\n",
      "        \n",
      "            f1 = std::get<1>(o);\n",
      "        \n",
      "            f2 = std::get<2>(o);\n",
      "        \n",
      "            f3 = std::get<3>(o);\n",
      "        \n",
      "            f4 = std::get<4>(o);\n",
      "        \n",
      "            f5 = std::get<5>(o);\n",
      "        \n",
      "     }\n",
      "\n",
      "     std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "     > to_tuple() {\n",
      "\n",
      "        std::tuple<\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        ,\n",
      "        \n",
      "        std::array<char, MAX_STR_LEN>\n",
      "        ,\n",
      "        \n",
      "        int64_t\n",
      "        \n",
      "        \n",
      "        > r;\n",
      "        \n",
      "            std::get<0>(r) = f0;\n",
      "        \n",
      "            std::get<1>(r) = f1;\n",
      "        \n",
      "            std::get<2>(r) = f2;\n",
      "        \n",
      "            std::get<3>(r) = f3;\n",
      "        \n",
      "            std::get<4>(r) = f4;\n",
      "        \n",
      "            std::get<5>(r) = f5;\n",
      "        \n",
      "        return r;\n",
      "     }\n",
      "\n",
      "    // shamelessly terrible disambiguation: one solution is named factory methods\n",
      "    //MaterializedTupleRef_V6013932443_0_1_2_3_4_5 (std::vector<int64_t> vals, bool ignore1, bool ignore2) {\n",
      "    //    \n",
      "    //        f0 = vals[0];\n",
      "    //    \n",
      "    //        f1 = vals[1];\n",
      "    //    \n",
      "    //        f2 = vals[2];\n",
      "    //    \n",
      "    //        f3 = vals[3];\n",
      "    //    \n",
      "    //        f4 = vals[4];\n",
      "    //    \n",
      "    //        f5 = vals[5];\n",
      "    //    \n",
      "    //}\n",
      "\n",
      "    // use the tuple schema to interpret the input stream\n",
      "    static MaterializedTupleRef_V6013932443_0_1_2_3_4_5 fromIStream(std::istream& ss, char delim=' ') {\n",
      "        MaterializedTupleRef_V6013932443_0_1_2_3_4_5 _ret;\n",
      "\n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f0 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f1 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f2;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f3;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               // beware; truncate= true, so unckecked truncation for stringlen >= MAX_STR_LEN!\n",
      "               _ret.f4 = to_array<MAX_STR_LEN, std::string, true>(_temp);\n",
      "               }\n",
      "            \n",
      "        \n",
      "            \n",
      "               {\n",
      "               // use operator>> to parse into proper numeric type\n",
      "               ss >> _ret.f5;\n",
      "               //throw away the next delimiter\n",
      "               std::string _temp;\n",
      "               std::getline(ss, _temp, delim);\n",
      "               }\n",
      "            \n",
      "        \n",
      "\n",
      "        return _ret;\n",
      "    }\n",
      "\n",
      "    void toOStream(std::ostream& os) const {\n",
      "        os.write((char*)this, this->fieldsSize());\n",
      "    }\n",
      "\n",
      "    void toOStreamAscii(std::ostream& os) const {\n",
      "        os\n",
      "        \n",
      "        \n",
      "        << f0 << \" \"\n",
      "        \n",
      "        << f1 << \" \"\n",
      "        \n",
      "        << f2 << \" \"\n",
      "        \n",
      "        << f3 << \" \"\n",
      "        \n",
      "        << f4 << \" \"\n",
      "        \n",
      "        << f5 <<\n",
      "        \n",
      "        std::endl;\n",
      "    }\n",
      "\n",
      "    //template <typename Tuple, typename T>\n",
      "    //MaterializedTupleRef_V6013932443_0_1_2_3_4_5 (const Tuple& v0, const T& from) {\n",
      "    //    constexpr size_t v0_size = std::tuple_size<Tuple>::value;\n",
      "    //    constexpr int from_size = T::numFields();\n",
      "    //    static_assert(MaterializedTupleRef_V6013932443_0_1_2_3_4_5::numFields() == (v0_size + from_size), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //    std::memcpy(((char*)&_fields)+v0_size*sizeof(int64_t), &(from._fields), from_size*sizeof(int64_t));\n",
      "    //}\n",
      "\n",
      "    //template <typename Tuple>\n",
      "    //MaterializedTupleRef_V6013932443_0_1_2_3_4_5 (const Tuple& v0) {\n",
      "    //    static_assert(MaterializedTupleRef_V6013932443_0_1_2_3_4_5::numFields() == (std::tuple_size<Tuple>::value), \"constructor only works on same number of total fields\");\n",
      "    //    TupleUtils::assign<0, decltype(_scheme)>(_fields, v0);\n",
      "    //}\n",
      "\n",
      "    std::ostream& dump(std::ostream& o) const {\n",
      "      o << \"Materialized(\";\n",
      "\n",
      "      \n",
      "        o << f0 << \",\";\n",
      "      \n",
      "        o << f1 << \",\";\n",
      "      \n",
      "        o << f2 << \",\";\n",
      "      \n",
      "        o << f3 << \",\";\n",
      "      \n",
      "        o << f4 << \",\";\n",
      "      \n",
      "        o << f5 << \",\";\n",
      "      \n",
      "\n",
      "      o << \")\";\n",
      "      return o;\n",
      "    }\n",
      "\n",
      "    public:\n",
      "    static MaterializedTupleRef_V6013932443_0_1_2_3_4_5 fromRelationInfo(relationInfo * rel, int row) {\n",
      "        // DOESN'T WORK WITH SCHEMAS WITH STRINGS\n",
      "      MaterializedTupleRef_V6013932443_0_1_2_3_4_5 _t;\n",
      "      \n",
      "         _t.f0 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+0]));\n",
      "      \n",
      "         _t.f1 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+1]));\n",
      "      \n",
      "         _t.f2 = *(int64_t*)(&(rel->relation[row*rel->fields+2]));\n",
      "      \n",
      "         _t.f3 = *(int64_t*)(&(rel->relation[row*rel->fields+3]));\n",
      "      \n",
      "         _t.f4 = *(std::array<char, MAX_STR_LEN>*)(&(rel->relation[row*rel->fields+4]));\n",
      "      \n",
      "         _t.f5 = *(int64_t*)(&(rel->relation[row*rel->fields+5]));\n",
      "      \n",
      "      return _t;\n",
      "    }\n",
      "  } ;\n",
      "\n",
      "  std::ostream& operator<< (std::ostream& o, const MaterializedTupleRef_V6013932443_0_1_2_3_4_5& t) {\n",
      "    return t.dump(o);\n",
      "  }\n",
      "\n",
      "static MaterializedTupleRef_V6013932443_0_1_2_3_4_5 create_V4455626933(const MaterializedTupleRef_V4410861523_0_1_2_3& t1, const MaterializedTupleRef_V4839141921_0_1& t2) {\n",
      "    MaterializedTupleRef_V6013932443_0_1_2_3_4_5 t;\n",
      "    \n",
      "        t.f0 = t1.f0;\n",
      "    \n",
      "        t.f1 = t1.f1;\n",
      "    \n",
      "        t.f2 = t1.f2;\n",
      "    \n",
      "        t.f3 = t1.f3;\n",
      "    \n",
      "\n",
      "    \n",
      "        t.f4 = t2.f0;\n",
      "    \n",
      "        t.f5 = t2.f1;\n",
      "    \n",
      "\n",
      "    return t;\n",
      "}\n",
      "std::vector<MaterializedTupleRef_V2340303319_0_1_2> result;\n",
      "\n",
      "\n",
      "StringIndex string_index;\n",
      "void init( ) {\n",
      "}\n",
      "\n",
      "\n",
      "void query(struct relationInfo *resultInfo)\n",
      "{\n",
      "  printf(\"\\nstarting Query stdout\\n\");fflush(stdout);\n",
      "\n",
      "  double start = timer();\n",
      "\n",
      "  uint64 resultcount = 0;\n",
      "  struct relationInfo __result___val;\n",
      "  struct relationInfo *__result__ = &__result___val;\n",
      "\n",
      "\n",
      "  // -----------------------------------------------------------\n",
      "  // Fill in query here\n",
      "  // -----------------------------------------------------------\n",
      "  \n",
      "\n",
      "\n",
      " \n",
      "auto start_V9698976189 = walltime();\n",
      "auto start_0 = walltime();\n",
      "\n",
      "std::cout  << \"timestamp 0 start \" << std::setprecision(15) << start_0 << std::endl;\n",
      "\n",
      "\n",
      "auto V5630118086 = tuplesFromAscii<MaterializedTupleRef_V5630118086_0_1_2>(\"/Users/shrainik/Dropbox/raco/examples/fed_accumulo_spark_c/dnssample_parsed.txt\");\n",
      "\n",
      "auto end_0 = walltime();\n",
      "auto runtime_0 = end_0 - start_0;\n",
      "\n",
      "std::cout  << \"pipeline 0: \" << runtime_0 << \" s\" << std::endl;\n",
      "\n",
      "\n",
      "\n",
      "std::cout  << \"timestamp 0 end \" << std::setprecision(15) << end_0 << std::endl;\n",
      "\n",
      "\n",
      "auto start_3 = walltime();\n",
      "\n",
      "std::cout  << \"timestamp 3 start \" << std::setprecision(15) << start_3 << std::endl;\n",
      "\n",
      "\n",
      "auto V5039388092 = tuplesFromAscii<MaterializedTupleRef_V5039388092_0_1_2>(\"V7341013414\");\n",
      "\n",
      "auto end_3 = walltime();\n",
      "auto runtime_3 = end_3 - start_3;\n",
      "\n",
      "std::cout  << \"pipeline 3: \" << runtime_3 << \" s\" << std::endl;\n",
      "\n",
      "\n",
      "\n",
      "std::cout  << \"timestamp 3 end \" << std::setprecision(15) << end_3 << std::endl;\n",
      "\n",
      "\n",
      "auto start_6 = walltime();\n",
      "\n",
      "std::cout  << \"timestamp 6 start \" << std::setprecision(15) << start_6 << std::endl;\n",
      "\n",
      "\n",
      "auto V240378163 = tuplesFromAscii<MaterializedTupleRef_V240378163_0_1_2>(\"V6957298498\");\n",
      "\n",
      "auto end_6 = walltime();\n",
      "auto runtime_6 = end_6 - start_6;\n",
      "\n",
      "std::cout  << \"pipeline 6: \" << runtime_6 << \" s\" << std::endl;\n",
      "\n",
      "\n",
      "\n",
      "std::cout  << \"timestamp 6 end \" << std::setprecision(15) << end_6 << std::endl;\n",
      "\n",
      "\n",
      "auto start_9 = walltime();\n",
      "\n",
      "std::cout  << \"timestamp 9 start \" << std::setprecision(15) << start_9 << std::endl;\n",
      "\n",
      "\n",
      "auto V4244548386 = tuplesFromAscii<MaterializedTupleRef_V4244548386_0_1_2>(\"V7434941858\");\n",
      "\n",
      "auto end_9 = walltime();\n",
      "auto runtime_9 = end_9 - start_9;\n",
      "\n",
      "std::cout  << \"pipeline 9: \" << runtime_9 << \" s\" << std::endl;\n",
      "\n",
      "\n",
      "\n",
      "std::cout  << \"timestamp 9 end \" << std::setprecision(15) << end_9 << std::endl;\n",
      "\n",
      "\n",
      "auto start_11 = walltime();\n",
      "\n",
      "std::cout  << \"timestamp 11 start \" << std::setprecision(15) << start_11 << std::endl;\n",
      "\n",
      "\n",
      "auto V2824441650 = tuplesFromAscii<MaterializedTupleRef_V2824441650_0_1_2>(\"V5614044245\");\n",
      "\n",
      "auto end_11 = walltime();\n",
      "auto runtime_11 = end_11 - start_11;\n",
      "\n",
      "std::cout  << \"pipeline 11: \" << runtime_11 << \" s\" << std::endl;\n",
      "\n",
      "\n",
      "\n",
      "std::cout  << \"timestamp 11 end \" << std::setprecision(15) << end_11 << std::endl;\n",
      "\n",
      "\n",
      "auto end_V9698976189 = walltime();\n",
      "\n",
      "auto runtime_V9698976189 = end_V9698976189 - start_V9698976189;\n",
      "\n",
      "std::cout << \"pipeline group V9698976189: \"\n",
      "          << runtime_V9698976189\n",
      "          << \" s\" << std::endl;\n",
      "\n",
      "auto start_V625033736 = walltime();\n",
      "// Compiled subplan for CStore(public:adhoc:nameJaccard)[CApply(src_name=$0,dst_name=$1,jaccard_coeff=($2 / (($3 + $4) - $2)))[CApply(u=$0,v=$1,gamma=$2,od=$3,od1=$5)[CHashJoin(($1 = $4))[CApply(u=$0,v=$1,gamma=$2,od=$4)[CHashJoin(($0 = $3))[CApply(u=$0,v=$1,gamma=$2)[CGroupBy($0,$1; COUNT($2))[CApply(row=$0,row1=$1,value1=$2)[CApply(row=$0,row1=$2,value=$4)[CHashJoin(($1 = $3))[CApply(row=$0,col=$1)[CApply(dns=$2,dns1=$4)[CHashJoin(($0 = $3))[CApply(dst_ip=$1,value=$2,dns=$4)[CHashJoin(($0 = $3))[CMemoryScan[CFileScan(public:adhoc:V5614044245)],CApply(ip=$1,dns=$2)[CMemoryScan[CFileScan(public:adhoc:/Users/shrainik/Dropbox/raco/examples/fed_accumulo_spark_c/dnssample_parsed.txt)]]]],CApply(ip=$1,dns=$2)[CMemoryScan[CFileScan(public:adhoc:/Users/shrainik/Dropbox/raco/examples/fed_accumulo_spark_c/dnssample_parsed.txt)]]]]],CApply(row=$1,col=$2,value=$0)[CApply(value=$1,dns=$2,dns1=$4)[CHashJoin(($0 = $3))[CApply(dst_ip=$1,value=$2,dns=$4)[CHashJoin(($0 = $3))[CMemoryScan[CFileScan(public:adhoc:V7434941858)],CApply(ip=$1,dns=$2)[CMemoryScan[CFileScan(public:adhoc:/Users/shrainik/Dropbox/raco/examples/fed_accumulo_spark_c/dnssample_parsed.txt)]]]],CApply(ip=$1,dns=$2)[CMemoryScan[CFileScan(public:adhoc:/Users/shrainik/Dropbox/raco/examples/fed_accumulo_spark_c/dnssample_parsed.txt)]]]]]]]]]],CApply(row=$0,od=$1)[CGroupBy($0; COUNT($1))[CApply(row=$1,value=$0)[CApply(value=$1,dns=$2)[CHashJoin(($0 = $3))[CApply(dst_ip=$1,value=$2,dns=$4)[CHashJoin(($0 = $3))[CMemoryScan[CFileScan(public:adhoc:V6957298498)],CApply(ip=$1,dns=$2)[CMemoryScan[CFileScan(public:adhoc:/Users/shrainik/Dropbox/raco/examples/fed_accumulo_spark_c/dnssample_parsed.txt)]]]],CApply(ip=$1)[CMemoryScan[CFileScan(public:adhoc:/Users/shrainik/Dropbox/raco/examples/fed_accumulo_spark_c/dnssample_parsed.txt)]]]]]]]]],CApply(row=$0,od=$1)[CGroupBy($0; COUNT($1))[CApply(row=$1,value=$0)[CApply(value=$1,dns=$2)[CHashJoin(($0 = $3))[CApply(dst_ip=$1,value=$2,dns=$4)[CHashJoin(($0 = $3))[CMemoryScan[CFileScan(public:adhoc:V7341013414)],CApply(ip=$1,dns=$2)[CMemoryScan[CFileScan(public:adhoc:/Users/shrainik/Dropbox/raco/examples/fed_accumulo_spark_c/dnssample_parsed.txt)]]]],CApply(ip=$1)[CMemoryScan[CFileScan(public:adhoc:/Users/shrainik/Dropbox/raco/examples/fed_accumulo_spark_c/dnssample_parsed.txt)]]]]]]]]]]]\n",
      "\n",
      "auto start_1 = walltime();\n",
      "\n",
      "std::cout  << \"timestamp 1 start \" << std::setprecision(15) << start_1 << std::endl;\n",
      "\n",
      "\n",
      "for (auto t_006 : V5630118086) {\n",
      "    // CApply(ip=$1)\n",
      "MaterializedTupleRef_V7324074249_0 t_005;t_005.f0 = t_006.f1;\n",
      "insert(hash_001, t_005.f0, t_005);\n",
      "} // end scan over V5630118086\n",
      "auto end_1 = walltime();\n",
      "auto runtime_1 = end_1 - start_1;\n",
      "\n",
      "std::cout  << \"pipeline 1: \" << runtime_1 << \" s\" << std::endl;\n",
      "\n",
      "\n",
      "\n",
      "std::cout  << \"timestamp 1 end \" << std::setprecision(15) << end_1 << std::endl;\n",
      "\n",
      "\n",
      "auto start_2 = walltime();\n",
      "\n",
      "std::cout  << \"timestamp 2 start \" << std::setprecision(15) << start_2 << std::endl;\n",
      "\n",
      "\n",
      "for (auto t_006 : V5630118086) {\n",
      "    // CApply(ip=$1,dns=$2)\n",
      "MaterializedTupleRef_V4184513601_0_1 t_008;t_008.f0 = t_006.f1;\n",
      "t_008.f1 = t_006.f2;\n",
      "insert(hash_002, t_008.f0, t_008);\n",
      "} // end scan over V5630118086\n",
      "auto end_2 = walltime();\n",
      "auto runtime_2 = end_2 - start_2;\n",
      "\n",
      "std::cout  << \"pipeline 2: \" << runtime_2 << \" s\" << std::endl;\n",
      "\n",
      "\n",
      "\n",
      "std::cout  << \"timestamp 2 end \" << std::setprecision(15) << end_2 << std::endl;\n",
      "\n",
      "\n",
      "auto start_4 = walltime();\n",
      "\n",
      "std::cout  << \"timestamp 4 start \" << std::setprecision(15) << start_4 << std::endl;\n",
      "\n",
      "\n",
      "for (auto t_009 : V5039388092) {\n",
      "    for (auto V6127434487 : lookup(hash_002, t_009.f0)) {\n",
      "    auto t_010 = create_V2950028442(t_009, V6127434487);\n",
      "    // CApply(dst_ip=$1,value=$2,dns=$4)\n",
      "MaterializedTupleRef_V7965580226_0_1_2 t_007;t_007.f0 = t_010.f1;\n",
      "t_007.f1 = t_010.f2;\n",
      "t_007.f2 = t_010.f4;\n",
      "for (auto V7999694187 : lookup(hash_001, t_007.f0)) {\n",
      "    auto t_011 = create_V8766972874(t_007, V7999694187);\n",
      "    // CApply(value=$1,dns=$2)\n",
      "MaterializedTupleRef_V7687329561_0_1 t_004;t_004.f0 = t_011.f1;\n",
      "t_004.f1 = t_011.f2;\n",
      "// CApply(row=$1,value=$0)\n",
      "MaterializedTupleRef_V9458626130_0_1 t_003;t_003.f0 = t_004.f1;\n",
      "t_003.f1 = t_004.f0;\n",
      "COUNT_insert(group_hash_000, t_003.f0, t_003.f1);\n",
      "}\n",
      "}\n",
      "} // end scan over V5039388092\n",
      "auto end_4 = walltime();\n",
      "auto runtime_4 = end_4 - start_4;\n",
      "\n",
      "std::cout  << \"pipeline 4: \" << runtime_4 << \" s\" << std::endl;\n",
      "\n",
      "\n",
      "\n",
      "std::cout  << \"timestamp 4 end \" << std::setprecision(15) << end_4 << std::endl;\n",
      "\n",
      "\n",
      "auto start_5 = walltime();\n",
      "\n",
      "std::cout  << \"timestamp 5 start \" << std::setprecision(15) << start_5 << std::endl;\n",
      "\n",
      "\n",
      "for (auto it=group_hash_000.begin(); it!=group_hash_000.end(); it++) {\n",
      "    MaterializedTupleRef_V6852235585_0_1 t_012(it->first, it->second);\n",
      "    // CApply(row=$0,od=$1)\n",
      "MaterializedTupleRef_V4839141921_0_1 t_002;t_002.f0 = t_012.f0;\n",
      "t_002.f1 = t_012.f1;\n",
      "insert(hash_000, t_002.f0, t_002);\n",
      "}\n",
      "auto end_5 = walltime();\n",
      "auto runtime_5 = end_5 - start_5;\n",
      "\n",
      "std::cout  << \"pipeline 5: \" << runtime_5 << \" s\" << std::endl;\n",
      "\n",
      "\n",
      "\n",
      "std::cout  << \"timestamp 5 end \" << std::setprecision(15) << end_5 << std::endl;\n",
      "\n",
      "\n",
      "auto start_7 = walltime();\n",
      "\n",
      "std::cout  << \"timestamp 7 start \" << std::setprecision(15) << start_7 << std::endl;\n",
      "\n",
      "\n",
      "for (auto t_018 : V240378163) {\n",
      "    for (auto V1146099582 : lookup(hash_002, t_018.f0)) {\n",
      "    auto t_019 = create_V9723642197(t_018, V1146099582);\n",
      "    // CApply(dst_ip=$1,value=$2,dns=$4)\n",
      "MaterializedTupleRef_V9774699966_0_1_2 t_017;t_017.f0 = t_019.f1;\n",
      "t_017.f1 = t_019.f2;\n",
      "t_017.f2 = t_019.f4;\n",
      "for (auto V9942487185 : lookup(hash_001, t_017.f0)) {\n",
      "    auto t_020 = create_V7968469703(t_017, V9942487185);\n",
      "    // CApply(value=$1,dns=$2)\n",
      "MaterializedTupleRef_V5287524902_0_1 t_016;t_016.f0 = t_020.f1;\n",
      "t_016.f1 = t_020.f2;\n",
      "// CApply(row=$1,value=$0)\n",
      "MaterializedTupleRef_V3087637349_0_1 t_015;t_015.f0 = t_016.f1;\n",
      "t_015.f1 = t_016.f0;\n",
      "COUNT_insert(group_hash_001, t_015.f0, t_015.f1);\n",
      "}\n",
      "}\n",
      "} // end scan over V240378163\n",
      "auto end_7 = walltime();\n",
      "auto runtime_7 = end_7 - start_7;\n",
      "\n",
      "std::cout  << \"pipeline 7: \" << runtime_7 << \" s\" << std::endl;\n",
      "\n",
      "\n",
      "\n",
      "std::cout  << \"timestamp 7 end \" << std::setprecision(15) << end_7 << std::endl;\n",
      "\n",
      "\n",
      "auto start_8 = walltime();\n",
      "\n",
      "std::cout  << \"timestamp 8 start \" << std::setprecision(15) << start_8 << std::endl;\n",
      "\n",
      "\n",
      "for (auto it=group_hash_001.begin(); it!=group_hash_001.end(); it++) {\n",
      "    MaterializedTupleRef_V1689264244_0_1 t_021(it->first, it->second);\n",
      "    // CApply(row=$0,od=$1)\n",
      "MaterializedTupleRef_V8082870640_0_1 t_014;t_014.f0 = t_021.f0;\n",
      "t_014.f1 = t_021.f1;\n",
      "insert(hash_003, t_014.f0, t_014);\n",
      "}\n",
      "auto end_8 = walltime();\n",
      "auto runtime_8 = end_8 - start_8;\n",
      "\n",
      "std::cout  << \"pipeline 8: \" << runtime_8 << \" s\" << std::endl;\n",
      "\n",
      "\n",
      "\n",
      "std::cout  << \"timestamp 8 end \" << std::setprecision(15) << end_8 << std::endl;\n",
      "\n",
      "\n",
      "auto start_10 = walltime();\n",
      "\n",
      "std::cout  << \"timestamp 10 start \" << std::setprecision(15) << start_10 << std::endl;\n",
      "\n",
      "\n",
      "for (auto t_028 : V4244548386) {\n",
      "    for (auto V4072883217 : lookup(hash_002, t_028.f0)) {\n",
      "    auto t_029 = create_V8132519124(t_028, V4072883217);\n",
      "    // CApply(dst_ip=$1,value=$2,dns=$4)\n",
      "MaterializedTupleRef_V2650345716_0_1_2 t_027;t_027.f0 = t_029.f1;\n",
      "t_027.f1 = t_029.f2;\n",
      "t_027.f2 = t_029.f4;\n",
      "for (auto V686248993 : lookup(hash_002, t_027.f0)) {\n",
      "    auto t_030 = create_V2101838709(t_027, V686248993);\n",
      "    // CApply(value=$1,dns=$2,dns1=$4)\n",
      "MaterializedTupleRef_V2352247948_0_1_2 t_026;t_026.f0 = t_030.f1;\n",
      "t_026.f1 = t_030.f2;\n",
      "t_026.f2 = t_030.f4;\n",
      "// CApply(row=$1,col=$2,value=$0)\n",
      "MaterializedTupleRef_V5998582294_0_1_2 t_025;t_025.f0 = t_026.f1;\n",
      "t_025.f1 = t_026.f2;\n",
      "t_025.f2 = t_026.f0;\n",
      "insert(hash_004, t_025.f1, t_025);\n",
      "}\n",
      "}\n",
      "} // end scan over V4244548386\n",
      "auto end_10 = walltime();\n",
      "auto runtime_10 = end_10 - start_10;\n",
      "\n",
      "std::cout  << \"pipeline 10: \" << runtime_10 << \" s\" << std::endl;\n",
      "\n",
      "\n",
      "\n",
      "std::cout  << \"timestamp 10 end \" << std::setprecision(15) << end_10 << std::endl;\n",
      "\n",
      "\n",
      "auto start_12 = walltime();\n",
      "\n",
      "std::cout  << \"timestamp 12 start \" << std::setprecision(15) << start_12 << std::endl;\n",
      "\n",
      "\n",
      "for (auto t_034 : V2824441650) {\n",
      "    for (auto V4785774111 : lookup(hash_002, t_034.f0)) {\n",
      "    auto t_035 = create_V8572126959(t_034, V4785774111);\n",
      "    // CApply(dst_ip=$1,value=$2,dns=$4)\n",
      "MaterializedTupleRef_V7599661600_0_1_2 t_033;t_033.f0 = t_035.f1;\n",
      "t_033.f1 = t_035.f2;\n",
      "t_033.f2 = t_035.f4;\n",
      "for (auto V5314670053 : lookup(hash_002, t_033.f0)) {\n",
      "    auto t_036 = create_V384261100(t_033, V5314670053);\n",
      "    // CApply(dns=$2,dns1=$4)\n",
      "MaterializedTupleRef_V1715756987_0_1 t_032;t_032.f0 = t_036.f2;\n",
      "t_032.f1 = t_036.f4;\n",
      "// CApply(row=$0,col=$1)\n",
      "MaterializedTupleRef_V538555819_0_1 t_031;t_031.f0 = t_032.f0;\n",
      "t_031.f1 = t_032.f1;\n",
      "for (auto V2292152580 : lookup(hash_004, t_031.f1)) {\n",
      "    auto t_037 = create_V4953929627(t_031, V2292152580);\n",
      "    // CApply(row=$0,row1=$2,value=$4)\n",
      "MaterializedTupleRef_V8887445041_0_1_2 t_024;t_024.f0 = t_037.f0;\n",
      "t_024.f1 = t_037.f2;\n",
      "t_024.f2 = t_037.f4;\n",
      "// CApply(row=$0,row1=$1,value1=$2)\n",
      "MaterializedTupleRef_V9266923760_0_1_2 t_023;t_023.f0 = t_024.f0;\n",
      "t_023.f1 = t_024.f1;\n",
      "t_023.f2 = t_024.f2;\n",
      "COUNT_insert(group_hash_002, t_023.f0, t_023.f1, t_023.f2);\n",
      "}\n",
      "}\n",
      "}\n",
      "} // end scan over V2824441650\n",
      "auto end_12 = walltime();\n",
      "auto runtime_12 = end_12 - start_12;\n",
      "\n",
      "std::cout  << \"pipeline 12: \" << runtime_12 << \" s\" << std::endl;\n",
      "\n",
      "\n",
      "\n",
      "std::cout  << \"timestamp 12 end \" << std::setprecision(15) << end_12 << std::endl;\n",
      "\n",
      "\n",
      "auto start_13 = walltime();\n",
      "\n",
      "std::cout  << \"timestamp 13 start \" << std::setprecision(15) << start_13 << std::endl;\n",
      "\n",
      "\n",
      "for (auto it=group_hash_002.begin(); it!=group_hash_002.end(); it++) {\n",
      "    MaterializedTupleRef_V2392129956_0_1_2 t_038(it->first.first, it->first.second, it->second);\n",
      "    // CApply(u=$0,v=$1,gamma=$2)\n",
      "MaterializedTupleRef_V5812125899_0_1_2 t_022;t_022.f0 = t_038.f0;\n",
      "t_022.f1 = t_038.f1;\n",
      "t_022.f2 = t_038.f2;\n",
      "for (auto V2585427246 : lookup(hash_003, t_022.f0)) {\n",
      "    auto t_039 = create_V6789029498(t_022, V2585427246);\n",
      "    // CApply(u=$0,v=$1,gamma=$2,od=$4)\n",
      "MaterializedTupleRef_V4410861523_0_1_2_3 t_013;t_013.f0 = t_039.f0;\n",
      "t_013.f1 = t_039.f1;\n",
      "t_013.f2 = t_039.f2;\n",
      "t_013.f3 = t_039.f4;\n",
      "for (auto V6614019334 : lookup(hash_000, t_013.f1)) {\n",
      "    auto t_040 = create_V4455626933(t_013, V6614019334);\n",
      "    // CApply(u=$0,v=$1,gamma=$2,od=$3,od1=$5)\n",
      "MaterializedTupleRef_V4104807128_0_1_2_3_4 t_001;t_001.f0 = t_040.f0;\n",
      "t_001.f1 = t_040.f1;\n",
      "t_001.f2 = t_040.f2;\n",
      "t_001.f3 = t_040.f3;\n",
      "t_001.f4 = t_040.f5;\n",
      "// CApply(src_name=$0,dst_name=$1,jaccard_coeff=($2 / (($3 + $4) - $2)))\n",
      "MaterializedTupleRef_V2340303319_0_1_2 t_000;t_000.f0 = t_001.f0;\n",
      "t_000.f1 = t_001.f1;\n",
      "t_000.f2 = ( (t_001.f2) / (( (( (t_001.f3) + (t_001.f4) )) - (t_001.f2) )) );\n",
      "result.push_back(t_000);\n",
      "std::cout << t_000 << std::endl;\n",
      "      \n",
      "}\n",
      "}\n",
      "}\n",
      "auto end_13 = walltime();\n",
      "auto runtime_13 = end_13 - start_13;\n",
      "\n",
      "std::cout  << \"pipeline 13: \" << runtime_13 << \" s\" << std::endl;\n",
      "\n",
      "\n",
      "\n",
      "std::cout  << \"timestamp 13 end \" << std::setprecision(15) << end_13 << std::endl;\n",
      "\n",
      "\n",
      "auto end_V625033736 = walltime();\n",
      "\n",
      "auto runtime_V625033736 = end_V625033736 - start_V625033736;\n",
      "\n",
      "std::cout << \"pipeline group V625033736: \"\n",
      "          << runtime_V625033736\n",
      "          << \" s\" << std::endl;\n",
      "\n",
      "\n",
      "  \n",
      "\n",
      "  // return final result\n",
      "  resultInfo->tuples = __result__->tuples;\n",
      "  resultInfo->fields = __result__->fields;\n",
      "  resultInfo->relation = __result__->relation;\n",
      "\n",
      "}\n",
      "\n",
      "\n",
      "\n",
      "int main(int argc, char **argv) {\n",
      "\n",
      "  struct relationInfo resultInfo;\n",
      "\n",
      "  init();\n",
      "\n",
      "    printf(\"post-init stdout\\n\");fflush(stdout);\n",
      "\n",
      "  // Execute the query\n",
      "  query(&resultInfo);\n",
      "\n",
      "    printf(\"post-query stdout\\n\");fflush(stdout);\n",
      "\n",
      "    std::ofstream outputfile;\n",
      "    outputfile.open(\"matrix_output\");\n",
      "    for (auto outTuple : result) {\n",
      "        outTuple.toOStreamAscii(outputfile);\n",
      "    }\n",
      "    outputfile.close();\n",
      "#ifdef ZAPPA\n",
      "//  printrelation(&resultInfo);\n",
      "#endif\n",
      "//  free(resultInfo.relation);\n",
      "\n",
      "    printf(\"exiting stdout\\n\");fflush(stdout);\n",
      "\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "##Submit the plan for federated execution\n",
    "fed_conn.execute_query(federated_plan)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}