FlowDev initial

.drone.yml

@@ -0,0 +1,73 @@
+workspace:
+  base: /app
+  path: .
+
+cache:
+    - ".git"
+    - "browser/vue-flow/node_modules"
+    - "go/deps"
+
+pipeline:
+
+  restore-cache:
+    image: drillster/drone-volume-cache
+    restore: true
+    mount:
+      - ./browser/vue-flow/node_modules
+      - ./go/deps
+    volumes:
+      - /tmp/cache:/cache
+
+  frontend:
+    image: node:6
+    commands:
+      - cd browser/vue-flow 
+      - yarn 
+      - yarn build
+
+  backend: 
+    image: golang
+    environment:
+      - GOPATH=/app/go/deps:/app/go
+    commands: 
+      - go get github.com/axw/gocov/gocov
+      - go get github.com/gohxs/folder2go
+      - go get -d ./go/src/...
+      - go get -d -t ./go/src/...
+      - go/deps/bin/gocov test -v -race ./go/src/... | go/deps/bin/gocov report
+      - go/deps/bin/folder2go -nobackup ./browser/vue-flow/dist webbin go/src/flow/cmd/demo/webbin/webbin.go
+      - CGO_ENABLED=0 go build -o DIST/demo1 demos/cmd/demo1  
+
+  rebuild-cache:
+    image: drillster/drone-volume-cache
+    rebuild: true
+    mount:
+      - ./browser/vue-flow/node_modules
+      - ./go/deps
+    volumes:
+      - /tmp/cache:/cache
+
+  deploy:
+    image: docker
+    when:
+      environment: staging
+      event: deployment
+    commands:
+      - echo $HOME
+      - mkdir -p DIST
+      - cp -r browser/vue-flow/dist DIST/web
+      - docker build --rm -t hexasoftware.com:5000/flow-proto -f ./docker/Dockerfile .
+      - docker push hexasoftware.com:5000/flow-proto
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+      - /home/stdio/.docker/config.json:/root/.docker/config.json
+  #check secrets
+  notify:
+    image: drillster/drone-email
+    from: drone@hexasoftware.com
+    skip_verify: true
+    secrets: [email_password, email_recipients, email_host, email_username]
+    when:
+      status: [ failure, success ]
+
+

.gitignore

@@ -0,0 +1,2 @@
+DIST
+/store

Makefile

