// Package global Code generated for package main by go-bindata DO NOT EDIT. (@generated)
// sources:
// .tmp/data/ui/index.html
// .tmp/data/xiang/apis/README.md
// .tmp/data/xiang/apis/sys.http.json
// .tmp/data/xiang/flows/README.md
// .tmp/data/xiang/flows/table/get.flow.json
// .tmp/data/xiang/models/README.md
// .tmp/data/xiang/models/user.json
package global

import (
	"bytes"
	"compress/gzip"
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"os"
	"path/filepath"
	"strings"
	"time"
)

func bindataRead(data []byte, name string) ([]byte, error) {
	gz, err := gzip.NewReader(bytes.NewBuffer(data))
	if err != nil {
		return nil, fmt.Errorf("Read %q: %v", name, err)
	}

	var buf bytes.Buffer
	_, err = io.Copy(&buf, gz)
	clErr := gz.Close()

	if err != nil {
		return nil, fmt.Errorf("Read %q: %v", name, err)
	}
	if clErr != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

type asset struct {
	bytes []byte
	info  os.FileInfo
}

type bindataFileInfo struct {
	name    string
	size    int64
	mode    os.FileMode
	modTime time.Time
}

// Name return file name
func (fi bindataFileInfo) Name() string {
	return fi.name
}

// Size return file size
func (fi bindataFileInfo) Size() int64 {
	return fi.size
}

// Mode return file mode
func (fi bindataFileInfo) Mode() os.FileMode {
	return fi.mode
}

// Mode return file modify time
func (fi bindataFileInfo) ModTime() time.Time {
	return fi.modTime
}

// IsDir return file whether a directory
func (fi bindataFileInfo) IsDir() bool {
	return fi.mode&os.ModeDir != 0
}

// Sys return file is sys mode
func (fi bindataFileInfo) Sys() interface{} {
	return nil
}

type assetFile struct {
	*bytes.Reader
	name            string
	childInfos      []os.FileInfo
	childInfoOffset int
}

type assetOperator struct{}

// Open implement http.FileSystem interface
func (f *assetOperator) Open(name string) (http.File, error) {
	var err error
	if len(name) > 0 && name[0] == '/' {
		name = name[1:]
	}
	content, err := Asset(name)
	if err == nil {
		return &assetFile{name: name, Reader: bytes.NewReader(content)}, nil
	}
	children, err := AssetDir(name)
	if err == nil {
		childInfos := make([]os.FileInfo, 0, len(children))
		for _, child := range children {
			childPath := filepath.Join(name, child)
			info, errInfo := AssetInfo(filepath.Join(name, child))
			if errInfo == nil {
				childInfos = append(childInfos, info)
			} else {
				childInfos = append(childInfos, newDirFileInfo(childPath))
			}
		}
		return &assetFile{name: name, childInfos: childInfos}, nil
	}

	// If the error is not found, return an error that will
	// result in a 404 error. Otherwise the server returns
	// a 500 error for files not found.
	if strings.Contains(err.Error(), "not found") {
		return nil, os.ErrNotExist
	}
	return nil, err
}

// Close no need do anything
func (f *assetFile) Close() error {
	return nil
}

// Readdir read dir's children file info
func (f *assetFile) Readdir(count int) ([]os.FileInfo, error) {
	if len(f.childInfos) == 0 {
		return nil, os.ErrNotExist
	}
	if count <= 0 {
		return f.childInfos, nil
	}
	if f.childInfoOffset+count > len(f.childInfos) {
		count = len(f.childInfos) - f.childInfoOffset
	}
	offset := f.childInfoOffset
	f.childInfoOffset += count
	return f.childInfos[offset : offset+count], nil
}

// Stat read file info from asset item
func (f *assetFile) Stat() (os.FileInfo, error) {
	if len(f.childInfos) != 0 {
		return newDirFileInfo(f.name), nil
	}
	return AssetInfo(f.name)
}

// newDirFileInfo return default dir file info
func newDirFileInfo(name string) os.FileInfo {
	return &bindataFileInfo{
		name:    name,
		size:    0,
		mode:    os.FileMode(2147484068), // equal os.FileMode(0644)|os.ModeDir
		modTime: time.Time{}}
}

// AssetFile return a http.FileSystem instance that data backend by asset
func AssetFile() http.FileSystem {
	return &assetOperator{}
}

var _uiIndexHTML = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xca\x48\xcd\xc9\xc9\x57\x28\xcf\x2f\xca\x49\xe1\x02\x04\x00\x00\xff\xff\x2d\x3b\x08\xaf\x0c\x00\x00\x00")

func uiIndexHTMLBytes() ([]byte, error) {
	return bindataRead(
		_uiIndexHTML,
		"ui/index.html",
	)
}

func uiIndexHTML() (*asset, error) {
	bytes, err := uiIndexHTMLBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "ui/index.html", size: 12, mode: os.FileMode(420), modTime: time.Unix(1631095267, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xiangApisReadmeMd = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x52\x56\x70\x0c\xf0\x54\x78\xd6\xb7\xf4\x69\xff\x62\x2e\x40\x00\x00\x00\xff\xff\xcc\x30\x5e\xae\x0d\x00\x00\x00")

func xiangApisReadmeMdBytes() ([]byte, error) {
	return bindataRead(
		_xiangApisReadmeMd,
		"xiang/apis/README.md",
	)
}

func xiangApisReadmeMd() (*asset, error) {
	bytes, err := xiangApisReadmeMdBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "xiang/apis/README.md", size: 13, mode: os.FileMode(420), modTime: time.Unix(1631095267, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xiangApisSysHTTPJSON = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x4c\x90\x31\x4e\x03\x31\x10\x45\x7b\x9f\x62\x34\xa2\x0c\xce\x42\xe9\x8e\x02\x10\x1d\x05\x5d\x94\xc2\xec\x1a\xe2\x28\x6b\x5b\x33\x36\x28\x8a\x72\x05\x38\x02\x05\xe2\x04\x94\x39\x0f\xe4\x1a\x68\xbc\x4b\x92\xc6\x92\xdf\xfb\xf3\x35\x9a\x8d\x02\xc0\x60\x7b\x87\x06\x70\xff\xbd\xdb\xef\x3e\x7e\xdf\xbe\x7e\xde\x3f\x71\x22\xe6\xc5\x11\xfb\x18\x44\x5e\xe8\x46\x37\x03\xed\x1c\xb7\xe4\x53\x1e\xcd\xe9\xd8\xd5\xfd\xdd\x90\x79\xa6\x58\x92\x58\x5e\xf3\x48\x8a\xa5\x4e\xc8\xa3\xb3\xe4\xe8\x7c\xf9\x9a\x07\x91\x6c\x5e\x30\x1a\x98\x29\x00\x80\x4d\x7d\x47\x2c\xf1\xa9\x0f\x4f\x71\x6a\x7c\x57\xd3\x55\xf5\x2e\x2f\x62\xed\xba\xbd\x7e\x38\xe2\x44\xb1\x75\x2c\x55\xd8\xc7\xce\xad\x58\x17\x76\xa4\x6f\x7c\x38\x99\xf5\xb2\xf3\x0c\xcf\x92\x25\xdb\x6b\x69\x05\x34\xf5\xc3\x38\x3f\xa4\x62\xc9\x68\x0e\xbb\x00\x20\x67\x9b\x8b\x54\x5f\x36\xcd\xe4\x88\xf3\x3a\xd5\xd3\xd9\x94\x56\xbe\xb5\x72\x92\xe9\x92\x63\xc0\x31\xb2\x55\xff\xef\x5c\x6d\xd5\x5f\x00\x00\x00\xff\xff\x8a\x81\x76\x11\x6e\x01\x00\x00")

func xiangApisSysHTTPJSONBytes() ([]byte, error) {
	return bindataRead(
		_xiangApisSysHTTPJSON,
		"xiang/apis/sys.http.json",
	)
}

func xiangApisSysHTTPJSON() (*asset, error) {
	bytes, err := xiangApisSysHTTPJSONBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "xiang/apis/sys.http.json", size: 366, mode: os.FileMode(420), modTime: time.Unix(1631095267, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xiangFlowsReadmeMd = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x52\x56\x78\xba\x7d\xe9\x93\xbd\x73\x9e\x6d\x6d\xe4\x02\x04\x00\x00\xff\xff\x8c\xe8\x04\x3a\x0c\x00\x00\x00")

func xiangFlowsReadmeMdBytes() ([]byte, error) {
	return bindataRead(
		_xiangFlowsReadmeMd,
		"xiang/flows/README.md",
	)
}

func xiangFlowsReadmeMd() (*asset, error) {
	bytes, err := xiangFlowsReadmeMdBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "xiang/flows/README.md", size: 12, mode: os.FileMode(420), modTime: time.Unix(1631095267, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xiangFlowsTableGetFlowJSON = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x74\x90\x4d\x4a\xc4\x40\x10\x85\xf7\x39\x45\x51\xb8\x0c\x21\xba\x9c\xab\xc8\x20\x9d\x74\x31\x36\x56\xd2\x43\xff\x8c\x8b\xa6\x41\x2f\xe1\xca\x8d\x27\xd0\x1b\x78\x19\xc9\x39\xa4\x3a\x33\x99\x04\x71\x13\xc2\x7b\xaf\xbe\x7e\x55\xa9\x02\x40\x56\x1d\x31\xee\x00\xa7\xf7\x97\xe9\xed\xeb\xe7\xfb\x63\x7a\xfd\xc4\x5a\xac\x13\x39\x6f\xec\x28\xe6\x6d\xd3\x36\xed\xac\x6a\xf2\xbd\x33\xc7\x70\x76\xfe\x8e\x8d\x56\x93\xc7\x1d\xdc\x57\x00\x00\xa9\x7c\x45\x56\x03\xc9\x40\xf4\xe4\x4a\xb0\xa8\x47\x67\x7b\xf2\x12\xc7\xc1\x6a\x62\xdf\x88\xdf\x1c\x28\x5c\x33\xca\x1d\xae\xbc\x35\xb3\xb8\x9e\x98\xfa\x20\x3e\x1a\x8d\xf5\xf9\xa1\x5a\x78\x9d\x61\xc2\x7d\xbd\x4e\xb3\x19\x8c\x84\xef\xda\x8d\x6c\x9d\x26\x57\x1e\x49\x80\xbd\xe5\x38\x94\xe5\x7a\x47\x2a\x90\x7e\x50\x41\x80\x76\x59\x5a\x6e\x80\x90\xb7\xe8\xe7\x47\x72\xb4\x2d\x5a\xca\xae\x81\x3e\xa8\x10\xbd\xc0\x4e\x8a\x63\xb9\x07\x8d\xaa\x63\xd2\x08\xb9\xfe\x7f\xee\xb2\xd3\x32\x95\xd2\x8d\x19\x9b\x36\xe7\xb9\x98\x48\x6c\x9e\x08\x21\xaf\x20\xfb\xe5\xff\xa2\x2e\x8d\xd1\xc6\x50\xba\x0a\xc9\xc6\x90\x33\xce\x69\x49\xee\xab\x5c\xfd\x06\x00\x00\xff\xff\x34\x26\x65\xb9\x1d\x02\x00\x00")

func xiangFlowsTableGetFlowJSONBytes() ([]byte, error) {
	return bindataRead(
		_xiangFlowsTableGetFlowJSON,
		"xiang/flows/table/get.flow.json",
	)
}

func xiangFlowsTableGetFlowJSON() (*asset, error) {
	bytes, err := xiangFlowsTableGetFlowJSONBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "xiang/flows/table/get.flow.json", size: 541, mode: os.FileMode(420), modTime: time.Unix(1631095267, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xiangModelsReadmeMd = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x52\x56\x78\x36\x75\xc3\xb3\xde\x75\xcf\x56\x2c\x7c\x3a\xaf\x9b\x0b\x10\x00\x00\xff\xff\xb5\xd1\x53\xc2\x0f\x00\x00\x00")

func xiangModelsReadmeMdBytes() ([]byte, error) {
	return bindataRead(
		_xiangModelsReadmeMd,
		"xiang/models/README.md",
	)
}

func xiangModelsReadmeMd() (*asset, error) {
	bytes, err := xiangModelsReadmeMdBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "xiang/models/README.md", size: 15, mode: os.FileMode(420), modTime: time.Unix(1631095267, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xiangModelsUserJSON = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x59\xed\x53\x13\x57\x17\xff\xce\x5f\x71\x67\x1f\xe7\x19\x7d\x9e\x64\xdc\xdd\x20\x86\x7c\x32\x48\x9d\xc1\xb7\x22\xf8\x82\x28\x65\x36\xd9\x9b\xb0\x74\xb3\x89\xd9\x5d\x0c\xa4\x99\x09\xb5\x22\x54\x10\xb4\x50\x64\x4a\x1d\xb5\x82\xb4\xbe\x44\x2a\x23\x19\x94\xf1\x8f\x69\xee\x66\xf9\xd4\x7f\xa1\xb3\x2f\xd9\x2c\xbb\x37\x4b\x02\xb6\x3a\xd2\x4f\x84\x7b\xf7\x9e\xf3\xbb\xbf\x73\xee\x39\xe7\x9e\x9b\x6d\x02\x80\x10\x98\x04\x24\x42\x80\x28\xcf\xae\x28\xe3\xeb\x84\x4f\x1b\x93\x98\x08\xaf\x0d\x6a\x1f\xd8\x3e\x91\x45\x98\xd6\x3f\x00\x80\x88\x26\x13\x09\x28\x48\xd5\x95\xea\xa3\x95\xca\x1c\x14\xe2\x9c\xa0\xaf\xe8\x10\x84\x64\x7b\x1b\xd1\x04\x40\x4e\x17\x1c\x4d\xf2\x72\x42\x10\x89\x10\xb8\xa2\x7f\x9a\x05\x04\xcf\x44\x20\xaf\x7f\xdb\x4e\xf8\xaa\xba\x38\x56\xfb\x4f\x1a\x4e\x41\x73\xce\x90\x00\x4c\x4c\xc0\xb6\x10\xdd\xf9\x16\xcd\x8d\x99\xca\x6d\x70\x13\x8c\x20\xf7\x6b\x72\x2a\x13\x15\x69\x11\x2e\xde\x21\x48\x30\x6e\xed\x46\x93\x06\x85\xb8\x34\x40\x84\xc0\x11\xd2\x1a\xb3\xed\x51\x99\xc8\xa3\xd5\x07\x2e\x4d\x32\xcf\x9b\x54\x49\x69\x19\x5a\xe3\x9c\xc0\xc2\x8c\x73\x70\x88\xe1\x39\x96\x91\xb8\xa4\x6d\xff\xf6\x0d\xe9\x1f\x25\xa0\x34\x90\x64\x35\x8d\x1a\xd8\x64\xcc\xd2\xa5\xcf\x32\xe9\xb8\xbe\x96\xe0\x4c\xf8\x7d\xbe\xed\x8b\x45\x91\x89\xeb\x5b\xcc\x66\x39\x21\x25\x4b\xb9\x5c\x79\xf5\x2d\x7a\x70\x7b\x6b\x76\x41\x2d\x14\x7c\x20\x9b\xd5\x59\xcb\xe5\xd0\xc6\x6c\xa9\xb8\xa1\xcc\xbd\x42\x2f\xe6\x09\x4b\x46\xce\xb7\x13\xaa\x04\x27\xe0\x21\x91\x1e\x50\xaa\x3a\xd1\x93\xa7\xa5\x8d\x3b\xa4\x4d\xa3\xf9\xab\xaf\xc9\xa6\xdf\x6d\x62\x63\x17\x6e\x13\xeb\x16\x75\xd9\x17\x0a\x72\xa2\x3a\x9a\x4c\x69\x9c\xeb\xb4\x31\xac\x8e\x1f\x10\xa2\xc4\xc4\x62\xda\x0f\xdd\xa5\xfb\x70\x16\x57\xd7\x96\xd1\xf4\xba\xa1\x18\xe8\x0b\x41\xf9\xe5\xa3\xf2\xcc\x18\xba\x7b\xdf\x07\x74\x01\x00\xdd\xbd\x8f\xd6\x97\x7c\x40\x93\x02\x6c\x07\x48\x97\xc5\xc2\x18\x23\xf3\xba\x2c\x53\xdd\x3f\xe6\x1e\xa2\x94\xe6\x84\xf8\x9e\xbc\x43\x2d\x2c\x95\x8a\x1b\xe8\xc5\x7c\xf9\xf9\x72\xa9\xf8\x7b\x23\x3e\xb2\x8d\xfe\xed\xc0\x76\x32\x40\x4d\xa0\xa5\xe2\x14\x5a\x5c\x51\x5f\x16\xd1\x74\x41\x9d\xbc\x81\x7e\x5a\xc3\xc1\x35\xec\x74\x58\x17\x7e\x58\x97\xdc\xa8\xa3\x29\x13\xb7\x95\xc5\x0d\x34\xbd\x8e\x09\x27\xc9\x08\xc7\x63\xbc\xcd\x24\xbb\xfe\x48\xe2\xd2\x80\xf5\x87\x68\x7a\x38\xa5\x2f\x08\x7f\xd1\x4d\x7c\x86\x5e\x92\x62\x24\x09\xa6\x6b\x44\x13\xe2\x2b\xea\x4a\xc0\xdf\xda\x77\xf5\x2a\x9b\x6d\xcd\x1d\xa8\x03\xa3\xf2\xf0\x1d\x7a\x37\x6d\x60\x6c\x3c\xbc\x2c\xbc\x45\x9b\x73\xa8\x30\x56\x7e\x38\xea\x36\x7c\x8a\x11\xc5\xeb\xc9\x34\x26\x91\xd4\x34\x3d\x7d\xa4\x05\x67\x7b\xbc\x1e\xcb\xd2\x9d\xe1\xee\xee\x4b\x5f\x76\xb5\xef\x9b\x48\x91\xe0\x84\xd3\x06\x65\x58\x74\x2d\x75\xe5\x14\xb5\xb0\x54\x9e\x5d\x6d\xf1\x53\xc1\xd2\xe6\xd4\x9f\xef\x26\xd1\x93\xa7\xe8\xd5\x34\x1a\x5b\x40\x2f\xe6\x95\xc2\xd4\x1f\xf9\x51\x23\xcd\xa1\x7b\x93\xe5\xe7\x5a\x4c\x57\x1e\x7c\xa7\x8c\xcf\x34\x84\x93\xc9\x78\xe1\xa4\x82\x9f\x0a\x50\xef\x43\x75\x85\xf4\xb7\xf6\xfd\xdf\xcb\xd8\xdb\xc0\xaa\xb7\x5e\xa3\x57\x77\xd1\xe4\x4d\x34\xf3\xac\x54\xcc\x97\x8a\xbf\x35\x5e\x2f\xec\x00\x28\xec\xef\xdd\x13\x20\x8d\xc2\x0a\x7f\x1f\x10\x16\xe3\x1f\xd9\x1b\x2c\x9b\x59\x3f\x20\xac\x63\xff\x39\xf0\xdf\xff\xed\x09\x98\xe1\x57\x0d\xc7\x47\xf4\xf4\x07\x34\x33\xe5\x8e\x8c\xfa\xdf\xfa\xa3\x62\x10\x9b\x10\x9d\xc2\xf7\x77\xcc\xa3\x77\x36\xae\x61\xd6\xad\xc5\xbc\xba\x3c\x4a\x6b\xde\xd6\x60\x09\xef\x1d\xcc\x9a\xeb\xa8\xe4\x4b\xc5\x29\xf5\xc6\xa6\xfa\xe6\xa6\xfa\xfe\x16\x4d\xba\x20\xd4\xe7\x54\xea\xc6\xb3\xd2\xdb\x4d\xb5\x30\xaa\x95\xd9\xb8\xbc\xcb\xb1\x51\xe6\x43\x64\xdd\x9a\x8a\xf0\x25\xd6\x47\xbb\xd4\x7d\xd2\xf5\xd8\x41\xad\x14\xa3\x82\xb9\x43\xdf\x18\xbf\x9a\x73\x3d\x87\x3c\xeb\x32\x13\xd4\x9e\xea\x32\x75\x6d\x59\x19\x5f\x2f\x6d\x2e\x6c\x3d\xfe\xd9\xed\x1f\x11\x86\x67\x84\x28\x26\x00\x71\x35\x2f\xf7\x34\x36\x02\xd9\xd5\x1c\x44\x63\xf3\xa5\xcd\x85\x43\xb8\x7b\x1c\xf9\xef\x05\xdf\xd3\xd6\x7b\xb8\xe0\x87\x3b\x3b\xc0\x29\x38\xec\x36\xf2\xd7\xf6\xc1\xdd\x46\x00\xb7\xf4\x1a\x67\x5c\x16\xb8\x6b\xb2\x6b\x74\xdf\x1c\x72\xad\x40\x0c\xfb\x7b\x19\xff\x88\x51\x6a\x64\x83\x5e\x77\x2f\x27\xa8\xf2\xec\xea\xae\x2b\xdb\xfa\xbd\x04\x15\xc6\xb6\xee\x2d\xb9\x1d\x45\x84\xd1\x34\x94\x76\xe9\x2b\xb5\xfc\x01\x9f\x21\x1c\x9e\xe5\x44\xb4\xbf\x13\x85\xcb\x87\x02\xb4\xf7\x05\xde\xe9\x43\x01\xfa\xef\x75\xa2\xf2\xcb\x3c\xba\x83\x69\x17\xa7\xa1\x28\xe3\xca\x59\x09\x66\x24\xac\xed\x5d\x82\xb6\x3b\x91\x37\x0a\x65\xe2\x57\xb4\x3a\x57\x7a\xff\x48\x19\x2d\xb8\xb1\xc0\x8c\x94\x66\xdc\x50\x06\xc5\xa4\x80\x85\x52\x43\x5a\x23\x80\xca\xdf\xbf\x51\xf2\xa3\xf8\x8d\xea\x9d\x4d\xe3\x03\x00\x05\x4d\x24\x0b\x94\xc5\x09\x65\x6e\xdc\x07\x58\x4e\x34\x07\xe6\x1f\x2a\x73\xe3\x98\x83\x29\x31\x92\x2c\xee\xd4\xa5\xb5\x75\x4b\x4d\x0d\xd8\x0e\xae\x35\x07\x88\x8a\x62\x5b\xfb\xf6\x33\x3f\x79\x1e\x8d\x55\x4f\x5e\x6a\xa2\xac\xb3\xab\x6a\x0a\x3f\x6c\x49\xae\x75\xe4\x9a\x00\xd0\x95\x12\x69\xc8\x5b\x8c\x67\x8d\xa7\x9f\x21\x86\x97\xa1\xed\xe5\xc7\xe9\x26\x56\x73\xbd\x6a\xf7\xca\x03\x4e\x08\x50\x2e\xef\x31\x3b\xc9\x96\xe5\x8d\xbb\x42\x08\x10\x74\x80\x6c\xa1\x9b\xa9\xd6\x60\x80\xa4\xa8\xa3\x24\x49\x1d\xb1\x09\x34\x5a\xb8\x21\x40\x50\x81\x56\x92\x24\x49\x8a\xa2\xa8\xea\xb4\xd5\xe8\x0b\x01\x22\x3a\xd4\x7d\xea\x58\xd7\xe5\x96\xea\xac\x56\x89\x84\x00\x71\xa2\x2d\x10\xcb\x1c\x87\xe7\xaa\x13\x66\xe6\x09\x01\xa2\xe7\xcc\x79\xf6\x6c\xd7\x45\x2e\x1e\x89\x5f\xe0\xc2\x9d\x2c\x77\xf2\x78\x8c\xb9\x14\xbf\x14\x1d\xa1\x3b\x99\x73\x3d\xd7\x6d\x6b\x8c\x43\x81\xf3\x76\xe3\xec\x87\x40\x56\x93\x9c\x31\xce\xdf\x3a\x61\x52\xed\x3c\xbe\x15\xf6\x8c\x97\x88\xfa\xa8\x73\xbe\x46\xd8\xa9\x0b\xd2\x2d\x54\x6b\x90\x26\x69\xf2\x28\x49\x37\xf7\x78\x50\x47\xd3\x34\x8d\xa7\xee\xda\xc5\x63\xf2\x79\xaa\xbd\xc3\x45\xdd\xc9\xf6\x01\xba\x97\xbb\x20\xe1\xa8\xbb\xde\x06\x2f\x0f\x9e\x3e\x7a\x62\x30\x12\x1d\x4a\x85\xd9\xb6\x74\x46\x6a\x3f\x11\x1b\x1c\x66\xc5\x64\xe7\xa9\x81\xae\xb3\xbb\xa4\x0e\x2d\xbd\xde\x89\x3a\xe7\xbb\x4d\x95\x3a\xda\x45\x9d\xed\x05\xd4\x8b\x39\xd2\x93\xb9\x40\x20\x10\x68\x90\xb9\x9e\x5e\x8a\x3e\xc3\x75\x8e\x7c\x24\xe6\xac\x73\xad\x07\x58\xdc\x29\xb6\xf7\x73\xf4\x47\x52\x27\xab\x8e\x47\xd9\x7e\x83\x95\x7e\xb3\xe0\xb6\x65\x1d\xeb\x81\xb8\xfa\x7e\x6b\x71\xd8\xe7\x36\x88\xb1\x1e\x6b\x60\x57\xaa\x46\x37\x57\x94\x1f\x6f\x29\xbf\xe4\xcb\x6b\x8f\x6b\xe5\xff\xfe\x98\xcc\xf3\xce\x94\x5f\xc5\x64\x16\x09\x6e\x20\xd6\x32\x07\x63\x56\xee\xca\x02\x42\xe2\x12\x50\x94\x98\x44\x4a\xac\xe4\x28\x40\x88\xc9\x98\xd4\xcf\x42\x1e\x4a\xb0\x32\x0a\x72\x4d\xb9\xa6\xbf\x02\x00\x00\xff\xff\xdf\xdf\x90\x77\x9c\x1f\x00\x00")

func xiangModelsUserJSONBytes() ([]byte, error) {
	return bindataRead(
		_xiangModelsUserJSON,
		"xiang/models/user.json",
	)
}

func xiangModelsUserJSON() (*asset, error) {
	bytes, err := xiangModelsUserJSONBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "xiang/models/user.json", size: 8092, mode: os.FileMode(420), modTime: time.Unix(1631095267, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

// Asset loads and returns the asset for the given name.
// It returns an error if the asset could not be found or
// could not be loaded.
func Asset(name string) ([]byte, error) {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	if f, ok := _bindata[cannonicalName]; ok {
		a, err := f()
		if err != nil {
			return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err)
		}
		return a.bytes, nil
	}
	return nil, fmt.Errorf("Asset %s not found", name)
}

// MustAsset is like Asset but panics when Asset would return an error.
// It simplifies safe initialization of global variables.
func MustAsset(name string) []byte {
	a, err := Asset(name)
	if err != nil {
		panic("asset: Asset(" + name + "): " + err.Error())
	}

	return a
}

// AssetInfo loads and returns the asset info for the given name.
// It returns an error if the asset could not be found or
// could not be loaded.
func AssetInfo(name string) (os.FileInfo, error) {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	if f, ok := _bindata[cannonicalName]; ok {
		a, err := f()
		if err != nil {
			return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err)
		}
		return a.info, nil
	}
	return nil, fmt.Errorf("AssetInfo %s not found", name)
}

// AssetNames returns the names of the assets.
func AssetNames() []string {
	names := make([]string, 0, len(_bindata))
	for name := range _bindata {
		names = append(names, name)
	}
	return names
}

// _bindata is a table, holding each asset generator, mapped to its name.
var _bindata = map[string]func() (*asset, error){
	"ui/index.html":                   uiIndexHTML,
	"xiang/apis/README.md":            xiangApisReadmeMd,
	"xiang/apis/sys.http.json":        xiangApisSysHTTPJSON,
	"xiang/flows/README.md":           xiangFlowsReadmeMd,
	"xiang/flows/table/get.flow.json": xiangFlowsTableGetFlowJSON,
	"xiang/models/README.md":          xiangModelsReadmeMd,
	"xiang/models/user.json":          xiangModelsUserJSON,
}

// AssetDir returns the file names below a certain
// directory embedded in the file by go-bindata.
// For example if you run go-bindata on data/... and data contains the
// following hierarchy:
//     data/
//       foo.txt
//       img/
//         a.png
//         b.png
// then AssetDir("data") would return []string{"foo.txt", "img"}
// AssetDir("data/img") would return []string{"a.png", "b.png"}
// AssetDir("foo.txt") and AssetDir("notexist") would return an error
// AssetDir("") will return []string{"data"}.
func AssetDir(name string) ([]string, error) {
	node := _bintree
	if len(name) != 0 {
		cannonicalName := strings.Replace(name, "\\", "/", -1)
		pathList := strings.Split(cannonicalName, "/")
		for _, p := range pathList {
			node = node.Children[p]
			if node == nil {
				return nil, fmt.Errorf("Asset %s not found", name)
			}
		}
	}
	if node.Func != nil {
		return nil, fmt.Errorf("Asset %s not found", name)
	}
	rv := make([]string, 0, len(node.Children))
	for childName := range node.Children {
		rv = append(rv, childName)
	}
	return rv, nil
}

type bintree struct {
	Func     func() (*asset, error)
	Children map[string]*bintree
}

var _bintree = &bintree{nil, map[string]*bintree{
	"ui": {nil, map[string]*bintree{
		"index.html": {uiIndexHTML, map[string]*bintree{}},
	}},
	"xiang": {nil, map[string]*bintree{
		"apis": {nil, map[string]*bintree{
			"README.md":     {xiangApisReadmeMd, map[string]*bintree{}},
			"sys.http.json": {xiangApisSysHTTPJSON, map[string]*bintree{}},
		}},
		"flows": {nil, map[string]*bintree{
			"README.md": {xiangFlowsReadmeMd, map[string]*bintree{}},
			"table": {nil, map[string]*bintree{
				"get.flow.json": {xiangFlowsTableGetFlowJSON, map[string]*bintree{}},
			}},
		}},
		"models": {nil, map[string]*bintree{
			"README.md": {xiangModelsReadmeMd, map[string]*bintree{}},
			"user.json": {xiangModelsUserJSON, map[string]*bintree{}},
		}},
	}},
}}

// RestoreAsset restores an asset under the given directory
func RestoreAsset(dir, name string) error {
	data, err := Asset(name)
	if err != nil {
		return err
	}
	info, err := AssetInfo(name)
	if err != nil {
		return err
	}
	err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755))
	if err != nil {
		return err
	}
	err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode())
	if err != nil {
		return err
	}
	err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
	if err != nil {
		return err
	}
	return nil
}

// RestoreAssets restores an asset under the given directory recursively
func RestoreAssets(dir, name string) error {
	children, err := AssetDir(name)
	// File
	if err != nil {
		return RestoreAsset(dir, name)
	}
	// Dir
	for _, child := range children {
		err = RestoreAssets(dir, filepath.Join(name, child))
		if err != nil {
			return err
		}
	}
	return nil
}

func _filePath(dir, name string) string {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...)
}
