More vuex to nodes and node activity

* Added different color with sockets with values

Makefile

@@ -45,8 +45,10 @@ builder:
 
 test: 
 	make -C go test
+generate:
+	make -C go generate
 
 
 
-.PHONY: all clean frontend backend builder
+.PHONY: all clean frontend backend builder generate
 

TODO.md

@@ -2,6 +2,8 @@
 
 ## Ideas
 
+* [ ] FlowServer: Maintain flow to keep variables
+* [ ] Create a special operator "var" to handle local data
 * [x] triggers, vertical slots in nodes, handling events giving the possibility
       to trigger execution of subsequent nodes based on links
 * [ ] handle Trigger activity to show highlighted trigger

browser/vue-flow/src/assets/dark-theme.css

@@ -1,19 +1,20 @@
 .dark {
-  --header-background: #212121 !important;
-  --header-color: #eee !important;
-  --background: #303030 !important;
-  --background-secondary: #424242 !important;
-  --background-tertiary: #323232 !important;
-  --normal: #eee !important;
-  --normal-secondary: #777 !important;
-
-  /* --primary: #f57c00 !important; */
-  --primary: #c55c00 !important;
-  --primary-darker: #a53c00 !important;
-  --primary-lighter: #ff8c20 !important;
-  --node-label: var(--normal) !important;
-  --node-socket: var(--primary) !important;
-  --link-hover: var(--primary) !important;
+  --header-background: #212121;
+  --header-color: #eee;
+  --background: #303030;
+  --background-secondary: #424242;
+  --background-tertiary: #323232;
+  --normal: #eee;
+  --normal-secondary: #777;
+
+  /* --primary: #f57c00 ; */
+  --primary: #c55c00;
+  --primary-darker: #a53c00;
+  --primary-lighter: #ff8c20;
+  --node-label: var(--normal);
+  --node-socket: var(--primary);
+  --node-socket--withvalue: black;
+  --link-hover: var(--primary);
   --selector-background: rgba(200, 150, 50, 0.1);
   --selector-color: var(--primary);
 }

browser/vue-flow/src/assets/default-theme.css

@@ -14,6 +14,7 @@
   --secondary-inverse: #fff;
   --node-label: #fff;
   --node-socket: #444;
+  --node-socket--withvalue: #44a;
   --link-hover: #f00;
   --selector-background: rgba(0, 0, 200, 0.1);
   --selector-color: var(--primary);
@@ -34,8 +35,8 @@
 
 .primary-inverse {
   position: relative;
-  background: var(--primary);
-  color: var(--primary-inverse);
+  background: var(--primary) !important;
+  color: var(--primary-inverse) !important;
 }
 
 button.active:hover::after,