@@ -0,0 +1,54 @@
+
+all: DIST/demo1 DIST/web
+
+clean:
+	rm -rf DIST
+
+DIST:
+	mkdir -p DIST
+
+DIST/demo1: DIST
+	cd go;make
+	cp go/DIST/* DIST/
+
+
+flow-ui/node_modules:
+	cd flow-ui; yarn
+
+DIST/web: DIST flow-ui/node_modules
+	mkdir -p DIST/web
+	cd flow-ui;yarn build
+	cp -r flow-ui/dist/* DIST/web
+
+DIST/.dockerized: DIST/demo1 DIST/web
+	docker build --rm -t hexasoftware.com:5000/flow-proto -f ./docker/Dockerfile .
+	touch DIST/.dockerized
+
+docker: DIST/.dockerized
+
+
+push: DIST/.dockerized
+	docker push hexasoftware.com:5000/flow-proto
+
+frontend: DIST/web
+
+backend: DIST/demo1
+
+dev: clean backend
+	tmux split "DEBUG=1 DIST/demo1;$$SHELL"
+	cd flow-ui; yarn dev
+
+builder:
+	git add -A .
+	git commit -m "Droning building $$(date)"
+	git push builder master
+
+test: 
+	make -C go test
+generate:
+	make -C go generate
+
+
+
+.PHONY: all clean frontend backend builder generate
+

flow-ui

@@ -0,0 +1 @@
+Subproject commit c8a59f2fce421e8862bd0eb184675f6ed56d8000

go/.gitignore

@@ -0,0 +1,5 @@
+deps
+pkg
+bin
+DIST
+

go/Makefile

@@ -0,0 +1,57 @@
+# Luis Figueiredo (luisf@hexasoftware.com)
+# 
+
+GOPATH=$(CURDIR)/deps:$(CURDIR)
+DIST=./DIST
+BUILDENV=
+GETENV=
+
+
+# Source in packages names
+# What packages to build
+
+# CLI Packages
+CLI=demos/cmd/demo1
+BIN=$(addprefix $(DIST)/, $(notdir $(CLI)))
+
+# Windows build
+ifeq ($(GOOS),windows)
+	ENV+=CC=i686-w64-mingw32-gcc CXX=i686-w64-mingw32-g++ CGO_ENABLED=1 GOOS=$(GOOS) GOARCH=$(GOARCH)
+	BIN:=$(addsuffix .exe, $(BIN))
+endif
+
+.PHONY: all deps clean dist-clean $(BIN)
+
+all: $(BIN) deps
+	@$(ENV) echo -e "\e[32;01mBuilt for OS: `go env GOOS`, ARCH: `go env GOARCH`\e[0m"
+	
+$(BIN): deps
+	$(BUILDENV) GOPATH="$(GOPATH)" go build -o $@ $(CLI)
+
+# generate
+generate:
+	GOPATH="$(GOPATH)" go generate -v ./src/...
+
+test:
+	$(ENV) gocov test -race ./src/... | gocov report
+
+#$(BIN): $(addprefix src/,$(SOURCE))
+#	echo $<
+
+deps:
+	$(GETENV) GOPATH="$(GOPATH)" go get -v ./src/... # everything from source
+	# test package 
+	$(GETENV) GOPATH="$(GOPATH)" go get -v -t ./src/...
+
+clean:
+	rm -rf $(DIST)
+
+dist-clean: clean
+	rm -rf bin
+	rm -rf pkg
+	rm -rf deps
+
+$(DIST):
+	mkdir -p $(DIST)
+
+

go/src/demos/cmd/demo1/assets/assets.go

@@ -0,0 +1,373 @@
+// Package assets -- Generated by folder2go (http://github.com/gohxs/folder2go)
+package assets
+import (
+	"mime"
+	"net/http"
+	"path/filepath"
+	"strings"
+)
+type fs map[string][]byte
+
+var (
+	// Data contains the binarized folder
+	Data = fs{ 
+		"index.html": []byte{ 
+			0x3C, 0x21, 0x44, 0x4F, 0x43, 0x54, 0x59, 0x50, 0x45, 0x20, 0x68, 0x74, 0x6D, 0x6C, 0x3E, 0x0A, 0x3C, 0x68, 0x74, 0x6D, 
+			0x6C, 0x3E, 0x0A, 0x09, 0x3C, 0x68, 0x65, 0x61, 0x64, 0x3E, 0x0A, 0x09, 0x09, 0x3C, 0x74, 0x69, 0x74, 0x6C, 0x65, 0x3E, 
+			0x66, 0x6C, 0x6F, 0x77, 0x3C, 0x2F, 0x74, 0x69, 0x74, 0x6C, 0x65, 0x3E, 0x0A, 0x09, 0x09, 0x3C, 0x73, 0x74, 0x79, 0x6C, 
+			0x65, 0x3E, 0x0A, 0x2E, 0x61, 0x70, 0x70, 0x2D, 0x73, 0x65, 0x6C, 0x65, 0x63, 0x74, 0x6F, 0x72, 0x20, 0x7B, 0x0A, 0x20, 
+			0x20, 0x64, 0x69, 0x73, 0x70, 0x6C, 0x61, 0x79, 0x3A, 0x66, 0x6C, 0x65, 0x78, 0x3B, 0x0A, 0x20, 0x20, 0x66, 0x6C, 0x65, 
+			0x78, 0x2D, 0x66, 0x6C, 0x6F, 0x77, 0x3A, 0x63, 0x6F, 0x6C, 0x75, 0x6D, 0x6E, 0x3B, 0x0A, 0x20, 0x20, 0x6A, 0x75, 0x73, 
+			0x74, 0x69, 0x66, 0x79, 0x2D, 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x6E, 0x74, 0x3A, 0x20, 0x63, 0x65, 0x6E, 0x74, 0x65, 0x72, 
+			0x3B, 0x0A, 0x20, 0x20, 0x61, 0x6C, 0x69, 0x67, 0x6E, 0x2D, 0x69, 0x74, 0x65, 0x6D, 0x73, 0x3A, 0x20, 0x63, 0x65, 0x6E, 
+			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, 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, 0x6D, 0x61, 0x63, 0x68, 0x69, 0x6E, 0x65, 0x6C, 0x65, 0x61, 0x72, 0x6E, 
+			0x69, 0x6E, 0x67, 0x22, 0x3E, 0x4D, 0x61, 0x63, 0x68, 0x69, 0x6E, 0x65, 0x20, 0x4C, 0x65, 0x61, 0x72, 0x6E, 0x69, 0x6E, 
+			0x67, 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, 			 
+		},
+	
+	}
+)
+
+
+// AssetHandleFunc Http handler
+func AssetHandleFunc(w http.ResponseWriter, r *http.Request) {
+	urlPath := ""
+
+	// func that handles mux
+	server := r.Context().Value(http.ServerContextKey).(*http.Server)
+	mux, ok := server.Handler.(*http.ServeMux)
+	if ok {
+		_, handlerPath := mux.Handler(r)
+		urlPath = strings.TrimPrefix(r.URL.String(), handlerPath)
+	}
+	if urlPath == "" { // Auto index
+		urlPath = "index.html"
+	}
+	data, ok := Data[urlPath]
+	if !ok {
+		w.WriteHeader(404)
+	}
+
+	w.Header().Set("Content-type", mime.TypeByExtension(filepath.Ext(urlPath)))
+	w.Write(data)
+}
+

go/src/demos/cmd/demo1/main.go

@@ -0,0 +1,86 @@
+package main
+
+import (
+	"demos/cmd/demo1/assets"
+	"demos/ops/decodeops"
+	"demos/ops/defaultops"
+	"demos/ops/devops"
+	"demos/ops/genericops"
+	"demos/ops/ml"
+	"demos/ops/stringops"
+	"demos/ops/webops"
+	"log"
+	"mime"
+	"net/http"
+	"path/filepath"
+	"strings"
+
+	"github.com/gohxs/prettylog"
+	"github.com/gohxs/webu"
+	"github.com/gohxs/webu/chain"
+	"github.com/hexasoftware/flow/flowserver"
+)
+
+//go:generate go get github.com/gohxs/folder2go
+//go:generate folder2go -handler -nobackup static assets assets
+
+func main() {
+	prettylog.Global()
+	log.Println("Running version:", flowserver.Version)
+
+	addr := ":2015"
+	log.Println("Starting server  at:", addr)
+
+	c := chain.New(webu.ChainLogger(prettylog.New("req")))
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/", assetFunc)
+
+	defops := defaultops.New()
+	defops.Merge(genericops.New())
+	defops.Merge(stringops.New())
+
+	mux.Handle("/default/", c.Build(
+		http.StripPrefix("/default", flowserver.New(defops, "default")),
+	))
+
+	mlReg := ml.New()
+	mlReg.Merge(genericops.New())
+	mlReg.Merge(stringops.New())
+	mlReg.Merge(webops.New())
+	mlReg.Merge(decodeops.New())
+
+	mux.Handle("/machinelearning/", c.Build(
+		http.StripPrefix("/machinelearning", flowserver.New(mlReg, "ml")),
+	))
+
+	mux.Handle("/devops/", c.Build(
+		http.StripPrefix("/devops", flowserver.New(devops.New(), "devops")),
+	))
+
+	// Context registry
+	http.ListenAndServe(addr, mux)
+}
+
+func assetFunc(w http.ResponseWriter, r *http.Request) {
+	urlPath := ""
+
+	// func that handles mux
+	server := r.Context().Value(http.ServerContextKey).(*http.Server)
+	mux, ok := server.Handler.(*http.ServeMux)
+	if ok {
+		_, handlerPath := mux.Handler(r)
+		urlPath = strings.TrimPrefix(r.URL.String(), handlerPath)
+	}
+	if urlPath == "" { // Auto index
+		urlPath = "index.html"
+	}
+	data, ok := assets.Data[urlPath]
+	if !ok {
+		http.Redirect(w, r, "/default", 302)
+		//w.WriteHeader(404)
+	}
+
+	w.Header().Set("Content-type", mime.TypeByExtension(filepath.Ext(urlPath)))
+	w.Write(data)
+}

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

@@ -0,0 +1,30 @@
+<!DOCTYPE html>
+<html>
+	<head>
+		<title>flow</title>
+		<style>
+.app-selector {
+  display:flex;
+  flex-flow:column;
+  justify-content: center;
+  align-items: center;
+  height:100%;
+}
+.app-selector >* { padding:10px; }
+.app-selector-items:first-child { border-right: #000; }
+		</style>
+	</head>
+	<body>
+		<div class="app-selector">
+		<img src="sample.png">
+    <h3> Sample ideas using flow: </h3>
+    <div class="app-selector-items">
+			[<a href="/default">Default thing</a>]
+			[<a href="/machinelearning">Machine Learning</a>]
+			[<a href="/devops">Devops sample</a>]
+			[<a href="/testops">testing registry</a>]
+    </div>
+	</div>
+	</body
+</html>
+

go/src/demos/cmd/simple/main.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"log"
+	"net/http"
+	"strings"
+
+	"github.com/hexasoftware/flow"
+	"github.com/hexasoftware/flow/flowserver"
+	"github.com/hexasoftware/flow/registry"
+)
+
+func main() {
+
+	r := registry.New()
+	r.Add("hello", func() string {
+		return "hello world"
+	})
+
+	// Describing functions:
+
+	// utility to apply functions to several entries
+	registry.Describer(
+		r.Add(strings.Split).Inputs("str", "sep").Output("slice"),
+		r.Add(strings.Join).Inputs("slice", "sep").Output("string"),
+	).Tags("strings").
+		Extra("style", registry.M{"color": "#a77"})
+
+	f := flow.New()
+	f.UseRegistry(r)
+
+	op := f.Op("Join",
+		f.Op("Split", "hello world", " "),
+		",",
+	)
+	res, err := op.Process()
+	if err != nil {
+		log.Fatal(err)
+	}
+	log.Println("res:", res)
+
+	http.ListenAndServe(":5000", flowserver.New(r, "storename"))
+
+}

go/src/demos/cmd/xor/main.go

@@ -0,0 +1,145 @@
+package main
+
+import (
+	"demos/ops/ml"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"runtime/pprof"
+
+	"github.com/hexasoftware/flow"
+	"gonum.org/v1/gonum/mat"
+)
+
+var cpuprofile = flag.String("cpuprofile", "", "write cpu profile to file")
+var memprofile = flag.String("memprofile", "", "write mem profile to file")
+
+func main() {
+	flag.Parse()
+
+	if *cpuprofile != "" {
+		f, err := os.Create(*cpuprofile)
+		if err != nil {
+			log.Fatal(err)
+		}
+		pprof.StartCPUProfile(f)
+		defer pprof.StopCPUProfile()
+	}
+	if *memprofile != "" {
+		f, err := os.Create(*memprofile)
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer pprof.WriteHeapProfile(f)
+	}
+	// Registry for machine learning
+	r := ml.New()
+
+	f := flow.New()
+	f.UseRegistry(r)
+
+	samples := []float64{
+		0, 0,
+		0, 1,
+		1, 0,
+		1, 1,
+	}
+	labels := []float64{
+		0,
+		1,
+		1,
+		0,
+	}
+	learningRate := float64(0.3)
+
+	nInputs := 2
+	nHidden := 5
+	nOutput := 1
+	nSamples := 4
+
+	matSamples := mat.NewDense(nSamples, 2, samples)
+	matLabels := mat.NewDense(nSamples, 1, labels)
+
+	// Define input
+	// Make a matrix out of the input and output
+	x := f.In(0)
+	y := f.In(1)
+
+	// [ 1, 2, 3, 4, 5]
+	// [ 1, 2, 3, 4, 5]
+	wHidden := f.Var("wHidden", f.Op("matNewRand", nInputs, nHidden))
+
+	// [ 1 ]
+	// [ 2 ]
+	// [ 3 ]
+	// [ 4 ]
+	// [ 5 ]
+	wOut := f.Var("wOut", f.Op("matNewRand", nHidden, nOutput))
+
+	// Forward process
+	hiddenLayerInput := f.Op("matMul", x, wHidden)
+	hiddenLayerActivations := f.Op("matSigmoid", hiddenLayerInput)
+	outputLayerInput := f.Op("matMul", hiddenLayerActivations, wOut)
+	// Activations
+	output := f.Op("matSigmoid", outputLayerInput)
+
+	// Back propagation
+	// output weights
+	networkError := f.Op("matSub", y, output)
+	slopeOutputLayer := f.Op("matSigmoidPrime", output)
+	dOutput := f.Op("matMulElem", networkError, slopeOutputLayer)
+	wOutAdj := f.Op("matScale",
+		learningRate,
+		f.Op("matMul", f.Op("matTranspose", hiddenLayerActivations), dOutput),
+	)
+
+	// hidden weights
+	errorAtHiddenLayer := f.Op("matMul", dOutput, f.Op("matTranspose", wOut))
+	slopeHiddenLayer := f.Op("matSigmoidPrime", hiddenLayerActivations)
+	dHiddenLayer := f.Op("matMulElem", errorAtHiddenLayer, slopeHiddenLayer)
+	wHiddenAdj := f.Op("matScale",
+		learningRate,
+		f.Op("matMul", f.Op("matTranspose", x), dHiddenLayer),
+	)
+
+	// Adjust the parameters
+	setwOut := f.SetVar("wOut", f.Op("matAdd", wOut, wOutAdj))
+	setwHidden := f.SetVar("wHidden", f.Op("matAdd", wHidden, wHiddenAdj))
+
+	// Training
+	for i := 0; i < 5000; i++ {
+		sess := f.NewSession()
+		sess.Inputs(matSamples, matLabels)
+		_, err := sess.Run(setwOut, setwHidden)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+
+	// Same as above because its simple
+	testSamples := matSamples
+	testLabels := matLabels
+
+	res, err := output.Process(testSamples)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	predictions := res.(mat.Matrix)
+	log.Println("Predictions", predictions)
+
+	var rights int
+	numPreds, _ := predictions.Dims()
+	log.Println("Number of predictions:", numPreds)
+	for i := 0; i < numPreds; i++ {
+		if predictions.At(i, 0) > 0.5 && testLabels.At(i, 0) == 1.0 ||
+			predictions.At(i, 0) < 0.5 && testLabels.At(i, 0) == 0 {
+			rights++
+		}
+	}
+
+	accuracy := float64(rights) / float64(numPreds)
+	fmt.Printf("\nAccuracy = %0.2f\n\n", accuracy)
+
+}

go/src/demos/ops/decodeops/decodeops.go

@@ -0,0 +1,45 @@
+package decodeops
+
+import (
+	"bytes"
+	"image"
+	// Image decoders
+	_ "image/gif"
+	_ "image/jpeg"
+	_ "image/png"
+
+	"github.com/hexasoftware/flow/registry"
+)
+
+//New decoding ops
+func New() *registry.R {
+	r := registry.New()
+	r.Add(DecodeImage).Tags("experiment-decode")
+	return r
+}
+
+// DecodeImage from a byte array
+func DecodeImage(in []byte) (image.Image, error) {
+	br := bytes.NewReader(in)
+	im, _, err := image.Decode(br)
+	return im, err
+}
+
+/*func decodePNG(in []byte) (image.Image, error) {
+	br := bytes.NewReader(in)
+	im, err := png.Decode(br)
+	if err != nil {
+		return nil, err
+	}
+	return im, nil
+}
+
+func decodeJPG(in []byte) (image.Image, error) {
+	br := bytes.NewReader(in)
+	im, err := jpeg.Decode(br)
+	if err != nil {
+		return nil, err
+	}
+
+	return im, nil
+}*/

