diff --git a/cli_client/cmd_hid.go b/cli_client/cmd_hid.go
index 21a144d..4b5c11d 100644
--- a/cli_client/cmd_hid.go
+++ b/cli_client/cmd_hid.go
@@ -3,6 +3,7 @@ package cli_client
 import (
 	"github.com/spf13/cobra"
 	"fmt"
+	"path/filepath"
 	"strings"
 	"io"
 	"bufio"
@@ -10,6 +11,7 @@ import (
 	"errors"
 	"log"
 	"strconv"
+	pb "github.com/mame82/P4wnP1_go/proto"
 )
 
 var (
@@ -161,6 +163,7 @@ func parseHIDRunScripCmd(cmd *cobra.Command, args []string) (serverScriptPath st
 
 	if transferNeeded {
 		// create random remote file
+
 		serverScriptPath, err = ClientCreateTempFile(StrRemoteHost,StrRemotePort,"","HIDscript")
 		if err != nil {
 			return "",err
@@ -168,8 +171,10 @@ func parseHIDRunScripCmd(cmd *cobra.Command, args []string) (serverScriptPath st
 			fmt.Printf("TempFile created: %s\n", serverScriptPath)
 		}
 
+		filename := filepath.Base(serverScriptPath)
+
 		//transfer from reader to remote file
-		err = ClientUploadFile(StrRemoteHost, StrRemotePort, srcReader, serverScriptPath, true)
+		err = ClientUploadFile(StrRemoteHost, StrRemotePort, srcReader, pb.AccessibleFolder_TMP, filename, true)
 		if err != nil { return "",errors.New(fmt.Sprintf("Error transfering HIDScript content to P4wnP1 Server: %v", err))}
 	}
 
diff --git a/cli_client/rpc_client.go b/cli_client/rpc_client.go
index ec3c172..b242d27 100644
--- a/cli_client/rpc_client.go
+++ b/cli_client/rpc_client.go
@@ -1,15 +1,14 @@
 package cli_client
 
 import (
-	"log"
 	"google.golang.org/grpc"
+	"log"
 
-	pb "github.com/mame82/P4wnP1_go/proto"
-	"time"
-	"golang.org/x/net/context"
-	"os"
 	"fmt"
+	pb "github.com/mame82/P4wnP1_go/proto"
+	"golang.org/x/net/context"
 	"io"
+	"time"
 )
 
 
@@ -65,6 +64,7 @@ func clientCreateTempDirOfFile(host string, port string, dir string, prefix stri
 	return
 }
 
+/*
 func ClientUploadFileFromSrcPath(host string, port string, srcPath string, destPath string, forceOverwrite bool) (err error) {
 	//open local file for reading
 	flag := os.O_RDONLY
@@ -74,6 +74,7 @@ func ClientUploadFileFromSrcPath(host string, port string, srcPath string, destP
 
 	return  ClientUploadFile(host,port,f,destPath,forceOverwrite)
 }
+*/
 
 func ClientRegisterEvent(host string, port string,  evtType int64) (err error) {
 	// open gRPC Client
@@ -95,7 +96,7 @@ func ClientRegisterEvent(host string, port string,  evtType int64) (err error) {
 	return nil
 }
 
-func ClientUploadFile(host string, port string, src io.Reader, destPath string, forceOverwrite bool) (err error) {
+func ClientUploadFile(host string, port string, src io.Reader, folder pb.AccessibleFolder, filename string, forceOverwrite bool) (err error) {
 
 	// open gRPC Client
 	address := host + ":" + port
@@ -108,14 +109,15 @@ func ClientUploadFile(host string, port string, src io.Reader, destPath string,
 	_, err = client.FSWriteFile(
 		context.Background(),
 		&pb.WriteFileRequest{
-			Path: destPath,
+			Folder:folder,
+			Filename: filename,
 			Data: []byte{}, //empty chunk
 			Append: false,
 			MustNotExist: !forceOverwrite,
 		})
 	if err != nil {return}
 
-	fmt.Printf("Start appending to %s\n", destPath)
+	fmt.Printf("Start appending to %s in folder\n", filename, pb.AccessibleFolder_name[int32(folder)])
 
 	// start appending chunks read from source file to remote file (Remote file is closed and opened every time, but
 	// this avoids client to server streaming, which would be hard to implement for gRPC-web
@@ -132,7 +134,8 @@ func ClientUploadFile(host string, port string, src io.Reader, destPath string,
 		client.FSWriteFile(
 			context.Background(),
 			&pb.WriteFileRequest{
-				Path: destPath,
+				Folder:folder,
+				Filename: filename,
 				Data: sendData,
 				Append: true,
 				MustNotExist: false,
diff --git a/proto/gopherjs/grpc.pb.gopherjs.go b/proto/gopherjs/grpc.pb.gopherjs.go
index 6a6f869..34b2b9c 100644
--- a/proto/gopherjs/grpc.pb.gopherjs.go
+++ b/proto/gopherjs/grpc.pb.gopherjs.go
@@ -285,6 +285,29 @@ func (x WiFiAuthMode) String() string {
 	return WiFiAuthMode_name[int(x)]
 }
 
+type AccessibleFolder int
+
+const (
+	AccessibleFolder_TMP          AccessibleFolder = 0
+	AccessibleFolder_BASH_SCRIPTS AccessibleFolder = 1
+	AccessibleFolder_HID_SCRIPTS  AccessibleFolder = 2
+)
+
+var AccessibleFolder_name = map[int]string{
+	0: "TMP",
+	1: "BASH_SCRIPTS",
+	2: "HID_SCRIPTS",
+}
+var AccessibleFolder_value = map[string]int{
+	"TMP":          0,
+	"BASH_SCRIPTS": 1,
+	"HID_SCRIPTS":  2,
+}
+
+func (x AccessibleFolder) String() string {
+	return AccessibleFolder_name[int(x)]
+}
+
 type ActionDeploySettingsTemplate_TemplateType int
 
 const (
@@ -3066,17 +3089,26 @@ func (m *TempDirOrFileResponse) Unmarshal(rawBytes []byte) (*TempDirOrFileRespon
 }
 
 type ReadFileRequest struct {
-	Path  string
-	Start int64
-	Data  []byte
+	Folder   AccessibleFolder
+	Filename string
+	Start    int64
+	Len      int64
 }
 
-// GetPath gets the Path of the ReadFileRequest.
-func (m *ReadFileRequest) GetPath() (x string) {
+// GetFolder gets the Folder of the ReadFileRequest.
+func (m *ReadFileRequest) GetFolder() (x AccessibleFolder) {
 	if m == nil {
 		return x
 	}
-	return m.Path
+	return m.Folder
+}
+
+// GetFilename gets the Filename of the ReadFileRequest.
+func (m *ReadFileRequest) GetFilename() (x string) {
+	if m == nil {
+		return x
+	}
+	return m.Filename
 }
 
 // GetStart gets the Start of the ReadFileRequest.
@@ -3087,12 +3119,12 @@ func (m *ReadFileRequest) GetStart() (x int64) {
 	return m.Start
 }
 
-// GetData gets the Data of the ReadFileRequest.
-func (m *ReadFileRequest) GetData() (x []byte) {
+// GetLen gets the Len of the ReadFileRequest.
+func (m *ReadFileRequest) GetLen() (x int64) {
 	if m == nil {
 		return x
 	}
-	return m.Data
+	return m.Len
 }
 
 // MarshalToWriter marshals ReadFileRequest to the provided writer.
@@ -3101,16 +3133,20 @@ func (m *ReadFileRequest) MarshalToWriter(writer jspb.Writer) {
 		return
 	}
 
-	if len(m.Path) > 0 {
-		writer.WriteString(1, m.Path)
+	if int(m.Folder) != 0 {
+		writer.WriteEnum(1, int(m.Folder))
+	}
+
+	if len(m.Filename) > 0 {
+		writer.WriteString(2, m.Filename)
 	}
 
 	if m.Start != 0 {
-		writer.WriteInt64(2, m.Start)
+		writer.WriteInt64(3, m.Start)
 	}
 
-	if len(m.Data) > 0 {
-		writer.WriteBytes(3, m.Data)
+	if m.Len != 0 {
+		writer.WriteInt64(4, m.Len)
 	}
 
 	return
@@ -3132,11 +3168,13 @@ func (m *ReadFileRequest) UnmarshalFromReader(reader jspb.Reader) *ReadFileReque
 
 		switch reader.GetFieldNumber() {
 		case 1:
-			m.Path = reader.ReadString()
+			m.Folder = AccessibleFolder(reader.ReadEnum())
 		case 2:
-			m.Start = reader.ReadInt64()
+			m.Filename = reader.ReadString()
 		case 3:
-			m.Data = reader.ReadBytes()
+			m.Start = reader.ReadInt64()
+		case 4:
+			m.Len = reader.ReadInt64()
 		default:
 			reader.SkipField()
 		}
@@ -3160,6 +3198,7 @@ func (m *ReadFileRequest) Unmarshal(rawBytes []byte) (*ReadFileRequest, error) {
 
 type ReadFileResponse struct {
 	ReadCount int64
+	Data      []byte
 }
 
 // GetReadCount gets the ReadCount of the ReadFileResponse.
@@ -3170,6 +3209,14 @@ func (m *ReadFileResponse) GetReadCount() (x int64) {
 	return m.ReadCount
 }
 
+// GetData gets the Data of the ReadFileResponse.
+func (m *ReadFileResponse) GetData() (x []byte) {
+	if m == nil {
+		return x
+	}
+	return m.Data
+}
+
 // MarshalToWriter marshals ReadFileResponse to the provided writer.
 func (m *ReadFileResponse) MarshalToWriter(writer jspb.Writer) {
 	if m == nil {
@@ -3180,6 +3227,10 @@ func (m *ReadFileResponse) MarshalToWriter(writer jspb.Writer) {
 		writer.WriteInt64(1, m.ReadCount)
 	}
 
+	if len(m.Data) > 0 {
+		writer.WriteBytes(2, m.Data)
+	}
+
 	return
 }
 
@@ -3200,6 +3251,8 @@ func (m *ReadFileResponse) UnmarshalFromReader(reader jspb.Reader) *ReadFileResp
 		switch reader.GetFieldNumber() {
 		case 1:
 			m.ReadCount = reader.ReadInt64()
+		case 2:
+			m.Data = reader.ReadBytes()
 		default:
 			reader.SkipField()
 		}
@@ -3222,18 +3275,27 @@ func (m *ReadFileResponse) Unmarshal(rawBytes []byte) (*ReadFileResponse, error)
 }
 
 type WriteFileRequest struct {
-	Path         string
+	Folder       AccessibleFolder
+	Filename     string
 	Append       bool
 	MustNotExist bool
 	Data         []byte
 }
 
-// GetPath gets the Path of the WriteFileRequest.
-func (m *WriteFileRequest) GetPath() (x string) {
+// GetFolder gets the Folder of the WriteFileRequest.
+func (m *WriteFileRequest) GetFolder() (x AccessibleFolder) {
 	if m == nil {
 		return x
 	}
-	return m.Path
+	return m.Folder
+}
+
+// GetFilename gets the Filename of the WriteFileRequest.
+func (m *WriteFileRequest) GetFilename() (x string) {
+	if m == nil {
+		return x
+	}
+	return m.Filename
 }
 
 // GetAppend gets the Append of the WriteFileRequest.
@@ -3266,20 +3328,24 @@ func (m *WriteFileRequest) MarshalToWriter(writer jspb.Writer) {
 		return
 	}
 
-	if len(m.Path) > 0 {
-		writer.WriteString(1, m.Path)
+	if int(m.Folder) != 0 {
+		writer.WriteEnum(1, int(m.Folder))
+	}
+
+	if len(m.Filename) > 0 {
+		writer.WriteString(2, m.Filename)
 	}
 
 	if m.Append {
-		writer.WriteBool(2, m.Append)
+		writer.WriteBool(3, m.Append)
 	}
 
 	if m.MustNotExist {
-		writer.WriteBool(3, m.MustNotExist)
+		writer.WriteBool(4, m.MustNotExist)
 	}
 
 	if len(m.Data) > 0 {
-		writer.WriteBytes(4, m.Data)
+		writer.WriteBytes(5, m.Data)
 	}
 
 	return
@@ -3301,12 +3367,14 @@ func (m *WriteFileRequest) UnmarshalFromReader(reader jspb.Reader) *WriteFileReq
 
 		switch reader.GetFieldNumber() {
 		case 1:
-			m.Path = reader.ReadString()
+			m.Folder = AccessibleFolder(reader.ReadEnum())
 		case 2:
-			m.Append = reader.ReadBool()
+			m.Filename = reader.ReadString()
 		case 3:
-			m.MustNotExist = reader.ReadBool()
+			m.Append = reader.ReadBool()
 		case 4:
+			m.MustNotExist = reader.ReadBool()
+		case 5:
 			m.Data = reader.ReadBytes()
 		default:
 			reader.SkipField()
diff --git a/proto/grpc.pb.go b/proto/grpc.pb.go
index abdb792..44b9b99 100644
--- a/proto/grpc.pb.go
+++ b/proto/grpc.pb.go
@@ -300,6 +300,30 @@ func (x WiFiAuthMode) String() string {
 }
 func (WiFiAuthMode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
 
+type AccessibleFolder int32
+
+const (
+	AccessibleFolder_TMP          AccessibleFolder = 0
+	AccessibleFolder_BASH_SCRIPTS AccessibleFolder = 1
+	AccessibleFolder_HID_SCRIPTS  AccessibleFolder = 2
+)
+
+var AccessibleFolder_name = map[int32]string{
+	0: "TMP",
+	1: "BASH_SCRIPTS",
+	2: "HID_SCRIPTS",
+}
+var AccessibleFolder_value = map[string]int32{
+	"TMP":          0,
+	"BASH_SCRIPTS": 1,
+	"HID_SCRIPTS":  2,
+}
+
+func (x AccessibleFolder) String() string {
+	return proto.EnumName(AccessibleFolder_name, int32(x))
+}
+func (AccessibleFolder) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
+
 type ActionDeploySettingsTemplate_TemplateType int32
 
 const (
@@ -1706,9 +1730,10 @@ func (m *TempDirOrFileResponse) GetResultPath() string {
 }
 
 type ReadFileRequest struct {
-	Path  string `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
-	Start int64  `protobuf:"varint,2,opt,name=start" json:"start,omitempty"`
-	Data  []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
+	Folder   AccessibleFolder `protobuf:"varint,1,opt,name=folder,enum=P4wnP1_grpc.AccessibleFolder" json:"folder,omitempty"`
+	Filename string           `protobuf:"bytes,2,opt,name=filename" json:"filename,omitempty"`
+	Start    int64            `protobuf:"varint,3,opt,name=start" json:"start,omitempty"`
+	Len      int64            `protobuf:"varint,4,opt,name=len" json:"len,omitempty"`
 }
 
 func (m *ReadFileRequest) Reset()                    { *m = ReadFileRequest{} }
@@ -1716,9 +1741,16 @@ func (m *ReadFileRequest) String() string            { return proto.CompactTextS
 func (*ReadFileRequest) ProtoMessage()               {}
 func (*ReadFileRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{29} }
 
-func (m *ReadFileRequest) GetPath() string {
+func (m *ReadFileRequest) GetFolder() AccessibleFolder {
 	if m != nil {
-		return m.Path
+		return m.Folder
+	}
+	return AccessibleFolder_TMP
+}
+
+func (m *ReadFileRequest) GetFilename() string {
+	if m != nil {
+		return m.Filename
 	}
 	return ""
 }
@@ -1730,15 +1762,16 @@ func (m *ReadFileRequest) GetStart() int64 {
 	return 0
 }
 
-func (m *ReadFileRequest) GetData() []byte {
+func (m *ReadFileRequest) GetLen() int64 {
 	if m != nil {
-		return m.Data
+		return m.Len
 	}
-	return nil
+	return 0
 }
 
 type ReadFileResponse struct {
-	ReadCount int64 `protobuf:"varint,1,opt,name=readCount" json:"readCount,omitempty"`
+	ReadCount int64  `protobuf:"varint,1,opt,name=readCount" json:"readCount,omitempty"`
+	Data      []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
 }
 
 func (m *ReadFileResponse) Reset()                    { *m = ReadFileResponse{} }
@@ -1753,11 +1786,19 @@ func (m *ReadFileResponse) GetReadCount() int64 {
 	return 0
 }
 
+func (m *ReadFileResponse) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
 type WriteFileRequest struct {
-	Path         string `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
-	Append       bool   `protobuf:"varint,2,opt,name=append" json:"append,omitempty"`
-	MustNotExist bool   `protobuf:"varint,3,opt,name=mustNotExist" json:"mustNotExist,omitempty"`
-	Data         []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
+	Folder       AccessibleFolder `protobuf:"varint,1,opt,name=folder,enum=P4wnP1_grpc.AccessibleFolder" json:"folder,omitempty"`
+	Filename     string           `protobuf:"bytes,2,opt,name=filename" json:"filename,omitempty"`
+	Append       bool             `protobuf:"varint,3,opt,name=append" json:"append,omitempty"`
+	MustNotExist bool             `protobuf:"varint,4,opt,name=mustNotExist" json:"mustNotExist,omitempty"`
+	Data         []byte           `protobuf:"bytes,5,opt,name=data,proto3" json:"data,omitempty"`
 }
 
 func (m *WriteFileRequest) Reset()                    { *m = WriteFileRequest{} }
@@ -1765,9 +1806,16 @@ func (m *WriteFileRequest) String() string            { return proto.CompactText
 func (*WriteFileRequest) ProtoMessage()               {}
 func (*WriteFileRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} }
 
-func (m *WriteFileRequest) GetPath() string {
+func (m *WriteFileRequest) GetFolder() AccessibleFolder {
 	if m != nil {
-		return m.Path
+		return m.Folder
+	}
+	return AccessibleFolder_TMP
+}
+
+func (m *WriteFileRequest) GetFilename() string {
+	if m != nil {
+		return m.Filename
 	}
 	return ""
 }
@@ -2468,6 +2516,7 @@ func init() {
 	proto.RegisterEnum("P4wnP1_grpc.WiFiWorkingMode", WiFiWorkingMode_name, WiFiWorkingMode_value)
 	proto.RegisterEnum("P4wnP1_grpc.WiFiStateMode", WiFiStateMode_name, WiFiStateMode_value)
 	proto.RegisterEnum("P4wnP1_grpc.WiFiAuthMode", WiFiAuthMode_name, WiFiAuthMode_value)
+	proto.RegisterEnum("P4wnP1_grpc.AccessibleFolder", AccessibleFolder_name, AccessibleFolder_value)
 	proto.RegisterEnum("P4wnP1_grpc.ActionDeploySettingsTemplate_TemplateType", ActionDeploySettingsTemplate_TemplateType_name, ActionDeploySettingsTemplate_TemplateType_value)
 	proto.RegisterEnum("P4wnP1_grpc.EthernetInterfaceSettings_Mode", EthernetInterfaceSettings_Mode_name, EthernetInterfaceSettings_Mode_value)
 }
@@ -3913,225 +3962,230 @@ var _P4WNP1_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("grpc.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 3508 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x5a, 0x5b, 0x77, 0xe3, 0xc8,
-	0x71, 0x26, 0x45, 0x5d, 0xc8, 0xa2, 0x28, 0x42, 0x3d, 0x92, 0x86, 0xa3, 0xb9, 0x2e, 0xbc, 0x5e,
-	0x4f, 0xe4, 0x58, 0x3b, 0xab, 0xd5, 0xce, 0xae, 0xf7, 0xd8, 0x67, 0xcd, 0x3b, 0x39, 0xc3, 0xdb,
-	0x69, 0x90, 0xab, 0x24, 0x3e, 0xc7, 0x34, 0x04, 0xb4, 0x28, 0x78, 0x48, 0x80, 0x01, 0x1a, 0x9a,
-	0x55, 0x1e, 0x9c, 0x73, 0xf2, 0x27, 0xf2, 0x96, 0x9f, 0x90, 0xc7, 0xe4, 0x17, 0xe5, 0x3d, 0x2f,
-	0x79, 0x8e, 0x4f, 0x77, 0xe3, 0x2e, 0x90, 0x9a, 0x9d, 0x79, 0xab, 0xae, 0xae, 0xfa, 0xba, 0x51,
-	0x55, 0x5d, 0x5d, 0x5d, 0x24, 0xc0, 0xcc, 0x5e, 0x6a, 0xa7, 0x4b, 0xdb, 0xa2, 0x16, 0x2a, 0x8e,
-	0xce, 0xdf, 0x9b, 0xa3, 0xaf, 0xa6, 0x8c, 0x25, 0xff, 0x05, 0xa4, 0xb1, 0x6d, 0xcc, 0x66, 0xc4,
-	0xae, 0x6a, 0xd4, 0xb0, 0x4c, 0x85, 0x50, 0x54, 0x83, 0xbd, 0x18, 0xcf, 0xa9, 0x64, 0x5f, 0xe4,
-	0x5e, 0x16, 0xcf, 0x8e, 0x4f, 0x23, 0x9a, 0xa7, 0x31, 0x11, 0x9c, 0xd0, 0x40, 0x08, 0x36, 0x07,
-	0xea, 0x82, 0x54, 0x36, 0x5e, 0x64, 0x5f, 0x16, 0x30, 0xa7, 0xe5, 0xff, 0x02, 0x28, 0xc5, 0xc4,
-	0xd0, 0x1e, 0x6c, 0x18, 0x7a, 0x25, 0xfb, 0x22, 0xfb, 0xb2, 0x84, 0x37, 0x0c, 0x1d, 0x55, 0x60,
-	0xc7, 0x32, 0x89, 0x72, 0x6d, 0x51, 0xae, 0x98, 0xc7, 0xfe, 0x10, 0x1d, 0x43, 0xde, 0x70, 0x98,
-	0xd6, 0x0d, 0xa9, 0xe4, 0xf8, 0x54, 0x30, 0x46, 0x4f, 0xa0, 0x60, 0x2c, 0x16, 0x2e, 0x55, 0x2f,
-	0xe7, 0xa4, 0xb2, 0xc9, 0x27, 0x43, 0x06, 0xea, 0xc1, 0x9e, 0x43, 0xec, 0x1b, 0x43, 0x23, 0x0a,
-	0x55, 0x6d, 0x4a, 0xf4, 0xca, 0xd6, 0x8b, 0xec, 0xcb, 0xe2, 0x99, 0x9c, 0xf6, 0x35, 0x4a, 0x4c,
-	0xb2, 0x93, 0xc1, 0x09, 0x5d, 0xf4, 0x0f, 0x80, 0x5c, 0xe7, 0xb2, 0xad, 0xea, 0x33, 0x42, 0xeb,
-	0x96, 0x69, 0x12, 0x8d, 0x21, 0x6e, 0x73, 0xc4, 0x2f, 0xd2, 0x10, 0x27, 0x4a, 0x2d, 0x21, 0xdd,
-	0xc9, 0xe0, 0x14, 0x0c, 0xa4, 0xc2, 0x61, 0xc0, 0x6d, 0x18, 0x8e, 0x16, 0x80, 0xef, 0x70, 0xf0,
-	0xbf, 0x5b, 0x0b, 0x1e, 0x55, 0xe8, 0x64, 0x70, 0x3a, 0x12, 0xea, 0x42, 0xe9, 0xbd, 0x71, 0x65,
-	0x54, 0x47, 0xbe, 0x25, 0xf2, 0x1c, 0xfa, 0xb3, 0x34, 0xe8, 0x8b, 0xa8, 0x60, 0x27, 0x83, 0xe3,
-	0x9a, 0xcc, 0x0e, 0x8c, 0x11, 0x6c, 0xbf, 0xea, 0x28, 0x54, 0xad, 0x14, 0x56, 0xdb, 0xe1, 0xe2,
-	0x8e, 0x34, 0xb3, 0xc3, 0x5d, 0x0c, 0xf4, 0x3d, 0xe4, 0x1d, 0xe7, 0xba, 0x67, 0xcd, 0x0c, 0xb3,
-	0x02, 0x1c, 0xef, 0x49, 0xaa, 0xa7, 0x94, 0x0e, 0x97, 0xe9, 0x64, 0x70, 0x20, 0x8f, 0x30, 0x48,
-	0xfa, 0xb5, 0xb6, 0xec, 0x11, 0xd5, 0x21, 0x6d, 0x5b, 0x35, 0xd9, 0x37, 0x16, 0x39, 0xc6, 0xe7,
-	0x69, 0x18, 0x8d, 0x4e, 0x7d, 0x14, 0x95, 0xed, 0x64, 0xf0, 0x1d, 0x7d, 0xd4, 0x82, 0xdd, 0x99,
-	0x6d, 0xb9, 0x4b, 0x4c, 0x34, 0xc2, 0xa2, 0x6f, 0x97, 0xe3, 0xbd, 0x48, 0xc3, 0x6b, 0x47, 0xe4,
-	0x3a, 0x19, 0x1c, 0xd3, 0x43, 0x7f, 0x82, 0x83, 0xe8, 0x58, 0x21, 0xff, 0xec, 0x12, 0x53, 0x23,
-	0x95, 0x12, 0xc7, 0x7b, 0x79, 0x1f, 0x9e, 0x2f, 0xdf, 0xc9, 0xe0, 0x54, 0x1c, 0x74, 0x0e, 0xdb,
-	0xb3, 0xa5, 0x61, 0x75, 0xcd, 0xca, 0x1e, 0x47, 0x4c, 0x3d, 0xad, 0xed, 0x51, 0x77, 0xd8, 0x65,
-	0x36, 0xf3, 0x64, 0x51, 0x03, 0xe0, 0x52, 0x75, 0xae, 0x15, 0xcd, 0x36, 0x96, 0xb4, 0x52, 0x4e,
-	0x39, 0x19, 0x5e, 0x5e, 0x60, 0x7e, 0xaf, 0x05, 0x92, 0x9d, 0x2c, 0x8e, 0xe8, 0xa1, 0x2a, 0x14,
-	0xae, 0x0d, 0xdd, 0x03, 0x91, 0x52, 0x82, 0x2a, 0x02, 0xd2, 0xe9, 0x36, 0x02, 0x8c, 0x50, 0x0b,
-	0x69, 0x70, 0xa4, 0x93, 0xe5, 0xdc, 0xba, 0x55, 0x08, 0xa5, 0x86, 0x39, 0x73, 0xc6, 0x64, 0xb1,
-	0x9c, 0xab, 0x94, 0x54, 0xf6, 0x53, 0xe2, 0x5f, 0xe0, 0x35, 0x52, 0x15, 0x3a, 0x59, 0xbc, 0x02,
-	0x0a, 0x9d, 0x40, 0x6e, 0x6e, 0xcd, 0x2a, 0x88, 0x23, 0x1e, 0xa5, 0x20, 0xf6, 0xac, 0x59, 0x27,
-	0x8b, 0x99, 0x10, 0x7a, 0x0d, 0x3b, 0xcc, 0x46, 0x43, 0x97, 0x56, 0x1e, 0xa4, 0x18, 0x54, 0xc8,
-	0x33, 0x7b, 0x0e, 0x5d, 0xf6, 0x29, 0xbe, 0x30, 0xfa, 0x1d, 0x14, 0xb8, 0x7f, 0x14, 0x62, 0xea,
-	0x95, 0x83, 0x94, 0x00, 0xf6, 0x34, 0x7d, 0x19, 0x66, 0x86, 0x40, 0xa1, 0x56, 0x80, 0x1d, 0xcf,
-	0x55, 0xb5, 0x3c, 0x6c, 0x0b, 0x51, 0xf9, 0x21, 0x1c, 0xa6, 0xe6, 0x27, 0xf9, 0x31, 0x3c, 0x5a,
-	0x99, 0x66, 0xe4, 0x67, 0xf0, 0x64, 0x5d, 0x9a, 0x90, 0x8f, 0xe0, 0x20, 0xed, 0xac, 0x47, 0x40,
-	0xef, 0x9e, 0x59, 0xf9, 0x4b, 0x28, 0x27, 0x0e, 0x20, 0x4b, 0xbf, 0x73, 0x46, 0x4c, 0x1c, 0x62,
-	0xf3, 0x5c, 0x5e, 0xc0, 0x21, 0x43, 0x7e, 0x04, 0x0f, 0x57, 0x9c, 0x36, 0xb9, 0x0b, 0x0f, 0x52,
-	0x02, 0x9d, 0xe1, 0x71, 0x7b, 0xf0, 0xfb, 0xc3, 0xc3, 0x0b, 0x18, 0xe8, 0x00, 0xb6, 0x6e, 0xd4,
-	0xb9, 0x2b, 0x6e, 0x96, 0x2d, 0x2c, 0x06, 0xf2, 0xbf, 0xc2, 0xe3, 0x35, 0x67, 0xe6, 0x1e, 0xc8,
-	0x13, 0x90, 0xba, 0x33, 0xd3, 0xb2, 0xc9, 0xd0, 0xa5, 0xc3, 0xab, 0xa1, 0xad, 0x13, 0xdb, 0xbb,
-	0x7e, 0xee, 0xf0, 0xd1, 0x11, 0x6c, 0xf3, 0x15, 0x9d, 0x4a, 0xee, 0x45, 0xee, 0xe5, 0x16, 0xf6,
-	0x46, 0xf2, 0x7f, 0x67, 0x83, 0xbb, 0x4d, 0x9c, 0x31, 0x74, 0x2a, 0xe2, 0x67, 0xe0, 0x2e, 0xf8,
-	0x8a, 0x7b, 0x67, 0x07, 0xb1, 0x28, 0x60, 0x52, 0x03, 0x77, 0x81, 0x7d, 0x21, 0xf4, 0x7b, 0x80,
-	0xa5, 0x3b, 0x9f, 0x4f, 0x96, 0x0d, 0xeb, 0xbd, 0xc9, 0xd7, 0xdf, 0x3b, 0x7b, 0x7a, 0x47, 0xa5,
-	0x6b, 0x8e, 0x02, 0x21, 0x1c, 0x51, 0x40, 0xdf, 0x02, 0x88, 0x23, 0xdd, 0xd4, 0x67, 0xe2, 0x8a,
-	0xdc, 0x3b, 0x7b, 0x98, 0xa2, 0xce, 0xa6, 0x71, 0x44, 0x54, 0xfe, 0x16, 0x0e, 0x53, 0x8f, 0x38,
-	0x7a, 0x06, 0xe0, 0x70, 0x2a, 0x62, 0xb5, 0x08, 0x47, 0x7e, 0x0d, 0x07, 0x69, 0xc7, 0xfa, 0x5e,
-	0xbd, 0xff, 0xcb, 0xc2, 0x93, 0x75, 0xe7, 0x17, 0xc9, 0xb0, 0x4b, 0x3d, 0x3a, 0x02, 0x11, 0xe3,
-	0xa1, 0x37, 0xb0, 0x49, 0x6f, 0x97, 0xc4, 0xb3, 0xd3, 0xeb, 0x0f, 0x4e, 0x0e, 0xa7, 0x3e, 0x31,
-	0xbe, 0x5d, 0x12, 0xcc, 0x31, 0x64, 0x02, 0xbb, 0x51, 0x2e, 0xda, 0x87, 0x52, 0x6b, 0xd2, 0xeb,
-	0x4d, 0x95, 0xe6, 0x78, 0xdc, 0x1d, 0xb4, 0x15, 0x29, 0x83, 0x8a, 0xb0, 0x33, 0x68, 0x8e, 0x2f,
-	0x86, 0xf8, 0xad, 0x94, 0x45, 0x79, 0xd8, 0xbc, 0xe8, 0xb6, 0xba, 0xd2, 0x06, 0xda, 0x81, 0xdc,
-	0x44, 0xa9, 0x49, 0x39, 0x54, 0x82, 0x42, 0xad, 0x37, 0x69, 0x8e, 0x87, 0xc3, 0x71, 0x47, 0xda,
-	0x44, 0x0f, 0xa0, 0x3c, 0xc6, 0xdd, 0x76, 0xbb, 0x89, 0xa7, 0xd5, 0xfa, 0xb8, 0x3b, 0x1c, 0x28,
-	0xd2, 0x96, 0x5c, 0x84, 0x42, 0x90, 0x64, 0xe4, 0x25, 0x94, 0x62, 0x19, 0xe4, 0x67, 0x87, 0xcb,
-	0x97, 0xd1, 0x73, 0xb0, 0x77, 0xf6, 0xe8, 0x8e, 0xf4, 0xd0, 0xa5, 0x3f, 0x32, 0x01, 0xff, 0x88,
-	0x34, 0xa1, 0x9c, 0xc8, 0x3c, 0x1f, 0x75, 0xd2, 0xde, 0xc3, 0x31, 0x4b, 0x0b, 0x98, 0x1d, 0x2d,
-	0x87, 0xfa, 0xe6, 0x55, 0xa8, 0x65, 0xab, 0x33, 0xee, 0xba, 0x71, 0x8a, 0xeb, 0xa2, 0x3c, 0xf4,
-	0x0d, 0xe4, 0x1d, 0x4f, 0x8d, 0x43, 0x17, 0x13, 0x9b, 0xbf, 0x30, 0x5a, 0x86, 0x8f, 0x8b, 0x03,
-	0x51, 0xf9, 0xdf, 0x73, 0xb0, 0x1b, 0x9d, 0x62, 0x25, 0xa6, 0x19, 0xae, 0xc1, 0x69, 0x56, 0x26,
-	0xea, 0x86, 0xc3, 0xea, 0x3e, 0xdd, 0x3b, 0xc2, 0xc1, 0x98, 0xc5, 0xa5, 0x4d, 0x66, 0xee, 0x5c,
-	0xa5, 0x96, 0x7d, 0xcb, 0x4f, 0x48, 0x01, 0x47, 0x38, 0xe8, 0x07, 0xd8, 0x7d, 0x6f, 0xd9, 0xef,
-	0x0c, 0x73, 0x36, 0x5d, 0x58, 0xba, 0xa8, 0x24, 0xf7, 0x12, 0xb9, 0x9b, 0x6d, 0xe0, 0x42, 0x08,
-	0xf5, 0x2d, 0x9d, 0xe0, 0xe2, 0xfb, 0x70, 0x80, 0x5e, 0x43, 0x41, 0x75, 0xe9, 0xb5, 0xd0, 0xde,
-	0x4a, 0x71, 0x0b, 0xd3, 0xae, 0xba, 0xf4, 0x9a, 0xab, 0xe6, 0x55, 0x8f, 0x62, 0x55, 0xaf, 0x76,
-	0xad, 0x9a, 0x26, 0x99, 0xf3, 0x42, 0xb2, 0x84, 0xfd, 0x21, 0x3a, 0x85, 0x6d, 0x75, 0x39, 0xad,
-	0x29, 0x8a, 0x57, 0x04, 0x3e, 0xbc, 0x03, 0x57, 0x53, 0x94, 0xfa, 0xd5, 0x0c, 0x6f, 0xa9, 0xcb,
-	0x9a, 0xa2, 0xa0, 0x1f, 0xa0, 0xac, 0xcd, 0x0d, 0x62, 0x52, 0xa6, 0x33, 0x9d, 0x1b, 0x0e, 0xad,
-	0xe4, 0x79, 0xe9, 0xbe, 0x52, 0xb1, 0x24, 0xe4, 0x6b, 0x8a, 0xd2, 0x33, 0x1c, 0x8a, 0x1e, 0xf3,
-	0x8b, 0x9c, 0x4c, 0x1d, 0xc7, 0xd0, 0x79, 0x35, 0x97, 0xc7, 0x79, 0xc6, 0x50, 0x1c, 0x43, 0x67,
-	0xb9, 0xcf, 0x24, 0x3f, 0x2d, 0x2c, 0x93, 0xd7, 0x2c, 0x79, 0xec, 0x8d, 0xe4, 0xff, 0xcc, 0x42,
-	0x81, 0x7b, 0x86, 0xb2, 0xd3, 0x7b, 0x0a, 0x9b, 0xdc, 0x00, 0x22, 0x8a, 0x8f, 0xef, 0xba, 0x96,
-	0x49, 0x71, 0x0b, 0x70, 0xb9, 0xe8, 0xd7, 0x6f, 0xc4, 0xbf, 0x1e, 0xc1, 0x26, 0xdf, 0x87, 0x70,
-	0x15, 0xa7, 0x51, 0x1d, 0xca, 0x9a, 0x6b, 0xdb, 0xc4, 0x0c, 0x42, 0x8f, 0xfb, 0x69, 0x6d, 0x0c,
-	0x25, 0x35, 0xe4, 0x33, 0x80, 0xd0, 0x04, 0x6c, 0x19, 0x45, 0xe9, 0x36, 0xfc, 0x38, 0x62, 0x34,
-	0x92, 0x20, 0x37, 0x52, 0xde, 0x7a, 0xaf, 0x17, 0x46, 0xca, 0x9f, 0x41, 0x49, 0xa1, 0x36, 0x73,
-	0x35, 0x71, 0x1c, 0x16, 0xea, 0x12, 0xe4, 0x16, 0xce, 0xcc, 0xd3, 0x62, 0xa4, 0xfc, 0x0a, 0x50,
-	0x4c, 0xa4, 0x6a, 0xdb, 0xea, 0x2d, 0x0b, 0xc9, 0x85, 0x33, 0xe3, 0x34, 0x7f, 0x47, 0x15, 0x70,
-	0x30, 0x96, 0x4f, 0x61, 0xb7, 0x79, 0x43, 0x4c, 0xea, 0x9d, 0x26, 0x16, 0xa2, 0xcc, 0x69, 0xc4,
-	0x64, 0x79, 0x88, 0x43, 0xe7, 0x70, 0x84, 0x23, 0xab, 0x00, 0x5c, 0x9e, 0x1f, 0x6c, 0x74, 0x0c,
-	0x3b, 0xd4, 0xe1, 0x0b, 0x8a, 0x5d, 0x74, 0x32, 0xd8, 0x67, 0xa0, 0x23, 0xd8, 0xa2, 0x97, 0x96,
-	0x25, 0x6c, 0x9a, 0xef, 0x64, 0xb0, 0x18, 0xa2, 0x0a, 0x6c, 0x53, 0xc3, 0xa4, 0xaf, 0xcf, 0xb9,
-	0x55, 0x73, 0xac, 0x12, 0x14, 0xe3, 0xda, 0x16, 0xe4, 0x6e, 0xd4, 0xb9, 0xdc, 0x83, 0x2d, 0xbe,
-	0x04, 0x33, 0x0b, 0x0d, 0x77, 0xc1, 0x69, 0xf4, 0x65, 0x70, 0xfb, 0x6d, 0xa4, 0x84, 0x55, 0xb8,
-	0xb5, 0xe0, 0x5a, 0xfc, 0x33, 0x1c, 0xb0, 0xb3, 0xdf, 0x30, 0xec, 0xa1, 0xdd, 0x32, 0xe6, 0xc4,
-	0xff, 0x50, 0x09, 0x72, 0xba, 0xe1, 0x57, 0x0b, 0x8c, 0x64, 0xc1, 0xb5, 0xb4, 0xc9, 0x95, 0xf1,
-	0x93, 0x67, 0x74, 0x6f, 0xc4, 0x4c, 0x62, 0x99, 0xf3, 0xdb, 0x96, 0x35, 0x67, 0xd7, 0xb2, 0x78,
-	0xfa, 0x45, 0x38, 0xec, 0xfa, 0x4a, 0xac, 0xe0, 0x2c, 0x2d, 0xd3, 0x21, 0xe2, 0xb8, 0x3b, 0xee,
-	0x9c, 0x8e, 0x54, 0x7a, 0xed, 0x5f, 0x43, 0x21, 0x47, 0x1e, 0x42, 0x19, 0x13, 0x55, 0x8f, 0xee,
-	0x0a, 0xc1, 0xe6, 0x32, 0x14, 0xe6, 0x34, 0xcb, 0x82, 0x0e, 0xbb, 0xdf, 0xf8, 0xb6, 0x72, 0x58,
-	0x0c, 0x98, 0xa4, 0xae, 0x52, 0x95, 0xef, 0x67, 0x17, 0x73, 0x5a, 0x7e, 0x05, 0x52, 0x08, 0xe8,
-	0x6d, 0xe2, 0x09, 0x14, 0x6c, 0xa2, 0xea, 0x75, 0xcb, 0x35, 0xa9, 0x67, 0xc9, 0x90, 0x21, 0xdf,
-	0x80, 0x74, 0x61, 0x1b, 0x94, 0xdc, 0xb7, 0x87, 0x23, 0x96, 0x06, 0x96, 0xac, 0x9e, 0x14, 0x39,
-	0xcd, 0x1b, 0xb1, 0x6c, 0xbb, 0x70, 0x1d, 0x3a, 0xb0, 0x68, 0xf3, 0x27, 0x76, 0xd6, 0x85, 0x75,
-	0x62, 0xbc, 0x60, 0xa7, 0x9b, 0x91, 0x9d, 0xfe, 0x12, 0xca, 0x6c, 0xc9, 0xae, 0x79, 0x65, 0xad,
-	0x59, 0x56, 0xfe, 0x2b, 0x48, 0xa1, 0x98, 0xf7, 0x41, 0x69, 0x49, 0x97, 0x9d, 0x53, 0xe3, 0x5f,
-	0x88, 0x67, 0x21, 0x4e, 0x33, 0x1e, 0xcf, 0x02, 0x39, 0x7e, 0xa4, 0x83, 0x93, 0xbe, 0xb0, 0xf4,
-	0xb1, 0xb1, 0x10, 0xb9, 0x35, 0x87, 0xfd, 0x21, 0x33, 0xb2, 0xe1, 0x34, 0x0c, 0x9b, 0x67, 0xcd,
-	0x3c, 0x16, 0x03, 0xf9, 0x9f, 0x40, 0x0a, 0xaa, 0x8a, 0xc8, 0x09, 0x11, 0xa5, 0x44, 0xd4, 0xab,
-	0x21, 0x07, 0x7d, 0x01, 0x7b, 0xd4, 0x58, 0x10, 0xcb, 0xa5, 0x0a, 0xd1, 0x2c, 0x53, 0x77, 0xbc,
-	0xa4, 0x92, 0xe0, 0xca, 0xcf, 0x60, 0x37, 0xc0, 0x7e, 0x63, 0x5d, 0x26, 0x3b, 0x11, 0xf2, 0xe7,
-	0x91, 0xb5, 0xdf, 0x58, 0x97, 0x3c, 0x39, 0x4a, 0x90, 0x33, 0x74, 0xd1, 0x0c, 0x29, 0x61, 0x46,
-	0xca, 0x3f, 0x42, 0xa5, 0xd3, 0x6d, 0x60, 0xd7, 0x34, 0x0d, 0x73, 0xf6, 0xc6, 0xba, 0xe4, 0xb9,
-	0x0d, 0xf3, 0x18, 0x8b, 0x20, 0xe6, 0x78, 0x6f, 0x03, 0xc1, 0xe6, 0xcd, 0xa2, 0xab, 0xfb, 0x56,
-	0x62, 0x34, 0x73, 0xac, 0x63, 0xb9, 0xb6, 0x46, 0xbc, 0x1c, 0xe7, 0x8d, 0xe4, 0xbf, 0x42, 0x39,
-	0xf2, 0xe5, 0x1c, 0xee, 0xd7, 0x90, 0xfb, 0x8b, 0x75, 0xc9, 0xf1, 0x92, 0xc9, 0x2e, 0xba, 0x51,
-	0xcc, 0xa4, 0x98, 0x95, 0x0c, 0xa7, 0x65, 0x98, 0x86, 0x73, 0x1d, 0x5c, 0x84, 0x11, 0x4e, 0x78,
-	0x36, 0xde, 0x38, 0x96, 0x19, 0x5e, 0x85, 0x3e, 0x47, 0x3e, 0x85, 0x62, 0xaf, 0xd9, 0x08, 0x6e,
-	0xda, 0xe7, 0x50, 0xbc, 0x9c, 0x1b, 0xe6, 0xbb, 0xa9, 0x16, 0xc4, 0x71, 0x09, 0x03, 0x67, 0x89,
-	0x40, 0xfe, 0x9f, 0x4d, 0xd8, 0x13, 0x2f, 0x8c, 0x40, 0xa7, 0x02, 0x3b, 0xc4, 0x14, 0x17, 0x71,
-	0x56, 0xb4, 0x72, 0xbc, 0x21, 0x33, 0xe3, 0x8d, 0xa1, 0xfb, 0xb9, 0xf5, 0xc6, 0xe0, 0x9c, 0x65,
-	0x90, 0xe7, 0x19, 0xc9, 0x23, 0x5b, 0x35, 0xdd, 0x2b, 0x55, 0xa3, 0xae, 0x4d, 0x6c, 0x1e, 0x2f,
-	0x05, 0x1c, 0xe3, 0xb1, 0x15, 0x96, 0xb6, 0xa5, 0xbb, 0x1a, 0xe5, 0x61, 0x53, 0xc0, 0xfe, 0x90,
-	0x9b, 0x95, 0xd8, 0x86, 0x2a, 0xee, 0x53, 0x66, 0x56, 0x3e, 0x42, 0xcf, 0xa0, 0xe8, 0x3a, 0x64,
-	0x5a, 0x6f, 0xd4, 0xa7, 0xcd, 0x7a, 0x9f, 0xdf, 0xa9, 0x79, 0x5c, 0x70, 0x1d, 0x52, 0x6f, 0xd4,
-	0x9b, 0xf5, 0x3e, 0xbb, 0xfd, 0xd8, 0x3c, 0x1e, 0x34, 0xba, 0x0a, 0xef, 0x8d, 0xe4, 0x71, 0xde,
-	0x75, 0x08, 0x1f, 0xa3, 0x97, 0x20, 0xb1, 0xc9, 0x4e, 0xb7, 0x31, 0x7d, 0xdb, 0xfc, 0xc7, 0xda,
-	0xb0, 0x8a, 0x1b, 0xde, 0x0d, 0xb9, 0xe7, 0x3a, 0xa4, 0xd3, 0x6d, 0xf8, 0x5c, 0x24, 0x43, 0xc9,
-	0x97, 0xec, 0x0f, 0x27, 0x4a, 0x93, 0xb7, 0x31, 0xf2, 0xb8, 0x28, 0xc4, 0x38, 0xcb, 0xdf, 0x0a,
-	0x93, 0xc1, 0xd5, 0x0b, 0xde, 0xa4, 0x10, 0x5b, 0x61, 0xf1, 0x54, 0xbd, 0x40, 0x0f, 0x61, 0x87,
-	0xcd, 0x4f, 0xfa, 0x0a, 0x6f, 0x38, 0xe4, 0xf1, 0xb6, 0xeb, 0x90, 0x49, 0x5f, 0x41, 0x4f, 0x01,
-	0xd8, 0x84, 0xd2, 0xc4, 0xdd, 0x6a, 0xcf, 0xbb, 0x88, 0x99, 0x9e, 0x60, 0xa0, 0x37, 0xb0, 0x67,
-	0x9b, 0xba, 0xe1, 0x4c, 0x83, 0x12, 0x4b, 0x74, 0x03, 0x7e, 0x11, 0xaf, 0x0f, 0x63, 0xbe, 0x6a,
-	0xd2, 0x6b, 0x62, 0x9b, 0x84, 0xe2, 0x12, 0x57, 0x0d, 0x5c, 0xd8, 0x07, 0x49, 0xd3, 0xb5, 0x29,
-	0xd1, 0x16, 0x21, 0x5a, 0xf9, 0xc3, 0xd1, 0xf6, 0x34, 0x5d, 0x6b, 0x6a, 0x8b, 0x00, 0xae, 0x0a,
-	0xbb, 0xee, 0x22, 0xb2, 0x31, 0xd1, 0x27, 0x78, 0xb6, 0x06, 0x6a, 0xd2, 0x57, 0x70, 0xd1, 0x5d,
-	0x04, 0x3b, 0x92, 0x47, 0x70, 0x94, 0xbe, 0x18, 0x2f, 0x5c, 0x2c, 0x87, 0x4e, 0x55, 0x5d, 0xf7,
-	0xaf, 0x95, 0x3c, 0x63, 0x54, 0x75, 0xdd, 0x46, 0x8f, 0x20, 0xaf, 0x93, 0x1b, 0x31, 0x27, 0xc2,
-	0x6e, 0x47, 0x27, 0x37, 0x6c, 0x4a, 0xfe, 0x3d, 0xec, 0xdf, 0x59, 0x93, 0xa5, 0x23, 0x4d, 0xb7,
-	0xad, 0x85, 0x17, 0xb9, 0x62, 0xc0, 0x0e, 0xf0, 0x95, 0x31, 0x0f, 0x5a, 0x9a, 0x8c, 0x96, 0xa7,
-	0xf0, 0x99, 0x78, 0x67, 0x10, 0xdd, 0xdf, 0x4a, 0xd7, 0xa4, 0xc4, 0xbe, 0x52, 0x35, 0x12, 0x7c,
-	0xf8, 0xf7, 0xb0, 0xc9, 0x4b, 0x31, 0xd1, 0x45, 0x8d, 0x77, 0xc7, 0x56, 0x6a, 0x61, 0xae, 0x23,
-	0xff, 0x5b, 0x0e, 0x1e, 0xad, 0x46, 0x4e, 0xcb, 0xc6, 0x3f, 0x78, 0x99, 0x57, 0xbc, 0x0b, 0x7e,
-	0xfd, 0x61, 0xab, 0x9d, 0x46, 0x0a, 0x32, 0x96, 0x3c, 0x96, 0xcc, 0x38, 0xc4, 0x71, 0xce, 0xfd,
-	0xe4, 0x10, 0x72, 0x58, 0x41, 0x63, 0x12, 0xba, 0x50, 0x9d, 0x77, 0xe7, 0xde, 0xb9, 0x0c, 0xc6,
-	0xd1, 0x53, 0xbf, 0x15, 0x3f, 0xf5, 0x43, 0x40, 0xfa, 0xb5, 0xb6, 0x54, 0x88, 0x7d, 0x43, 0xec,
-	0xa0, 0x76, 0x13, 0x8d, 0xd3, 0xe7, 0xb1, 0x4d, 0x36, 0x3a, 0xf5, 0x51, 0x5c, 0x0c, 0xa7, 0xa8,
-	0xa2, 0xcf, 0xa1, 0xe4, 0x87, 0x52, 0xd7, 0x9c, 0x38, 0xc4, 0x3b, 0xce, 0x71, 0xa6, 0x5c, 0x87,
-	0x4d, 0x5e, 0x63, 0x03, 0x6c, 0xf7, 0xab, 0x83, 0x49, 0xb5, 0x27, 0x65, 0x50, 0x19, 0x8a, 0x6c,
-	0x8d, 0x69, 0xbd, 0xd7, 0x6d, 0x0e, 0xc6, 0x52, 0x36, 0x60, 0x28, 0x4d, 0xfc, 0x63, 0x13, 0x4b,
-	0x1b, 0xec, 0x39, 0x37, 0x19, 0xf4, 0xab, 0x83, 0x6a, 0xbb, 0xd9, 0x90, 0x72, 0xf2, 0xff, 0xe7,
-	0x00, 0xdd, 0xdd, 0x55, 0x58, 0xad, 0x8d, 0x2c, 0x3b, 0xc8, 0x8a, 0x21, 0x07, 0xbd, 0x84, 0xb2,
-	0x18, 0x05, 0xe6, 0xf6, 0x62, 0x27, 0xc9, 0xe6, 0x2d, 0x14, 0xa2, 0x3a, 0xbc, 0x10, 0xf0, 0x2c,
-	0x1e, 0x32, 0xd0, 0x09, 0x48, 0xa6, 0x45, 0xd9, 0xc3, 0xc1, 0xb2, 0x0d, 0xaa, 0xf2, 0x1e, 0xb8,
-	0x68, 0x73, 0xdf, 0xe1, 0xa3, 0x53, 0x40, 0xba, 0x35, 0xb0, 0x68, 0xcd, 0x30, 0xf5, 0x70, 0x59,
-	0xe1, 0x8b, 0x94, 0x19, 0x76, 0x5f, 0x6a, 0xea, 0x7c, 0x7e, 0xa9, 0x6a, 0xef, 0xbc, 0xf6, 0x9d,
-	0x48, 0x99, 0x09, 0x2e, 0x3a, 0x87, 0x6d, 0x5b, 0x35, 0x67, 0xc4, 0xa9, 0xec, 0xf0, 0x28, 0x7e,
-	0xb2, 0xc2, 0x65, 0x98, 0x09, 0x61, 0x4f, 0x16, 0xb5, 0x60, 0xc7, 0x5a, 0x8a, 0x9f, 0x10, 0xc4,
-	0x3b, 0xe4, 0xef, 0xef, 0xf1, 0xf4, 0xe9, 0x50, 0x88, 0x37, 0x4d, 0x6a, 0xdf, 0x62, 0x5f, 0x19,
-	0xd5, 0xa1, 0xe8, 0xb0, 0x0f, 0xd4, 0x3a, 0x96, 0x43, 0x9d, 0x4a, 0x81, 0x63, 0x7d, 0xb6, 0x0a,
-	0x2b, 0x90, 0xc4, 0x51, 0xad, 0xe3, 0xef, 0x61, 0x37, 0x8a, 0xce, 0x6e, 0x9d, 0x77, 0xe4, 0xd6,
-	0xf3, 0x1b, 0x23, 0xe3, 0x2f, 0xde, 0x82, 0xf7, 0xe2, 0xfd, 0x7e, 0xe3, 0xbb, 0xac, 0x6c, 0x41,
-	0x39, 0xf1, 0x8d, 0xfc, 0x0e, 0x65, 0x44, 0xcf, 0x7a, 0x1f, 0xf4, 0xbd, 0x22, 0x9c, 0x60, 0x7e,
-	0xb2, 0x5c, 0x12, 0x3f, 0xed, 0x44, 0x38, 0x81, 0xcf, 0x79, 0x3d, 0x14, 0xf5, 0x39, 0x63, 0xc8,
-	0xdf, 0xc1, 0x41, 0xda, 0x17, 0xf1, 0x57, 0x87, 0xaa, 0x05, 0xaf, 0x0e, 0x55, 0xe3, 0x75, 0xc6,
-	0xd2, 0xc3, 0xdf, 0x30, 0x96, 0xf2, 0x0e, 0x6c, 0x35, 0x17, 0x4b, 0x7a, 0x7b, 0xf2, 0x1b, 0x90,
-	0x92, 0x1d, 0x23, 0xb4, 0x0d, 0x1b, 0x93, 0x91, 0x94, 0x41, 0x79, 0xd8, 0x6c, 0x0c, 0x2f, 0x06,
-	0x52, 0x16, 0xed, 0x40, 0x6e, 0xd8, 0x6a, 0x49, 0x1b, 0x27, 0x5f, 0x02, 0x84, 0x1d, 0x22, 0x76,
-	0x5e, 0x70, 0x57, 0xe9, 0x0e, 0xda, 0xa2, 0xf9, 0xd1, 0xaa, 0xf6, 0x7a, 0x6c, 0xc0, 0x9b, 0x1f,
-	0xb5, 0xe1, 0xb8, 0x23, 0x6d, 0x9c, 0xfc, 0x6f, 0x16, 0x76, 0xbc, 0xb6, 0x04, 0x2a, 0xc0, 0xd6,
-	0x60, 0xd2, 0x9f, 0x7e, 0x25, 0x65, 0x7c, 0xf2, 0x4c, 0xca, 0xfa, 0xe4, 0xd7, 0xd2, 0x86, 0x4f,
-	0x9e, 0x4b, 0x39, 0x9f, 0xfc, 0x46, 0xda, 0xf4, 0xc9, 0xd7, 0xd2, 0x96, 0x4f, 0x7e, 0x2b, 0x6d,
-	0xfb, 0xe4, 0x77, 0xd2, 0x8e, 0x4f, 0xfe, 0x56, 0xca, 0xb3, 0x1d, 0xf1, 0x25, 0x5e, 0x49, 0x85,
-	0x80, 0xfe, 0x4a, 0x82, 0x80, 0x3e, 0x93, 0x8a, 0x01, 0xfd, 0xb5, 0xb4, 0x1b, 0xd0, 0xe7, 0x52,
-	0x29, 0xa0, 0xbf, 0x91, 0xf6, 0x02, 0xfa, 0xb5, 0x54, 0x0e, 0xe8, 0x6f, 0x25, 0x29, 0xa0, 0xbf,
-	0x93, 0xf6, 0x03, 0xfa, 0xb7, 0x12, 0xf2, 0xe9, 0xb3, 0x57, 0xd2, 0x83, 0x93, 0xdf, 0xc0, 0x6e,
-	0xb4, 0xb5, 0xc2, 0x8c, 0xd7, 0x1b, 0x5e, 0x08, 0x7b, 0x76, 0xba, 0xed, 0x8e, 0x94, 0x65, 0xe2,
-	0xe3, 0x61, 0xbb, 0xdd, 0x6b, 0x4a, 0x1b, 0x27, 0x0d, 0x28, 0x27, 0x1a, 0x06, 0xcc, 0x96, 0x93,
-	0xc1, 0xdb, 0x01, 0xb3, 0x7d, 0x86, 0x79, 0xa3, 0x3a, 0x12, 0x3e, 0x50, 0xc6, 0x55, 0x69, 0x03,
-	0x3d, 0x80, 0xb2, 0x32, 0xae, 0x4e, 0x5b, 0xd5, 0x6e, 0x6f, 0xf8, 0x63, 0x13, 0x4f, 0xab, 0x23,
-	0x29, 0x77, 0xd2, 0x80, 0x52, 0xec, 0xdd, 0x8c, 0x0e, 0x61, 0x9f, 0x49, 0x0d, 0x86, 0xe3, 0x69,
-	0x7d, 0x38, 0x18, 0x34, 0xeb, 0xe3, 0x66, 0x43, 0x18, 0xbe, 0x3a, 0x9a, 0x4e, 0x18, 0xe0, 0x3e,
-	0x94, 0x98, 0x44, 0x38, 0xbb, 0x71, 0xf2, 0x85, 0xe8, 0x9e, 0xf8, 0xed, 0x07, 0xb4, 0x0b, 0xf9,
-	0x8b, 0x51, 0xf5, 0x6c, 0x3a, 0x52, 0xde, 0x8a, 0xfd, 0x0f, 0x47, 0xcd, 0x81, 0x94, 0x3d, 0xfb,
-	0x8f, 0x63, 0xd8, 0x1e, 0x9d, 0x5f, 0x0c, 0x46, 0x5f, 0xa1, 0x3e, 0x54, 0xda, 0x84, 0xfa, 0xf7,
-	0x5b, 0xec, 0x9a, 0x44, 0x28, 0x7e, 0xaf, 0xb0, 0x80, 0x3b, 0x7e, 0xbc, 0xe6, 0x2a, 0x97, 0x33,
-	0xa8, 0x03, 0x0f, 0x04, 0xd6, 0x27, 0x23, 0xb5, 0x60, 0xbf, 0x4d, 0x68, 0xa2, 0xe0, 0xfc, 0x08,
-	0x9c, 0x21, 0xec, 0x2b, 0x77, 0x70, 0xd6, 0xe9, 0xdc, 0x07, 0xf8, 0x07, 0xd8, 0x6b, 0x13, 0x1a,
-	0x2d, 0x9d, 0xd3, 0x76, 0x55, 0x89, 0xf1, 0x22, 0xd2, 0x02, 0x41, 0x89, 0x23, 0xac, 0x94, 0x3e,
-	0x4e, 0xc1, 0x96, 0x33, 0xa8, 0x01, 0xbb, 0x7d, 0x56, 0x94, 0x4f, 0xfa, 0x0a, 0xbf, 0x3d, 0xee,
-	0x29, 0xb0, 0x56, 0xa0, 0x4c, 0xe1, 0xb9, 0x70, 0xd6, 0xea, 0xe2, 0xe3, 0x03, 0x0b, 0x99, 0x15,
-	0x0b, 0x58, 0xf0, 0xab, 0x36, 0xa1, 0xd5, 0xf9, 0xfc, 0xfe, 0xfa, 0x29, 0xcd, 0x86, 0xa7, 0xf1,
-	0xe4, 0x7f, 0x1f, 0x86, 0x9c, 0x41, 0x73, 0xf8, 0x3c, 0x12, 0xcd, 0xab, 0x57, 0x8b, 0x77, 0xac,
-	0x62, 0x0d, 0x9d, 0xe3, 0x0f, 0xfc, 0x64, 0x39, 0x83, 0xfa, 0xfc, 0x7d, 0x89, 0x5d, 0xd3, 0xbb,
-	0x3f, 0x9f, 0xa6, 0xbf, 0xd8, 0xbc, 0x67, 0xed, 0xf1, 0x93, 0x55, 0xd3, 0xec, 0x49, 0xc6, 0xe1,
-	0xca, 0x51, 0x38, 0xf6, 0x62, 0xbd, 0x07, 0x71, 0xf5, 0x13, 0x51, 0xce, 0x20, 0x0c, 0x87, 0x9d,
-	0x6e, 0xa3, 0x4d, 0x68, 0xf8, 0x6e, 0x14, 0xaf, 0xcc, 0xd5, 0x5a, 0xf7, 0x6e, 0xb1, 0x09, 0xa8,
-	0xd3, 0x6d, 0xd4, 0x55, 0x53, 0x23, 0xf3, 0x70, 0x97, 0x6b, 0x00, 0xd3, 0xe3, 0x62, 0x00, 0x0f,
-	0xc5, 0xd6, 0xbc, 0x57, 0x75, 0x20, 0x9f, 0x1e, 0x07, 0x4f, 0x57, 0xe2, 0xb3, 0x27, 0xbb, 0x9c,
-	0x41, 0x35, 0x38, 0x0a, 0xb6, 0x55, 0x9d, 0xcf, 0xef, 0x81, 0x4b, 0xdf, 0xd3, 0x1f, 0x7d, 0x73,
-	0x25, 0x5e, 0xfa, 0xeb, 0xbe, 0xee, 0x97, 0xc9, 0xa9, 0xd4, 0x2e, 0x01, 0xdf, 0x60, 0xb1, 0xa5,
-	0x04, 0x6d, 0xa0, 0x84, 0x5b, 0x93, 0xed, 0xa1, 0x15, 0x1b, 0x7c, 0x0b, 0xd0, 0x52, 0xfc, 0xe6,
-	0x13, 0x8a, 0x7b, 0x2a, 0xd1, 0xe4, 0x4a, 0x58, 0x2c, 0xd9, 0xb1, 0xe2, 0x1e, 0x28, 0xb5, 0x94,
-	0x36, 0xa1, 0x7e, 0xef, 0x27, 0x81, 0x97, 0xe8, 0x1c, 0x25, 0xf0, 0x92, 0x0d, 0x23, 0x39, 0x83,
-	0xfe, 0x0c, 0x87, 0x2d, 0xa5, 0x6e, 0x13, 0x95, 0x92, 0x58, 0xa7, 0x0e, 0x25, 0xfe, 0x77, 0x90,
-	0xd2, 0x27, 0x3c, 0x96, 0xd7, 0x89, 0x04, 0x2b, 0xfc, 0x01, 0x8a, 0xbc, 0xf7, 0xd8, 0xe3, 0x65,
-	0x75, 0xc2, 0x2b, 0xd1, 0x06, 0x6b, 0xd2, 0x7c, 0x6c, 0x4a, 0xce, 0xbc, 0xca, 0xa2, 0x36, 0x14,
-	0x9b, 0xda, 0x75, 0xd0, 0x0d, 0x5b, 0x97, 0x03, 0xd6, 0xcc, 0xc9, 0x19, 0xd4, 0x05, 0x24, 0x52,
-	0x4c, 0xec, 0xa7, 0x8a, 0xd5, 0xcd, 0xe9, 0xe3, 0xa3, 0xf4, 0x06, 0xb9, 0x9c, 0x41, 0xbf, 0x83,
-	0xdd, 0x36, 0xa1, 0x61, 0x63, 0x3d, 0x2d, 0x5e, 0x57, 0x6b, 0xb7, 0xe0, 0x48, 0x98, 0x23, 0x60,
-	0xd6, 0xaf, 0x45, 0x51, 0xfe, 0xf3, 0x70, 0x30, 0xec, 0x2b, 0xd4, 0xb2, 0xc9, 0x85, 0x71, 0x15,
-	0x7e, 0xcf, 0xaf, 0x12, 0xe2, 0xab, 0x7e, 0x0f, 0x5a, 0x11, 0xae, 0x23, 0x38, 0x64, 0xb9, 0x87,
-	0xc1, 0xea, 0x31, 0xdc, 0x75, 0x76, 0x5f, 0x6d, 0x43, 0x8e, 0x58, 0xf1, 0x7e, 0xef, 0xfb, 0x79,
-	0xa0, 0xab, 0xbf, 0xbb, 0x0f, 0x8f, 0x38, 0x96, 0x7f, 0x61, 0x7c, 0x30, 0x64, 0xfa, 0x27, 0x0f,
-	0x85, 0x3b, 0x52, 0xb6, 0x97, 0xe6, 0x8e, 0xe7, 0xab, 0xf1, 0xc5, 0x0f, 0x07, 0xcc, 0x2f, 0x8f,
-	0x23, 0xd7, 0xd9, 0x9d, 0xff, 0x70, 0xdd, 0x9f, 0x2b, 0x93, 0x2a, 0xfc, 0xd2, 0x7f, 0x2a, 0x00,
-	0x93, 0x73, 0x98, 0x2c, 0xe7, 0xec, 0xb5, 0xb8, 0x1e, 0xe1, 0xfe, 0x05, 0xfe, 0x08, 0x8f, 0xd2,
-	0x17, 0xa8, 0xea, 0xfa, 0x27, 0x83, 0xff, 0x09, 0x9e, 0xac, 0xda, 0xfd, 0xc2, 0xba, 0xf9, 0xf4,
-	0xcd, 0x8f, 0xe1, 0x71, 0xe8, 0xc2, 0xe4, 0xfc, 0x47, 0xfb, 0xb1, 0x07, 0x87, 0x1c, 0xf1, 0x8e,
-	0x07, 0xef, 0xd9, 0x6e, 0x7a, 0x98, 0x5d, 0xc2, 0x2f, 0xa2, 0xe7, 0x60, 0x95, 0x1f, 0xd7, 0xc5,
-	0xef, 0x07, 0xd8, 0xf9, 0xf9, 0xba, 0x35, 0x98, 0x2b, 0x3f, 0x09, 0xbf, 0x0f, 0x07, 0xa1, 0x9d,
-	0x83, 0x3b, 0xf5, 0xa3, 0x0d, 0x3c, 0x80, 0xc3, 0x10, 0x2e, 0xfc, 0x7b, 0xc3, 0xc7, 0xe2, 0x5d,
-	0x6e, 0xf3, 0x7f, 0x51, 0x7e, 0xfd, 0xb7, 0x00, 0x00, 0x00, 0xff, 0xff, 0xc4, 0xe0, 0x0d, 0x9a,
-	0x53, 0x29, 0x00, 0x00,
+	// 3587 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x5a, 0x4b, 0x73, 0x23, 0xc9,
+	0x71, 0xc6, 0x83, 0x0f, 0x20, 0x01, 0x10, 0xcd, 0x1a, 0x92, 0x83, 0xe1, 0x3c, 0xb7, 0xb5, 0x5a,
+	0x8d, 0x29, 0x8b, 0xbb, 0xcb, 0xe5, 0xce, 0xae, 0x36, 0x24, 0xaf, 0xf0, 0x06, 0x66, 0xf0, 0x8a,
+	0x6a, 0x60, 0x69, 0x5b, 0x11, 0x82, 0x9a, 0xdd, 0x45, 0xb0, 0x35, 0x40, 0x37, 0xdc, 0x5d, 0xe0,
+	0x2c, 0x7d, 0x90, 0x23, 0x7c, 0xf6, 0xdd, 0x37, 0xff, 0x04, 0xdf, 0x6c, 0xff, 0x22, 0xdf, 0x7d,
+	0xf1, 0xd9, 0x8e, 0xaa, 0xea, 0x37, 0x1b, 0xe0, 0xec, 0x4c, 0xe8, 0x96, 0x95, 0x9d, 0xf5, 0x55,
+	0x55, 0x66, 0x56, 0x66, 0x56, 0x02, 0x00, 0x33, 0x7b, 0xa9, 0x9d, 0x2e, 0x6d, 0x8b, 0x5a, 0xa8,
+	0x30, 0x3a, 0x7f, 0x67, 0x8e, 0xbe, 0x9c, 0x32, 0x96, 0xfc, 0x27, 0x90, 0xc6, 0xb6, 0x31, 0x9b,
+	0x11, 0xbb, 0xaa, 0x51, 0xc3, 0x32, 0x15, 0x42, 0x51, 0x0d, 0xf6, 0x22, 0x3c, 0xa7, 0x92, 0x7e,
+	0x91, 0x7d, 0x59, 0x38, 0x3b, 0x3e, 0x0d, 0xcd, 0x3c, 0x8d, 0x88, 0xe0, 0xd8, 0x0c, 0x84, 0x60,
+	0x6b, 0xa0, 0x2e, 0x48, 0x25, 0xf3, 0x22, 0xfd, 0x32, 0x8f, 0x39, 0x2d, 0xff, 0x27, 0x40, 0x29,
+	0x22, 0x86, 0xf6, 0x20, 0x63, 0xe8, 0x95, 0xf4, 0x8b, 0xf4, 0xcb, 0x12, 0xce, 0x18, 0x3a, 0xaa,
+	0xc0, 0xae, 0x65, 0x12, 0xe5, 0xda, 0xa2, 0x7c, 0x62, 0x0e, 0x7b, 0x43, 0x74, 0x0c, 0x39, 0xc3,
+	0x61, 0xb3, 0x6e, 0x48, 0x25, 0xcb, 0x3f, 0xf9, 0x63, 0xf4, 0x04, 0xf2, 0xc6, 0x62, 0xb1, 0xa2,
+	0xea, 0xe5, 0x9c, 0x54, 0xb6, 0xf8, 0xc7, 0x80, 0x81, 0x7a, 0xb0, 0xe7, 0x10, 0xfb, 0xc6, 0xd0,
+	0x88, 0x42, 0x55, 0x9b, 0x12, 0xbd, 0xb2, 0xfd, 0x22, 0xfd, 0xb2, 0x70, 0x26, 0x27, 0x9d, 0x46,
+	0x89, 0x48, 0x76, 0x52, 0x38, 0x36, 0x17, 0xfd, 0x2d, 0xa0, 0x95, 0x73, 0xd9, 0x56, 0xf5, 0x19,
+	0xa1, 0x75, 0xcb, 0x34, 0x89, 0xc6, 0x10, 0x77, 0x38, 0xe2, 0x67, 0x49, 0x88, 0x13, 0xa5, 0x16,
+	0x93, 0xee, 0xa4, 0x70, 0x02, 0x06, 0x52, 0xe1, 0xd0, 0xe7, 0x36, 0x0c, 0x47, 0xf3, 0xc1, 0x77,
+	0x39, 0xf8, 0x5f, 0x6d, 0x04, 0x0f, 0x4f, 0xe8, 0xa4, 0x70, 0x32, 0x12, 0xea, 0x42, 0xe9, 0x9d,
+	0x71, 0x65, 0x54, 0x47, 0x9e, 0x26, 0x72, 0x1c, 0xfa, 0x93, 0x24, 0xe8, 0x8b, 0xb0, 0x60, 0x27,
+	0x85, 0xa3, 0x33, 0x99, 0x1e, 0x18, 0xc3, 0xdf, 0x7e, 0xd5, 0x51, 0xa8, 0x5a, 0xc9, 0xaf, 0xd7,
+	0xc3, 0xc5, 0x1d, 0x69, 0xa6, 0x87, 0xbb, 0x18, 0xe8, 0x3b, 0xc8, 0x39, 0xce, 0x75, 0xcf, 0x9a,
+	0x19, 0x66, 0x05, 0x38, 0xde, 0x93, 0x44, 0x4b, 0x29, 0x1d, 0x2e, 0xd3, 0x49, 0x61, 0x5f, 0x1e,
+	0x61, 0x90, 0xf4, 0x6b, 0x6d, 0xd9, 0x23, 0xaa, 0x43, 0xda, 0xb6, 0x6a, 0xb2, 0x33, 0x16, 0x38,
+	0xc6, 0xa7, 0x49, 0x18, 0x8d, 0x4e, 0x7d, 0x14, 0x96, 0xed, 0xa4, 0xf0, 0x9d, 0xf9, 0xa8, 0x05,
+	0xc5, 0x99, 0x6d, 0xad, 0x96, 0x98, 0x68, 0x84, 0x79, 0x5f, 0x91, 0xe3, 0xbd, 0x48, 0xc2, 0x6b,
+	0x87, 0xe4, 0x3a, 0x29, 0x1c, 0x99, 0x87, 0xfe, 0x00, 0x07, 0xe1, 0xb1, 0x42, 0xfe, 0x61, 0x45,
+	0x4c, 0x8d, 0x54, 0x4a, 0x1c, 0xef, 0xe5, 0x7d, 0x78, 0x9e, 0x7c, 0x27, 0x85, 0x13, 0x71, 0xd0,
+	0x39, 0xec, 0xcc, 0x96, 0x86, 0xd5, 0x35, 0x2b, 0x7b, 0x1c, 0x31, 0xf1, 0xb6, 0xb6, 0x47, 0xdd,
+	0x61, 0x97, 0xe9, 0xcc, 0x95, 0x45, 0x0d, 0x80, 0x4b, 0xd5, 0xb9, 0x56, 0x34, 0xdb, 0x58, 0xd2,
+	0x4a, 0x39, 0xe1, 0x66, 0xb8, 0x71, 0x81, 0xd9, 0xbd, 0xe6, 0x4b, 0x76, 0xd2, 0x38, 0x34, 0x0f,
+	0x55, 0x21, 0x7f, 0x6d, 0xe8, 0x2e, 0x88, 0x94, 0xe0, 0x54, 0x21, 0x90, 0x4e, 0xb7, 0xe1, 0x63,
+	0x04, 0xb3, 0x90, 0x06, 0x47, 0x3a, 0x59, 0xce, 0xad, 0x5b, 0x85, 0x50, 0x6a, 0x98, 0x33, 0x67,
+	0x4c, 0x16, 0xcb, 0xb9, 0x4a, 0x49, 0x65, 0x3f, 0xc1, 0xff, 0x05, 0x5e, 0x23, 0x71, 0x42, 0x27,
+	0x8d, 0xd7, 0x40, 0xa1, 0x13, 0xc8, 0xce, 0xad, 0x59, 0x05, 0x71, 0xc4, 0xa3, 0x04, 0xc4, 0x9e,
+	0x35, 0xeb, 0xa4, 0x31, 0x13, 0x42, 0xaf, 0x60, 0x97, 0xe9, 0x68, 0xb8, 0xa2, 0x95, 0x07, 0x09,
+	0x0a, 0x15, 0xf2, 0x4c, 0x9f, 0xc3, 0x15, 0x3b, 0x8a, 0x27, 0x8c, 0x7e, 0x03, 0x79, 0x6e, 0x1f,
+	0x85, 0x98, 0x7a, 0xe5, 0x20, 0xc1, 0x81, 0xdd, 0x99, 0x9e, 0x0c, 0x53, 0x83, 0x3f, 0xa1, 0x96,
+	0x87, 0x5d, 0xd7, 0x54, 0xb5, 0x1c, 0xec, 0x08, 0x51, 0xf9, 0x21, 0x1c, 0x26, 0xc6, 0x27, 0xf9,
+	0x31, 0x3c, 0x5a, 0x1b, 0x66, 0xe4, 0x67, 0xf0, 0x64, 0x53, 0x98, 0x90, 0x8f, 0xe0, 0x20, 0xe9,
+	0xae, 0x87, 0x40, 0xef, 0xde, 0x59, 0xf9, 0x73, 0x28, 0xc7, 0x2e, 0x20, 0x0b, 0xbf, 0x73, 0x46,
+	0x4c, 0x1c, 0x62, 0xf3, 0x58, 0x9e, 0xc7, 0x01, 0x43, 0x7e, 0x04, 0x0f, 0xd7, 0xdc, 0x36, 0xb9,
+	0x0b, 0x0f, 0x12, 0x1c, 0x9d, 0xe1, 0x71, 0x7d, 0xf0, 0xfc, 0xe1, 0xe2, 0xf9, 0x0c, 0x74, 0x00,
+	0xdb, 0x37, 0xea, 0x7c, 0x25, 0x32, 0xcb, 0x36, 0x16, 0x03, 0xf9, 0x9f, 0xe0, 0xf1, 0x86, 0x3b,
+	0x73, 0x0f, 0xe4, 0x09, 0x48, 0xdd, 0x99, 0x69, 0xd9, 0x64, 0xb8, 0xa2, 0xc3, 0xab, 0xa1, 0xad,
+	0x13, 0xdb, 0x4d, 0x3f, 0x77, 0xf8, 0xe8, 0x08, 0x76, 0xf8, 0x8a, 0x4e, 0x25, 0xfb, 0x22, 0xfb,
+	0x72, 0x1b, 0xbb, 0x23, 0xf9, 0xbf, 0xd2, 0x7e, 0x6e, 0x13, 0x77, 0x0c, 0x9d, 0x0a, 0xff, 0x19,
+	0xac, 0x16, 0x7c, 0xc5, 0xbd, 0xb3, 0x83, 0x88, 0x17, 0x30, 0xa9, 0xc1, 0x6a, 0x81, 0x3d, 0x21,
+	0xf4, 0x5b, 0x80, 0xe5, 0x6a, 0x3e, 0x9f, 0x2c, 0x1b, 0xd6, 0x3b, 0x93, 0xaf, 0xbf, 0x77, 0xf6,
+	0xf4, 0xce, 0x94, 0xae, 0x39, 0xf2, 0x85, 0x70, 0x68, 0x02, 0xfa, 0x06, 0x40, 0x5c, 0xe9, 0xa6,
+	0x3e, 0x13, 0x29, 0x72, 0xef, 0xec, 0x61, 0xc2, 0x74, 0xf6, 0x19, 0x87, 0x44, 0xe5, 0x6f, 0xe0,
+	0x30, 0xf1, 0x8a, 0xa3, 0x67, 0x00, 0x0e, 0xa7, 0x42, 0x5a, 0x0b, 0x71, 0xe4, 0x57, 0x70, 0x90,
+	0x74, 0xad, 0xef, 0x9d, 0xf7, 0xbf, 0x69, 0x78, 0xb2, 0xe9, 0xfe, 0x22, 0x19, 0x8a, 0xd4, 0xa5,
+	0x43, 0x10, 0x11, 0x1e, 0x7a, 0x0d, 0x5b, 0xf4, 0x76, 0x49, 0x5c, 0x3d, 0xbd, 0x7a, 0xef, 0xe0,
+	0x70, 0xea, 0x11, 0xe3, 0xdb, 0x25, 0xc1, 0x1c, 0x43, 0x26, 0x50, 0x0c, 0x73, 0xd1, 0x3e, 0x94,
+	0x5a, 0x93, 0x5e, 0x6f, 0xaa, 0x34, 0xc7, 0xe3, 0xee, 0xa0, 0xad, 0x48, 0x29, 0x54, 0x80, 0xdd,
+	0x41, 0x73, 0x7c, 0x31, 0xc4, 0x6f, 0xa4, 0x34, 0xca, 0xc1, 0xd6, 0x45, 0xb7, 0xd5, 0x95, 0x32,
+	0x68, 0x17, 0xb2, 0x13, 0xa5, 0x26, 0x65, 0x51, 0x09, 0xf2, 0xb5, 0xde, 0xa4, 0x39, 0x1e, 0x0e,
+	0xc7, 0x1d, 0x69, 0x0b, 0x3d, 0x80, 0xf2, 0x18, 0x77, 0xdb, 0xed, 0x26, 0x9e, 0x56, 0xeb, 0xe3,
+	0xee, 0x70, 0xa0, 0x48, 0xdb, 0x72, 0x01, 0xf2, 0x7e, 0x90, 0x91, 0x97, 0x50, 0x8a, 0x44, 0x90,
+	0x9f, 0xec, 0x2e, 0x9f, 0x87, 0xef, 0xc1, 0xde, 0xd9, 0xa3, 0x3b, 0xd2, 0xc3, 0x15, 0xfd, 0x81,
+	0x09, 0x78, 0x57, 0xa4, 0x09, 0xe5, 0x58, 0xe4, 0xf9, 0xa0, 0x9b, 0xf6, 0x0e, 0x8e, 0x59, 0x58,
+	0xc0, 0xec, 0x6a, 0x39, 0xd4, 0x53, 0xaf, 0x42, 0x2d, 0x5b, 0x9d, 0x71, 0xd3, 0x8d, 0x13, 0x4c,
+	0x17, 0xe6, 0xa1, 0xaf, 0x21, 0xe7, 0xb8, 0xd3, 0x38, 0x74, 0x21, 0xb6, 0xf9, 0x0b, 0xa3, 0x65,
+	0x78, 0xb8, 0xd8, 0x17, 0x95, 0xff, 0x35, 0x0b, 0xc5, 0xf0, 0x27, 0x56, 0x62, 0x9a, 0xc1, 0x1a,
+	0x9c, 0x66, 0x65, 0xa2, 0x6e, 0x38, 0xac, 0xee, 0xd3, 0xdd, 0x2b, 0xec, 0x8f, 0x99, 0x5f, 0xda,
+	0x64, 0xb6, 0x9a, 0xab, 0xd4, 0xb2, 0x6f, 0xf9, 0x0d, 0xc9, 0xe3, 0x10, 0x07, 0x7d, 0x0f, 0xc5,
+	0x77, 0x96, 0xfd, 0xd6, 0x30, 0x67, 0xd3, 0x85, 0xa5, 0x8b, 0x4a, 0x72, 0x2f, 0x16, 0xbb, 0xd9,
+	0x06, 0x2e, 0x84, 0x50, 0xdf, 0xd2, 0x09, 0x2e, 0xbc, 0x0b, 0x06, 0xe8, 0x15, 0xe4, 0xd5, 0x15,
+	0xbd, 0x16, 0xb3, 0xb7, 0x13, 0xcc, 0xc2, 0x66, 0x57, 0x57, 0xf4, 0x9a, 0x4f, 0xcd, 0xa9, 0x2e,
+	0xc5, 0xaa, 0x5e, 0xed, 0x5a, 0x35, 0x4d, 0x32, 0xe7, 0x85, 0x64, 0x09, 0x7b, 0x43, 0x74, 0x0a,
+	0x3b, 0xea, 0x72, 0x5a, 0x53, 0x14, 0xb7, 0x08, 0x7c, 0x78, 0x07, 0xae, 0xa6, 0x28, 0xf5, 0xab,
+	0x19, 0xde, 0x56, 0x97, 0x35, 0x45, 0x41, 0xdf, 0x43, 0x59, 0x9b, 0x1b, 0xc4, 0xa4, 0x6c, 0xce,
+	0x74, 0x6e, 0x38, 0xb4, 0x92, 0xe3, 0xa5, 0xfb, 0xda, 0x89, 0x25, 0x21, 0x5f, 0x53, 0x94, 0x9e,
+	0xe1, 0x50, 0xf4, 0x98, 0x27, 0x72, 0x32, 0x75, 0x1c, 0x43, 0xe7, 0xd5, 0x5c, 0x0e, 0xe7, 0x18,
+	0x43, 0x71, 0x0c, 0x9d, 0xc5, 0x3e, 0x93, 0xfc, 0xb8, 0xb0, 0x4c, 0x5e, 0xb3, 0xe4, 0xb0, 0x3b,
+	0x92, 0xff, 0x3d, 0x0d, 0x79, 0x6e, 0x19, 0xca, 0x6e, 0xef, 0x29, 0x6c, 0x71, 0x05, 0x08, 0x2f,
+	0x3e, 0xbe, 0x6b, 0x5a, 0x26, 0xc5, 0x35, 0xc0, 0xe5, 0xc2, 0xa7, 0xcf, 0x44, 0x4f, 0x8f, 0x60,
+	0x8b, 0xef, 0x43, 0x98, 0x8a, 0xd3, 0xa8, 0x0e, 0x65, 0x6d, 0x65, 0xdb, 0xc4, 0xf4, 0x5d, 0x8f,
+	0xdb, 0x69, 0xa3, 0x0f, 0xc5, 0x67, 0xc8, 0x67, 0x00, 0x81, 0x0a, 0xd8, 0x32, 0x8a, 0xd2, 0x6d,
+	0x78, 0x7e, 0xc4, 0x68, 0x24, 0x41, 0x76, 0xa4, 0xbc, 0x71, 0x5f, 0x2f, 0x8c, 0x94, 0x3f, 0x81,
+	0x92, 0x42, 0x6d, 0x66, 0x6a, 0xe2, 0x38, 0xcc, 0xd5, 0x25, 0xc8, 0x2e, 0x9c, 0x99, 0x3b, 0x8b,
+	0x91, 0xf2, 0x17, 0x80, 0x22, 0x22, 0x55, 0xdb, 0x56, 0x6f, 0x99, 0x4b, 0x2e, 0x9c, 0x19, 0xa7,
+	0xf9, 0x3b, 0x2a, 0x8f, 0xfd, 0xb1, 0x7c, 0x0a, 0xc5, 0xe6, 0x0d, 0x31, 0xa9, 0x7b, 0x9b, 0x98,
+	0x8b, 0x32, 0xa3, 0x11, 0x93, 0xc5, 0x21, 0x0e, 0x9d, 0xc5, 0x21, 0x8e, 0xac, 0x02, 0x70, 0x79,
+	0x7e, 0xb1, 0xd1, 0x31, 0xec, 0x52, 0x87, 0x2f, 0x28, 0x76, 0xd1, 0x49, 0x61, 0x8f, 0x81, 0x8e,
+	0x60, 0x9b, 0x5e, 0x5a, 0x96, 0xd0, 0x69, 0xae, 0x93, 0xc2, 0x62, 0x88, 0x2a, 0xb0, 0x43, 0x0d,
+	0x93, 0xbe, 0x3a, 0xe7, 0x5a, 0xcd, 0xb2, 0x4a, 0x50, 0x8c, 0x6b, 0xdb, 0x90, 0xbd, 0x51, 0xe7,
+	0x72, 0x0f, 0xb6, 0xf9, 0x12, 0x4c, 0x2d, 0x34, 0xd8, 0x05, 0xa7, 0xd1, 0xe7, 0x7e, 0xf6, 0xcb,
+	0x24, 0xb8, 0x55, 0xb0, 0x35, 0x3f, 0x2d, 0xfe, 0x11, 0x0e, 0xd8, 0xdd, 0x6f, 0x18, 0xf6, 0xd0,
+	0x6e, 0x19, 0x73, 0xe2, 0x1d, 0x54, 0x82, 0xac, 0x6e, 0x78, 0xd5, 0x02, 0x23, 0x99, 0x73, 0x2d,
+	0x6d, 0x72, 0x65, 0xfc, 0xe8, 0x2a, 0xdd, 0x1d, 0x31, 0x95, 0x58, 0xe6, 0xfc, 0xb6, 0x65, 0xcd,
+	0x59, 0x5a, 0x16, 0x4f, 0xbf, 0x10, 0x87, 0xa5, 0xaf, 0xd8, 0x0a, 0xce, 0xd2, 0x32, 0x1d, 0x22,
+	0xae, 0xbb, 0xb3, 0x9a, 0xd3, 0x91, 0x4a, 0xaf, 0xbd, 0x34, 0x14, 0x70, 0xe4, 0x7f, 0x49, 0x43,
+	0x19, 0x13, 0x55, 0x0f, 0x6f, 0xeb, 0x6b, 0xd8, 0xb9, 0x12, 0x0b, 0xa5, 0x13, 0xf2, 0x6f, 0x55,
+	0xd3, 0x88, 0xe3, 0x18, 0x97, 0x73, 0x22, 0xd6, 0xc6, 0xae, 0x30, 0x33, 0xf1, 0x95, 0x31, 0x27,
+	0x66, 0xf0, 0xe0, 0xf5, 0xc7, 0x2c, 0x8a, 0x3a, 0x2c, 0x3f, 0x0a, 0x7d, 0x63, 0x31, 0x60, 0xe7,
+	0x9f, 0x13, 0x93, 0xbb, 0x6e, 0x16, 0x33, 0x52, 0x6e, 0x80, 0x14, 0xec, 0xc6, 0x3d, 0xc2, 0x13,
+	0xc8, 0xdb, 0x44, 0xd5, 0xeb, 0xd6, 0xca, 0xa4, 0xae, 0x1d, 0x02, 0x06, 0x33, 0x90, 0xae, 0x52,
+	0x95, 0xaf, 0x58, 0xc4, 0x9c, 0x96, 0xff, 0x23, 0x0d, 0xd2, 0x85, 0x6d, 0x50, 0xf2, 0x17, 0x3e,
+	0xd5, 0x11, 0x0b, 0x4c, 0x4b, 0x56, 0xe1, 0x0a, 0x8b, 0xb8, 0x23, 0x16, 0xff, 0x17, 0x2b, 0x87,
+	0x0e, 0x2c, 0xda, 0xfc, 0x91, 0x45, 0x1f, 0xf1, 0x1a, 0x8f, 0xf0, 0xfc, 0x7d, 0x6f, 0x87, 0xf6,
+	0xfd, 0x73, 0x28, 0xb3, 0x1d, 0x77, 0xcd, 0x2b, 0xcb, 0xdb, 0x35, 0x82, 0xad, 0x65, 0x60, 0x39,
+	0x4e, 0xcb, 0x7f, 0x06, 0x29, 0x10, 0x73, 0x95, 0x94, 0x94, 0x06, 0x58, 0xe4, 0x30, 0xfe, 0x51,
+	0x6c, 0x3b, 0x8b, 0x39, 0xcd, 0x78, 0x3c, 0x2e, 0x65, 0x79, 0x90, 0xf1, 0x63, 0xcf, 0xc2, 0xd2,
+	0xc7, 0xc6, 0x82, 0xb8, 0xa6, 0xf0, 0x86, 0xcc, 0x6c, 0x86, 0xd3, 0x30, 0x6c, 0xbe, 0xcb, 0x1c,
+	0x16, 0x03, 0xf9, 0xef, 0x41, 0xf2, 0xeb, 0x9c, 0xd0, 0x9d, 0x15, 0xc5, 0x4d, 0xd8, 0xcf, 0x02,
+	0x0e, 0xfa, 0x0c, 0xf6, 0xa8, 0xb1, 0x20, 0xd6, 0x8a, 0x2a, 0x44, 0xb3, 0x4c, 0xdd, 0x71, 0xc3,
+	0x5c, 0x8c, 0x2b, 0x3f, 0x83, 0xa2, 0x8f, 0xfd, 0xda, 0xba, 0x8c, 0xf7, 0x46, 0xe4, 0x4f, 0x43,
+	0x6b, 0xbf, 0xb6, 0x2e, 0x79, 0xb8, 0x96, 0x20, 0x6b, 0xe8, 0xa2, 0x3d, 0x53, 0xc2, 0x8c, 0x94,
+	0x7f, 0x80, 0x4a, 0xa7, 0xdb, 0xc0, 0x2b, 0xd3, 0x34, 0xcc, 0xd9, 0x6b, 0xeb, 0x92, 0x47, 0x5b,
+	0xcc, 0xbd, 0x3e, 0x84, 0x98, 0xe5, 0xdd, 0x16, 0x04, 0x5b, 0x37, 0x8b, 0xae, 0xee, 0x69, 0x89,
+	0xd1, 0xcc, 0xb0, 0x8e, 0xb5, 0xb2, 0x35, 0xe2, 0x46, 0x5d, 0x77, 0x24, 0xff, 0x19, 0xca, 0xa1,
+	0x93, 0x73, 0xb8, 0x5f, 0x42, 0xf6, 0x4f, 0xd6, 0x25, 0xc7, 0x8b, 0x87, 0xdf, 0xf0, 0x46, 0x31,
+	0x93, 0x62, 0x5a, 0x32, 0x9c, 0x96, 0x61, 0x1a, 0xce, 0xb5, 0x9f, 0x9a, 0x43, 0x9c, 0xe0, 0xb6,
+	0xbe, 0x76, 0x2c, 0x33, 0x48, 0xce, 0x1e, 0x47, 0x3e, 0x85, 0x42, 0xaf, 0xd9, 0xf0, 0x73, 0xff,
+	0x73, 0x28, 0x5c, 0xce, 0x0d, 0xf3, 0xed, 0x54, 0xf3, 0xef, 0x46, 0x09, 0x03, 0x67, 0xf1, 0xcb,
+	0x21, 0xff, 0xf7, 0x16, 0xec, 0x89, 0x37, 0x8f, 0x3f, 0xa7, 0x02, 0xbb, 0xc4, 0x14, 0xa5, 0x41,
+	0x5a, 0x34, 0x97, 0xdc, 0x21, 0x53, 0xe3, 0x8d, 0xa1, 0x7b, 0xd1, 0xfe, 0xc6, 0xe0, 0x9c, 0xa5,
+	0x9f, 0x79, 0x18, 0xc9, 0x3d, 0x5b, 0x35, 0x57, 0x57, 0xaa, 0x46, 0x57, 0x36, 0xb1, 0xb9, 0xbf,
+	0xe4, 0x71, 0x84, 0xc7, 0x56, 0x58, 0xda, 0x96, 0xbe, 0xd2, 0x28, 0x77, 0x9b, 0x3c, 0xf6, 0x86,
+	0x5c, 0xad, 0xc4, 0x36, 0x54, 0x91, 0xe1, 0x99, 0x5a, 0xf9, 0x08, 0x3d, 0x83, 0xc2, 0xca, 0x21,
+	0xd3, 0x7a, 0xa3, 0x3e, 0x6d, 0xd6, 0xfb, 0x3c, 0xcb, 0xe7, 0x70, 0x7e, 0xe5, 0x90, 0x7a, 0xa3,
+	0xde, 0xac, 0xf7, 0x59, 0x3e, 0x66, 0xdf, 0xf1, 0xa0, 0xd1, 0x55, 0x78, 0xb7, 0x26, 0x87, 0x73,
+	0x2b, 0x87, 0xf0, 0x31, 0x7a, 0x09, 0x12, 0xfb, 0xd8, 0xe9, 0x36, 0xa6, 0x6f, 0x9a, 0x7f, 0x57,
+	0x1b, 0x56, 0x71, 0xc3, 0xcd, 0xd9, 0x7b, 0x2b, 0x87, 0x74, 0xba, 0x0d, 0x8f, 0x8b, 0x64, 0x28,
+	0x79, 0x92, 0xfd, 0xe1, 0x44, 0x69, 0xf2, 0xc6, 0x4a, 0x0e, 0x17, 0x84, 0x18, 0x67, 0x79, 0x5b,
+	0x61, 0x32, 0xb8, 0x7a, 0xc1, 0xdb, 0x26, 0x62, 0x2b, 0xcc, 0x9f, 0xaa, 0x17, 0xe8, 0x21, 0xec,
+	0xb2, 0xef, 0x93, 0xbe, 0xc2, 0x5b, 0x20, 0x39, 0xbc, 0xb3, 0x72, 0xc8, 0xa4, 0xaf, 0xa0, 0xa7,
+	0x00, 0xec, 0x83, 0xd2, 0xc4, 0xdd, 0x6a, 0xcf, 0x2d, 0x0d, 0xd8, 0x3c, 0xc1, 0x40, 0xaf, 0x61,
+	0xcf, 0x36, 0x75, 0xc3, 0x99, 0xfa, 0x45, 0x9f, 0xe8, 0x4f, 0xfc, 0x2c, 0x5a, 0xb1, 0x46, 0x6c,
+	0xd5, 0xa4, 0xd7, 0xc4, 0x36, 0x09, 0xc5, 0x25, 0x3e, 0xd5, 0x37, 0x61, 0x1f, 0x24, 0x4d, 0xd7,
+	0xa6, 0x44, 0x5b, 0x04, 0x68, 0xe5, 0xf7, 0x47, 0xdb, 0xd3, 0x74, 0xad, 0xa9, 0x2d, 0x7c, 0xb8,
+	0x2a, 0x14, 0x57, 0x8b, 0xd0, 0xc6, 0x44, 0xe7, 0xe2, 0xd9, 0x06, 0xa8, 0x49, 0x5f, 0xc1, 0x85,
+	0xd5, 0xc2, 0xdf, 0x91, 0x3c, 0x82, 0xa3, 0xe4, 0xc5, 0x78, 0x29, 0x65, 0x39, 0x74, 0xaa, 0xea,
+	0xba, 0x97, 0xe8, 0x72, 0x8c, 0x51, 0xd5, 0x75, 0x1b, 0x3d, 0x82, 0x9c, 0x4e, 0x6e, 0xc4, 0x37,
+	0xe1, 0x76, 0xbb, 0x3a, 0xb9, 0x61, 0x9f, 0xe4, 0xdf, 0xc2, 0xfe, 0x9d, 0x35, 0x59, 0x38, 0xd2,
+	0x74, 0xdb, 0x5a, 0xb8, 0x9e, 0x2b, 0x06, 0xec, 0x02, 0xb3, 0x88, 0xec, 0x35, 0x59, 0x19, 0x2d,
+	0x4f, 0xe1, 0x13, 0xf1, 0xf2, 0x21, 0xba, 0xb7, 0x95, 0xae, 0x49, 0x89, 0x7d, 0xa5, 0x6a, 0xc4,
+	0x3f, 0xf8, 0x77, 0xb0, 0xc5, 0x8b, 0x43, 0xd1, 0xd7, 0x8d, 0xf6, 0xeb, 0xd6, 0xce, 0xc2, 0x7c,
+	0x8e, 0xfc, 0xcf, 0x59, 0x78, 0xb4, 0x1e, 0x39, 0x29, 0x1a, 0x7f, 0xef, 0x46, 0x5e, 0xf1, 0x52,
+	0xf9, 0xe5, 0xfb, 0xad, 0x76, 0x1a, 0x2a, 0x11, 0x59, 0xf0, 0x58, 0x32, 0xe5, 0x10, 0xc7, 0x39,
+	0xf7, 0x82, 0x43, 0xc0, 0x61, 0x99, 0xca, 0x24, 0x74, 0xa1, 0x3a, 0x6f, 0xcf, 0xdd, 0x7b, 0xe9,
+	0x8f, 0xc3, 0xb7, 0x7e, 0x3b, 0x7a, 0xeb, 0x87, 0x80, 0xf4, 0x6b, 0x6d, 0xa9, 0x10, 0xfb, 0x86,
+	0xd8, 0x7e, 0x35, 0x29, 0x5a, 0xb9, 0xcf, 0x23, 0x9b, 0x6c, 0x74, 0xea, 0xa3, 0xa8, 0x18, 0x4e,
+	0x98, 0x8a, 0x3e, 0x85, 0x92, 0xe7, 0x4a, 0x5d, 0x73, 0xe2, 0x10, 0xf7, 0x3a, 0x47, 0x99, 0x72,
+	0x1d, 0xb6, 0x78, 0xd5, 0x0f, 0xb0, 0xd3, 0xaf, 0x0e, 0x26, 0xd5, 0x9e, 0x94, 0x42, 0x65, 0x28,
+	0xb0, 0x35, 0xa6, 0xf5, 0x5e, 0xb7, 0x39, 0x18, 0x4b, 0x69, 0x9f, 0xa1, 0x34, 0xf1, 0x0f, 0x4d,
+	0x2c, 0x65, 0xd8, 0x03, 0x73, 0x32, 0xe8, 0x57, 0x07, 0xd5, 0x76, 0xb3, 0x21, 0x65, 0xe5, 0xff,
+	0xcb, 0x02, 0xba, 0xbb, 0xab, 0xa0, 0x7e, 0x1c, 0x59, 0xb6, 0x1f, 0x15, 0x03, 0x0e, 0x7a, 0x09,
+	0x65, 0x31, 0xf2, 0xd5, 0xed, 0xfa, 0x4e, 0x9c, 0xcd, 0x9b, 0x3a, 0x44, 0x75, 0x78, 0x1d, 0xe1,
+	0x6a, 0x3c, 0x60, 0xa0, 0x13, 0x90, 0x4c, 0x8b, 0xb2, 0xa7, 0x8c, 0x65, 0x1b, 0x54, 0xe5, 0x5d,
+	0x79, 0x91, 0xea, 0xef, 0xf0, 0xd1, 0x29, 0x20, 0xdd, 0x1a, 0x58, 0xb4, 0x66, 0x98, 0x7a, 0xb0,
+	0xac, 0xb0, 0x45, 0xc2, 0x17, 0x96, 0x2f, 0x35, 0x75, 0x3e, 0xbf, 0x54, 0xb5, 0xb7, 0x6e, 0x43,
+	0x51, 0x84, 0xcc, 0x18, 0x17, 0x9d, 0xc3, 0x8e, 0xad, 0x9a, 0x33, 0xe2, 0x54, 0x76, 0xb9, 0x17,
+	0x3f, 0x59, 0x63, 0x32, 0xcc, 0x84, 0xb0, 0x2b, 0x8b, 0x5a, 0xb0, 0x6b, 0x2d, 0xc5, 0x8f, 0x1a,
+	0xe2, 0x65, 0xf4, 0xd7, 0xf7, 0x58, 0xfa, 0x74, 0x28, 0xc4, 0x9b, 0x26, 0xb5, 0x6f, 0xb1, 0x37,
+	0x19, 0xd5, 0xa1, 0xe0, 0xb0, 0x03, 0x6a, 0x1d, 0xcb, 0xa1, 0x4e, 0x25, 0xcf, 0xb1, 0x3e, 0x59,
+	0x87, 0xe5, 0x4b, 0xe2, 0xf0, 0xac, 0xe3, 0xef, 0xa0, 0x18, 0x46, 0x67, 0x59, 0xe7, 0x2d, 0xb9,
+	0x75, 0xed, 0xc6, 0xc8, 0xe8, 0x1b, 0x3c, 0xef, 0xbe, 0xc1, 0xbf, 0xcb, 0x7c, 0x9b, 0x96, 0x2d,
+	0x28, 0xc7, 0xce, 0xc8, 0x73, 0x28, 0x23, 0x7a, 0xd6, 0x3b, 0xbf, 0x13, 0x17, 0xe2, 0xf8, 0xdf,
+	0x27, 0xcb, 0x25, 0xf1, 0xc2, 0x4e, 0x88, 0xe3, 0xdb, 0x9c, 0xd7, 0x43, 0x61, 0x9b, 0x33, 0x86,
+	0xfc, 0x2d, 0x1c, 0x24, 0x9d, 0x88, 0xbf, 0x83, 0x54, 0xcd, 0x7f, 0x07, 0xa9, 0x1a, 0xaf, 0x33,
+	0x96, 0x2e, 0x7e, 0xc6, 0x58, 0xca, 0xbb, 0xb0, 0xdd, 0x5c, 0x2c, 0xe9, 0xed, 0xc9, 0xaf, 0x40,
+	0x8a, 0xf7, 0xb0, 0xd0, 0x0e, 0x64, 0x26, 0x23, 0x29, 0x85, 0x72, 0xb0, 0xd5, 0x18, 0x5e, 0x0c,
+	0xa4, 0x34, 0xda, 0x85, 0xec, 0xb0, 0xd5, 0x92, 0x32, 0x27, 0x9f, 0x03, 0x04, 0x3d, 0x2b, 0x76,
+	0x5f, 0x70, 0x57, 0xe9, 0x0e, 0xda, 0xa2, 0x1d, 0xd3, 0xaa, 0xf6, 0x7a, 0x6c, 0xc0, 0xdb, 0x31,
+	0xb5, 0xe1, 0xb8, 0x23, 0x65, 0x4e, 0xfe, 0x27, 0x0d, 0xbb, 0x6e, 0xa3, 0x04, 0xe5, 0x61, 0x7b,
+	0x30, 0xe9, 0x4f, 0xbf, 0x94, 0x52, 0x1e, 0x79, 0x26, 0xa5, 0x3d, 0xf2, 0x2b, 0x29, 0xe3, 0x91,
+	0xe7, 0x52, 0xd6, 0x23, 0xbf, 0x96, 0xb6, 0x3c, 0xf2, 0x95, 0xb4, 0xed, 0x91, 0xdf, 0x48, 0x3b,
+	0x1e, 0xf9, 0xad, 0xb4, 0xeb, 0x91, 0xbf, 0x96, 0x72, 0x6c, 0x47, 0x7c, 0x89, 0x2f, 0xa4, 0xbc,
+	0x4f, 0x7f, 0x29, 0x81, 0x4f, 0x9f, 0x49, 0x05, 0x9f, 0xfe, 0x4a, 0x2a, 0xfa, 0xf4, 0xb9, 0x54,
+	0xf2, 0xe9, 0xaf, 0xa5, 0x3d, 0x9f, 0x7e, 0x25, 0x95, 0x7d, 0xfa, 0x1b, 0x49, 0xf2, 0xe9, 0x6f,
+	0xa5, 0x7d, 0x9f, 0xfe, 0xb5, 0x84, 0x3c, 0xfa, 0xec, 0x0b, 0xe9, 0xc1, 0xc9, 0xaf, 0xa0, 0x18,
+	0x6e, 0xf6, 0x30, 0xe5, 0xf5, 0x86, 0x17, 0x42, 0x9f, 0x9d, 0x6e, 0xbb, 0x23, 0xa5, 0x99, 0xf8,
+	0x78, 0xd8, 0x6e, 0xf7, 0x9a, 0x52, 0xe6, 0xa4, 0x01, 0xe5, 0x58, 0x0b, 0x83, 0xe9, 0x72, 0x32,
+	0x78, 0x33, 0x60, 0xba, 0x4f, 0x31, 0x6b, 0x54, 0x47, 0xc2, 0x06, 0xca, 0xb8, 0x2a, 0x65, 0xd0,
+	0x03, 0x28, 0x2b, 0xe3, 0xea, 0xb4, 0x55, 0xed, 0xf6, 0x86, 0x3f, 0x34, 0xf1, 0xb4, 0x3a, 0x92,
+	0xb2, 0x27, 0x0d, 0x28, 0x45, 0x5e, 0xf2, 0xe8, 0x10, 0xf6, 0x99, 0xd4, 0x60, 0x38, 0x9e, 0xd6,
+	0x87, 0x83, 0x41, 0xb3, 0x3e, 0x6e, 0x36, 0x84, 0xe2, 0xab, 0xa3, 0xe9, 0x84, 0x01, 0xee, 0x43,
+	0x89, 0x49, 0x04, 0x5f, 0x33, 0x27, 0x9f, 0x89, 0x7e, 0x8e, 0xd7, 0x10, 0x41, 0x45, 0xc8, 0x5d,
+	0x8c, 0xaa, 0x67, 0xd3, 0x91, 0xf2, 0x46, 0xec, 0x7f, 0x38, 0x6a, 0x0e, 0xa4, 0xf4, 0xc9, 0xdf,
+	0x80, 0x14, 0x7f, 0xa3, 0xb0, 0xfd, 0x8d, 0xfb, 0xcc, 0x6d, 0x24, 0x28, 0xd6, 0xaa, 0x4a, 0x67,
+	0xaa, 0xd4, 0x71, 0x77, 0x34, 0x56, 0x44, 0xe8, 0x64, 0x35, 0x8c, 0xc7, 0xc8, 0x9c, 0xfd, 0xdb,
+	0x31, 0xec, 0x8c, 0xce, 0x2f, 0x06, 0xa3, 0x2f, 0x51, 0x1f, 0x2a, 0x6d, 0x42, 0xbd, 0xfc, 0x18,
+	0x49, 0xb3, 0x08, 0x45, 0xf3, 0x12, 0x73, 0xd8, 0xe3, 0xc7, 0x1b, 0x4a, 0x01, 0x39, 0x85, 0x3a,
+	0xf0, 0x40, 0x60, 0x7d, 0x34, 0x52, 0x0b, 0xf6, 0xdb, 0x84, 0xc6, 0x0a, 0xd6, 0x0f, 0xc0, 0x19,
+	0xc2, 0xbe, 0x72, 0x07, 0x67, 0xd3, 0x9c, 0xfb, 0x00, 0x7f, 0x07, 0x7b, 0x6d, 0x42, 0xc3, 0xa5,
+	0x77, 0xd2, 0xae, 0x2a, 0x11, 0x5e, 0x48, 0x5a, 0x20, 0x28, 0x51, 0x84, 0xb5, 0xd2, 0xc7, 0x09,
+	0xd8, 0x72, 0x0a, 0x35, 0xa0, 0xd8, 0x67, 0x45, 0xfd, 0xa4, 0xaf, 0xf0, 0xec, 0x73, 0x4f, 0x81,
+	0xb6, 0x06, 0x65, 0x0a, 0xcf, 0x85, 0xb1, 0xd6, 0x17, 0x2f, 0xef, 0x59, 0x08, 0xad, 0x59, 0xc0,
+	0x82, 0x5f, 0xb4, 0x09, 0xad, 0xce, 0xe7, 0xf7, 0xd7, 0x5f, 0x49, 0x3a, 0x3c, 0x8d, 0x26, 0x8f,
+	0xfb, 0x30, 0xe4, 0x14, 0x9a, 0xc3, 0xa7, 0x21, 0x6f, 0x5e, 0xbf, 0x5a, 0xb4, 0x07, 0x17, 0x69,
+	0x51, 0x1d, 0xbf, 0xe7, 0x91, 0xe5, 0x14, 0xea, 0xf3, 0xf7, 0x29, 0x5e, 0x99, 0x6e, 0xfe, 0x7d,
+	0x9a, 0xfc, 0xe2, 0x73, 0x9f, 0xc5, 0xc7, 0x4f, 0xd6, 0x7d, 0x66, 0x4f, 0x3a, 0x0e, 0x57, 0x0e,
+	0xc3, 0xb1, 0x17, 0xef, 0x3d, 0x88, 0xeb, 0x9f, 0x98, 0x72, 0x0a, 0x61, 0x38, 0xec, 0x74, 0x1b,
+	0x6d, 0x42, 0x83, 0x77, 0xa7, 0x78, 0xa5, 0xae, 0x9f, 0x75, 0xef, 0x16, 0x9b, 0x80, 0x3a, 0xdd,
+	0x46, 0x5d, 0x35, 0x35, 0x32, 0x0f, 0x76, 0xb9, 0x01, 0x30, 0xd9, 0x2f, 0x06, 0xf0, 0x50, 0x6c,
+	0xcd, 0x7d, 0x95, 0xfb, 0xf2, 0xc9, 0x7e, 0xf0, 0x74, 0x2d, 0x3e, 0x7b, 0xf2, 0xcb, 0x29, 0x54,
+	0x83, 0x23, 0x7f, 0x5b, 0xd5, 0xf9, 0xfc, 0x1e, 0xb8, 0xe4, 0x3d, 0xfd, 0xde, 0x53, 0x57, 0xac,
+	0x53, 0xb0, 0xe9, 0x74, 0x3f, 0x8f, 0x7f, 0x4a, 0xec, 0x32, 0xf0, 0x0d, 0x16, 0x5a, 0x8a, 0xdf,
+	0x85, 0x8a, 0x99, 0x35, 0xde, 0x9d, 0x5a, 0xb3, 0xc1, 0x37, 0x00, 0x2d, 0xc5, 0x6b, 0x88, 0xa1,
+	0xa8, 0xa5, 0x62, 0x5d, 0xbb, 0x98, 0xc6, 0xe2, 0x5d, 0x34, 0x6e, 0x81, 0x52, 0x4b, 0x69, 0x13,
+	0xea, 0xf5, 0x8e, 0x62, 0x78, 0xb1, 0xce, 0x53, 0x0c, 0x2f, 0xde, 0x70, 0x92, 0x53, 0xe8, 0x8f,
+	0x70, 0xd8, 0x52, 0xea, 0x36, 0x51, 0x29, 0x89, 0xf4, 0x1e, 0x51, 0xec, 0x9f, 0x14, 0x09, 0x9d,
+	0xcf, 0x63, 0x79, 0x93, 0x88, 0xbf, 0xc2, 0xef, 0xa0, 0xc0, 0xbb, 0xa9, 0x3d, 0x5e, 0x96, 0xc7,
+	0xac, 0x12, 0x6e, 0x19, 0xc7, 0xd5, 0xc7, 0x3e, 0xc9, 0xa9, 0x2f, 0xd2, 0xa8, 0x0d, 0x85, 0xa6,
+	0x76, 0xed, 0x77, 0xd3, 0x36, 0xc5, 0x80, 0x0d, 0xdf, 0xe4, 0x14, 0xea, 0x02, 0x12, 0x21, 0x26,
+	0xf2, 0xe3, 0xcb, 0xfa, 0x76, 0xfb, 0xf1, 0x51, 0x72, 0xcb, 0x5f, 0x4e, 0xa1, 0xdf, 0x40, 0xb1,
+	0x4d, 0x68, 0xf0, 0x53, 0x41, 0x92, 0xbf, 0xae, 0x9f, 0xdd, 0x82, 0x23, 0xa1, 0x0e, 0x9f, 0x59,
+	0xbf, 0x16, 0x45, 0xfd, 0x4f, 0xc3, 0xc1, 0xb0, 0xaf, 0x50, 0xcb, 0x26, 0x17, 0xc6, 0x55, 0x70,
+	0x9e, 0x5f, 0xc4, 0xc4, 0xd7, 0xfd, 0xc2, 0xb5, 0xc6, 0x5d, 0x47, 0x70, 0xc8, 0x62, 0x0f, 0x83,
+	0xd5, 0x23, 0xb8, 0x9b, 0xf4, 0xbe, 0x5e, 0x87, 0x1c, 0xb1, 0xe2, 0xfe, 0x82, 0xf9, 0xd3, 0x40,
+	0xd7, 0x9f, 0xbb, 0x0f, 0x8f, 0x38, 0x96, 0x97, 0x30, 0xde, 0x1b, 0x32, 0xf9, 0xc8, 0x43, 0x61,
+	0x8e, 0x84, 0xed, 0x25, 0x99, 0xe3, 0xf9, 0x7a, 0x7c, 0xf1, 0x53, 0x08, 0xb3, 0xcb, 0xe3, 0x50,
+	0x3a, 0xbb, 0xf3, 0xaf, 0xb4, 0xfb, 0x63, 0x65, 0x7c, 0x0a, 0x4f, 0xfa, 0x4f, 0x05, 0x60, 0xfc,
+	0x1b, 0x26, 0xcb, 0x39, 0x7b, 0x6d, 0x6e, 0x46, 0xb8, 0x7f, 0x81, 0xdf, 0xc3, 0xa3, 0xe4, 0x05,
+	0xaa, 0xba, 0xfe, 0xd1, 0xe0, 0x7f, 0x80, 0x27, 0xeb, 0x76, 0xbf, 0xb0, 0x6e, 0x3e, 0x7e, 0xf3,
+	0x63, 0x78, 0x1c, 0x98, 0x30, 0xfe, 0xfd, 0x83, 0xed, 0xd8, 0x83, 0x43, 0x8e, 0x78, 0xc7, 0x82,
+	0xf7, 0x6c, 0x37, 0xd9, 0xcd, 0x2e, 0xe1, 0x67, 0xe1, 0x7b, 0xb0, 0xce, 0x8e, 0x9b, 0xfc, 0xf7,
+	0x3d, 0xf4, 0xfc, 0x7c, 0xd3, 0x1a, 0xcc, 0x94, 0x1f, 0x85, 0xdf, 0x87, 0x83, 0x40, 0xcf, 0x7e,
+	0x4e, 0xfd, 0x60, 0x05, 0x0f, 0xe0, 0x30, 0x80, 0x0b, 0xfe, 0xb0, 0xf1, 0xa1, 0x78, 0x97, 0x3b,
+	0xfc, 0x7f, 0xa1, 0x5f, 0xfd, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xaa, 0xe7, 0x13, 0x02, 0x25,
+	0x2a, 0x00, 0x00,
 }
diff --git a/proto/grpc.proto b/proto/grpc.proto
index 32c0f0c..a277901 100644
--- a/proto/grpc.proto
+++ b/proto/grpc.proto
@@ -221,7 +221,6 @@ enum WiFiAuthMode {
     OPEN = 1; //Open System Authentication (no authentication)
 }
 
-
 message WiFiSettings {
     /* Generic */
     string name = 1; //for template storage
@@ -289,21 +288,30 @@ message TempDirOrFileResponse {
     string resultPath = 1;
 }
 
+enum AccessibleFolder {
+    TMP = 0;
+    BASH_SCRIPTS = 1;
+    HID_SCRIPTS = 2;
+}
+
 message ReadFileRequest {
-    string path = 1;
-    int64 start = 2;
-    bytes data = 3;
+    AccessibleFolder folder = 1;
+    string filename = 2;
+    int64 start = 3;
+    int64 len = 4;
 }
 
 message ReadFileResponse {
     int64 readCount = 1;
+    bytes data = 2;
 }
 
 message WriteFileRequest {
-    string path = 1;
-    bool append = 2;
-    bool mustNotExist = 3;
-    bytes data = 4;
+    AccessibleFolder folder = 1;
+    string filename = 2;
+    bool append = 3;
+    bool mustNotExist = 4;
+    bytes data = 5;
 }
 
 message FileInfoRequest {
diff --git a/service/rpc_server.go b/service/rpc_server.go
index aafb0d5..77e6cce 100644
--- a/service/rpc_server.go
+++ b/service/rpc_server.go
@@ -6,6 +6,7 @@ import (
 	pb "github.com/mame82/P4wnP1_go/proto"
 	"golang.org/x/net/context"
 	"google.golang.org/grpc"
+	"io"
 	"log"
 	"net"
 	"encoding/json"
@@ -256,13 +257,44 @@ func (s *server) EventListen(eReq *pb.EventRequest, eStream pb.P4WNP1_EventListe
 }
 
 func (s *server) FSWriteFile(ctx context.Context, req *pb.WriteFileRequest) (empty *pb.Empty, err error) {
-	return &pb.Empty{}, common.WriteFile(req.Path, req.MustNotExist, req.Append, req.Data)
+	filePath := "/" + req.Filename
+	switch req.Folder {
+	case pb.AccessibleFolder_TMP:
+		filePath = "/tmp" + filePath
+	case pb.AccessibleFolder_BASH_SCRIPTS:
+		filePath = PATH_BASH_SCRIPTS + filePath
+	case pb.AccessibleFolder_HID_SCRIPTS:
+		filePath = PATH_HID_SCRIPTS + filePath
+	default:
+		err = errors.New("Unknown folder")
+		return
+	}
+
+	return &pb.Empty{}, common.WriteFile(filePath, req.MustNotExist, req.Append, req.Data)
 
 }
 
 func (s *server) FSReadFile(ctx context.Context, req *pb.ReadFileRequest) (resp *pb.ReadFileResponse, err error) {
-	n,err := common.ReadFile(req.Path, req.Start, req.Data)
-	resp = &pb.ReadFileResponse{ReadCount: int64(n)}
+	//ToDo: check filename for path traversal attempts (don't care for security, currently - hey, we allow executing bash scripts as root - so what)
+
+	filePath := "/" + req.Filename
+	switch req.Folder {
+	case pb.AccessibleFolder_TMP:
+		filePath = "/tmp" + filePath
+	case pb.AccessibleFolder_BASH_SCRIPTS:
+		filePath = PATH_BASH_SCRIPTS + filePath
+	case pb.AccessibleFolder_HID_SCRIPTS:
+		filePath = PATH_HID_SCRIPTS + filePath
+	default:
+		err = errors.New("Unknown folder")
+		return
+	}
+
+	chunk := make([]byte, req.Len)
+	n,err := common.ReadFile(filePath, req.Start, chunk)
+	if err == io.EOF { err = nil } //we ignore eof error, as eof is indicated by n = 0
+	if err != nil {	return nil,err	}
+	resp = &pb.ReadFileResponse{ReadCount: int64(n), Data: chunk[:n]}
 	return
 }
 
diff --git a/web_client/common.go b/web_client/common.go
index 54be3f5..a9c6361 100644
--- a/web_client/common.go
+++ b/web_client/common.go
@@ -41,7 +41,8 @@ func UploadHIDScript(filename string, content string) (err error) {
 		&pb.WriteFileRequest{
 			Data: []byte(content),
 			Append: false,
-			Path: "/tmp/" + filename,
+			Filename:filename,
+			Folder: pb.AccessibleFolder_TMP,
 			MustNotExist: false,
 		},
 	)
diff --git a/web_client/globals.go b/web_client/globals.go
new file mode 100644
index 0000000..1ffc772
--- /dev/null
+++ b/web_client/globals.go
@@ -0,0 +1,29 @@
+package main
+
+const (
+	initHIDScript = `layout('us');			// US keyboard layout
+typingSpeed(100,150)	// Wait 100ms between key strokes + an additional random value between 0ms and 150ms (natural)
+
+waitLEDRepeat(NUM);		// Wait till NUM LED of target changes frequently multiple times (doesn't work on OSX)
+press("GUI r");
+delay(500);
+type("notepad\n")
+delay(1000);
+for (var i = 0; i < 3; i++) {
+  type("Hello from P4wnP1 run " + i + " !\n");
+  type("Moving mouse right ...");
+  moveStepped(500,0);
+  type("and left\n");
+  moveStepped(-500,0);
+}
+type("Let's type fast !!!!!!!!!!!!!!!\n")
+typingSpeed(0,0);
+for (var i = 3; i < 10; i++) {
+  type("Hello from P4wnP1 run " + i + " !\n");
+  type("Moving mouse right ...");
+  moveStepped(500,0);
+  type("and left\n");
+  moveStepped(-500,0);
+}`
+
+)
diff --git a/web_client/hvueCompHIDScript.go b/web_client/hvueCompHIDScript.go
index e43951d..01b5aef 100644
--- a/web_client/hvueCompHIDScript.go
+++ b/web_client/hvueCompHIDScript.go
@@ -13,6 +13,7 @@ type CompHIDScriptCodeEditorData struct {
 	CodeMirrorOptions *CodeMirrorOptionsType `js:"codemirrorOptions"`
 }
 
+// ToDo: Change into action of vuex store
 func SendAndRun(vm *hvue.VM) {
 	sourceCode := vm.Get("$store").Get("state").Get("currentHIDScriptSource").String()
 	md5 := StringToMD5(sourceCode) //Calculate MD5 hexstring of current script content
@@ -97,16 +98,41 @@ func InitComponentsHIDScript() {
 			data := struct {
 				*js.Object
 				ShowLoadHIDScriptModal bool   `js:"ShowLoadHIDScriptModal"`
+				ShowLoadHIDScriptPrependModal bool   `js:"ShowLoadHIDScriptPrependModal"`
 				ShowStoreHIDScriptModal bool   `js:"ShowStoreHIDScriptModal"`
+				ShowRansom bool   `js:"ShowRansom"`
 			}{Object: O()}
 			data.ShowLoadHIDScriptModal = false
+			data.ShowLoadHIDScriptPrependModal = false
 			data.ShowStoreHIDScriptModal = false
+			data.ShowRansom = false
 			return &data
 		}),
 		hvue.Method("updateStoredHIDScriptsList",
 			func(vm *hvue.VM) {
 				vm.Store.Call("dispatch", VUEX_ACTION_UPDATE_STORED_HID_SCRIPTS_LIST)
 			}),
+		hvue.Method("loadHIDScript",
+			func(vm *hvue.VM, name string) {
+				vm.Get("$q").Call("notify", "load  " + name)
+				updateReq := &jsLoadHidScriptSourceReq{Object:O()}
+				updateReq.FileName = name
+				updateReq.Mode = HID_SCRIPT_SOURCE_LOAD_MODE_REPLACE
+				vm.Store.Call("dispatch", VUEX_ACTION_UPDATE_CURRENT_HID_SCRIPT_SOURCE_FROM_REMOTE_FILE, updateReq)
+			}),
+		hvue.Method("loadHIDScriptPrepend",
+			func(vm *hvue.VM, name string) {
+				vm.Get("$q").Call("notify", "load prepend " + name)
+				updateReq := &jsLoadHidScriptSourceReq{Object:O()}
+				updateReq.FileName = name
+				updateReq.Mode = HID_SCRIPT_SOURCE_LOAD_MODE_PREPEND
+				vm.Store.Call("dispatch", VUEX_ACTION_UPDATE_CURRENT_HID_SCRIPT_SOURCE_FROM_REMOTE_FILE, updateReq)
+			}),
+		hvue.Method("storeHIDScript",
+			func(vm *hvue.VM, name *js.Object) {
+				vm.Get("$q").Call("notify", "store " + name.String())
+				vm.Store.Call("dispatch", VUEX_ACTION_STORE_CURRENT_HID_SCRIPT_SOURCE_TO_REMOTE_FILE, name)
+			}),
 		hvue.Method("SendAndRun",	SendAndRun),
 	)
 }
@@ -115,8 +141,11 @@ const (
 
 	compHIDScriptTemplate = `
 <q-page padding>
-	<modal-string-input v-model="ShowStoreHIDScriptModal" title="Store HIDScript" @save=""></modal-string-input>
-	<select-string-from-array :values="this.$store.state.StoredHIDScriptsList" v-model="ShowLoadHIDScriptModal" title="Load HIDScript to editor" @load=""></select-string-from-array>
+	<ransom-note v-model="ShowRansom"></ransom-note>
+
+	<modal-string-input v-model="ShowStoreHIDScriptModal" title="Store HIDScript" @save="storeHIDScript($event)"></modal-string-input>
+	<select-string-from-array :values="this.$store.state.StoredHIDScriptsList" v-model="ShowLoadHIDScriptModal" title="Load HIDScript to editor" @load="loadHIDScript($event)"></select-string-from-array>
+	<select-string-from-array :values="this.$store.state.StoredHIDScriptsList" v-model="ShowLoadHIDScriptPrependModal" title="Load HIDScript to editor" @load="loadHIDScriptPrepend($event)"></select-string-from-array>
 
 
 	<div class="row gutter-sm">
@@ -129,11 +158,11 @@ const (
 
 				<q-card-main>
 					<div class="row gutter-sm">
-	    				<div class="col-12 col-sm"><q-btn class="fit" color="primary" label="run" @click="SendAndRun()" icon="play_circle_filled" /></div>
-    					<div class="col-12 col-sm"><q-btn class="fit" color="secondary" label="store" icon="save" @click="ShowStoreHIDScriptModal=true" /></div>
-    					<div class="col-12 col-sm"><q-btn class="fit" color="warning" label="load & replace" icon="settings_backup_restore" @click="updateStoredHIDScriptsList(); ShowLoadHIDScriptModal=true"/></div>
-    					<div class="col-12 col-sm"><q-btn class="fit" color="warning" label="load & prepend" icon="add_to_photos" @click="updateStoredHIDScriptsList(); ShowLoadHIDScriptModal=true"/></div>
-    					<!-- <div class="col-12 col-sm"><q-btn class="fit" color="warning" label="load & add" @click="updateStoredTriggerActionSetsList(); showAddTASModal=true" icon="add_to_photos" /></div> -->
+	    				<div class="col-6 col-sm"><q-btn class="fit" color="primary" label="run" @click="SendAndRun()" icon="play_circle_filled" /></div>
+    					<div class="col-6 col-sm"><q-btn class="fit" color="secondary" label="store" icon="save" @click="ShowStoreHIDScriptModal=true" /></div>
+    					<div class="col-6 col-sm"><q-btn class="fit" color="warning" label="load & replace" icon="settings_backup_restore" @click="updateStoredHIDScriptsList(); ShowLoadHIDScriptModal=true"/></div>
+    					<div class="col-6 col-sm"><q-btn class="fit" color="warning" label="load & prepend" icon="add_to_photos" @click="updateStoredHIDScriptsList(); ShowLoadHIDScriptPrependModal=true"/></div>
+    					<div class="col-12 col-sm md"><q-btn class="fit" color="negative" label="import DuckyScript" icon="accessible" @click="ShowRansom=true"/></div>
 					</div>
   				</q-card-main>
 
diff --git a/web_client/hvueComponentsDialog.go b/web_client/hvueComponentsDialog.go
index 691dd70..9e784a5 100644
--- a/web_client/hvueComponentsDialog.go
+++ b/web_client/hvueComponentsDialog.go
@@ -97,6 +97,25 @@ func InitComponentsDialog() {
 			hvue.Types(hvue.PBoolean),
 		),
 	)
+
+	hvue.NewComponent(
+		"ransom-note",
+		hvue.Template(templateRansomModal),
+		hvue.ComputedWithGetSet(
+			"visible",
+			func(vm *hvue.VM) interface{} {
+				return vm.Get("value")
+			},
+			func(vm *hvue.VM, newValue *js.Object) {
+				vm.Call("$emit", "input", newValue)
+			},
+			),
+		hvue.PropObj(
+			"value",
+			hvue.Required,
+			hvue.Types(hvue.PBoolean),
+		),
+	)
 }
 
 const templateSelectStringModal = `
@@ -160,4 +179,32 @@ const templateInputStringModal = `
 		</q-modal-layout>
 	</q-modal>
 </div>
+`
+const templateRansomModal = `
+<div>
+	<q-modal v-model="visible" content-css="background: red;" no-route-dismiss no-backdrop-dismiss>
+			<div style="color: white; font-size: 1.5em; font-family: monospace; padding: 10%">
+				
+You became victim of a VERY SILLY IDEA</br>
+███████████████████████████████████████████████████████████████████████████████</br>
+</br>
+The web page you've been viewing, provided a sophisticated experience</br>
+in terms of keyboard automation and scripting. There were LED based triggers,</br>
+there was scriptable mouse control, there were complex control structures</br>
+like if-else-branching and for-loops. Not to mention the capability of running</br>
+multiple asynchronous jobs.</br>
+</br>
+If you really need a converter for a limited, old-school language:</br>
+</br>
+1. Ask somebody else to write one.</br>
+2. Send me 10+ BTC and I'll write one'.</br>
+or</br>
+3. Write one yourself and don't send a PR'.</br>
+</br>
+If you want your DuckyScript encrypted, please enter it elsewhere!</br>
+				
+			</div>
+		</q-card>
+	</q-modal>
+</div>
 `
\ No newline at end of file
diff --git a/web_client/jsDataHandling.go b/web_client/jsDataHandling.go
index 98b8c8d..32af275 100644
--- a/web_client/jsDataHandling.go
+++ b/web_client/jsDataHandling.go
@@ -14,6 +14,18 @@ import (
 var eNoLogEvent = errors.New("No log event")
 var eNoHidEvent = errors.New("No HID event")
 
+type jsLoadHidScriptSourceMode int
+const (
+	HID_SCRIPT_SOURCE_LOAD_MODE_PREPEND jsLoadHidScriptSourceMode = iota
+	HID_SCRIPT_SOURCE_LOAD_MODE_APPEND
+	HID_SCRIPT_SOURCE_LOAD_MODE_REPLACE
+)
+type jsLoadHidScriptSourceReq struct {
+	*js.Object
+	FileName string `js:"FileName"`
+	Mode jsLoadHidScriptSourceMode `js:"Mode"`
+}
+
 type jsWifiRequestSettingsStorage struct {
 	*js.Object
 	TemplateName string `js:"TemplateName"`
diff --git a/web_client/main.go b/web_client/main.go
index 332734c..dd08952 100644
--- a/web_client/main.go
+++ b/web_client/main.go
@@ -83,6 +83,7 @@ func main() {
 	InitCompsLoadModals()
 	vm := hvue.NewVM(
 		hvue.El("#app"),
+/*
 		//add "testString" to data
 		hvue.DataFunc(func(vm *hvue.VM) interface{} {
 			data := struct{
@@ -94,6 +95,7 @@ func main() {
 			data.TestString = "type('hello');"
 			return &data
 		}),
+*/
 		//add console to app as computed property, to allow debug output on vue events
 		hvue.Computed(
 			"console",
@@ -103,6 +105,9 @@ func main() {
 		hvue.Computed("state", func(vm *hvue.VM) interface{} {
 			return vm.Get("$store").Get("state") //works only with Vuex store option added
 		}),
+		hvue.BeforeMount(func(vm *hvue.VM) {
+			vm.Get("$q").Get("addressbarColor").Call("set", "#027be3")
+		}),
 		Store(store), //include Vuex store in global scope, using own hvue fork, see here: https://github.com/HuckRidgeSW/hvue/pull/6
 		Router(router),
 	)
diff --git a/web_client/mvuexGlobalState.go b/web_client/mvuexGlobalState.go
index e2ac951..74ced82 100644
--- a/web_client/mvuexGlobalState.go
+++ b/web_client/mvuexGlobalState.go
@@ -7,6 +7,8 @@ import (
 	pb "github.com/mame82/P4wnP1_go/proto/gopherjs"
 	"github.com/mame82/hvue"
 	"github.com/mame82/mvuex"
+	"path/filepath"
+	"strings"
 	"time"
 )
 
@@ -45,36 +47,15 @@ const (
 
 	VUEX_ACTION_UPDATE_STORED_BASH_SCRIPTS_LIST = "updateStoredBashScriptsList"
 	VUEX_ACTION_UPDATE_STORED_HID_SCRIPTS_LIST = "updateStoredHIDScriptsList"
+	VUEX_ACTION_UPDATE_CURRENT_HID_SCRIPT_SOURCE_FROM_REMOTE_FILE              = "updateCurrentHidScriptSourceFromRemoteFile"
+	VUEX_ACTION_STORE_CURRENT_HID_SCRIPT_SOURCE_TO_REMOTE_FILE               = "storeCurrentHidScriptSourceToRemoteFile"
+
 
 	VUEX_MUTATION_SET_STORED_BASH_SCRIPTS_LIST    = "setStoredBashScriptsList"
 	VUEX_MUTATION_SET_STORED_HID_SCRIPTS_LIST    = "setStoredHIDScriptsList"
 
 	VUEX_MUTATION_SET_STORED_TRIGGER_ACTIONS_SETS_LIST = "setStoredTriggerActionSetsList"
 
-	initHIDScript = `layout('us');			// US keyboard layout
-typingSpeed(100,150)	// Wait 100ms between key strokes + an additional random value between 0ms and 150ms (natural)
-
-waitLEDRepeat(NUM);		// Wait till NUM LED of target changes frequently multiple times (doesn't work on OSX)
-press("GUI r");
-delay(500);
-type("notepad\n")
-delay(1000);
-for (var i = 0; i < 3; i++) {
-  type("Hello from P4wnP1 run " + i + " !\n");
-  type("Moving mouse right ...");
-  moveStepped(500,0);
-  type("and left\n");
-  moveStepped(-500,0);
-}
-type("Let's type fast !!!!!!!!!!!!!!!\n")
-typingSpeed(0,0);
-for (var i = 3; i < 10; i++) {
-  type("Hello from P4wnP1 run " + i + " !\n");
-  type("Moving mouse right ...");
-  moveStepped(500,0);
-  type("and left\n");
-  moveStepped(-500,0);
-}`
 
 	defaultTimeoutShort = time.Second * 5
 	defaultTimeout = time.Second * 10
@@ -140,13 +121,63 @@ func createGlobalStateStruct() GlobalState {
 	return state
 }
 
+func actionUpdateCurrentHidScriptSourceFromRemoteFile(store *mvuex.Store, context *mvuex.ActionContext, state *GlobalState, req *jsLoadHidScriptSourceReq) {
+	go func() {
+		println("Trying to update current hid script source from remote file ", req.FileName)
+
+		content,err := RpcClient.DownloadFileToBytes(defaultTimeoutMid, req.FileName, pb.AccessibleFolder_HID_SCRIPTS)
+		if err != nil {
+			QuasarNotifyError("Couldn't load HIDScript source " + req.FileName, err.Error(), QUASAR_NOTIFICATION_POSITION_TOP)
+			//println("err", err)
+			return
+		}
+
+		newSource := string(content)
+		switch req.Mode {
+		case HID_SCRIPT_SOURCE_LOAD_MODE_APPEND:
+			newSource = state.CurrentHIDScriptSource + newSource
+		case HID_SCRIPT_SOURCE_LOAD_MODE_PREPEND:
+			newSource = newSource + state.CurrentHIDScriptSource
+		case HID_SCRIPT_SOURCE_LOAD_MODE_REPLACE:
+		default:
+		}
+
+		context.Commit(VUEX_MUTATION_SET_CURRENT_HID_SCRIPT_SOURCE_TO, newSource)
+	}()
+
+	return
+}
+
+func actionStoreCurrentHidScriptSourceToRemoteFile(store *mvuex.Store, context *mvuex.ActionContext, state *GlobalState, filename *js.Object) {
+	go func() {
+		fname := filename.String()
+		ext := filepath.Ext(fname)
+		if lext := strings.ToLower(ext); lext != ".js" && lext != ".javascript" {
+			fname = fname + ".js"
+		}
+
+		println("Trying to store current hid script source to remote file ", fname)
+
+		content := []byte(state.CurrentHIDScriptSource)
+		err := RpcClient.UploadBytesToFile(defaultTimeoutMid, fname, pb.AccessibleFolder_HID_SCRIPTS, content, true)
+		if err != nil {
+			QuasarNotifyError("Couldn't store HIDScript source " + fname, err.Error(), QUASAR_NOTIFICATION_POSITION_TOP)
+			//println("err", err)
+			return
+		}
+
+	}()
+
+	return
+}
+
 func actionUpdateStoredBashScriptsList(store *mvuex.Store, context *mvuex.ActionContext, state *GlobalState) {
 	go func() {
-		println("Trying to fetch stored BasScripts list")
+		println("Trying to fetch stored BashScripts list")
 		//fetch deployed gadget settings
 		wsList, err := RpcClient.GetStoredBashScriptsList(defaultTimeout)
 		if err != nil {
-			println("Couldn't retrieve stored BasScripts list")
+			println("Couldn't retrieve stored BashScripts list")
 			return
 		}
 
@@ -181,7 +212,7 @@ func actionUpdateStoredHIDScriptsList(store *mvuex.Store, context *mvuex.ActionC
 func actionUpdateGadgetSettingsFromDeployed(store *mvuex.Store, context *mvuex.ActionContext, state *GlobalState) {
 	go func() {
 		//fetch deployed gadget settings
-		dGS, err := RpcClient.RpcGetDeployedGadgetSettings(defaultTimeoutShort)
+		dGS, err := RpcClient.GetDeployedGadgetSettings(defaultTimeoutShort)
 		if err != nil {
 			println("Couldn't retrieve deployed gadget settings")
 			return
@@ -266,7 +297,7 @@ func actionDeployWifiSettings(store *mvuex.Store, context *mvuex.ActionContext,
 func actionUpdateRunningHidJobs(store *mvuex.Store, context *mvuex.ActionContext, state *GlobalState) {
 	go func() {
 		//fetch deployed gadget settings
-		jobstates, err := RpcClient.RpcGetRunningHidJobStates(defaultTimeout)
+		jobstates, err := RpcClient.GetRunningHidJobStates(defaultTimeout)
 		if err != nil {
 			println("Couldn't retrieve stateof running HID jobs", err)
 			return
@@ -439,14 +470,14 @@ func actionDeployCurrentGadgetSettings(store *mvuex.Store, context *mvuex.Action
 		curGS := state.CurrentGadgetSettings.toGS()
 
 		//try to set them via gRPC (the server holds an internal state, setting != deploying)
-		err := RpcClient.RpcSetRemoteGadgetSettings(curGS, defaultTimeoutShort)
+		err := RpcClient.SetRemoteGadgetSettings(curGS, defaultTimeoutShort)
 		if err != nil {
 			QuasarNotifyError("Error in pre-check of new USB gadget settings", err.Error(), QUASAR_NOTIFICATION_POSITION_TOP)
 			return
 		}
 
 		//try to deploy the, now set, remote GadgetSettings via gRPC
-		_, err = RpcClient.RpcDeployRemoteGadgetSettings(defaultTimeout)
+		_, err = RpcClient.DeployRemoteGadgetSettings(defaultTimeout)
 		if err != nil {
 			QuasarNotifyError("Error while deploying new USB gadget settings", err.Error(), QUASAR_NOTIFICATION_POSITION_TOP)
 			return
@@ -542,6 +573,8 @@ func initMVuex() *mvuex.Store {
 
 		mvuex.Action(VUEX_ACTION_UPDATE_STORED_BASH_SCRIPTS_LIST, actionUpdateStoredBashScriptsList),
 		mvuex.Action(VUEX_ACTION_UPDATE_STORED_HID_SCRIPTS_LIST, actionUpdateStoredHIDScriptsList),
+		mvuex.Action(VUEX_ACTION_UPDATE_CURRENT_HID_SCRIPT_SOURCE_FROM_REMOTE_FILE, actionUpdateCurrentHidScriptSourceFromRemoteFile),
+		mvuex.Action(VUEX_ACTION_STORE_CURRENT_HID_SCRIPT_SOURCE_TO_REMOTE_FILE, actionStoreCurrentHidScriptSourceToRemoteFile),
 
 
 		mvuex.Getter("triggerActions", func(state *GlobalState) interface{} {
diff --git a/web_client/rpcClient.go b/web_client/rpcClient.go
index 9ab82dc..ef1c327 100644
--- a/web_client/rpcClient.go
+++ b/web_client/rpcClient.go
@@ -30,6 +30,52 @@ func NewRpcClient(addr string) Rpc {
 	return rcl
 }
 
+func (rpc *Rpc) UploadBytesToFile(timeout time.Duration, filename string, folder pb.AccessibleFolder, content []byte, allowOverwrite bool) (err error) {
+	ctx := context.Background()
+	if timeout > 0 {
+		newCtx, cancel := context.WithTimeout(ctx, timeout)
+		ctx = newCtx
+		defer cancel()
+	}
+
+	_, err = rpc.Client.FSWriteFile(ctx, &pb.WriteFileRequest{
+		Data: content,
+		Folder: folder,
+		Filename: filename,
+		Append: false,
+		MustNotExist: !allowOverwrite,
+	})
+	return err
+}
+
+// Warning, this method reads content completely to RAM
+func (rpc *Rpc) DownloadFileToBytes(timeout time.Duration, filename string, folder pb.AccessibleFolder) (content []byte, err error) {
+	ctx := context.Background()
+	if timeout > 0 {
+		newCtx, cancel := context.WithTimeout(ctx, timeout)
+		ctx = newCtx
+		defer cancel()
+	}
+
+	chunksize := int64(1 << 15)
+	readCount := chunksize
+
+	for readCount >= chunksize {
+		resp, err := rpc.Client.FSReadFile(ctx, &pb.ReadFileRequest{
+			Filename: filename,
+			Folder: folder,
+			Start: int64(len(content)),
+			Len:   chunksize,
+		})
+		if err != nil { return content,err }
+		content = append(content, resp.Data...)
+		readCount = resp.ReadCount
+	}
+
+	return
+}
+
+
 func (rpc *Rpc) GetStoredBashScriptsList(timeout time.Duration) (ws []string, err error) {
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
@@ -136,8 +182,8 @@ func (rpc *Rpc) GetAllDeployedEthernetInterfaceSettings(timeout time.Duration) (
 	*/
 }
 
-func (rpc *Rpc) RpcGetRunningHidJobStates(timeout time.Duration) (states []*pb.HIDRunningJobStateResult, err error) {
-	println("RpcGetRunningHidJobStates called")
+func (rpc *Rpc) GetRunningHidJobStates(timeout time.Duration) (states []*pb.HIDRunningJobStateResult, err error) {
+	println("GetRunningHidJobStates called")
 
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
@@ -221,9 +267,9 @@ func (rpc *Rpc) DeployStoredTriggerActionsSetAdd(timeout time.Duration, name *pb
 
 
 
-func (rpc *Rpc) RpcGetDeployedGadgetSettings(timeout time.Duration) (*pb.GadgetSettings, error) {
+func (rpc *Rpc) GetDeployedGadgetSettings(timeout time.Duration) (*pb.GadgetSettings, error) {
 	//gs := vue.GetVM(c).Get("gadgetSettings")
-	println("RpcGetDeployedGadgetSettings called")
+	println("GetDeployedGadgetSettings called")
 
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
@@ -232,9 +278,9 @@ func (rpc *Rpc) RpcGetDeployedGadgetSettings(timeout time.Duration) (*pb.GadgetS
 
 }
 
-func (rpc *Rpc) RpcSetRemoteGadgetSettings(targetGS *pb.GadgetSettings, timeout time.Duration) (err error) {
+func (rpc *Rpc) SetRemoteGadgetSettings(targetGS *pb.GadgetSettings, timeout time.Duration) (err error) {
 	//gs := vue.GetVM(c).Get("gadgetSettings")
-	println("RpcSetRemoteGadgetSettings called")
+	println("SetRemoteGadgetSettings called")
 
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
@@ -251,9 +297,9 @@ func (rpc *Rpc) RpcSetRemoteGadgetSettings(targetGS *pb.GadgetSettings, timeout
 	return nil
 }
 
-func (rpc *Rpc) RpcDeployRemoteGadgetSettings(timeout time.Duration) (*pb.GadgetSettings, error) {
+func (rpc *Rpc) DeployRemoteGadgetSettings(timeout time.Duration) (*pb.GadgetSettings, error) {
 	//gs := vue.GetVM(c).Get("gadgetSettings")
-	println("RpcDeployRemoteGadgetSettings called")
+	println("DeployRemoteGadgetSettings called")
 
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
@@ -264,7 +310,7 @@ func (rpc *Rpc) RpcDeployRemoteGadgetSettings(timeout time.Duration) (*pb.Gadget
 
 func (rpc *Rpc) ConnectionTest(timeout time.Duration) (err error) {
 	//gs := vue.GetVM(c).Get("gadgetSettings")
-	println("RpcDeployRemoteGadgetSettings called")
+	println("DeployRemoteGadgetSettings called")
 
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()