@@ -185,7 +186,7 @@ h3 {
 }
 
 .flow-container__control button {
-  color: var(--normal) !important;
+  color: var(--normal);
 }
 
 .flow-container__info {

browser/vue-flow/src/components/flow/editor.js

@@ -40,6 +40,11 @@ export default {
   },
   computed: {
     ...mapGetters('flow', ['registry', 'activity', 'nodeData', 'nodeById']),
+    outputNode () {
+      const n = this.nodeData.nodes.find(n => n.src === 'Output')
+
+      return !!n
+    },
     viewClasses () {
       return {
         'flow-linking': this.linking || this.stickySockets,
@@ -71,13 +76,9 @@ export default {
         return {
           transform: `translate(${node.x} ${node.y})`,
           id: node.id,
-          label: node.label,
-          inputs: nodeClass.inputs,
-          output: nodeClass.output,
           // Combine this into one
           match: highlight,
           dragging: this.dragging && !!this.dragging[node.id],
-          nodeStyle: nodeClass.style,
           activity: this.activity && this.activity.nodes && this.activity.nodes[node.id]
         }
       }
@@ -153,6 +154,7 @@ export default {
   },
   methods: {
     ...mapActions('flow', [
+      'NOTIFICATION_ADD',
       'DOCUMENT_SYNC',
       'NODE_RAISE', 'NODE_UPDATE', 'NODE_ADD', 'NODE_REMOVE', 'NODE_INSPECT', 'NODE_PROCESS',
       'LINK_ADD', 'LINK_REMOVE',
@@ -386,7 +388,9 @@ export default {
       }
       if (ev.button !== 0) return // first button
       if (ev.shiftKey) {
-        this.socketPointerDown(tnode.id, ev, {out: 0})
+        if (this.registry[tnode.src].output) {
+          this.socketPointerDown(tnode.id, ev, {out: 0})
+        }
         return
       }
       // this.NODE_INSPECT(tnode.id)
@@ -450,6 +454,13 @@ export default {
     //
     // STORE
     nodeAdd (src, x = 100, y = 100) {
+      if (src === 'Output') {
+        const n = this.nodeData.nodes.find(n => n.src === src)
+        if (n) {
+          this.NOTIFICATION_ADD('Output node already exists')
+          return
+        }
+      }
       const newNode = {
         id: utils.guid(),
         x: x,
@@ -510,21 +521,11 @@ export default {
           this.selector = null
         }})
     },
+    documentProcess () {
+      const n = this.nodeData.nodes.find(n => n.src === 'Output')
+      this.NODE_PROCESS(n.id)
+    },
 
-    // service events
-    /* sendFlowEvent (type, param) {
-      this.$flowService[type](param)
-    }, */
-
-    //
-    // DOCUMENT_DYNC () {
-    // this.DOCUMENT_SYNC()
-    // this.$flowService.documentUpdate(this.nodeData, this.$route.params.sessId)
-    // },
-    /* sendDocumentRun () {
-      console.log('Document running')
-      this.$flowService.documentRun(this.nodeData, this.$route.params.sessId)
-    }, */
     // HELPERS depending on svg ref
     createSVGPoint (x, y) {
       const p = this.$refs.svg.createSVGPoint()

browser/vue-flow/src/components/flow/editor.vue

@@ -72,6 +72,7 @@
       <button v-if="panzoom.x!=0 || panzoom.y!=0 || panzoom.zoom!=1" @click="panzoomReset">
         Reset view
       </button>
+      <button v-if="outputNode" @click="documentProcess" class="primary-inverse">RUN</button>
     </div>
     <div class="flow-container__info">
       x:{{ panzoom.x.toFixed(2) }} y:{{ panzoom.y.toFixed(2) }} scale:{{ panzoom.zoom.toFixed(2) }}

browser/vue-flow/src/components/flow/node.vue

@@ -75,7 +75,6 @@
       v-bind="inputProps(i)"
       @mousedown.stop.prevent="socketPointerDown($event, {in:i})"
       class="flow-node__socket flow-node__socket--inputs"
-      :class="{'flow-node__socket--match': match.type == 'socket-in' && (inp.type == match.dtype || match.dtype == 'interface {}' || inp.type=='interface {}')}"
     >
       <circle r="5" />
       <!--<rect :x="-16-inputLabel(i).length*7 " :y="-10" :width="inputLabel(i).length*7" :height="20" fill="red" stroke-width="0"/>-->
@@ -101,7 +100,6 @@
       :key="'out'+0"
       @mousedown.stop.prevent="socketPointerDown($event, {out:0})"
       class="flow-node__socket flow-node__socket--outputs"
-      :class="{ 'flow-node__socket--match': match.type =='socket-out' && (output.type == match.dtype || match.dtype == 'interface {}' || output.type == 'interface {}'), }"
     >
       <circle r="5" />
 
@@ -143,13 +141,14 @@
     />
 
     <flow-node-activity
-      v-if="activity"
+      v-if="nodeActivity"
       :node-id="id"
       :transform="'translate('+bodyProps.width/2 +','+ -bodyProps.height/2 +')'"/>
   </g>
 </template>
 
 <script>
+import {mapGetters} from 'vuex'
 import FlowNodeActivity from './node-activity'
 
 import utils from '@/utils/utils'
@@ -166,14 +165,11 @@ export default {
   components: {FlowNodeActivity},
   props: {
     'id': {type: String, required: true},
-    'label': {type: String, default: ''},
-    'inputs': {type: Array, default: () => []},
-    'output': {type: Object, default: ''},
     'match': {type: Object, default: () => {}},
     'dragging': {type: Boolean, default: false},
-    'selected': {type: Boolean, default: false},
-    'activity': {type: Object, default: () => {}},
-    'nodeStyle': {type: Object, default: () => {}}
+    'selected': {type: Boolean, default: false}
+    // 'activity': {type: Object, default: () => {}},
+    // 'nodeStyle': {type: Object, default: () => {}}
   },
   data () {
     return {
@@ -183,16 +179,30 @@ export default {
     }
   },
   computed: {
+    ...mapGetters('flow', ['nodeData', 'registry', 'activity']),
+    node () {
+      return this.nodeData.nodes.find(n => n.id === this.id)
+    },
+    inputs () {
+      return this.registry[this.node.src].inputs || []
+    },
+    output () {
+      return this.registry[this.node.src].output
+    },
+    nodeActivity () {
+      return this.activity && this.activity.nodes && this.activity.nodes[this.id]
+    },
     style () {
-      return this.nodeStyle || {}
+      return this.registry[this.node.src].style || {}
     },
+
     status () {
-      return this.activity && (this.activity.status || '')
+      return this.nodeActivity && (this.nodeActivity.status || '')
     },
     labelWrap () {
       let wrapThreshold = 8 // initial wrap threshold
       const opt = shapeOpts[this.style.shape] || shapeOpts.default
-      return utils.textWrap(this.label, wrapThreshold, opt.textWrap)
+      return utils.textWrap(this.node.label, wrapThreshold, opt.textWrap)
     },
     labelProps () {
       return {
@@ -225,8 +235,17 @@ export default {
     },
     inputProps () {
       return (i) => {
+        let defaultInput = this.node.defaultInputs[i]
+
+        const inp = this.inputs[i]
+        const match = this.match.type === 'socket-in' && (inp.type === this.match.dtype || this.match.dtype === 'interface {}' || inp.type === 'interface {}')
+
         const {x, y} = this.inputPos(i)
         return {
+          class: {
+            'flow-node__socket--match': match,
+            'flow-node__socket--withvalue': !!defaultInput
+          },
           transform: `translate(${x} ${y})`
         }
       }
@@ -234,9 +253,13 @@ export default {
     outputProps () {
       return (i) => {
         const {x, y} = this.outputPos(i)
+        const outp = this.output
+        const match = this.match.type === 'socket-out' && (outp.type === this.match.dtype || this.match.dtype === 'interface {}' || outp.type === 'interface {}')
         return {
           transform: `translate(${x} ${y})`,
-          r: 5
+          class: {
+            'flow-node__socket--match': match
+          }
         }
       }
     },
@@ -250,6 +273,10 @@ export default {
         return input
       }
     },
+    defInput () {
+      return (i) => {
+      }
+    },
     inputLabelBGProps () {
       return (i) => {
         if (!this.$refs.inputLabel) {
@@ -386,6 +413,11 @@ export default {
   stroke-width:10;
 }
 
+.flow-node__socket--withvalue {
+  fill: var(--node-socket--withvalue) !important;
+  stroke: var(--node-socket-withvalue) !important;
+}
+
 .flow-linking .flow-node__socket {
   opacity:1;
   pointer-events: inherit;

browser/vue-flow/src/components/panel-inspector.vue

@@ -55,16 +55,16 @@
 
         <div class="flow-inspector__area flow-inspector--activity ">
           <div
-            v-if="activity && activity[nodeInspect.id] && activity[nodeInspect.id].data"
+            v-if="nodeActivity && nodeActivity.data"
             class="flow-inspector--properties-result">
             <label>Result</label>
-            <div class="property">{{ activity && activity[nodeInspect.id] && activity[nodeInspect.id].data }}</div>
+            <div class="property">{{ nodeActivity && nodeActivity.data }}</div>
           </div>
           <div
-            v-if="activity && activity[nodeInspect.id] && activity[nodeInspect.id].error"
+            v-if="nodeActivity && nodeActivity.error"
             class="flow-inspector--properties-error">
             <label>Error</label>
-            <div class="property">{{ activity && activity[nodeInspect.id] && activity[nodeInspect.id].error }}</div>
+            <div class="property">{{ nodeActivity && nodeActivity.error }}</div>
           </div>
         </div>
         <!-- PARAMETERS -->
@@ -112,7 +112,10 @@ export default {
     }
   },
   computed: {
-    ...mapGetters('flow', ['registry', 'activity'])
+    ...mapGetters('flow', ['registry', 'activity']),
+    nodeActivity () {
+      return this.activity && this.activity.nodes && this.activity.nodes[this.nodeInspect.id]
+    }
   },
   watch: {
     '$store.state.flow.nodeInspect' (node) {

browser/vue-flow/src/store/flow/default-registry.js

@@ -5,12 +5,23 @@ export default{
     style: { color: '#686', shape: 'circle' },
     props: {} // should be sent in the node
   },
+  'Variable': {
+    categories: ['core'],
+    inputs: [{type: 'interface {}', name: 'initial'}],
+    output: {type: 'interface {}'},
+    style: { color: '#88a', shape: 'circle' }
+  },
   'Const': {
     categories: ['core'],
     output: {type: 'interface {}'},
     style: { color: '#555' }
     // , props: {value: ''}
   },
+  'Output': {
+    categories: ['core'],
+    inputs: [{type: 'interface {}'}],
+    style: { color: '#111', shape: 'circle' }
+  },
   'Notify': {
     categories: ['flow-web'],
     inputs: [{type: 'interface {}'}, {type: 'string', name: 'msg'}],

browser/vue-flow/src/store/ws.js

@@ -72,7 +72,7 @@ export default store => {
     store.commit(flow.REGISTRY_UPDATE, Object.assign({}, defRegistry, res))
   })
   flowService.on('nodeActivity', (v) => {
-    store.commit(flow.ACTIVITY_UPDATE, v.data || {})
+    store.commit(flow.ACTIVITY_UPDATE, v.data || {nodes: {}})
   })
   flowService.on('sessionNotify', (v) => {
     // ACTION

go/src/flow/flow_test.go

@@ -223,7 +223,8 @@ func TestLocalRegistry(t *testing.T) {
 	a := assert.A(t)
 
 	r := registry.New()
-	e := r.Register("test", func() string { return "" })
+	e, err := r.Register("test", func() string { return "" })
+	a.Eq(err, nil, "should not error registering a func")
 	a.NotEq(e, nil, "registered in a local register")
 
 	f := flow.New()
@@ -231,41 +232,9 @@ func TestLocalRegistry(t *testing.T) {
 	op, _ := f.Op("test")
 	a.NotEq(op, nil, "operation should be valid")
 
-	op, err := f.Op("none")
+	op, err = f.Op("none")
 	a.NotEq(err, nil, "flow should contain an error")
 }
-func TestFlowParam(t *testing.T) {
-	a := assert.A(t)
-
-	r := registry.New()
-	f := flow.New()
-	f.SetRegistry(r)
-
-	r.Register("myflow", func(f *flow.Flow) flow.Data {
-		f.Data["test"] = "other test"
-		return f.Data["test"]
-	})
-
-	v := f.Var("test", "hello test")
-
-	vres, err := v.Process()
-	a.Eq(err, nil, "should not error reading var")
-	a.Eq(vres, "hello test", "should be the value setted by the var operation")
-
-	t.Log("The flow:", f)
-
-	op, err := f.Op("myflow")
-	a.Eq(err, nil, "should not error fetching operation")
-	r1, err := op.Process()
-	a.Eq(err, nil, "should not error executing operation")
-	a.Eq(r1, "other test", "should be equal")
-
-	vres, err = v.Process()
-	a.Eq(err, nil, "should not error reading var")
-	a.Eq(vres, "other test", "should be the value setted by the previous operation")
-	t.Log(f)
-
-}
 
 func init() {
 	registry.Register("vecmul", VecMul)

go/src/flow/operation.go

@@ -136,22 +136,10 @@ func (f *Flow) makeExecutor(id string, fn interface{}) executorFunc {
 // NEW PARALLEL PROCESSING
 ///////////
 func (f *Flow) processInputs(ctx OpCtx, op *operation, fnval reflect.Value, params ...Data) ([]reflect.Value, error) {
-	// Flow injector
 	nInputs := fnval.Type().NumIn()
 
 	// Total inputs
-	OcallParam := make([]reflect.Value, nInputs)
-	callParam := OcallParam
-	offs := 0
-
-	// Inject flow if the first param is of type Flow
-	if nInputs > 0 && fnval.Type().In(0) == reflect.TypeOf(f) {
-		OcallParam[0] = reflect.ValueOf(f)
-		offs = 1
-		nInputs--
-		//shift one to process inputs
-		callParam = OcallParam[1:]
-	}
+	callParam := make([]reflect.Value, nInputs)
 
 	if nInputs != len(op.inputs) {
 		return nil, fmt.Errorf("expect %d inputs got %d", nInputs, len(op.inputs))
@@ -165,7 +153,7 @@ func (f *Flow) processInputs(ctx OpCtx, op *operation, fnval reflect.Value, para
 	for i, in := range op.inputs {
 		go func(i int, in *operation) {
 			defer wg.Done()
-			inTyp := fnval.Type().In(i + offs)
+			inTyp := fnval.Type().In(i)
 			/////////////////
 			// Executor
 			fr, err := in.executor(ctx, params...)
@@ -206,7 +194,7 @@ func (f *Flow) processInputs(ctx OpCtx, op *operation, fnval reflect.Value, para
 		return nil, errors.New(callErrors)
 	}
 
-	return OcallParam, nil
+	return callParam, nil
 }
 
 // DefVar define var operation with optional initial
@@ -253,6 +241,8 @@ func (f *Flow) DefOp(id string, name string, params ...interface{}) (Operation,
 			inputs[i], _ = c.(*operation)
 		}
 	}
+	// If special executor we attach our func
+
 	// Grab executor here
 	registryFn, err := f.registry.Get(name)
 	if err != nil {

go/src/flow/registry/describer.go

@@ -93,3 +93,48 @@ func (d EDescriber) Extra(name string, value interface{}) EDescriber {
 	}
 	return d
 }
+
+/*/ Describer
+type Describer struct {
+	target *Description
+}
+
+// Description set module description
+func (d *Describer) Description(m string) *Describer {
+	d.target.Desc = m
+	return d
+
+}
+
+//Tags of the entry
+func (d *Describer) Tags(cat ...string) *Describer {
+	d.target.Tags = cat
+	return d
+}
+
+// Inputs description for Inputs
+func (d *Describer) Inputs(desc ...string) *Describer {
+	for i, dstr := range desc {
+		if i >= len(d.target.Inputs) { // do nothing
+			return d
+		}
+		curDesc := d.target.Inputs[i]
+		d.target.Inputs[i] = DescType{curDesc.Type, dstr}
+	}
+	return d
+}
+
+// Output description for Input
+func (d *Describer) Output(desc string) *Describer {
+	d.target.Output = DescType{
+		d.target.Output.Type,
+		desc,
+	}
+	return d
+}
+
+// Extra information on entry
+func (d *Describer) Extra(name string, extra interface{}) *Describer {
+	d.target.Extra[name] = extra
+	return d
+}*/

go/src/flow/registry/describer_test.go

@@ -12,9 +12,9 @@ func TestMakeBatch(t *testing.T) {
 	r := registry.New()
 
 	b := registry.Describer(
-		r.Add(strings.Split, strings.Join),
-		r.Add(strings.Compare),
-		r.Register("named", strings.Compare),
+		r.MustAdd(strings.Split, strings.Join),
+		r.MustAdd(strings.Compare),
+		r.MustRegister("named", strings.Compare),
 	)
 	a.Eq(len(b), 4, "should have 3 entries in batch")
 
@@ -25,5 +25,23 @@ func TestMakeBatch(t *testing.T) {
 		a.Eq(en.Description.Inputs[0].Name, "str", "first input should be string")
 		a.Eq(en.Description.Output.Name, "result", "output should be equal")
 	}
+}
+func TestNilDescription(t *testing.T) {
+	a := assert.A(t)
+	r := registry.New()
+
+	r.MustRegister("test", strings.Compare)
+	e, _ := r.Entry("test")
+	e.Description = nil
+
+	b := registry.Describer(e)
+	a.Eq(len(b), 1, "should have 3 entries in batch")
+
+	// Testing adding to a nil description
+	b.Tags("")
+	b.Description("")
+	b.Inputs("str")
+	b.Output("result")
+	b.Extra("v", "v")
 
 }

go/src/flow/registry/entry.go

@@ -18,45 +18,36 @@ type Entry struct {
 	Inputs      []reflect.Type
 	Output      reflect.Type
 	Description *Description
-	err         error
 }
 
 // NewEntry creates and describes a New Entry
-func NewEntry(r *R, fn interface{}) *Entry {
+func NewEntry(r *R, fn interface{}) (*Entry, error) {
 	e := &Entry{registry: r, fn: fn}
 
 	fntyp := reflect.TypeOf(e.fn)
 	if fntyp.Kind() != reflect.Func {
-		e.err = ErrNotAFunc
-		return e
+		return nil, ErrNotAFunc
 	}
-	if fntyp.NumOut() == 0 {
-		e.err = ErrOutput
-		return e
-	}
-	outTyp := fntyp.Out(0)
-	if outTyp.Kind() == reflect.Func {
-		outTyp.Out(0)
+	var Output DescType
+	if fntyp.NumOut() > 0 {
+		outTyp := fntyp.Out(0)
+		if outTyp.Kind() == reflect.Func {
+			outTyp.Out(0)
+		}
+		Output = DescType{fmt.Sprint(outTyp), ""}
+		e.Output = outTyp // ?
+
 	}
 
 	fnTyp := reflect.TypeOf(e.fn)
 	nInputs := fnTyp.NumIn()
-	// Experimental
-	offs := 0
-	if fnTyp.NumIn() > 0 && fnTyp.In(0).String() == "*flow.Flow" {
-		nInputs--
-		offs = 1
-	}
-	///
 
 	Inputs := make([]DescType, nInputs)
 	for i := 0; i < nInputs; i++ {
-		inTyp := fnTyp.In(i + offs)
+		inTyp := fnTyp.In(i)
 		Inputs[i] = DescType{fmt.Sprint(inTyp), ""}
 		e.Inputs = append(e.Inputs, inTyp) // ?
 	}
-	Output := DescType{fmt.Sprint(outTyp), ""}
-	e.Output = outTyp // ?
 
 	e.Description = &Description{
 		Tags:   []string{"generic"},
@@ -64,15 +55,10 @@ func NewEntry(r *R, fn interface{}) *Entry {
 		Output: Output,
 		Extra:  map[string]interface{}{},
 	}
-	return e
+	return e, nil
 }
 
 // Describer return a description builder
 func (e *Entry) Describer() EDescriber {
 	return Describer(e)
 }
-
-// Err returns error of the entry if any
-func (e *Entry) Err() error {
-	return e.err
-}

go/src/flow/registry/entry_test.go

@@ -26,66 +26,44 @@ func TestFlowFunc(t *testing.T) {
 func TestNewEntryInvalid(t *testing.T) {
 	a := assert.A(t)
 	r := registry.New()
-	e := registry.NewEntry(r, "string")
-	a.Eq(e.Err(), registry.ErrNotAFunc, "entry is not a function")
+	_, err := registry.NewEntry(r, "string")
+	a.Eq(err, registry.ErrNotAFunc, "entry is not a function")
 }
 func TestNewEntryValid(t *testing.T) {
 	a := assert.A(t)
 	r := registry.New()
-	e := registry.NewEntry(r, func(a int) int { return 0 })
-	a.Eq(e.Err(), nil, "fetching an entry")
+	_, err := registry.NewEntry(r, func(a int) int { return 0 })
+	a.Eq(err, nil, "fetching an entry")
 }
 
 func TestDescription(t *testing.T) {
 	a := assert.A(t)
 	r := registry.New()
 
-	e := registry.NewEntry(r, func(a int) int { return 0 })
+	e, err := registry.NewEntry(r, func(a int) int { return 0 })
+	a.Eq(err, nil, "should not fail creating new entry")
 	e.Describer().Tags("a", "b")
-	a.Eq(e.Err(), nil, "should not fail setting categories")
 	a.Eq(len(e.Description.Tags), 2, "should have 2 categories")
 	a.Eq(len(e.Description.Inputs), 1, "Should have 2 input description")
 
-	e2 := registry.NewEntry(r, func(a, b int) int { return 0 })
+	e2, err := registry.NewEntry(r, func(a, b int) int { return 0 })
+	a.Eq(err, nil, "should not fail creating new entry")
+
 	a.Eq(len(e2.Description.Inputs), 2, "Should have 2 input description")
 
 	e.Describer().Inputs("input")
-	a.Eq(e.Err(), nil, "should not fail setting input name")
 	a.Eq(e.Description.Inputs[0].Name, "input", "should have the input description")
 
 	e.Describer().Inputs("input", "2", "3")
 	a.Eq(len(e.Description.Inputs), 1, "should have only one input")
 
 	e.Describer().Output("output name")
-	a.Eq(e.Err(), nil, "should not fail setting input description")
 	a.Eq(e.Description.Output.Name, "output name", "output description should be the same")
 
 	e.Describer().Extra("test", 123)
-	a.Eq(e.Err(), nil, "should not fail setting extra doc")
 	a.Eq(e.Description.Extra["test"], 123, "extra text should be as expected")
 
 	e.Describer().Description("test")
-	a.Eq(e.Err(), nil, "should not fail setting description")
-
-}
-
-func TestDescriptionError(t *testing.T) {
-	a := assert.A(t)
-	r := registry.New()
-	e := registry.NewEntry(r, "string")
-
-	a.Eq(e.Err(), registry.ErrNotAFunc, "entry is not a function")
-	e.Describer().Tags("a", "b")
-	a.Eq(e.Err(), registry.ErrNotAFunc, "entry is not a function")
-	e.Describer().Inputs("input")
-	a.Eq(e.Err(), registry.ErrNotAFunc, "entry is not a function")
-	e.Describer().Output("output")
-	a.Eq(e.Err(), registry.ErrNotAFunc, "entry is not a function")
-	e.Describer().Extra("test", 123)
-	a.Eq(e.Err(), registry.ErrNotAFunc, "entry is not a function")
-
-	e.Describer().Description("test")
-	a.Eq(e.Err(), registry.ErrNotAFunc, "entry is not a function")
 
 }
 
@@ -94,9 +72,9 @@ func TestEntryBatch(t *testing.T) {
 	r := registry.New()
 
 	b := registry.Describer(
-		registry.NewEntry(r, func() int { return 0 }),
-		registry.NewEntry(r, func() int { return 0 }),
-		registry.NewEntry(r, func() int { return 0 }),
+		r.MustAdd(func() int { return 0 }),
+		r.MustAdd(func() int { return 0 }),
+		r.MustAdd(func() int { return 0 }),
 	).Tags("test").Extra("name", 1)
 
 	a.Eq(len(b), 3, "should have 3 items")

go/src/flow/registry/registry.go

@@ -39,30 +39,52 @@ func (r *R) Clone() *R {
 	return newR
 }
 
-// Add unnamed function
-func (r *R) Add(fns ...interface{}) EDescriber {
+// Add function to registry
+func (r *R) Add(fns ...interface{}) (EDescriber, error) {
 
 	b := EDescriber{}
 	for _, fn := range fns {
 		if reflect.TypeOf(fn).Kind() != reflect.Func {
-			return nil
+			return nil, ErrNotAFunc
 		}
 		// Automatic naming
 		name := runtime.FuncForPC(reflect.ValueOf(fn).Pointer()).Name()
 		name = path.Ext(name)[1:]
-		b = append(b, r.Register(name, fn))
+		e, err := r.Register(name, fn)
+		if err != nil {
+			return nil, err
+		}
+		b = append(b, e)
 	}
 
-	return b
+	return b, nil
+}
+
+// MustAdd adds a function to registry or panics
+func (r *R) MustAdd(fns ...interface{}) EDescriber {
+	d, err := r.Add(fns...)
+	if err != nil {
+		panic(err)
+	}
+	return d
 }
 
 //Register should be a func only register
-func (r *R) Register(name string, v interface{}) *Entry {
-	e := NewEntry(r, v)
-	if e.err != nil {
-		return e
+func (r *R) Register(name string, v interface{}) (*Entry, error) {
+	e, err := NewEntry(r, v)
+	if err != nil {
+		return nil, err
 	}
 	r.data[name] = e
+	return e, nil
+}
+
+// MustRegister register a function or panic on error
+func (r *R) MustRegister(name string, v interface{}) *Entry {
+	e, err := r.Register(name, v)
+	if err != nil {
+		panic(err)
+	}
 	return e
 }
 
@@ -77,7 +99,7 @@ func (r *R) Get(name string, params ...interface{}) (interface{}, error) {
 	// and that returns 1 or more values
 
 	vtyp := reflect.TypeOf(v)
-	if vtyp.Out(0).Kind() != reflect.Func {
+	if vtyp.NumOut() == 0 || vtyp.Out(0).Kind() != reflect.Func {
 		return v, nil
 	}
 	// Constructor

go/src/flow/registry/registry_test.go

@@ -37,36 +37,35 @@ func TestEntry(t *testing.T) {
 func TestRegister(t *testing.T) {
 	a := assert.A(t)
 	r := registry.New()
-	e := r.Register("func", func(a, b int) int { return 0 })
-	a.Eq(e.Err(), nil, "should register a function")
+	_, err := r.Register("func", func(a, b int) int { return 0 })
+	a.Eq(err, nil, "should register a function")
 }
 func TestRegisterDuplicate(t *testing.T) {
 	a := assert.A(t)
 	r := registry.New()
 	r.Register("func", func(a, b int) int { return 0 })
-	e := r.Register("func", func(b int) int { return 0 })
-
-	a.Eq(e.Err(), nil, "should allow duplicate")
+	_, err := r.Register("func", func(b int) int { return 0 })
+	a.Eq(err, nil, "should allow duplicate")
 }
-func TestRegisterInvalidOutput(t *testing.T) {
+func TestRegisterOutput(t *testing.T) {
 	a := assert.A(t)
 	r := registry.New()
-	e := r.Register("func", func(a int) {})
-	a.Eq(e.Err(), registry.ErrOutput, "should give output error")
+	_, err := r.Register("func", func(a int) {})
+	a.Eq(err, nil, "should not give output error")
 }
 
 func TestRegisterInvalidInput(t *testing.T) {
 	a := assert.A(t)
 	r := registry.New()
-	e := r.Register("func", func() int { return 0 })
-	a.Eq(e.Err(), nil, "should register a func without params")
+	_, err := r.Register("func", func() int { return 0 })
+	a.Eq(err, nil, "should register a func without params")
 }
 
 func TestRegistryGet(t *testing.T) {
 	a := assert.A(t)
 	r := registry.New()
-	e := r.Register("func", func() int { return 0 })
-	a.Eq(e.Err(), nil, "should register func")
+	_, err := r.Register("func", func() int { return 0 })
+	a.Eq(err, nil, "should register func")
 
 	fn, err := r.Get("func")
 	a.Eq(err, nil, "should fetch a function")
@@ -83,12 +82,12 @@ func TestRegistryGetEmpty(t *testing.T) {
 func TestRegistryGetConstructor(t *testing.T) {
 	a := assert.A(t)
 	r := registry.New()
-	e := r.Register("func", func() func() int {
+	_, err := r.Register("func", func() func() int {
 		return func() int {
 			return 0
 		}
 	})
-	a.Eq(e.Err(), nil, "should register the constructor func")
+	a.Eq(err, nil, "should register the constructor func")
 
 	ifn, err := r.Get("func")
 	a.Eq(err, nil, "get should not error")
@@ -104,12 +103,12 @@ func TestRegistryGetConstructorParam(t *testing.T) {
 	a := assert.A(t)
 
 	r := registry.New()
-	e := r.Register("func2", func(a, b int) func() int {
+	_, err := r.Register("func2", func(a, b int) func() int {
 		return func() int {
 			return a + b
 		}
 	})
-	a.Eq(e.Err(), nil)
+	a.Eq(err, nil)
 	ifn, err := r.Get("func2", 1, 1)
 	a.Eq(err, nil, "should not fail passing params to constructor")
 	a.NotEq(ifn, nil, "should return a function")
@@ -156,12 +155,50 @@ func TestClone(t *testing.T) {
 	_, ok := d2["vecmul"]
 	a.Eq(ok, true, "should be equal")
 }
+func TestNotAFunc(t *testing.T) {
+	r := registry.New()
+
+	_, err := r.Add("test")
+	assert.Eq(t, err, registry.ErrNotAFunc, "should give not a func error")
+}
+
+func TestRegisterErr(t *testing.T) {
+	r := registry.New()
+
+	_, err := r.Register("name", "notfunc")
+	assert.Eq(t, err, registry.ErrNotAFunc, "should give not a func error")
+}
+
+func TestRegisterMust(t *testing.T) {
+	a := assert.A(t)
+	r := registry.New()
+
+	func() {
+		defer func() {
+			p := recover()
+			a.Eq(p, registry.ErrNotAFunc, "should panic giving ErrNotAFunc")
+		}()
+
+		r.MustRegister("name", "notfunc")
+	}()
+
+	func() {
+		defer func() {
+			p := recover()
+			a.Eq(p, registry.ErrNotAFunc, "should panic giving ErrNotAFunc")
+		}()
+
+		r.MustAdd("name", "notfunc")
+
+	}()
+}
 
-func TestAddEntry(t *testing.T) {
+/*func TestAddEntry(t *testing.T) {
 	a := assert.A(t)
 	r := registry.New()
 
-	g := r.Add(r.Register("vecadd", dummy1))
+	g, err := r.Register("vecadd", dummy1)
+	//a.Eq(err, ErrNotAFunc, "should error giving a func")
 	a.Eq(len(g), 0, "should contain 1 entry")
 
 	r.Add(dummy2)
@@ -170,7 +207,7 @@ func TestAddEntry(t *testing.T) {
 	a.Eq(err, nil, "should not error fetching descriptions")
 	a.Eq(len(d), 2, "should contain 2 descriptions")
 
-}
+}*/
 
 func dummy1([]float32, []float32) []float32 {
 	return []float32{1, 3, 3, 7}

go/src/flowserver/cmd/demo1/assets/assets.go

@@ -23,24 +23,324 @@ var (
 			0x74, 0x65, 0x72, 0x3B, 0x0A, 0x20, 0x20, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3A, 0x31, 0x30, 0x30, 0x25, 0x3B, 0x0A, 
 			0x7D, 0x0A, 0x2E, 0x61, 0x70, 0x70, 0x2D, 0x73, 0x65, 0x6C, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x20, 0x3E, 0x2A, 0x20, 0x7B, 
 			0x20, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6E, 0x67, 0x3A, 0x31, 0x30, 0x70, 0x78, 0x3B, 0x20, 0x7D, 0x0A, 0x2E, 0x61, 0x70, 
-			0x70, 0x2D, 0x73, 0x65, 0x6C, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x2D, 0x69, 0x74, 0x65, 0x6D, 0x73, 0x20, 0x2A, 0x3A, 0x66, 
-			0x69, 0x72, 0x73, 0x74, 0x2D, 0x63, 0x68, 0x69, 0x6C, 0x64, 0x20, 0x7B, 0x20, 0x62, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x2D, 
-			0x72, 0x69, 0x67, 0x68, 0x74, 0x3A, 0x20, 0x23, 0x30, 0x30, 0x30, 0x3B, 0x20, 0x7D, 0x0A, 0x09, 0x09, 0x3C, 0x2F, 0x73, 
-			0x74, 0x79, 0x6C, 0x65, 0x3E, 0x0A, 0x09, 0x3C, 0x2F, 0x68, 0x65, 0x61, 0x64, 0x3E, 0x0A, 0x09, 0x3C, 0x62, 0x6F, 0x64, 
-			0x79, 0x3E, 0x0A, 0x09, 0x09, 0x3C, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6C, 0x61, 0x73, 0x73, 0x3D, 0x22, 0x61, 0x70, 0x70, 
-			0x2D, 0x73, 0x65, 0x6C, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x22, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x68, 0x33, 0x3E, 
-			0x20, 0x53, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x20, 0x69, 0x64, 0x65, 0x61, 0x73, 0x20, 0x75, 0x73, 0x69, 0x6E, 0x67, 0x20, 
-			0x66, 0x6C, 0x6F, 0x77, 0x3A, 0x20, 0x3C, 0x2F, 0x68, 0x33, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x64, 0x69, 0x76, 
-			0x20, 0x63, 0x6C, 0x61, 0x73, 0x73, 0x3D, 0x22, 0x61, 0x70, 0x70, 0x2D, 0x73, 0x65, 0x6C, 0x65, 0x63, 0x74, 0x6F, 0x72, 
-			0x2D, 0x69, 0x74, 0x65, 0x6D, 0x73, 0x22, 0x3E, 0x0A, 0x09, 0x09, 0x09, 0x3C, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3D, 
-			0x22, 0x2F, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x22, 0x3E, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x20, 0x74, 
-			0x68, 0x69, 0x6E, 0x67, 0x3C, 0x2F, 0x61, 0x3E, 0x0A, 0x09, 0x09, 0x09, 0x3C, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3D, 
-			0x22, 0x2F, 0x64, 0x65, 0x76, 0x6F, 0x70, 0x73, 0x22, 0x3E, 0x44, 0x65, 0x76, 0x6F, 0x70, 0x73, 0x20, 0x73, 0x61, 0x6D, 
-			0x70, 0x6C, 0x65, 0x3C, 0x2F, 0x61, 0x3E, 0x0A, 0x09, 0x09, 0x09, 0x3C, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3D, 0x22, 
-			0x2F, 0x74, 0x65, 0x73, 0x74, 0x6F, 0x70, 0x73, 0x22, 0x3E, 0x74, 0x65, 0x73, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x72, 0x65, 
-			0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x3C, 0x2F, 0x61, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x3C, 0x2F, 0x64, 0x69, 0x76, 
-			0x3E, 0x0A, 0x09, 0x3C, 0x2F, 0x64, 0x69, 0x76, 0x3E, 0x0A, 0x09, 0x3C, 0x2F, 0x62, 0x6F, 0x64, 0x79, 0x0A, 0x3C, 0x2F, 
-			0x68, 0x74, 0x6D, 0x6C, 0x3E, 0x0A, 0x0A, 			 
+			0x70, 0x2D, 0x73, 0x65, 0x6C, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x2D, 0x69, 0x74, 0x65, 0x6D, 0x73, 0x3A, 0x66, 0x69, 0x72, 
+			0x73, 0x74, 0x2D, 0x63, 0x68, 0x69, 0x6C, 0x64, 0x20, 0x7B, 0x20, 0x62, 0x6F, 0x72, 0x64, 0x65, 0x72, 0x2D, 0x72, 0x69, 
+			0x67, 0x68, 0x74, 0x3A, 0x20, 0x23, 0x30, 0x30, 0x30, 0x3B, 0x20, 0x7D, 0x0A, 0x09, 0x09, 0x3C, 0x2F, 0x73, 0x74, 0x79, 
+			0x6C, 0x65, 0x3E, 0x0A, 0x09, 0x3C, 0x2F, 0x68, 0x65, 0x61, 0x64, 0x3E, 0x0A, 0x09, 0x3C, 0x62, 0x6F, 0x64, 0x79, 0x3E, 
+			0x0A, 0x09, 0x09, 0x3C, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6C, 0x61, 0x73, 0x73, 0x3D, 0x22, 0x61, 0x70, 0x70, 0x2D, 0x73, 
+			0x65, 0x6C, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x22, 0x3E, 0x0A, 0x09, 0x09, 0x3C, 0x69, 0x6D, 0x67, 0x20, 0x73, 0x72, 0x63, 
+			0x3D, 0x22, 0x73, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x2E, 0x70, 0x6E, 0x67, 0x22, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x3C, 
+			0x68, 0x33, 0x3E, 0x20, 0x53, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x20, 0x69, 0x64, 0x65, 0x61, 0x73, 0x20, 0x75, 0x73, 0x69, 
+			0x6E, 0x67, 0x20, 0x66, 0x6C, 0x6F, 0x77, 0x3A, 0x20, 0x3C, 0x2F, 0x68, 0x33, 0x3E, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x3C, 
+			0x64, 0x69, 0x76, 0x20, 0x63, 0x6C, 0x61, 0x73, 0x73, 0x3D, 0x22, 0x61, 0x70, 0x70, 0x2D, 0x73, 0x65, 0x6C, 0x65, 0x63, 
+			0x74, 0x6F, 0x72, 0x2D, 0x69, 0x74, 0x65, 0x6D, 0x73, 0x22, 0x3E, 0x0A, 0x09, 0x09, 0x09, 0x5B, 0x3C, 0x61, 0x20, 0x68, 
+			0x72, 0x65, 0x66, 0x3D, 0x22, 0x2F, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74, 0x22, 0x3E, 0x44, 0x65, 0x66, 0x61, 0x75, 
+			0x6C, 0x74, 0x20, 0x74, 0x68, 0x69, 0x6E, 0x67, 0x3C, 0x2F, 0x61, 0x3E, 0x5D, 0x0A, 0x09, 0x09, 0x09, 0x5B, 0x3C, 0x61, 
+			0x20, 0x68, 0x72, 0x65, 0x66, 0x3D, 0x22, 0x2F, 0x67, 0x6F, 0x6E, 0x75, 0x6D, 0x6F, 0x70, 0x73, 0x22, 0x3E, 0x47, 0x6F, 
+			0x6E, 0x75, 0x6D, 0x3C, 0x2F, 0x61, 0x3E, 0x5D, 0x0A, 0x09, 0x09, 0x09, 0x5B, 0x3C, 0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 
+			0x3D, 0x22, 0x2F, 0x64, 0x65, 0x76, 0x6F, 0x70, 0x73, 0x22, 0x3E, 0x44, 0x65, 0x76, 0x6F, 0x70, 0x73, 0x20, 0x73, 0x61, 
+			0x6D, 0x70, 0x6C, 0x65, 0x3C, 0x2F, 0x61, 0x3E, 0x5D, 0x0A, 0x09, 0x09, 0x09, 0x5B, 0x3C, 0x61, 0x20, 0x68, 0x72, 0x65, 
+			0x66, 0x3D, 0x22, 0x2F, 0x74, 0x65, 0x73, 0x74, 0x6F, 0x70, 0x73, 0x22, 0x3E, 0x74, 0x65, 0x73, 0x74, 0x69, 0x6E, 0x67, 
+			0x20, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x3C, 0x2F, 0x61, 0x3E, 0x5D, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x3C, 
+			0x2F, 0x64, 0x69, 0x76, 0x3E, 0x0A, 0x09, 0x3C, 0x2F, 0x64, 0x69, 0x76, 0x3E, 0x0A, 0x09, 0x3C, 0x2F, 0x62, 0x6F, 0x64, 
+			0x79, 0x0A, 0x3C, 0x2F, 0x68, 0x74, 0x6D, 0x6C, 0x3E, 0x0A, 0x0A, 			 
+		},
+	
+		"sample.png": []byte{ 
+			0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0xBB, 
+			0x00, 0x00, 0x00, 0xA6, 0x08, 0x02, 0x00, 0x00, 0x00, 0x0D, 0xBA, 0x69, 0x78, 0x00, 0x00, 0x00, 0x03, 0x73, 0x42, 0x49, 
+			0x54, 0x08, 0x08, 0x08, 0xDB, 0xE1, 0x4F, 0xE0, 0x00, 0x00, 0x16, 0x9E, 0x49, 0x44, 0x41, 0x54, 0x78, 0x9C, 0xED, 0x9D, 
+			0x7B, 0x54, 0x53, 0x57, 0xBE, 0xC7, 0xF7, 0x39, 0x79, 0x9D, 0xBC, 0x48, 0x78, 0x24, 0x81, 0x04, 0x07, 0x82, 0x28, 0x58, 
+			0x41, 0x11, 0xA9, 0x45, 0x6D, 0x3B, 0x0A, 0x4E, 0x1D, 0x1F, 0x1D, 0x75, 0x4D, 0x2B, 0x8E, 0x9D, 0x8E, 0x6D, 0x1D, 0x67, 
+			0x46, 0x7B, 0x15, 0x75, 0x56, 0xC7, 0x67, 0xBD, 0x55, 0x4A, 0xD5, 0x45, 0xBD, 0x03, 0x9D, 0xD5, 0x99, 0xE9, 0xC5, 0x3A, 
+			0x57, 0xBB, 0x14, 0x5B, 0xA7, 0x9D, 0x5A, 0xED, 0x52, 0x14, 0xF1, 0x55, 0x41, 0x45, 0xAC, 0x25, 0x28, 0xA0, 0xC8, 0x33, 
+			0x40, 0x48, 0x80, 0xBC, 0x43, 0x92, 0x93, 0xE4, 0xDC, 0x3F, 0x8E, 0x4D, 0x31, 0x04, 0xE4, 0x20, 0x90, 0x04, 0xF6, 0xE7, 
+			0x0F, 0x56, 0xF2, 0xDB, 0xE7, 0xEC, 0xFC, 0x38, 0xF9, 0x66, 0xEF, 0xDF, 0xFE, 0x9D, 0x7D, 0xF6, 0x46, 0x4C, 0x26, 0x13, 
+			0x80, 0x40, 0x06, 0x0C, 0xEA, 0x6B, 0x07, 0x20, 0x01, 0x06, 0x54, 0x0C, 0x84, 0x1A, 0x50, 0x31, 0x10, 0x6A, 0x40, 0xC5, 
+			0x40, 0xA8, 0x01, 0x15, 0x03, 0xA1, 0x06, 0x54, 0x0C, 0x84, 0x1A, 0x50, 0x31, 0x10, 0x6A, 0x40, 0xC5, 0x40, 0xA8, 0x01, 
+			0x15, 0x03, 0xA1, 0x06, 0x54, 0x0C, 0x84, 0x1A, 0x50, 0x31, 0x10, 0x6A, 0x40, 0xC5, 0x40, 0xA8, 0x01, 0x15, 0x03, 0xA1, 
+			0x06, 0x54, 0x0C, 0x84, 0x1A, 0x50, 0x31, 0x10, 0x6A, 0x40, 0xC5, 0x40, 0xA8, 0x01, 0x15, 0x03, 0xA1, 0x06, 0x54, 0x0C, 
+			0x84, 0x1A, 0x50, 0x31, 0x10, 0x6A, 0x40, 0xC5, 0x40, 0xA8, 0x01, 0x15, 0x03, 0xA1, 0x06, 0x54, 0x0C, 0x84, 0x1A, 0x50, 
+			0x31, 0x10, 0x6A, 0x40, 0xC5, 0x40, 0xA8, 0x01, 0x15, 0x03, 0xA1, 0x06, 0x54, 0x0C, 0x84, 0x1A, 0x50, 0x31, 0x10, 0x6A, 
+			0x40, 0xC5, 0x40, 0xA8, 0x01, 0x15, 0x03, 0xA1, 0x06, 0xDD, 0xD7, 0x0E, 0x8C, 0x45, 0xBA, 0xBB, 0xBB, 0x4D, 0x26, 0x93, 
+			0xDD, 0x6E, 0x47, 0x10, 0xC4, 0x62, 0xB1, 0x20, 0x08, 0xE2, 0x13, 0x37, 0x08, 0x82, 0xC0, 0x30, 0x0C, 0x41, 0x10, 0x26, 
+			0x93, 0xC9, 0x66, 0xB3, 0x79, 0x3C, 0xDE, 0x40, 0xCE, 0x42, 0xE0, 0x6A, 0x20, 0x23, 0x89, 0x5E, 0xAF, 0xD7, 0x6A, 0xB5, 
+			0x4C, 0x26, 0x33, 0x28, 0x28, 0x88, 0xCB, 0xE5, 0x02, 0x00, 0xD8, 0x6C, 0xB6, 0x0F, 0xFD, 0xB1, 0xD9, 0x6C, 0x2E, 0x97, 
+			0xCB, 0x6A, 0xB5, 0x6A, 0xB5, 0x5A, 0x1C, 0xC7, 0x85, 0x42, 0xA1, 0x40, 0x20, 0xE8, 0xFF, 0x14, 0xA8, 0x98, 0x11, 0xC2, 
+			0xE5, 0x72, 0xB5, 0xB5, 0xB5, 0xD1, 0x68, 0x34, 0x89, 0x44, 0xE2, 0x5B, 0x95, 0xF4, 0x45, 0x77, 0x77, 0xB7, 0x5A, 0xAD, 
+			0xB6, 0xDB, 0xED, 0x52, 0xA9, 0x94, 0x46, 0xA3, 0xF5, 0x75, 0x18, 0x54, 0xCC, 0x48, 0x60, 0xB3, 0xD9, 0xD4, 0x6A, 0xB5, 
+			0x40, 0x20, 0x10, 0x8B, 0xC5, 0xBE, 0xF6, 0xE5, 0x09, 0x68, 0xB5, 0x5A, 0x95, 0x4A, 0x25, 0x95, 0x4A, 0x59, 0x2C, 0x96, 
+			0xD7, 0x03, 0x60, 0x1C, 0x33, 0xEC, 0xB8, 0x5C, 0x2E, 0x95, 0x4A, 0x15, 0x1E, 0x1E, 0xDE, 0xB3, 0xC1, 0xBF, 0xA0, 0xBF, 
+			0xA0, 0xC1, 0x35, 0x0A, 0x8B, 0x42, 0x6D, 0x57, 0x8B, 0x99, 0xE2, 0x18, 0x56, 0x8C, 0x1C, 0x93, 0xA7, 0x09, 0xD2, 0x7C, 
+			0xE8, 0x27, 0x49, 0x70, 0x70, 0x30, 0x8A, 0xA2, 0xED, 0xED, 0xED, 0x91, 0x91, 0x91, 0x28, 0xEA, 0x65, 0x60, 0x04, 0xDB, 
+			0x98, 0x61, 0xA7, 0xA5, 0xA5, 0x85, 0xCF, 0xE7, 0xBB, 0x5B, 0x17, 0xB5, 0x43, 0x9D, 0xD7, 0x9A, 0x57, 0x69, 0xAE, 0x04, 
+			0x00, 0x24, 0x70, 0x12, 0xC4, 0x4C, 0xB1, 0xDA, 0xAE, 0xAE, 0xB7, 0xD5, 0x9B, 0x9D, 0x66, 0x39, 0x26, 0xCF, 0x94, 0x66, 
+			0xCA, 0x59, 0x72, 0x9F, 0xFA, 0x0B, 0x00, 0x00, 0x5A, 0xAD, 0x56, 0xA7, 0xD3, 0x45, 0x44, 0x44, 0xF4, 0x2E, 0x82, 0x8A, 
+			0x19, 0x5E, 0x0C, 0x06, 0x43, 0x77, 0x77, 0x77, 0x54, 0x54, 0x14, 0xF9, 0xF6, 0x82, 0xFE, 0xC2, 0xA7, 0xED, 0x9F, 0x02, 
+			0x00, 0x36, 0x44, 0x6C, 0x48, 0xE5, 0xA7, 0xF6, 0x3C, 0x52, 0x61, 0x51, 0xE4, 0xB5, 0xE6, 0x69, 0x70, 0xCD, 0x06, 0xE9, 
+			0x86, 0x74, 0x41, 0xBA, 0x0F, 0x7C, 0x7D, 0x9C, 0xC6, 0xC6, 0x46, 0x36, 0x9B, 0x1D, 0x14, 0x14, 0xE4, 0x61, 0x87, 0xF9, 
+			0x98, 0xE1, 0x45, 0xAB, 0xD5, 0xF6, 0x6C, 0x5D, 0x3E, 0x6D, 0xFF, 0x54, 0xCE, 0x92, 0xE7, 0xC7, 0xE6, 0x7B, 0xC8, 0x05, 
+			0x00, 0x90, 0xC8, 0x49, 0xCC, 0x8B, 0xC9, 0x4B, 0x13, 0xA6, 0x7D, 0xD4, 0xFA, 0x51, 0xBD, 0xAD, 0xDE, 0x6B, 0x6D, 0x04, 
+			0x41, 0xB8, 0x5C, 0x2E, 0x97, 0xCB, 0x45, 0x10, 0x44, 0x6F, 0xA3, 0xD7, 0x53, 0xFA, 0x39, 0xBE, 0xA7, 0xB1, 0x37, 0x32, 
+			0x99, 0xAC, 0xB3, 0xB3, 0xB3, 0xB7, 0xDD, 0x2F, 0xDA, 0x98, 0xDB, 0x35, 0xED, 0x45, 0x65, 0x0D, 0x7A, 0xA3, 0xCD, 0xC3, 
+			0x9E, 0x96, 0x12, 0x95, 0xFE, 0x6C, 0x14, 0x00, 0xE0, 0x42, 0x59, 0x63, 0xF1, 0xAD, 0xC6, 0x80, 0x2B, 0x3D, 0x57, 0x7A, 
+			0x7F, 0x6E, 0x92, 0x78, 0xC6, 0xB4, 0xC9, 0x64, 0xD1, 0xF6, 0xC6, 0xED, 0x1D, 0xB4, 0xD6, 0xCF, 0xA7, 0x1E, 0xE6, 0xA2, 
+			0x5C, 0xA3, 0xC5, 0x6E, 0x34, 0xDB, 0x3D, 0xCE, 0xE5, 0x73, 0x99, 0x28, 0x86, 0x67, 0xD6, 0x65, 0xF2, 0x68, 0xBC, 0x5C, 
+			0x79, 0xAE, 0x47, 0xA9, 0xDD, 0x6E, 0x3F, 0x72, 0xE4, 0xC8, 0xED, 0xDB, 0xB7, 0x99, 0x4C, 0xE6, 0xA2, 0x45, 0x8B, 0xE6, 
+			0xCD, 0x9B, 0x07, 0x00, 0xE8, 0xE8, 0xE8, 0x38, 0x78, 0xF0, 0x60, 0x43, 0x43, 0x43, 0x48, 0x48, 0xC8, 0xAA, 0x55, 0xAB, 
+			0xE2, 0xE3, 0xE3, 0xDD, 0xC7, 0x13, 0x04, 0x51, 0x5D, 0x5D, 0x7D, 0xF8, 0xF0, 0x61, 0xAD, 0x56, 0x1B, 0x13, 0x13, 0xB3, 
+			0x66, 0xCD, 0x9A, 0xE0, 0xE0, 0x60, 0x00, 0x40, 0x61, 0x61, 0xE1, 0xD9, 0xB3, 0x67, 0x71, 0x1C, 0x4F, 0x49, 0x49, 0xF9, 
+			0xED, 0x6F, 0x7F, 0xCB, 0x60, 0x30, 0x40, 0x1F, 0x28, 0x95, 0x4A, 0x2E, 0x97, 0xEB, 0x31, 0xB2, 0xF3, 0x8B, 0xC8, 0x37, 
+			0x39, 0x4E, 0x12, 0xCC, 0xC7, 0xEA, 0x5A, 0x74, 0x1E, 0xF6, 0x18, 0x99, 0xD0, 0xE3, 0x45, 0x60, 0x95, 0xCE, 0x4E, 0x10, 
+			0x4F, 0x7B, 0x26, 0x9A, 0xCF, 0x65, 0x02, 0x00, 0x2E, 0xE8, 0x2F, 0x34, 0x21, 0x0F, 0xDE, 0x8B, 0xDA, 0xC9, 0x45, 0xB9, 
+			0x00, 0x00, 0x16, 0x83, 0x06, 0xB8, 0xCC, 0x9E, 0x27, 0x9A, 0x9D, 0xE6, 0xEF, 0xAD, 0x3F, 0xBC, 0xC8, 0x99, 0x9D, 0x29, 
+			0xCD, 0xDC, 0xD9, 0xB8, 0xF3, 0x94, 0xF6, 0xD4, 0xCB, 0xC1, 0x2F, 0xBB, 0x4B, 0x09, 0x82, 0xB8, 0x78, 0xF1, 0x62, 0x5B, 
+			0x5B, 0xDB, 0xFE, 0xFD, 0xFB, 0xB5, 0x5A, 0x6D, 0x76, 0x76, 0xF6, 0xA4, 0x49, 0x93, 0xA4, 0x52, 0xE9, 0xB1, 0x63, 0xC7, 
+			0xC6, 0x8D, 0x1B, 0xB7, 0x79, 0xF3, 0xE6, 0x5B, 0xB7, 0x6E, 0xFD, 0xF3, 0x9F, 0xFF, 0xCC, 0xC9, 0xC9, 0xA1, 0xD3, 0x1F, 
+			0x7D, 0xA7, 0x38, 0x8E, 0xFF, 0xFD, 0xEF, 0x7F, 0x7F, 0xFD, 0xF5, 0xD7, 0xA7, 0x4C, 0x99, 0x72, 0xFC, 0xF8, 0xF1, 0x82, 
+			0x82, 0x82, 0xB5, 0x6B, 0xD7, 0x36, 0x37, 0x37, 0x7F, 0xF3, 0xCD, 0x37, 0xDB, 0xB7, 0x6F, 0x17, 0x08, 0x04, 0x1F, 0x7E, 
+			0xF8, 0xE1, 0x95, 0x2B, 0x57, 0xD2, 0xD2, 0xD2, 0xFA, 0x4A, 0x21, 0xF2, 0xF9, 0x7C, 0xB3, 0xD9, 0xEC, 0x8F, 0x8A, 0x01, 
+			0x00, 0xC8, 0xA5, 0x02, 0xB9, 0xB4, 0xCF, 0xDC, 0x51, 0x80, 0x96, 0x32, 0x89, 0x30, 0x71, 0x68, 0x10, 0x9B, 0xCD, 0x04, 
+			0x00, 0x74, 0x18, 0x5B, 0xC2, 0xF9, 0xC1, 0x2F, 0x86, 0xCC, 0x26, 0x4B, 0x99, 0x0C, 0x1A, 0x93, 0xF1, 0x53, 0xCE, 0xC3, 
+			0xEC, 0x32, 0xEF, 0x6B, 0xDC, 0xAD, 0xC6, 0xD5, 0xD3, 0x85, 0x49, 0x89, 0x9C, 0x44, 0x11, 0x43, 0x54, 0x67, 0xAD, 0xF3, 
+			0xA8, 0xB0, 0xA2, 0xA2, 0xE2, 0x85, 0x17, 0x5E, 0xE0, 0xF1, 0x78, 0x5C, 0x2E, 0x77, 0xCA, 0x94, 0x29, 0x0A, 0x85, 0x22, 
+			0x3C, 0x3C, 0x5C, 0xA1, 0x50, 0x64, 0x67, 0x67, 0xB3, 0x58, 0xAC, 0xD4, 0xD4, 0xD4, 0xE3, 0xC7, 0x8F, 0x2B, 0x95, 0x4A, 
+			0x1E, 0x8F, 0xB7, 0x67, 0xCF, 0x9E, 0x7D, 0xFB, 0xF6, 0xB5, 0xB5, 0xB5, 0xD1, 0xE9, 0xF4, 0xE9, 0xD3, 0xA7, 0xD3, 0x68, 
+			0xB4, 0x79, 0xF3, 0xE6, 0x65, 0x65, 0x65, 0xB9, 0x5C, 0x2E, 0x85, 0x42, 0x31, 0x75, 0xEA, 0x54, 0xA9, 0x54, 0x8A, 0x20, 
+			0xC8, 0x0B, 0x2F, 0xBC, 0x50, 0x51, 0x51, 0x91, 0x96, 0xD6, 0xE7, 0x00, 0x0D, 0xC3, 0xB0, 0xDE, 0x1D, 0x93, 0x5F, 0xC4, 
+			0x31, 0x3A, 0xA3, 0xAD, 0xA1, 0xCD, 0xA0, 0xEB, 0xD5, 0x2B, 0x05, 0x3A, 0xDD, 0xDD, 0xDD, 0xEE, 0xAC, 0xC6, 0x75, 0xE3, 
+			0xF5, 0xE7, 0xF8, 0xCF, 0x79, 0x3D, 0xCC, 0xEC, 0x32, 0xEF, 0x68, 0xDC, 0xD1, 0x6C, 0x69, 0xDB, 0x2A, 0xFA, 0x6F, 0x86, 
+			0x13, 0x03, 0x00, 0xC4, 0x60, 0x31, 0xF5, 0xD6, 0xC7, 0x42, 0x19, 0x82, 0x20, 0xF4, 0x7A, 0xBD, 0x40, 0x20, 0x40, 0x10, 
+			0x04, 0x41, 0x10, 0x81, 0x40, 0xA0, 0xD3, 0xE9, 0xBA, 0xBB, 0xBB, 0x6D, 0x36, 0x1B, 0x39, 0x68, 0x27, 0x8D, 0x5A, 0xAD, 
+			0x56, 0x28, 0x14, 0xBE, 0xF9, 0xE6, 0x9B, 0x6C, 0x36, 0x5B, 0xA7, 0xD3, 0x05, 0x05, 0x05, 0x91, 0xED, 0x47, 0x70, 0x70, 
+			0xB0, 0xC5, 0x62, 0xB1, 0xD9, 0x6C, 0x6E, 0x23, 0x82, 0x20, 0x42, 0xA1, 0x50, 0xA7, 0xD3, 0xF5, 0x13, 0xCD, 0xB0, 0x58, 
+			0x2C, 0x8B, 0xC5, 0xE2, 0x61, 0xF4, 0x8B, 0x36, 0xA6, 0xBC, 0x5A, 0x55, 0x7C, 0xAB, 0xD1, 0x1D, 0x01, 0x7C, 0xFC, 0xF1, 
+			0xC7, 0xFD, 0x07, 0x65, 0x81, 0x42, 0x50, 0x50, 0x90, 0x44, 0x22, 0x21, 0x5F, 0xDF, 0x6B, 0xBD, 0x37, 0x25, 0x6C, 0x8A, 
+			0x86, 0xAE, 0x31, 0x3B, 0xCD, 0xA7, 0xB4, 0xA7, 0x56, 0x84, 0xAD, 0x20, 0xED, 0x66, 0x97, 0x39, 0xD7, 0x92, 0xAB, 0xC6, 
+			0xD5, 0xBB, 0xA4, 0x7B, 0xC2, 0x1C, 0x32, 0x1B, 0xEE, 0x64, 0x32, 0x68, 0x72, 0x96, 0xFC, 0x86, 0xF1, 0x86, 0x47, 0x6D, 
+			0x38, 0x8E, 0xBB, 0x13, 0x24, 0x34, 0x1A, 0xCD, 0x6E, 0xB7, 0x3B, 0x1C, 0x0E, 0x00, 0x40, 0x4F, 0xA3, 0xC3, 0xE1, 0xA0, 
+			0xD3, 0xE9, 0xC9, 0xC9, 0xC9, 0x04, 0x41, 0xE0, 0x38, 0xEE, 0x4E, 0xDD, 0x92, 0x2F, 0x1C, 0x0E, 0x07, 0x8E, 0xE3, 0xEE, 
+			0xC0, 0x85, 0x46, 0xA3, 0xE1, 0x38, 0xDE, 0xFF, 0xBF, 0xD0, 0xBB, 0xC3, 0xF2, 0x0B, 0xC5, 0x78, 0x80, 0xE3, 0xF8, 0xE8, 
+			0x50, 0x8C, 0xDD, 0x6E, 0xB7, 0xDB, 0xED, 0xE4, 0x37, 0xF4, 0x0C, 0xFB, 0x99, 0x0A, 0x73, 0xC5, 0x8A, 0xB0, 0x15, 0x27, 
+			0x3B, 0x4F, 0x1E, 0xEF, 0x38, 0xAE, 0xB2, 0xA9, 0x32, 0xA5, 0x99, 0x66, 0xA7, 0x79, 0x47, 0xD3, 0x0E, 0x10, 0x0C, 0xB2, 
+			0xA3, 0xB2, 0xC3, 0x9C, 0x32, 0xA3, 0xE3, 0x51, 0x2C, 0xAC, 0x76, 0xA8, 0x45, 0x0C, 0x91, 0x47, 0x6D, 0x0C, 0x06, 0xC3, 
+			0x3D, 0x20, 0x72, 0x3A, 0x9D, 0x34, 0x1A, 0x8D, 0x0C, 0x59, 0xDC, 0x46, 0x97, 0xCB, 0x45, 0xA3, 0xD1, 0xC8, 0xEF, 0x18, 
+			0x41, 0x10, 0x06, 0x83, 0xE1, 0x74, 0x3A, 0xDD, 0x45, 0x00, 0x00, 0x1A, 0x8D, 0xD6, 0xB3, 0x12, 0xF2, 0xF8, 0xFE, 0xFF, 
+			0x85, 0xDE, 0x5F, 0x84, 0x3F, 0x2A, 0x06, 0x41, 0x90, 0xD1, 0xA1, 0x18, 0x1C, 0xC7, 0xDD, 0xBF, 0xE9, 0x18, 0x2C, 0xE6, 
+			0x82, 0xEE, 0x02, 0x00, 0xE0, 0x37, 0xA2, 0xDF, 0xB4, 0xE3, 0xED, 0xC5, 0xFA, 0x62, 0x00, 0x40, 0xBD, 0xB5, 0x5E, 0xED, 
+			0x50, 0xE7, 0x47, 0xE5, 0xCB, 0x59, 0x72, 0xA3, 0xE5, 0xA7, 0xA1, 0x53, 0x9D, 0xB5, 0x2E, 0x06, 0x8B, 0xE9, 0x59, 0x15, 
+			0x82, 0x20, 0x21, 0x21, 0x21, 0x5D, 0x5D, 0x5D, 0x04, 0x41, 0x10, 0x04, 0xA1, 0xD5, 0x6A, 0xE5, 0x72, 0x39, 0x9B, 0xCD, 
+			0xE6, 0x70, 0x38, 0x9D, 0x9D, 0x9D, 0x32, 0x99, 0x8C, 0x20, 0x08, 0x9D, 0x4E, 0x27, 0x10, 0x08, 0x08, 0x82, 0x20, 0x2F, 
+			0x60, 0x48, 0x48, 0x88, 0xBB, 0xD3, 0xE9, 0xEC, 0xEC, 0xC4, 0x30, 0x0C, 0xC3, 0xB0, 0x90, 0x90, 0x90, 0xFA, 0xFA, 0x7A, 
+			0xD2, 0xD8, 0xD5, 0xD5, 0xE5, 0xEE, 0xB6, 0xBC, 0xE2, 0x70, 0x38, 0x7A, 0xDF, 0x2B, 0xF0, 0x8B, 0x38, 0x66, 0xB4, 0x62, 
+			0x34, 0x1A, 0xAD, 0x56, 0x2B, 0xF9, 0x5A, 0x8E, 0xC9, 0x2D, 0x2E, 0x8B, 0xC2, 0xAC, 0x00, 0x00, 0x6C, 0x94, 0x6E, 0x9C, 
+			0x2B, 0x98, 0x5B, 0xAC, 0x2F, 0x6E, 0xC7, 0xDB, 0xB3, 0xA3, 0xB2, 0x3D, 0x92, 0xBC, 0xF5, 0xB6, 0xFA, 0x06, 0x6B, 0x43, 
+			0xEF, 0xCC, 0x6F, 0x52, 0x52, 0xD2, 0x95, 0x2B, 0x57, 0x8C, 0x46, 0xA3, 0x52, 0xA9, 0xAC, 0xAC, 0xAC, 0x4C, 0x48, 0x48, 
+			0x40, 0x51, 0x74, 0xCA, 0x94, 0x29, 0xE7, 0xCE, 0x9D, 0xB3, 0x5A, 0xAD, 0x25, 0x25, 0x25, 0x04, 0x41, 0xFC, 0xEC, 0x67, 
+			0x3F, 0x73, 0x3A, 0x9D, 0x77, 0xEE, 0xDC, 0x21, 0x08, 0x62, 0xDC, 0xB8, 0x71, 0x08, 0x82, 0x94, 0x94, 0x94, 0xD8, 0x6C, 
+			0xB6, 0xA2, 0xA2, 0xA2, 0xC9, 0x93, 0x27, 0xA3, 0x28, 0x3A, 0x75, 0xEA, 0xD4, 0x8A, 0x8A, 0x8A, 0xE6, 0xE6, 0x66, 0x93, 
+			0xC9, 0xF4, 0xDD, 0x77, 0xDF, 0x25, 0x26, 0x26, 0xF6, 0xE3, 0x7F, 0xEF, 0x81, 0x12, 0x00, 0x80, 0xB6, 0x7D, 0xFB, 0xF6, 
+			0xA7, 0xBD, 0x30, 0x4F, 0x4D, 0x7D, 0xAB, 0xBE, 0xBE, 0x55, 0x2F, 0x97, 0x0A, 0xC9, 0xA1, 0xE9, 0x8D, 0x1B, 0x37, 0x46, 
+			0x47, 0x1B, 0xE3, 0x70, 0x38, 0xF8, 0x7C, 0x3E, 0x99, 0x6B, 0x97, 0x30, 0x24, 0x57, 0x0C, 0x57, 0x6E, 0x98, 0x6E, 0xA4, 
+			0x0B, 0xD2, 0x99, 0x28, 0x33, 0x95, 0x9F, 0x9A, 0xC0, 0x49, 0xF8, 0x75, 0xD8, 0xAF, 0x23, 0x99, 0x91, 0xE4, 0xB4, 0x07, 
+			0x3B, 0xEE, 0xB4, 0xE3, 0x4E, 0x16, 0x93, 0xF6, 0x81, 0x2A, 0x0B, 0x27, 0xF0, 0x77, 0x22, 0xDF, 0x61, 0x22, 0x3F, 0x0D, 
+			0xBF, 0x11, 0x04, 0x89, 0x8C, 0x8C, 0x6C, 0x6A, 0x6A, 0x3A, 0x72, 0xE4, 0xC8, 0xCD, 0x9B, 0x37, 0x97, 0x2E, 0x5D, 0x9A, 
+			0x9C, 0x9C, 0x8C, 0x20, 0x48, 0x6C, 0x6C, 0xEC, 0xD5, 0xAB, 0x57, 0x0B, 0x0A, 0x0A, 0x94, 0x4A, 0xE5, 0x1F, 0xFF, 0xF8, 
+			0x47, 0x91, 0x48, 0xD4, 0xD5, 0xD5, 0xF5, 0xD7, 0xBF, 0xFE, 0x75, 0xEE, 0xDC, 0xB9, 0x2C, 0x16, 0x2B, 0x26, 0x26, 0xE6, 
+			0xC4, 0x89, 0x13, 0x5F, 0x7D, 0xF5, 0x15, 0x93, 0xC9, 0x7C, 0xEB, 0xAD, 0xB7, 0xD8, 0x6C, 0x36, 0x9F, 0xCF, 0x67, 0xB3, 
+			0xD9, 0x47, 0x8E, 0x1C, 0x29, 0x2C, 0x2C, 0x9C, 0x3C, 0x79, 0xF2, 0xD2, 0xA5, 0x4B, 0xFB, 0xE9, 0x98, 0xBA, 0xBA, 0xBA, 
+			0x38, 0x1C, 0x8E, 0x47, 0xC2, 0xC6, 0x97, 0x19, 0xBC, 0x07, 0x0F, 0x1E, 0x4C, 0x98, 0x30, 0x01, 0xFC, 0x98, 0x0A, 0x73, 
+			0x47, 0xBE, 0x79, 0x79, 0x79, 0x7D, 0x65, 0x30, 0x03, 0x0E, 0x0C, 0xC3, 0x96, 0x2F, 0x5F, 0x4E, 0x5E, 0xF4, 0x3A, 0x5B, 
+			0xDD, 0xA6, 0xBA, 0x4D, 0x69, 0x82, 0xB4, 0x4C, 0x69, 0x66, 0xCF, 0x63, 0xC8, 0xA4, 0x30, 0x99, 0xD3, 0x3B, 0xA4, 0xFF, 
+			0x47, 0x19, 0xFE, 0xDD, 0xFB, 0x51, 0xEF, 0x27, 0x72, 0xBC, 0xFC, 0xFA, 0xC9, 0x2E, 0x09, 0x00, 0x40, 0x0E, 0x76, 0x3C, 
+			0x8C, 0x28, 0x8A, 0xBA, 0xBB, 0x24, 0xF7, 0x5F, 0xF2, 0x4A, 0x7A, 0x3D, 0xBE, 0xA7, 0xB1, 0x37, 0x0E, 0x87, 0xA3, 0xB6, 
+			0xB6, 0x36, 0x3A, 0x3A, 0xDA, 0xC3, 0xEE, 0xCB, 0x5E, 0x69, 0xE3, 0xC6, 0x8D, 0x0F, 0x1E, 0x3C, 0x00, 0x00, 0x04, 0x07, 
+			0x61, 0xD1, 0x52, 0x41, 0x70, 0x10, 0xE6, 0x43, 0x67, 0x86, 0x09, 0xAD, 0x56, 0x5B, 0x55, 0x55, 0x45, 0xBE, 0x8E, 0x61, 
+			0xC5, 0xAC, 0x96, 0xAC, 0x2E, 0xD6, 0x17, 0x6F, 0xAC, 0xDB, 0x58, 0x67, 0xF3, 0x4C, 0xB7, 0xB4, 0xB8, 0x9A, 0xDE, 0x6D, 
+			0xFF, 0xCB, 0x35, 0xCB, 0xE5, 0x97, 0x43, 0x5E, 0xF6, 0x2A, 0x17, 0x00, 0x00, 0x82, 0x20, 0x28, 0x8A, 0xA2, 0x28, 0xDA, 
+			0xF3, 0x9B, 0x76, 0x1B, 0xC1, 0x8F, 0x43, 0x9B, 0x9E, 0x7F, 0xFB, 0x39, 0xBE, 0xFF, 0xB9, 0x7F, 0xE4, 0xF4, 0x0C, 0x2F, 
+			0x3E, 0xF8, 0xB0, 0x8D, 0xF9, 0xF9, 0xCF, 0x7F, 0xCE, 0xE3, 0xF1, 0x72, 0x73, 0x73, 0xC9, 0x96, 0xC6, 0xCD, 0x68, 0x6A, 
+			0x63, 0x00, 0x00, 0x04, 0x41, 0x2C, 0x5B, 0xB6, 0x2C, 0x34, 0x34, 0x94, 0x7C, 0xAB, 0x30, 0x2B, 0xF2, 0xDA, 0xF2, 0x34, 
+			0xB8, 0x46, 0xCE, 0x92, 0xCB, 0x31, 0xB9, 0x84, 0x29, 0x11, 0x8B, 0xC5, 0x0A, 0x8B, 0xA2, 0xD2, 0x5C, 0xC9, 0xA5, 0x71, 
+			0x7B, 0xDF, 0xA1, 0xF4, 0x09, 0x06, 0x83, 0x41, 0xA3, 0xD1, 0xC8, 0x64, 0xB2, 0xDE, 0x45, 0x3E, 0x56, 0x0C, 0x00, 0xA0, 
+			0xB7, 0x68, 0x46, 0x99, 0x62, 0x9C, 0x4E, 0x27, 0x97, 0xCB, 0x5D, 0xB6, 0x6C, 0x19, 0x87, 0xC3, 0x21, 0x2D, 0x66, 0xA7, 
+			0xF9, 0x82, 0xFE, 0x82, 0xC2, 0xA2, 0xA8, 0xB7, 0xD6, 0x6B, 0x70, 0x8D, 0x58, 0x2C, 0x4E, 0xE0, 0x24, 0x24, 0x70, 0x12, 
+			0x7E, 0x15, 0xFA, 0x2B, 0xF2, 0x1E, 0x82, 0x6F, 0xB1, 0xD9, 0x6C, 0x0D, 0x0D, 0x0D, 0xE3, 0xC6, 0x8D, 0xF3, 0xBB, 0xF9, 
+			0x31, 0xA4, 0x62, 0x00, 0x00, 0x82, 0xD0, 0xF0, 0x77, 0xB6, 0xEE, 0x4A, 0x9C, 0x14, 0x2B, 0xE4, 0xB3, 0xC0, 0xA8, 0x53, 
+			0x0C, 0xF8, 0x31, 0x04, 0x9E, 0x3F, 0x7F, 0xBE, 0xBB, 0xA5, 0xE9, 0x09, 0x19, 0xC7, 0xD8, 0x71, 0xA7, 0x0D, 0x77, 0xB2, 
+			0x1E, 0xBF, 0x7B, 0x30, 0xF2, 0x18, 0x0C, 0x06, 0x95, 0x4A, 0x25, 0x12, 0x89, 0xFA, 0x9A, 0x5A, 0xEA, 0x17, 0xA3, 0x6B, 
+			0x86, 0x20, 0xFA, 0xE8, 0xF9, 0x07, 0x85, 0xDF, 0x55, 0xFA, 0xDA, 0x91, 0xE1, 0x82, 0x4E, 0xA7, 0x9B, 0xCD, 0xE6, 0x53, 
+			0xA7, 0x4E, 0xD5, 0xD6, 0xD6, 0xF6, 0x95, 0x66, 0xB5, 0xE1, 0x4E, 0xA3, 0xD9, 0x6E, 0xC3, 0x9D, 0x23, 0xEC, 0x9B, 0x1B, 
+			0x87, 0xC3, 0xD1, 0xD6, 0xD6, 0xA6, 0xD1, 0x68, 0xA4, 0x52, 0x69, 0x3F, 0x33, 0x91, 0xFD, 0x25, 0x83, 0x47, 0x10, 0xC4, 
+			0xD7, 0x27, 0xBF, 0x4E, 0x8E, 0x0D, 0xF2, 0x88, 0x69, 0x46, 0x0D, 0x28, 0x8A, 0x3A, 0x9D, 0xCE, 0xB3, 0x67, 0xCF, 0xCA, 
+			0x64, 0xB2, 0xC4, 0xC4, 0x44, 0x91, 0x48, 0xC4, 0xE3, 0xF1, 0x9E, 0x98, 0x72, 0x1D, 0x01, 0x5C, 0x2E, 0x97, 0xC5, 0x62, 
+			0x31, 0x1A, 0x8D, 0x7A, 0xBD, 0x9E, 0xCF, 0xE7, 0x7B, 0x8D, 0x5D, 0x7A, 0x32, 0x8C, 0x8A, 0x69, 0x6A, 0x6A, 0x6A, 0x6E, 
+			0x6E, 0x6E, 0x6E, 0x6E, 0xEE, 0xEC, 0xEC, 0x34, 0x18, 0x0C, 0x06, 0x83, 0xC1, 0x68, 0x34, 0x92, 0x7F, 0xBB, 0xBA, 0xBA, 
+			0x7A, 0x27, 0x13, 0xED, 0x36, 0xFB, 0xC6, 0x8D, 0x1B, 0x73, 0x73, 0x3D, 0xE7, 0x85, 0x8C, 0x26, 0xD8, 0x6C, 0x76, 0x57, 
+			0x57, 0xD7, 0xB9, 0x73, 0xE7, 0x68, 0x34, 0x1A, 0x9B, 0xCD, 0x66, 0x30, 0x18, 0x18, 0x86, 0x3D, 0xFF, 0xFC, 0xF3, 0x00, 
+			0x80, 0x87, 0x4A, 0x5D, 0x5D, 0x8B, 0x2E, 0x46, 0x26, 0x1C, 0x1F, 0xE9, 0x65, 0x12, 0xC5, 0x70, 0x40, 0x8E, 0xB1, 0xE9, 
+			0x74, 0x3A, 0x8F, 0xC7, 0xC3, 0x30, 0xAC, 0xF7, 0x40, 0xDA, 0x2B, 0x43, 0xA9, 0x98, 0xB2, 0xB2, 0xB2, 0xF2, 0xF2, 0xF2, 
+			0xFA, 0xFA, 0xFA, 0xE6, 0xE6, 0xE6, 0x96, 0x96, 0x96, 0x41, 0xD4, 0x60, 0x32, 0x99, 0x6A, 0x6B, 0x6B, 0x87, 0xD0, 0x25, 
+			0xFF, 0x84, 0xFC, 0xB5, 0x90, 0xF7, 0x10, 0xAC, 0x56, 0xEB, 0xF8, 0xF1, 0xE3, 0x01, 0x00, 0x0D, 0x5D, 0x8D, 0xCD, 0x7A, 
+			0xF3, 0x84, 0x09, 0x61, 0xE3, 0xC7, 0x47, 0xF9, 0xDA, 0xC1, 0xFE, 0x18, 0x02, 0xC5, 0xDC, 0xBC, 0x79, 0xF3, 0xD2, 0xA5, 
+			0x4B, 0x97, 0x2F, 0x5F, 0xEE, 0x19, 0x44, 0x63, 0x18, 0x16, 0x1B, 0x1B, 0x1B, 0x17, 0x17, 0x37, 0x71, 0xE2, 0x44, 0xF2, 
+			0x51, 0x86, 0x9E, 0x90, 0x59, 0x4E, 0x77, 0xE4, 0xEB, 0x66, 0xEB, 0xD6, 0xAD, 0x0B, 0x16, 0x2C, 0xB8, 0x7F, 0xFF, 0xFE, 
+			0xD3, 0x7B, 0x05, 0x19, 0x26, 0x06, 0xAF, 0x98, 0xBA, 0xBA, 0xBA, 0x7F, 0xFF, 0xFB, 0xDF, 0x97, 0x2E, 0x5D, 0x32, 0x9B, 
+			0xCD, 0xA4, 0x25, 0x24, 0x24, 0xE4, 0xC5, 0x17, 0x5F, 0x9C, 0x3C, 0x79, 0xF2, 0xC4, 0x89, 0x13, 0x07, 0xD8, 0xC4, 0xF5, 
+			0x24, 0x2D, 0x2D, 0x6D, 0xC1, 0x82, 0xF9, 0x83, 0xF6, 0x07, 0x32, 0x32, 0x0C, 0x46, 0x31, 0xD5, 0xD5, 0xD5, 0xFF, 0xFA, 
+			0xD7, 0xBF, 0xAE, 0x5F, 0xBF, 0x4E, 0xBE, 0x8D, 0x8B, 0x8B, 0x9B, 0x3D, 0x7B, 0xF6, 0xCC, 0x99, 0x33, 0x27, 0x4E, 0x9C, 
+			0x38, 0x38, 0x27, 0xF0, 0x6E, 0xC3, 0x38, 0x11, 0x77, 0xE6, 0x8C, 0xA9, 0x83, 0x3B, 0x7D, 0x74, 0x40, 0xDE, 0x53, 0xF3, 
+			0x3A, 0x13, 0xD4, 0xAF, 0xA0, 0xA6, 0x98, 0xEF, 0xBF, 0xFF, 0xFE, 0xE8, 0xD1, 0xA3, 0x65, 0x65, 0x65, 0x00, 0x00, 0x0E, 
+			0x87, 0xB3, 0x62, 0xC5, 0x8A, 0x45, 0x8B, 0x16, 0x85, 0x85, 0x85, 0x3D, 0xA5, 0x13, 0x6B, 0x57, 0xFD, 0x6A, 0xC1, 0x82, 
+			0x97, 0x9E, 0xB2, 0x92, 0x40, 0xA7, 0xFF, 0x39, 0xA0, 0xFE, 0xC3, 0x40, 0x15, 0x63, 0x30, 0x18, 0xF6, 0xEE, 0xDD, 0x5B, 
+			0x52, 0x52, 0x02, 0x00, 0xE0, 0x72, 0xB9, 0xCB, 0x97, 0x2F, 0x5F, 0xBE, 0x7C, 0xB9, 0x3B, 0x89, 0xF9, 0x34, 0x90, 0xB1, 
+			0xCB, 0xD3, 0xD7, 0x03, 0x19, 0x19, 0x06, 0xA4, 0x98, 0x5B, 0xB7, 0x6E, 0xED, 0xD9, 0xB3, 0x47, 0xAF, 0xD7, 0x73, 0xB9, 
+			0xDC, 0x8C, 0x8C, 0x8C, 0x57, 0x5F, 0x7D, 0x75, 0x48, 0xB4, 0x02, 0x7E, 0x94, 0x8B, 0xCE, 0x68, 0xD3, 0x99, 0x6C, 0x42, 
+			0x1E, 0x8B, 0xCC, 0xF9, 0x8E, 0x4D, 0x7E, 0x9C, 0xF2, 0xE1, 0xD7, 0x2D, 0x4D, 0x9D, 0xAE, 0xEE, 0x09, 0x8A, 0xB1, 0x5A, 
+			0xAD, 0xB9, 0xB9, 0xB9, 0x67, 0xCE, 0x9C, 0x01, 0x00, 0xCC, 0x98, 0x31, 0x63, 0xE7, 0xCE, 0x9D, 0x4F, 0x5C, 0x2D, 0x62, 
+			0xE0, 0xB8, 0x5B, 0x17, 0x8F, 0x79, 0xBE, 0x63, 0x93, 0xBA, 0x16, 0x1D, 0x79, 0x11, 0xFC, 0x56, 0x31, 0xC7, 0xEE, 0x1E, 
+			0xDB, 0x54, 0xB4, 0xA9, 0x3F, 0xC5, 0x28, 0x14, 0x8A, 0xDD, 0xBB, 0x77, 0x6B, 0x34, 0x1A, 0x0C, 0xC3, 0xD6, 0xAD, 0x5B, 
+			0xB7, 0x64, 0xC9, 0x92, 0xA1, 0xF5, 0x00, 0x76, 0x46, 0x81, 0x42, 0x67, 0x77, 0xE7, 0xE6, 0xA2, 0xCD, 0x5F, 0xD6, 0x7C, 
+			0x09, 0xFA, 0xE9, 0x95, 0xCE, 0x9F, 0x3F, 0x9F, 0x9D, 0x9D, 0x4D, 0x10, 0x44, 0x6C, 0x6C, 0xEC, 0xEE, 0xDD, 0xBB, 0x23, 
+			0x23, 0x23, 0x47, 0xD0, 0x43, 0x88, 0xBF, 0xE0, 0x70, 0x39, 0x3E, 0x2E, 0xFF, 0x78, 0x5F, 0xE9, 0x3E, 0xA3, 0xDD, 0x48, 
+			0x5A, 0xBC, 0x2B, 0xC6, 0x2D, 0x97, 0xE7, 0x9E, 0x7B, 0xEE, 0x83, 0x0F, 0x3E, 0x70, 0x3F, 0x66, 0x07, 0x19, 0x53, 0x5C, 
+			0x6A, 0xBC, 0x94, 0x79, 0x3E, 0xF3, 0xA1, 0xEE, 0x61, 0x4F, 0xA3, 0x17, 0x29, 0xB8, 0xE5, 0x32, 0x67, 0xCE, 0x9C, 0x77, 
+			0xDF, 0x7D, 0x17, 0xCA, 0x65, 0x0C, 0xF2, 0x50, 0xF7, 0xF0, 0x2F, 0xC5, 0x7F, 0x29, 0xAC, 0x2B, 0xF4, 0xB0, 0xBF, 0x24, 
+			0x7F, 0xC9, 0x53, 0x0D, 0x6E, 0xB9, 0x2C, 0x58, 0xB0, 0x60, 0xCB, 0x96, 0x2D, 0xBE, 0x5A, 0xD4, 0x0F, 0xE2, 0x2B, 0x1E, 
+			0x68, 0x1F, 0xE4, 0x5C, 0xCF, 0xF9, 0xA2, 0xEA, 0x0B, 0x87, 0xCB, 0xD1, 0xD3, 0x1E, 0x23, 0x8C, 0xD9, 0x37, 0x77, 0xDF, 
+			0xC2, 0xF1, 0x0B, 0x1F, 0x53, 0xCC, 0xDD, 0xBB, 0x77, 0x49, 0xB9, 0xBC, 0xF2, 0xCA, 0x2B, 0xEB, 0xD7, 0xAF, 0x1F, 0x31, 
+			0x2F, 0x47, 0xF1, 0x3C, 0xDF, 0x81, 0xE3, 0xF3, 0x9C, 0xEF, 0x6D, 0xD5, 0xED, 0x9C, 0xEB, 0x39, 0xA7, 0x6B, 0x4F, 0x13, 
+			0xE0, 0xB1, 0x07, 0x39, 0x78, 0x0C, 0xDE, 0xD6, 0x59, 0x5B, 0xDF, 0x9E, 0xFE, 0x36, 0x03, 0x65, 0x80, 0x9E, 0xBD, 0x92, 
+			0x5E, 0xAF, 0xDF, 0xB1, 0x63, 0x07, 0x41, 0x10, 0xE9, 0xE9, 0xE9, 0x23, 0x29, 0x17, 0x00, 0x40, 0x72, 0x9C, 0x24, 0x39, 
+			0x4E, 0x32, 0x92, 0x9F, 0xE8, 0x87, 0xF8, 0x30, 0x13, 0x73, 0xB9, 0xE9, 0xF2, 0x87, 0x37, 0x3E, 0xBC, 0xD8, 0x78, 0xD1, 
+			0xC3, 0x8E, 0x00, 0xE4, 0xB5, 0x84, 0xD7, 0xB2, 0x5E, 0xCC, 0x12, 0x71, 0x7E, 0x7A, 0x40, 0xF3, 0x91, 0x62, 0x5C, 0x2E, 
+			0xD7, 0xAE, 0x5D, 0xBB, 0xC8, 0x27, 0xED, 0xB6, 0x6E, 0xDD, 0x3A, 0x72, 0xCE, 0x42, 0x7C, 0x47, 0x67, 0x77, 0xE7, 0xB1, 
+			0xBB, 0xC7, 0x3E, 0xAB, 0xFC, 0xEC, 0x5E, 0xC7, 0x3D, 0x8F, 0x22, 0x14, 0x41, 0x97, 0x4D, 0x5C, 0xB6, 0x6D, 0xD6, 0xB6, 
+			0xF8, 0xD0, 0x78, 0x8F, 0xA2, 0x47, 0x8A, 0x39, 0x74, 0xE8, 0xD0, 0x9D, 0x3B, 0x77, 0xB8, 0x5C, 0xEE, 0xFE, 0xFD, 0xFB, 
+			0x99, 0x4C, 0x26, 0x18, 0x59, 0x60, 0xCE, 0x17, 0x8C, 0x60, 0xCE, 0xD7, 0x49, 0x38, 0xCF, 0xD7, 0x9F, 0x3F, 0x5C, 0x71, 
+			0xF8, 0xCC, 0xC3, 0x33, 0x0E, 0xC2, 0xE1, 0x51, 0x8A, 0x02, 0x34, 0xE3, 0x99, 0x8C, 0x6D, 0xB3, 0xB6, 0xC5, 0x08, 0x63, 
+			0xBC, 0x9E, 0x4E, 0x07, 0x00, 0x94, 0x95, 0x95, 0x7D, 0xF6, 0xD9, 0x67, 0x08, 0x82, 0xEC, 0xD9, 0xB3, 0xC7, 0xBD, 0x16, 
+			0xC1, 0x48, 0x02, 0x73, 0xBE, 0x60, 0xF8, 0x73, 0xBE, 0x76, 0xA7, 0xBD, 0xA8, 0xA1, 0xE8, 0x9B, 0xFB, 0xDF, 0x9C, 0xA9, 
+			0x3B, 0xD3, 0xD9, 0xED, 0x65, 0xB9, 0x32, 0x3A, 0x42, 0x5F, 0x39, 0x79, 0xE5, 0xB6, 0x59, 0xDB, 0xC6, 0x05, 0x8D, 0xEB, 
+			0xA7, 0x1E, 0xBA, 0xD5, 0x6A, 0xCD, 0xCA, 0xCA, 0x02, 0x00, 0xAC, 0x5E, 0xBD, 0x3A, 0x25, 0x25, 0x65, 0x38, 0x7C, 0xF5, 
+			0x15, 0xE4, 0xAC, 0x44, 0x8F, 0x07, 0x72, 0x7B, 0x3E, 0x32, 0xE8, 0xB6, 0x00, 0x6F, 0xCB, 0x5E, 0x8C, 0x0E, 0x0C, 0x76, 
+			0xC3, 0xB7, 0xB5, 0xDF, 0x9E, 0x7A, 0x70, 0xAA, 0xA8, 0xBE, 0xC8, 0xE2, 0xF0, 0x5C, 0x0C, 0x86, 0x24, 0x2A, 0x28, 0xEA, 
+			0xAD, 0xA4, 0xB7, 0x7E, 0x97, 0xF0, 0xBB, 0x9E, 0xF1, 0x4A, 0x5F, 0xD0, 0x0B, 0x0A, 0x0A, 0xF4, 0x7A, 0x7D, 0x54, 0x54, 
+			0xD4, 0xEB, 0xAF, 0xBF, 0x3E, 0xD4, 0xDE, 0xFA, 0x9E, 0xE0, 0x99, 0x6B, 0xFE, 0x6B, 0x5E, 0xF8, 0x63, 0xA6, 0xDA, 0xAF, 
+			0xB3, 0x8F, 0xDD, 0x1D, 0xFF, 0xEA, 0x9F, 0x57, 0xC4, 0x93, 0x43, 0x33, 0xDD, 0xAD, 0x4F, 0x3F, 0x3E, 0xD3, 0x3A, 0xAA, 
+			0x1E, 0x76, 0x69, 0x37, 0xB7, 0x5F, 0x53, 0x5E, 0x2B, 0x51, 0x96, 0x5C, 0x6F, 0xBD, 0xAE, 0x50, 0x2B, 0x9C, 0x84, 0xF7, 
+			0xE7, 0x13, 0x18, 0x28, 0xE3, 0xE5, 0x09, 0x2F, 0xBF, 0x39, 0xE5, 0xCD, 0x39, 0x51, 0x73, 0x10, 0x30, 0xD0, 0x1F, 0x0C, 
+			0xBD, 0xA0, 0xA0, 0x00, 0x00, 0xB0, 0x79, 0xF3, 0xE6, 0x21, 0xF3, 0xD7, 0xCF, 0xC0, 0xB5, 0xDF, 0x9F, 0xFC, 0xF2, 0x46, 
+			0x87, 0x03, 0x00, 0xB2, 0x21, 0xB1, 0xEA, 0x9C, 0xC0, 0xD9, 0x58, 0x78, 0xF8, 0xD3, 0x6B, 0x74, 0x82, 0x3B, 0x75, 0xC9, 
+			0xAF, 0xC7, 0x83, 0xC0, 0x5F, 0x15, 0x80, 0x00, 0x44, 0x55, 0x47, 0xD5, 0xF5, 0xD6, 0xEB, 0x25, 0xCA, 0x92, 0xD2, 0x96, 
+			0xD2, 0x46, 0xBD, 0xE7, 0x7A, 0x8E, 0x1E, 0xC4, 0x06, 0xC7, 0xBE, 0x31, 0xE5, 0x8D, 0x55, 0x89, 0xAB, 0x82, 0xB1, 0x60, 
+			0xAA, 0x9F, 0x45, 0xB7, 0xD9, 0x6C, 0xA9, 0xA9, 0xA9, 0x49, 0x49, 0x49, 0x83, 0xF5, 0xD6, 0xDF, 0x41, 0x9C, 0x36, 0x7D, 
+			0xAB, 0x5A, 0xF3, 0x78, 0xA7, 0x63, 0x37, 0xA8, 0x5B, 0x0D, 0x80, 0x08, 0x89, 0x76, 0xF6, 0xB0, 0xBB, 0xFB, 0x29, 0xF7, 
+			0x83, 0xEC, 0x64, 0xFF, 0xD5, 0x5F, 0xE5, 0x3E, 0xEA, 0xCB, 0x94, 0x46, 0x65, 0x55, 0x47, 0x55, 0x55, 0x67, 0xD5, 0x3D, 
+			0xCD, 0xBD, 0xAA, 0xCE, 0xAA, 0xEA, 0xCE, 0x6A, 0x33, 0x6E, 0x7E, 0xE2, 0x59, 0x49, 0x92, 0xA4, 0x45, 0xB1, 0x8B, 0x16, 
+			0x8E, 0x5F, 0x38, 0x55, 0x3C, 0xF8, 0xE9, 0x8E, 0x74, 0x00, 0xC0, 0x08, 0x67, 0x5F, 0x7C, 0x82, 0xC7, 0xA3, 0xEA, 0xC0, 
+			0xDB, 0xEA, 0x4B, 0x00, 0x00, 0x82, 0x13, 0x93, 0xB6, 0x64, 0x7E, 0x52, 0x74, 0x18, 0x06, 0x4C, 0x1D, 0xD5, 0xDF, 0x9D, 
+			0x3E, 0x7D, 0xA3, 0x23, 0x7E, 0xE5, 0xC6, 0x54, 0xD5, 0xE1, 0xFF, 0x2D, 0x6E, 0xE7, 0x4E, 0xFF, 0xDD, 0xDB, 0x71, 0x3F, 
+			0xE4, 0x1D, 0xFB, 0xC1, 0x26, 0x7B, 0x69, 0xDD, 0x6B, 0xC2, 0xCB, 0x07, 0x4E, 0xDC, 0x1B, 0xDE, 0xBE, 0x4C, 0x6D, 0x51, 
+			0xAB, 0x4C, 0x2A, 0x95, 0x59, 0x45, 0xBE, 0x68, 0x33, 0xB5, 0xA9, 0x4C, 0xAA, 0x56, 0x53, 0xEB, 0x5D, 0xCD, 0xDD, 0xBE, 
+			0x22, 0x12, 0xAF, 0xA4, 0x47, 0xA7, 0x2F, 0x1C, 0xBF, 0x70, 0x71, 0xEC, 0x62, 0x19, 0xFF, 0x09, 0xCF, 0x22, 0x0D, 0x04, 
+			0xFA, 0xE2, 0xC5, 0x8B, 0x7D, 0x7E, 0x5F, 0x7A, 0x58, 0x73, 0xBE, 0xE4, 0xE2, 0x17, 0xEE, 0xC7, 0x72, 0xFB, 0x5A, 0x02, 
+			0x83, 0x20, 0x08, 0x82, 0x10, 0xCF, 0xCA, 0xC8, 0x48, 0xA1, 0xDF, 0x39, 0xFD, 0x7F, 0xC7, 0x3B, 0xE8, 0xD1, 0xCF, 0x2F, 
+			0xFD, 0x65, 0xC6, 0x92, 0xEE, 0x4F, 0x2E, 0xAB, 0xB4, 0x82, 0xD0, 0x30, 0x1A, 0xD0, 0xC8, 0xA2, 0x24, 0x98, 0x24, 0x4A, 
+			0x86, 0xFE, 0xD0, 0x28, 0x14, 0xF2, 0x74, 0x2D, 0x2A, 0x27, 0x18, 0x70, 0xDF, 0xDF, 0x0F, 0x46, 0xBB, 0x91, 0xF7, 0x21, 
+			0x0F, 0x00, 0x20, 0x02, 0x71, 0x62, 0x10, 0x7F, 0xEC, 0x72, 0xB5, 0xE6, 0x72, 0xCD, 0x53, 0xD6, 0x19, 0xC1, 0x8B, 0x78, 
+			0x36, 0xE2, 0xD9, 0x19, 0xD2, 0x19, 0x33, 0xA4, 0x33, 0x92, 0x25, 0xC9, 0x18, 0x7D, 0x28, 0x2F, 0x2C, 0x7D, 0xF5, 0xEA, 
+			0xD5, 0x43, 0x58, 0xDD, 0xE0, 0x18, 0xD6, 0x9C, 0x2F, 0x43, 0x34, 0xF3, 0xF7, 0xFF, 0x3D, 0xF3, 0xD1, 0x1B, 0x6B, 0xF5, 
+			0x97, 0xFF, 0x73, 0xA2, 0xAA, 0x8F, 0xA6, 0x81, 0x16, 0x35, 0x3D, 0x25, 0xBC, 0xE3, 0xD6, 0xC1, 			0x6F, 0xAB, 0x34, 0x28, 
+			0x00, 0xDA, 0xAF, 0x4F, 0x47, 0x66, 0x66, 0xA4, 0x4C, 0xBD, 0x78, 0xAD, 0xC3, 0x31, 0x5E, 0x12, 0x8A, 0x6A, 0xA3, 0xC3, 
+			0x4D, 0x1A, 0x6B, 0x78, 0x74, 0x18, 0x6A, 0x92, 0x08, 0xAD, 0xAA, 0x72, 0xCF, 0xC5, 0x87, 0x07, 0x89, 0xDD, 0x6E, 0x07, 
+			0x2C, 0x00, 0x00, 0xD0, 0x80, 0x1A, 0x0D, 0x18, 0xA4, 0x56, 0xF8, 0x0C, 0x7E, 0x82, 0x38, 0x21, 0x39, 0x3C, 0x39, 0x55, 
+			0x96, 0x9A, 0x12, 0x9E, 0xD2, 0xFF, 0xF0, 0xF8, 0x29, 0xA1, 0x87, 0x84, 0x84, 0x0C, 0x5F, 0xED, 0xFE, 0x00, 0x19, 0xF9, 
+			0x76, 0x3A, 0xC9, 0xF6, 0xC0, 0xAA, 0xEF, 0xBB, 0x69, 0x60, 0x49, 0xC2, 0x79, 0x56, 0xD5, 0xC3, 0xCE, 0x47, 0xC5, 0xAE, 
+			0xC6, 0xC6, 0x76, 0x24, 0x5E, 0x1A, 0xD6, 0xDE, 0xA4, 0x13, 0xCA, 0xC3, 0x84, 0x91, 0x91, 0xF4, 0x96, 0x1A, 0x65, 0x74, 
+			0x64, 0x24, 0x4F, 0x15, 0xC6, 0xD3, 0xD5, 0xAA, 0x9C, 0x00, 0x41, 0x7D, 0x13, 0xC4, 0x88, 0xD8, 0xA2, 0x67, 0x44, 0xCF, 
+			0xC4, 0x85, 0xC4, 0xC5, 0x87, 0xC5, 0xC7, 0x87, 0xC6, 0xC7, 0x85, 0xC4, 0x49, 0xB8, 0x23, 0x97, 0x45, 0xF3, 0x8B, 0x99, 
+			0x0C, 0xC3, 0x9A, 0xF3, 0x25, 0x23, 0x5F, 0x75, 0xCF, 0x38, 0xA6, 0x9F, 0xA3, 0x3D, 0x53, 0xA0, 0x00, 0x01, 0xE6, 0xF6, 
+			0x76, 0xDB, 0xB4, 0xC8, 0xA4, 0x68, 0x9E, 0xAA, 0xF2, 0x56, 0x2D, 0x2F, 0x21, 0x36, 0x3E, 0x52, 0x68, 0x55, 0xA9, 0x6C, 
+			0x43, 0x14, 0xF3, 0x92, 0x19, 0x76, 0x1E, 0x83, 0x17, 0x81, 0x4E, 0x16, 0x81, 0x38, 0x33, 0xA3, 0x19, 0xC7, 0xDA, 0x31, 
+			0x3A, 0xC6, 0xA1, 0x73, 0xF8, 0x4C, 0xBE, 0x84, 0x2B, 0x91, 0x70, 0x25, 0xE1, 0xBC, 0x70, 0xF2, 0xAF, 0x98, 0x23, 0x8E, 
+			0x16, 0x44, 0x0F, 0xC9, 0xE7, 0x0E, 0x1A, 0xBF, 0x50, 0xCC, 0x08, 0xE4, 0x7C, 0x11, 0x6F, 0x63, 0x22, 0xF0, 0xF8, 0xF8, 
+			0xC8, 0xAA, 0xEA, 0x30, 0xF1, 0xC2, 0x65, 0x02, 0xA2, 0x49, 0x8B, 0x00, 0x00, 0x50, 0x59, 0x54, 0x18, 0xD0, 0x95, 0xA9, 
+			0x71, 0x15, 0xB3, 0x83, 0x3B, 0x3B, 0x0E, 0x33, 0x95, 0x9F, 0x35, 0x29, 0x85, 0xA6, 0xE7, 0x27, 0xCB, 0x68, 0x1D, 0x37, 
+			0x86, 0x28, 0x8A, 0x01, 0x80, 0xCF, 0xE4, 0x9B, 0x32, 0x4D, 0xC0, 0xBD, 0xB4, 0xDB, 0x74, 0x7F, 0x4F, 0x7C, 0xFB, 0xC5, 
+			0x6A, 0x20, 0x23, 0x0F, 0x33, 0x48, 0x2C, 0x16, 0x8B, 0xC5, 0xA1, 0x02, 0x3A, 0x00, 0x58, 0x58, 0xB8, 0x48, 0x24, 0x12, 
+			0x07, 0xA1, 0xCE, 0xC6, 0xEB, 0xB7, 0x54, 0x61, 0xCF, 0x2F, 0x9D, 0x3F, 0x49, 0x14, 0x1C, 0x1C, 0x91, 0xB8, 0x78, 0x71, 
+			0x02, 0xBD, 0xE1, 0x7A, 0x45, 0x17, 0x62, 0x53, 0xA9, 0xAC, 0x22, 0x91, 0x43, 0xA9, 0x34, 0xBB, 0xF4, 0x4A, 0x15, 0x3D, 
+			0x3C, 0xDC, 0xDA, 0xD1, 0x3E, 0xAA, 0x32, 0x7E, 0x94, 0xF0, 0x8B, 0x36, 0x66, 0xB8, 0xE9, 0x35, 0x38, 0xA2, 0x45, 0xCD, 
+			0x5F, 0xF5, 0x63, 0xCE, 0x17, 0x88, 0x96, 0xFE, 0x3E, 0x01, 0x00, 0x53, 0xE5, 0xF1, 0xBC, 0xAF, 0xEE, 0x97, 0x7C, 0xFE, 
+			0x39, 0xB6, 0x64, 0xFE, 0x2F, 0x7F, 0x9F, 0xCA, 0x03, 0x26, 0x55, 0x75, 0xD1, 0xE7, 0xDF, 0x56, 0x98, 0x01, 0x40, 0x3A, 
+			0x5B, 0x3A, 0xAD, 0x56, 0x47, 0x83, 0xCA, 0x85, 0x10, 0xCA, 0x06, 0x95, 0x33, 0xDE, 0xD1, 0x6B, 0xCF, 0x8D, 0x31, 0xC4, 
+			0x28, 0x57, 0x8C, 0xB6, 0x34, 0x7F, 0x6F, 0x29, 0x00, 0x9E, 0x3D, 0x88, 0xF3, 0xC1, 0x89, 0x9C, 0x3D, 0xBD, 0xEF, 0x37, 
+			0x01, 0x80, 0x58, 0xEA, 0x2E, 0x16, 0xFC, 0xA3, 0xF8, 0xC7, 0x0C, 0x1E, 0x00, 0x08, 0x8A, 0x22, 0x84, 0xEB, 0xFE, 0x89, 
+			0x9C, 0x1C, 0xF2, 0x30, 0xA2, 0xEA, 0x44, 0x4E, 0x15, 0x59, 0x38, 0x3A, 0xEF, 0x43, 0x3D, 0x91, 0xD1, 0xAC, 0x98, 0xBE, 
+			0xBE, 0xD4, 0xBE, 0x6E, 0x3D, 0xBA, 0x2D, 0x1E, 0x45, 0x63, 0x56, 0x1C, 0x5E, 0x19, 0xA3, 0x71, 0x0C, 0x64, 0xD0, 0xF8, 
+			0x45, 0x1B, 0x03, 0xE7, 0xF9, 0x02, 0x3F, 0x98, 0xE7, 0x3B, 0x40, 0xFC, 0x42, 0x31, 0x70, 0x9E, 0x2F, 0x08, 0x9C, 0xB5, 
+			0x1D, 0x60, 0xAF, 0x04, 0xA1, 0x86, 0x5F, 0xB4, 0x31, 0x70, 0x9E, 0x2F, 0x08, 0x90, 0xB5, 0x1D, 0x80, 0x9F, 0xB4, 0x31, 
+			0xE5, 0xD5, 0xAA, 0xFC, 0xAF, 0xEF, 0x94, 0x57, 0xAB, 0x7C, 0xED, 0x88, 0x2F, 0xA9, 0x6B, 0xD1, 0x5D, 0x28, 0x6B, 0xE8, 
+			0xBD, 0xBD, 0xAA, 0xBF, 0xE1, 0x17, 0x8A, 0x81, 0x04, 0x10, 0x50, 0x31, 0x10, 0x6A, 0x40, 0xC5, 0x40, 0xA8, 0x01, 0x15, 
+			0x03, 0xA1, 0x86, 0x2F, 0x15, 0x43, 0x6E, 0xC7, 0x05, 0x09, 0x2C, 0xE0, 0x1E, 0x6E, 0xFE, 0x42, 0x8C, 0x4C, 0x98, 0x96, 
+			0x12, 0x05, 0x73, 0xBE, 0xFD, 0x61, 0x32, 0x99, 0xC8, 0xAD, 0x2B, 0x92, 0xE3, 0x26, 0xC0, 0x9C, 0xAF, 0xFF, 0x67, 0x62, 
+			0x48, 0x7C, 0x1C, 0xC7, 0x90, 0xA2, 0x81, 0xDD, 0x53, 0x00, 0xE1, 0xFB, 0xC8, 0xD7, 0x64, 0x32, 0xFD, 0x79, 0xCB, 0xCE, 
+			0xAB, 0x37, 0xEF, 0xEA, 0x8C, 0x36, 0x5F, 0xFB, 0xE2, 0x4B, 0xEA, 0x5B, 0xF5, 0xC5, 0xB7, 0x9A, 0xEA, 0x5B, 0xF5, 0xBE, 
+			0x76, 0xE4, 0x09, 0xF8, 0x5E, 0x31, 0x60, 0x0C, 0xEC, 0xE1, 0x36, 0x10, 0x60, 0xCE, 0x97, 0x1A, 0xE4, 0x1E, 0x6E, 0xB0, 
+			0x7B, 0xF2, 0x7F, 0x86, 0x3D, 0xF2, 0x35, 0x18, 0x0C, 0x0A, 0x85, 0xA2, 0xB2, 0xB2, 0xB2, 0xA6, 0xA6, 0x46, 0xAF, 0xD7, 
+			0x9B, 0xCD, 0x66, 0xB3, 0xD9, 0x6C, 0x30, 0x18, 0xC6, 0xE6, 0x1E, 0x6E, 0xA3, 0x80, 0xE1, 0x52, 0x4C, 0x75, 0x75, 0x75, 
+			0x71, 0x71, 0x71, 0x69, 0x69, 0x69, 0x53, 0x53, 0xD3, 0xC0, 0xCF, 0x1A, 0x23, 0x7B, 0xB8, 0x05, 0x34, 0x43, 0xAC, 0x98, 
+			0xF6, 0xF6, 0xF6, 0xD3, 0xA7, 0x4F, 0x17, 0x17, 0x17, 0x2B, 0x95, 0x4A, 0xB7, 0x71, 0xDA, 0xB4, 0x69, 0x12, 0x89, 0x44, 
+			0x2C, 0x16, 0x4B, 0x24, 0x12, 0x89, 0x44, 0x12, 0x16, 0x16, 0x16, 0x11, 0x11, 0x81, 0x61, 0x18, 0xDC, 0xC3, 0x2D, 0x10, 
+			0x19, 0x32, 0xC5, 0xE8, 0xF5, 0xFA, 0xC3, 0x87, 0x0F, 0x9F, 0x3C, 0x79, 0xD2, 0xE1, 0x70, 0x00, 0x00, 0x10, 0x04, 0x49, 
+			0x4A, 0x4A, 0xFA, 0xC5, 0x2F, 0x7E, 0x31, 0x67, 0xCE, 0x1C, 0x72, 0x8F, 0xBF, 0x27, 0x02, 0xF7, 0x70, 0x0B, 0x08, 0x86, 
+			0x40, 0x31, 0x76, 0xBB, 0xFD, 0x3F, 0xFF, 0xF9, 0xCF, 0xD1, 0xA3, 0x47, 0xF5, 0x7A, 0x3D, 0x00, 0x20, 0x2E, 0x2E, 0x6E, 
+			0xDE, 0xBC, 0x79, 0xE9, 0xE9, 0xE9, 0x5E, 0x77, 0x03, 0xF7, 0x0A, 0xDC, 0xC3, 0x0D, 0x8C, 0x9D, 0x79, 0xBE, 0xF7, 0xEE, 
+			0xDD, 0xDB, 0xBD, 0x7B, 0xB7, 0x4A, 0xA5, 0x02, 0x00, 0x4C, 0x9C, 0x38, 0x71, 0xC3, 0x86, 0x0D, 0x89, 0x89, 0x89, 0x54, 
+			0x2B, 0x81, 0x7B, 0xB8, 0x81, 0xC0, 0xC9, 0xF9, 0x0E, 0x5E, 0x31, 0x38, 0x8E, 0xE7, 0xE7, 0xE7, 0x7F, 0xF1, 0xC5, 0x17, 
+			0x04, 0x41, 0x84, 0x86, 0x86, 0xFE, 0xE1, 0x0F, 0x7F, 0x98, 0x3F, 0x7F, 0xFE, 0x20, 0x1E, 0xED, 0x81, 0x7B, 0xB8, 0x05, 
+			0x16, 0x83, 0x54, 0x4C, 0x4D, 0x4D, 0x4D, 0x56, 0x56, 0x56, 0x73, 0x73, 0x33, 0x8B, 0xC5, 0xCA, 0xC8, 0xC8, 0x78, 0xED, 
+			0xB5, 0xD7, 0x30, 0x6C, 0x30, 0xF7, 0x11, 0xE1, 0x1E, 0x6E, 0x6E, 0x46, 0xF3, 0x3C, 0xDF, 0xC2, 0xC2, 0xC2, 0x3F, 0xFD, 
+			0xE9, 0x4F, 0xCD, 0xCD, 0xCD, 0x32, 0x99, 0xEC, 0xD0, 0xA1, 0x43, 0xAB, 0x57, 0xAF, 0x7E, 0x1A, 0xB9, 0x00, 0x38, 0xCF, 
+			0x17, 0x00, 0x10, 0x38, 0x39, 0x5F, 0xCA, 0x6D, 0xCC, 0x27, 0x9F, 0x7C, 0x72, 0xEC, 0xD8, 0x31, 0x00, 0xC0, 0xAC, 0x59, 
+			0xB3, 0x76, 0xED, 0xDA, 0xC5, 0x66, 0xB3, 0x07, 0xFD, 0xD9, 0xB0, 0x33, 0x0A, 0x44, 0x28, 0x28, 0xC6, 0x66, 0xB3, 0x65, 
+			0x65, 0x65, 0x5D, 0xBD, 0x7A, 0x15, 0x45, 0xD1, 0x35, 0x6B, 0xD6, 0xAC, 0x5C, 0xB9, 0x72, 0xF8, 0xDC, 0x82, 0xF8, 0x2D, 
+			0x03, 0x55, 0x8C, 0x4E, 0xA7, 0x7B, 0xE7, 0x9D, 0x77, 0xEE, 0xDF, 0xBF, 0xCF, 0xE7, 0xF3, 0xDF, 0x7F, 0xFF, 0xFD, 0x51, 
+			0xBC, 0x9A, 0x2B, 0xA4, 0x7F, 0x06, 0xA4, 0x18, 0xBD, 0x5E, 0xFF, 0xF6, 0xDB, 0x6F, 0x2B, 0x95, 0x4A, 0xB9, 0x5C, 0x9E, 
+			0x93, 0x93, 0x23, 0x12, 0x3D, 0x79, 0x2D, 0x72, 0xC8, 0x68, 0xE5, 0xC9, 0x8A, 0xB1, 0x5A, 0xAD, 0x9B, 0x36, 0x6D, 0x52, 
+			0x2A, 0x95, 0x71, 0x71, 0x71, 0x1F, 0x7D, 0xF4, 0xD1, 0xE0, 0x82, 0x5C, 0x4A, 0xB8, 0x5C, 0xAE, 0xB1, 0xB3, 0xD5, 0x20, 
+			0x99, 0x22, 0x0F, 0x20, 0x9E, 0xF0, 0xC5, 0xE0, 0x38, 0xBE, 0x65, 0xCB, 0x96, 0x87, 0x0F, 0x1F, 0x46, 0x47, 0x47, 0x1F, 
+			0x38, 0x70, 0x60, 0x98, 0xE4, 0xE2, 0x31, 0xCF, 0x77, 0xD3, 0xA6, 0x4D, 0xC3, 0xF1, 0x29, 0x7E, 0x4E, 0xA0, 0xE4, 0x7C, 
+			0x11, 0x93, 0xC9, 0xD4, 0x57, 0x99, 0xD3, 0xE9, 0xDC, 0xB1, 0x63, 0x47, 0x69, 0x69, 0xA9, 0x48, 0x24, 0xCA, 0xCF, 0xCF, 
+			0x0F, 0x0E, 0xA6, 0xBC, 0x86, 0x3D, 0x64, 0xF4, 0xD1, 0x5F, 0x1B, 0xB3, 0x7F, 0xFF, 0xFE, 0xD2, 0xD2, 0x52, 0xA1, 0x50, 
+			0xF8, 0xB7, 0xBF, 0xFD, 0x6D, 0xB8, 0xE5, 0xA2, 0x33, 0xDA, 0x6E, 0xD7, 0xB4, 0x7B, 0x18, 0x85, 0x7C, 0x16, 0x39, 0x63, 
+			0x7C, 0x8C, 0x94, 0xFA, 0x7F, 0xFA, 0x0E, 0xF4, 0xA3, 0x98, 0xA3, 0x47, 0x8F, 0x16, 0x16, 0x16, 0xB2, 0xD9, 0xEC, 0xDC, 
+			0xDC, 0xDC, 0x88, 0x88, 0x88, 0xE1, 0xF6, 0x43, 0x6B, 0xB4, 0x5E, 0x28, 0x6B, 0xF0, 0x30, 0x46, 0x4B, 0x05, 0xE4, 0xF5, 
+			0x1D, 0x23, 0xA5, 0x72, 0x99, 0x30, 0x7D, 0xD8, 0x76, 0xE4, 0x1A, 0x2A, 0xBC, 0x2B, 0xA6, 0xBC, 0xBC, 0x3C, 0x3F, 0x3F, 
+			0x1F, 0x41, 0x90, 0xEC, 0xEC, 0x6C, 0xB9, 0x5C, 0x3E, 0x02, 0x7E, 0x04, 0xF3, 0xB1, 0xB4, 0x14, 0xCF, 0x75, 0x6C, 0xDD, 
+			0x91, 0xCD, 0x18, 0x29, 0x0D, 0x08, 0xBC, 0xC4, 0x31, 0x1A, 0x8D, 0xE6, 0x8D, 0x37, 0xDE, 0x30, 0x99, 0x4C, 0xEB, 0xD6, 
+			0xAD, 0xCB, 0xC8, 0xC8, 0xF0, 0x89, 0x5B, 0x10, 0xBF, 0xC5, 0xF3, 0xBE, 0x92, 0xC3, 0xE1, 0xD8, 0xB1, 0x63, 0x87, 0xC9, 
+			0x64, 0x9A, 0x3B, 0x77, 0x2E, 0x94, 0x0B, 0xA4, 0x37, 0x9E, 0x8A, 0x39, 0x78, 0xF0, 0x60, 0x4D, 0x4D, 0x8D, 0x4C, 0x26, 
+			0xDB, 0xB6, 0x6D, 0x9B, 0x4F, 0x1C, 0x82, 0xF8, 0x39, 0x8F, 0x29, 0xE6, 0xF6, 0xED, 0xDB, 0x05, 0x05, 0x05, 0x74, 0x3A, 
+			0x3D, 0x3B, 0x3B, 0xBB, 0xF7, 0x5C, 0x7F, 0x08, 0x04, 0xF4, 0x54, 0x8C, 0xD1, 0x68, 0x7C, 0xEF, 0xBD, 0xF7, 0x00, 0x00, 
+			0x6B, 0xD7, 0xAE, 0x1D, 0x99, 0x68, 0x17, 0x12, 0x88, 0xFC, 0xA4, 0x98, 0xBD, 0x7B, 0xF7, 0xEA, 0xF5, 0xFA, 0xA4, 0xA4, 
+			0xA4, 0x57, 0x5E, 0x79, 0xC5, 0x87, 0x0E, 0x41, 0xFC, 0x9C, 0x47, 0x8A, 0xB9, 0x78, 0xF1, 0xE2, 0xB5, 0x6B, 0xD7, 0x38, 
+			0x1C, 0xCE, 0xAE, 0x5D, 0xBB, 0x7C, 0xEB, 0x10, 0xC4, 0xCF, 0x41, 0x01, 0x00, 0x06, 0x83, 0xE1, 0xC0, 0x81, 0x03, 0x00, 
+			0x80, 0xF5, 0xEB, 0xD7, 0x0F, 0xFC, 0x01, 0x00, 0xC8, 0xD8, 0x04, 0x05, 0x00, 0xE4, 0xE5, 0xE5, 0x19, 0x8D, 0xC6, 0x67, 
+			0x9F, 0x7D, 0x76, 0xE1, 0xC2, 0x85, 0xBE, 0xF6, 0x07, 0xE2, 0xEF, 0xA0, 0xE5, 0xE5, 0xE5, 0x45, 0x45, 0x45, 0x6C, 0x36, 
+			0x7B, 0xFB, 0xF6, 0xED, 0xBE, 0x76, 0x06, 0x12, 0x00, 0xD0, 0xDA, 0xDA, 0xDA, 0x2C, 0x16, 0xCB, 0xFA, 0xF5, 0xEB, 0xA7, 
+			0x4D, 0x9B, 0xE6, 0x6B, 0x67, 0x20, 0x01, 0x00, 0xDA, 0xD1, 0xD1, 0x31, 0x69, 0xD2, 0xA4, 0xA5, 0x4B, 0x97, 0xFA, 0xDA, 
+			0x13, 0x48, 0x60, 0x80, 0xD2, 0x68, 0xB4, 0x9D, 0x3B, 0x77, 0xFA, 0xDA, 0x0D, 0x48, 0xC0, 0x80, 0xAE, 0x5C, 0xB9, 0x32, 
+			0x32, 0x32, 0xD2, 0xD7, 0x6E, 0x40, 0x02, 0x06, 0xA4, 0xAB, 0xAB, 0x8B, 0xDC, 0x72, 0x19, 0x02, 0x19, 0x08, 0x28, 0x94, 
+			0x0B, 0x84, 0x12, 0xFE, 0xB2, 0x0E, 0x1E, 0x24, 0x50, 0x80, 0x8A, 0x81, 0x50, 0x03, 0x2A, 0x06, 0x42, 0x0D, 0xA8, 0x18, 
+			0x08, 0x35, 0xA0, 0x62, 0x20, 0xD4, 0x80, 0x8A, 0x81, 0x50, 0x03, 0x2A, 0x06, 0x42, 0x0D, 0xA8, 0x18, 0x08, 0x35, 0xA0, 
+			0x62, 0x20, 0xD4, 0x80, 0x8A, 0x81, 0x50, 0x03, 0x2A, 0x06, 0x42, 0x0D, 0xA8, 0x18, 0x08, 0x35, 0xA0, 0x62, 0x20, 0xD4, 
+			0x80, 0x8A, 0x81, 0x50, 0x03, 0x2A, 0x06, 0x42, 0x0D, 0xA8, 0x18, 0x08, 0x35, 0xA0, 0x62, 0x20, 0xD4, 0x80, 0x8A, 0x81, 
+			0x50, 0x03, 0x2A, 0x06, 0x42, 0x0D, 0xA8, 0x18, 0x08, 0x35, 0xA0, 0x62, 0x20, 0xD4, 0x80, 0x8A, 0x81, 0x50, 0x03, 0x2A, 
+			0x06, 0x42, 0x0D, 0xA8, 0x18, 0x08, 0x35, 0xA0, 0x62, 0x20, 0xD4, 0x80, 0x8A, 0x81, 0x50, 0x03, 0x2A, 0x06, 0x42, 0x8D, 
+			0xFF, 0x07, 0x9E, 0x60, 0x30, 0xB1, 0x5A, 0xA7, 0x81, 0x17, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 
+			0x60, 0x82, 			 
 		},
 	
 	}

go/src/flowserver/cmd/demo1/defaultops/defaultops.go

@@ -16,21 +16,21 @@ func New() *registry.R {
 	r := registry.New()
 	// String functions
 	registry.Describer(
-		r.Add(strings.Split).Inputs("string", "separator"),
-		r.Add(strings.Join).Inputs("", "sep"),
-		r.Add(strings.Compare, strings.Contains),
-		r.Register("Cat", func(a, b string) string { return a + " " + b }),
-		r.Register("ToString", func(a interface{}) string { return fmt.Sprint(a) }),
+		r.MustAdd(strings.Split).Inputs("string", "separator"),
+		r.MustAdd(strings.Join).Inputs("", "sep"),
+		r.MustAdd(strings.Compare, strings.Contains),
+		r.MustRegister("Cat", func(a, b string) string { return a + " " + b }),
+		r.MustRegister("ToString", func(a interface{}) string { return fmt.Sprint(a) }),
 	).Tags("string").Extra("style", registry.M{"color": "#839"})
 
 	// Math functions
-	r.Add(
+	r.MustAdd(
 		math.Abs, math.Cos, math.Sin, math.Exp, math.Exp2, math.Tanh, math.Max, math.Min,
 	).Tags("math").Extra("style", registry.M{"color": "#386"})
 
 	registry.Describer(
-		r.Add(rand.Int, rand.Intn, rand.Float64),
-		r.Register("Perm", func(n int) []int {
+		r.MustAdd(rand.Int, rand.Intn, rand.Float64),
+		r.MustRegister("Perm", func(n int) []int {
 			if n > 10 { // Limiter for safety
 				n = 10
 			}
@@ -39,12 +39,12 @@ func New() *registry.R {
 	).Tags("rand").Extra("style", registry.M{"color": "#486"})
 
 	// Test functions
-	r.Add(testErrorPanic, testErrorDelayed, testRandomError).
+	r.MustAdd(testErrorPanic, testErrorDelayed, testRandomError).
 		Tags("testing-errors")
 
 	registry.Describer(
-		r.Register("wait", wait),
-		r.Register("waitRandom", waitRandom),
+		r.MustRegister("wait", wait),
+		r.MustRegister("waitRandom", waitRandom),
 	).Tags("testing-time").Extra("style", map[string]string{"color": "#8a5"})
 	return r
 }

go/src/flowserver/cmd/demo1/devops/devops.go

@@ -14,7 +14,7 @@ func New() *registry.R {
 
 	r := registry.New()
 
-	r.Add(
+	r.MustAdd(
 		dockerNew,
 		setWriter,
 		dockerTest,

go/src/flowserver/cmd/demo1/gonumops/gonumops.go

@@ -19,13 +19,13 @@ func New() *registry.R {
 
 	r := registry.New()
 
-	r.Add(
-		myVar,
-		normFloat,
-		tensorNew,
-		tensorMul,
-		tensorTranspose,
-		logistic,
+	registry.Describer(
+		r.MustAdd(tensorNew).Inputs("rows", "columns", "data"),
+		r.MustAdd(myVar,
+			normFloat,
+			tensorMul,
+			tensorTranspose,
+			logistic),
 	).Description("gonum functions").
 		Tags("gonum").
 		Extra("style", registry.M{"color": "#953"})
@@ -64,11 +64,13 @@ func tensorTranspose(a Tensor) Tensor {
 }
 
 func logistic(a Tensor) Tensor {
-	v := a.(mat.Vector)
-	ret := mat.NewVecDense(v.Len(), nil)
 	// Should be a vector perhaps
-	for i := 0; i < v.Len(); i++ {
-		ret.SetVec(i, activator(v.AtVec(i)))
+	r, c := a.Dims()
+	ret := mat.NewDense(r, c, nil)
+	for ; c >= 0; c-- {
+		for ; r >= 0; r-- {
+			ret.Set(r, c, activator(a.At(r, c)))
+		}
 	}
 	return ret
 }

go/src/flowserver/cmd/demo1/static/index.html

@@ -20,7 +20,7 @@
     <h3> Sample ideas using flow: </h3>
     <div class="app-selector-items">
 			[<a href="/default">Default thing</a>]
-			[<a href="/gonum">Gonum</a>]
+			[<a href="/gonumops">Gonum</a>]
 			[<a href="/devops">Devops sample</a>]
 			[<a href="/testops">testing registry</a>]
     </div>

go/src/flowserver/flowbuilder/builder.go

@@ -111,6 +111,7 @@ func (fb *FlowBuilder) Build(ID string) flow.Operation {
 		entry, err := r.Entry(node.Src)
 		if err != nil {
 			op, _ = f.DefErrOp(node.ID, err)
+			return nil
 		}
 		//// Process inputs ////
 		param := make([]flow.Data, len(entry.Inputs))
@@ -135,12 +136,13 @@ func (fb *FlowBuilder) Build(ID string) flow.Operation {
 			op, _ := f.DefErrOp(node.ID, err)
 			return op
 		}
+		fb.addTriggersTo(node)
 	}
 
 	return op
 }
 
-func (fb *FlowBuilder) addTriggersTo(node Node) error {
+func (fb *FlowBuilder) addTriggersTo(node *Node) error {
 	// Process triggers for this node
 	triggers := fb.doc.fetchTriggerFrom(node.ID)
 	for _, t := range triggers {

go/src/flowserver/flowserver.go

@@ -1,7 +1,6 @@
 package flowserver
 
 import (
-	"flow"
 	"flow/registry"
 	"log"
 	"net/http"
@@ -27,18 +26,6 @@ func New(r *registry.R, store string) *FlowServer {
 	if r == nil {
 		r = registry.Global.Clone()
 	}
-	// inject into registry
-	r.Register("Variable", func(f *flow.Flow, name string, initial flow.Data) flow.Data {
-		_, ok := f.Data[name]
-		if !ok {
-			f.Data[name] = initial
-		}
-		return f.Data[name]
-	}).Describer().
-		Inputs("name", "initial").
-		Tags("core").
-		Extra("style", registry.M{"color": "#88a"})
-
 	mux := http.NewServeMux()
 	mux.Handle("/conn", NewFlowSessionManager(r, store))
 

go/src/flowserver/session.go

@@ -197,12 +197,19 @@ func (s *FlowSession) NodeRun(c *websocket.Conn, data []byte) error {
 			return s
 		})
 		// Special func
-		localR.Register("Variable", func(f *flow.Flow, name string, initial flow.Data) flow.Data {
-			_, ok := f.Data[name]
+		localR.Register("Variable", func(name string, initial flow.Data) flow.Data {
+			_, ok := s.flow.Data[name]
 			if !ok {
-				f.Data[name] = initial
+				s.flow.Data[name] = initial
 			}
-			return f.Data[name]
+			return s.flow.Data[name]
+		})
+		localR.Register("Output", func(d interface{}) {
+
+			r := fmt.Sprint("Result:", d)
+			// Do something
+			s.Notify(r)
+			s.Write([]byte(r))
 		})
 		builder := flowbuilder.New(localR)
 		builder.Load(s.RawDoc).Build(ID)