go/src/demos/ops/defaultops/defaultops.go

@@ -0,0 +1,30 @@
+package defaultops
+
+import (
+	"math"
+	"math/rand"
+
+	"github.com/hexasoftware/flow/registry"
+)
+
+// New create a registry
+func New() *registry.R {
+	r := registry.New()
+	// String functions
+	// Math functions
+	r.Add(
+		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.Add("Perm", func(n int) []int {
+			if n > 10 { // Limiter for safety
+				n = 10
+			}
+			return rand.Perm(n)
+		}),
+	).Tags("rand").Extra("style", registry.M{"color": "#486"})
+
+	return r
+}

go/src/demos/ops/devops/devops.go

@@ -0,0 +1,143 @@
+package devops
+
+import (
+	"bufio"
+	"io"
+	"math/rand"
+	"strings"
+	"time"
+
+	"github.com/hexasoftware/flow/registry"
+)
+
+// New create a new devops Registry
+func New() *registry.R {
+
+	r := registry.New()
+
+	r.Add(
+		dockerNew,
+		setWriter,
+		dockerTest,
+	).Tags("build")
+
+	return r
+}
+
+//////////////////////
+// DevOps SIM
+////////
+
+// DockerHandler example
+type DockerHandler struct {
+	out io.Writer
+}
+
+func dockerNew() DockerHandler {
+	return DockerHandler{}
+}
+
+func setWriter(out io.Writer, o DockerHandler) DockerHandler {
+	o.out = out
+	return o
+}
+
+//
+func dockerTest(handler DockerHandler, imageName string) DockerHandler {
+	sampleData := `
+	make: Entering directory '/home/stdio/coding/Projects/Flow'
+make -C go test
+make[1]: Entering directory '/home/stdio/coding/Projects/Flow/go'
+gocov test -race ./src/... | gocov report
+ok  	flow	1.020s	coverage: 84.1% of statements
+?   	flow/cmd/buildops	[no test files]
+?   	flow/cmd/demo1	[no test files]
+?   	flow/flowserver	[no test files]
+?   	flow/flowserver/flowmsg	[no test files]
+?   	flow/internal/assert	[no test files]
+ok  	flow/registry	1.011s	coverage: 100.0% of statements
+
+flow/flow.go		 Flow.String			 100.00% (11/11)
+flow/utils.go		 RandString			 100.00% (10/10)
+flow/flow.go		 @290:21			 100.00% (8/8)
+flow/flow.go		 Flow.MarshalJSON		 100.00% (8/8)
+flow/flow.go		 Flow.Const			 100.00% (7/7)
+flow/flow.go		 Flow.Var			 100.00% (6/6)
+flow/flow.go		 @315:21			 100.00% (6/6)
+flow/hook.go		 Hooks.Attach			 100.00% (3/3)
+flow/flow.go		 Flow.Run			 100.00% (2/2)
+flow/flow.go		 Flow.SetRegistry		 100.00% (2/2)
+flow/operation.go	 @107:12			 100.00% (2/2)
+flow/operation.go	 operation.ID			 100.00% (1/1)
+flow/operation.go	 opFunc				 100.00% (1/1)
+flow/operation.go	 opVar				 100.00% (1/1)
+flow/operation.go	 opConst			 100.00% (1/1)
+flow/flow.go		 Flow.In			 100.00% (1/1)
+flow/operation.go	 @220:12			 100.00% (1/1)
+flow/flow.go		 Flow.Res			 100.00% (1/1)
+flow/operation.go	 @221:12			 100.00% (1/1)
+flow/operation.go	 opIn				 100.00% (1/1)
+flow/flow.go		 Flow.Hook			 100.00% (1/1)
+flow/operation.go	 operation.Set			 100.00% (1/1)
+flow/hook.go		 Hooks.wait			 100.00% (1/1)
+flow/flow.go		 Flow.SetIDGen			 100.00% (1/1)
+flow/hook.go		 Hooks.finish			 100.00% (1/1)
+flow/operation.go	 operation.processWithCtx	 100.00% (1/1)
+flow/flow.go		 @49:13				 100.00% (1/1)
+flow/operation.go	 newOpCtx			 100.00% (1/1)
+flow/operation.go	 operation.Process		 100.00% (1/1)
+flow/hook.go		 Hooks.start			 100.00% (1/1)
+flow/flow.go		 New				 100.00% (1/1)
+flow/flow.go		 Flow.DefOp			 92.31% (12/13)
+flow/flow.go		 Flow.Op			 88.89% (16/18)
+flow/flow.go		 @240:21			 84.21% (16/19)
+flow/flow.go		 Flow.run			 84.21% (16/19)
+flow/operation.go	 @166:8				 80.00% (4/5)
+flow/hook.go		 Hooks.Trigger			 78.57% (11/14)
+flow/flow.go		 Flow.Analyse			 75.00% (3/4)
+flow/flow.go		 Flow.getOp			 75.00% (3/4)
+flow/flow.go		 Flow.Must			 66.67% (2/3)
+flow/operation.go	 @93:12				 66.67% (2/3)
+flow/operation.go	 @121:12			 65.22% (30/46)
+flow/operation.go	 @123:10			 33.33% (1/3)
+flow/hook.go		 Hooks.error			 0.00% (0/1)
+flow/operation.go	 opNil				 0.00% (0/1)
+flow/operation.go	 @229:12			 0.00% (0/1)
+flow/operation.go	 dumbSet			 0.00% (0/0)
+flow			 ------------------------	 84.10% (201/239)
+
+flow/registry/entry.go		 NewEntry		 100.00% (18/18)
+flow/registry/registry.go	 R.Get			 100.00% (12/12)
+flow/registry/registry.go	 R.Add			 100.00% (8/8)
+flow/registry/entry.go		 Entry.DescInputs	 100.00% (8/8)
+flow/registry/batch.go		 Batch			 100.00% (6/6)
+flow/registry/registry.go	 R.Register		 100.00% (5/5)
+flow/registry/entry.go		 Entry.Extra		 100.00% (4/4)
+flow/registry/registry.go	 R.Entry		 100.00% (4/4)
+flow/registry/registry.go	 R.Clone		 100.00% (4/4)
+flow/registry/entry.go		 Entry.Tags		 100.00% (4/4)
+flow/registry/entry.go		 Entry.DescOutput	 100.00% (4/4)
+flow/registry/registry.go	 R.Descriptions		 100.00% (4/4)
+flow/registry/batch.go		 EntryBatch.Extra	 100.00% (3/3)
+flow/registry/batch.go		 EntryBatch.DescOutput	 100.00% (3/3)
+flow/registry/batch.go		 EntryBatch.DescInputs	 100.00% (3/3)
+flow/registry/batch.go		 EntryBatch.Tags	 100.00% (3/3)
+flow/registry/entry.go		 Entry.Err		 100.00% (1/1)
+flow/registry/registry.go	 New			 100.00% (1/1)
+flow/registry			 ---------------------	 100.00% (95/95)
+
+Total Coverage: 88.62% (296/334)
+make[1]: Leaving directory '/home/stdio/coding/Projects/Flow/go'
+make: Leaving directory '/home/stdio/coding/Projects/Flow'`
+
+	scanner := bufio.NewScanner(strings.NewReader(sampleData))
+
+	for scanner.Scan() {
+		time.Sleep(time.Duration(rand.Intn(3000)) * time.Millisecond)
+		if handler.out != nil {
+			handler.out.Write([]byte(scanner.Text()))
+		}
+	}
+
+	return handler
+}

go/src/demos/ops/genericops/registry.go

@@ -0,0 +1,60 @@
+package genericops
+
+import (
+	"errors"
+	"fmt"
+	"math/rand"
+	"strings"
+	"time"
+
+	"github.com/hexasoftware/flow"
+	"github.com/hexasoftware/flow/registry"
+)
+
+// New create new registry with generic operations
+func New() *registry.R {
+
+	r := registry.New()
+	// Test functions
+	r.Add(testErrorPanic, testErrorDelayed, testRandomError).
+		Tags("testing")
+
+	registry.Describer(
+		r.Add("wait", wait),
+		r.Add("waitRandom", waitRandom),
+	).Tags("testing").Extra("style", map[string]string{"color": "#8a5"})
+
+	r.Add(strings.Split, strings.Join).Tags("strings")
+
+	return r
+}
+func wait(data flow.Data, n int) flow.Data {
+	time.Sleep(time.Duration(n) * time.Second) // Simulate
+	return data
+}
+func waitRandom(data flow.Data) flow.Data {
+	time.Sleep(time.Duration(rand.Intn(10)) * time.Second)
+	return data
+}
+
+////////////////////////
+// testOps
+////////////////
+func testErrorPanic(n int) flow.Data {
+	dur := time.Duration(n)
+	time.Sleep(dur * time.Second)
+	panic("I panicked")
+}
+
+func testErrorDelayed(n int) (flow.Data, error) {
+	dur := time.Duration(n)
+	time.Sleep(dur * time.Second)
+	return nil, fmt.Errorf("I got an error %v", dur)
+}
+func testRandomError(d flow.Data) (flow.Data, error) {
+	r := rand.Intn(10)
+	if r > 5 {
+		return nil, errors.New("I failed on purpose")
+	}
+	return d, nil
+}

go/src/demos/ops/ml/activators.go

@@ -0,0 +1,10 @@
+package ml
+
+import "math"
+
+func sigmoid(v float64) float64 {
+	return 1 / (1 + math.Exp(-v))
+}
+func sigmoidPrime(v float64) float64 {
+	return v * (1 - v)
+}

go/src/demos/ops/ml/experiments.go

@@ -0,0 +1,158 @@
+package ml
+
+import (
+	"bytes"
+	"encoding/base64"
+	"errors"
+	"image"
+	"image/png"
+	"log"
+	"math"
+
+	"github.com/hexasoftware/flow/flowserver"
+	"gonum.org/v1/gonum/mat"
+)
+
+// imageToMat create a grayscaled matrix of the image
+func imageToGrayMatrix(im image.Image) (mat.Matrix, error) {
+	dims := im.Bounds().Size()
+	fdata := make([]float64, dims.X*dims.Y)
+
+	for y := 0; y < dims.Y; y++ {
+		for x := 0; x < dims.X; x++ {
+			oldPixel := im.At(x, y)
+			r, g, b, _ := oldPixel.RGBA()
+			lum := (19595*r + 38470*g + 7471*b + 1<<15) >> 24
+			fdata[x+y*dims.X] = float64(lum) / 256
+		}
+	}
+	m := mat.NewDense(dims.Y, dims.X, fdata)
+	return m, nil
+}
+
+func displayImg(img image.Image) (flowserver.Base64Data, error) {
+	pngEncoded := bytes.NewBuffer(nil)
+	err := png.Encode(pngEncoded, img)
+	if err != nil {
+		return flowserver.Base64Data([]byte{}), err
+	}
+	base64enc := base64.StdEncoding.EncodeToString(pngEncoded.Bytes())
+	out := bytes.NewBuffer(nil)
+	out.WriteString("data:image/png;base64,")
+	out.WriteString(base64enc)
+
+	return flowserver.Base64Data(out.String()), nil
+
+}
+func displayGrayMat(m mat.Matrix) (flowserver.Base64Data, error) {
+	r, c := m.Dims()
+
+	img := image.NewGray(image.Rect(0, 0, c, r))
+	for y := 0; y < r; y++ {
+		for x := 0; x < c; x++ {
+			img.Pix[x+y*c] = byte(m.At(y, x) * 255)
+		}
+	}
+	pngEncoded := bytes.NewBuffer(nil)
+
+	err := png.Encode(pngEncoded, img)
+	if err != nil {
+		return flowserver.Base64Data([]byte{}), err
+	}
+	base64enc := base64.StdEncoding.EncodeToString(pngEncoded.Bytes())
+	out := bytes.NewBuffer(nil)
+	out.WriteString("data:image/png;base64,")
+	out.WriteString(base64enc)
+
+	return flowserver.Base64Data(out.String()), nil
+
+}
+
+// Test
+func toGrayImage(data []byte, w, h int) (flowserver.Base64Data, error) {
+	// Convert matrix to byte 0-255
+
+	/*bdata := make([]byte, w*h)
+	for i, v := range data {
+		bdata[i] = byte(v * 255)
+	}*/
+
+	img := image.NewGray(image.Rect(0, 0, w, h))
+	for i, v := range data {
+		img.Pix[i] = v
+	}
+	pngEncoded := bytes.NewBuffer(nil)
+
+	err := png.Encode(pngEncoded, img)
+	if err != nil {
+		return flowserver.Base64Data([]byte{}), err
+	}
+
+	base64enc := base64.StdEncoding.EncodeToString(pngEncoded.Bytes())
+
+	out := bytes.NewBuffer(nil)
+	out.WriteString("data:image/png;base64,")
+	out.WriteString(base64enc)
+
+	return flowserver.Base64Data(out.String()), nil
+
+	/*for y:=0;y<h;y++ {
+		for x:=0;x<w;x++ {
+			bdata[x + y *w] = data[
+		}
+	}*/
+}
+
+// Convolution matrix
+func matConv(a mat.Matrix, conv mat.Matrix) (mat.Matrix, error) {
+	convR, convC := conv.Dims()
+
+	if convR&1 == 0 || convC&1 == 0 {
+		return nil, errors.New("kernel matrix should have odd columns and odd rows")
+	}
+	midR := int(math.Floor(float64(convR) / 2))
+	midC := int(math.Floor(float64(convC) / 2))
+	log.Println("Middle:", midR, midC)
+
+	norm := float64(0)
+	for cy := 0; cy < convR; cy++ {
+		for cx := 0; cx < convC; cx++ {
+			norm += conv.At(cy, cx)
+		}
+	}
+	if norm == 0 {
+		norm = 1.0
+	}
+
+	rows, cols := a.Dims()
+	ret := mat.NewDense(rows, cols, nil)
+	for y := 0; y < rows; y++ { // Matrix loop
+		for x := 0; x < cols; x++ {
+			acc := float64(0) //accumulator
+			for cy := 0; cy < convR; cy++ {
+				matY := y + cy - midR
+				if matY < 0 || matY >= rows {
+					continue
+				}
+				for cx := 0; cx < convC; cx++ {
+					matX := x + (cx - midC)
+					if matX < 0 || matX >= cols {
+						continue
+					}
+					acc += a.At(matY, matX) * (conv.At(cy, cx) / norm)
+				}
+			}
+			//acc /= 9
+			if acc > 1.0 {
+				acc = 1
+			}
+			if acc < 0.0 {
+				acc = 0.0
+			}
+
+			ret.Set(y, x, acc)
+		}
+	}
+	return ret, nil
+
+}

go/src/demos/ops/ml/gonumops.go

@@ -0,0 +1,126 @@
+// Package ml machine learning operations for flow
+package ml
+
+import (
+	"math/rand"
+
+	"github.com/hexasoftware/flow"
+	"github.com/hexasoftware/flow/registry"
+	"gonum.org/v1/gonum/mat"
+)
+
+// Matrix wrapper
+type Matrix = mat.Matrix
+
+// New registry
+func New() *registry.R {
+
+	r := registry.New()
+
+	registry.Describer(
+		r.Add(matNew).Inputs("rows", "columns", "data"),
+		r.Add(
+			normFloat,
+			matNewRand,
+			matAdd,
+			matSub,
+			matMul,
+			matMulElem,
+			matScale,
+			matTranspose,
+			matSigmoid,
+			matSigmoidPrime,
+			toFloatArr,
+		),
+		r.Add("train", func(a, b, c, d flow.Data) []flow.Data {
+			return []flow.Data{a, b, c, d}
+		}).Inputs("dummy", "dummy", "dummy", "dummy"),
+	).Description("gonum functions").
+		Tags("gonum").
+		Extra("style", registry.M{"color": "#953"})
+
+	registry.Describer(
+		r.Add(imageToGrayMatrix),
+		r.Add(displayImg),
+		r.Add(toGrayImage),
+		r.Add(matConv).Inputs("matrix", "conv"),
+		r.Add(displayGrayMat),
+	).Tags("experiment")
+
+	return r
+}
+
+func normFloat(n int) []float64 {
+	data := make([]float64, n)
+	for i := range data {
+		data[i] = rand.NormFloat64()
+	}
+	return data
+}
+
+func matNew(r, c int, data []float64) Matrix {
+	return mat.NewDense(r, c, data)
+}
+func matNewRand(r, c int) Matrix {
+	data := normFloat(r * c)
+
+	return mat.NewDense(r, c, data)
+
+}
+
+func matAdd(a Matrix, b Matrix) Matrix {
+	var r mat.Dense
+	r.Add(a, b)
+	return &r
+}
+func matSub(a, b Matrix) Matrix {
+	var r mat.Dense
+	r.Sub(a, b)
+	return &r
+}
+
+func matMul(a Matrix, b Matrix) Matrix {
+	var r mat.Dense
+	r.Mul(a, b)
+	return &r
+}
+func matMulElem(a, b Matrix) Matrix {
+	var r mat.Dense
+	r.MulElem(a, b)
+	return &r
+}
+
+// Scalar per element multiplication
+func matScale(f float64, a Matrix) Matrix {
+	var r mat.Dense
+	r.Scale(f, a)
+	return &r
+}
+
+func matTranspose(a Matrix) Matrix {
+	return a.T()
+}
+
+// sigmoid Activator
+func matSigmoid(a Matrix) Matrix {
+	ret := &mat.Dense{}
+	ret.Apply(func(_, _ int, v float64) float64 { return sigmoid(v) }, a)
+	return ret
+}
+
+func matSigmoidPrime(a Matrix) Matrix {
+	ret := &mat.Dense{}
+	ret.Apply(func(_, _ int, v float64) float64 { return sigmoidPrime(v) }, a)
+	return ret
+}
+
+func toFloatArr(a Matrix) []float64 {
+	r, c := a.Dims()
+	ret := make([]float64, r*c)
+	for i := 0; i < c; i++ {
+		for j := 0; j < r; j++ {
+			ret[i*r+j] = a.At(j, i)
+		}
+	}
+	return ret
+}

go/src/demos/ops/stringops/stringops.go

@@ -0,0 +1,22 @@
+package stringops
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/hexasoftware/flow/registry"
+)
+
+// New create string operations
+func New() *registry.R {
+	r := registry.New()
+	registry.Describer(
+		r.Add(strings.Split).Inputs("string", "separator"),
+		r.Add(strings.Join).Inputs("", "sep"),
+		r.Add(strings.Compare, strings.Contains),
+		r.Add("Cat", func(a, b string) string { return a + " " + b }),
+		r.Add("ToString", func(a interface{}) string { return fmt.Sprint(a) }),
+	).Tags("string").Extra("style", registry.M{"color": "#839"})
+
+	return r
+}

go/src/demos/ops/webops/webops.go

@@ -0,0 +1,34 @@
+package webops
+
+import (
+	"io/ioutil"
+	"net/http"
+
+	"github.com/hexasoftware/flow/registry"
+)
+
+// New creates web operations for flow
+func New() *registry.R {
+	r := registry.New()
+
+	r.Add(httpGet).Tags("http").
+		Extra("style", registry.M{"color": "#828"})
+
+	return r
+}
+
+func httpGet(url string) ([]byte, error) {
+
+	res, err := http.Get(url)
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+
+	out, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	return out, nil
+}

go/src/github.com/hexasoftware/flow

@@ -0,0 +1 @@
+Subproject commit e6f22577b4e70841c3d6f1b61597afdd293408cf