package assets

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

func bindata_read(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 bindata_file_info struct {
	name string
	size int64
	mode os.FileMode
	modTime time.Time
}

func (fi bindata_file_info) Name() string {
	return fi.name
}
func (fi bindata_file_info) Size() int64 {
	return fi.size
}
func (fi bindata_file_info) Mode() os.FileMode {
	return fi.mode
}
func (fi bindata_file_info) ModTime() time.Time {
	return fi.modTime
}
func (fi bindata_file_info) IsDir() bool {
	return false
}
func (fi bindata_file_info) Sys() interface{} {
	return nil
}

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

func init_doc_about_bytes() ([]byte, error) {
	return bindata_read(
		_init_doc_about,
		"init-doc/about",
	)
}

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

	info := bindata_file_info{name: "init-doc/about", size: 1677, mode: os.FileMode(420), modTime: time.Unix(1427804268, 0)}
	a := &asset{bytes: bytes, info:  info}
	return a, nil
}

var _init_doc_contact = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x1c\xcd\x41\x6a\x05\x21\x0c\xc6\xf1\xbd\xa7\xf8\xa0\xeb\xa7\x7b\x57\xa5\x43\xa1\xdd\xf6\x06\xd6\x97\xd1\xc0\x68\xa6\x1a\x07\xe6\xf6\xd5\xb7\xfa\x43\xf2\x23\xd9\xa4\x10\x72\xa8\x09\x32\x14\x5c\x67\x1a\xbe\x7f\x36\xc4\x1c\x14\x4d\xa4\x80\x77\xdc\x32\x26\xba\x08\xa1\xde\xf8\x1b\xd4\x95\xa5\x76\x6b\xcc\x26\x55\x43\x54\x68\x26\xf0\xb9\x77\x3c\xe9\x82\x52\x28\xde\x3c\xf0\x31\x52\xf7\xc8\xaa\x67\xf7\xce\x25\xd6\x3c\x7e\x6d\x94\xe2\x96\x74\x49\x1e\xaf\x72\xef\xf3\xe0\xe4\x5f\x74\x9c\x1e\xdc\xa2\xdd\x1b\x51\x95\x27\x59\x69\xc9\xbd\x2d\x35\xd7\x9f\x25\xf0\xe1\xd7\x83\xf7\x35\xb1\x2c\xe6\x3f\x00\x00\xff\xff\x7d\x69\x95\xc6\xbd\x00\x00\x00")

func init_doc_contact_bytes() ([]byte, error) {
	return bindata_read(
		_init_doc_contact,
		"init-doc/contact",
	)
}

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

	info := bindata_file_info{name: "init-doc/contact", size: 189, mode: os.FileMode(420), modTime: time.Unix(1427876009, 0)}
	a := &asset{bytes: bytes, info:  info}
	return a, nil
}

var _init_doc_help = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x3c\x8f\xc1\x71\xc4\x20\x0c\x45\xef\x5b\x85\x66\x72\xc6\xbe\xbb\x8d\x54\xc0\x82\x30\x9a\x60\xe4\x48\x62\x77\xe8\x3e\xe0\xc4\x39\xf2\xf5\xde\x47\xfa\xe4\x03\x21\x63\x39\x53\x2b\x20\xa8\xdc\x24\xa0\x42\x62\x81\x44\x35\x52\xdd\xa1\x8f\x0c\xde\xbe\x83\x17\x6e\x35\x02\x9d\x49\xb7\xc7\xc3\xc1\x77\xa3\xf0\xe5\xd4\xbc\xd8\x06\xfe\xf7\x09\x9a\xf9\x0d\x9c\xe0\xe5\x85\xb8\xe9\x45\x43\x42\x6f\x6d\xb4\x2f\xc3\xba\x82\xc0\xc7\xe1\x6b\xd4\xe9\x15\x52\x9b\x86\x2f\xe5\x3f\xbf\x39\xe7\xe6\x6e\x1b\xe0\x0b\xa5\xdf\x53\x88\xa8\x41\xe8\x39\xf6\x24\x53\x2c\x69\xd0\xd9\xec\xd4\x6d\x5d\x77\xb2\xdc\x9e\xcb\x20\xd7\x59\xb0\xee\xec\xfe\x8a\xc0\x32\x82\x4a\x18\x57\x9e\xac\x64\x2c\x7d\x78\x1f\xd7\x94\x2b\x90\x84\x25\x09\x62\xe5\x88\x0b\xcb\x7e\x1b\xf3\xcf\x56\xc9\xfa\x24\x20\x64\x5f\x2b\x96\xc7\x4f\x00\x00\x00\xff\xff\x2c\xe0\x8e\xed\x37\x01\x00\x00")

func init_doc_help_bytes() ([]byte, error) {
	return bindata_read(
		_init_doc_help,
		"init-doc/help",
	)
}

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

	info := bindata_file_info{name: "init-doc/help", size: 311, mode: os.FileMode(420), modTime: time.Unix(1427876009, 0)}
	a := &asset{bytes: bytes, info:  info}
	return a, nil
}

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

func init_doc_quick_start_bytes() ([]byte, error) {
	return bindata_read(
		_init_doc_quick_start,
		"init-doc/quick-start",
	)
}

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

	info := bindata_file_info{name: "init-doc/quick-start", size: 1685, mode: os.FileMode(420), modTime: time.Unix(1428360466, 0)}
	a := &asset{bytes: bytes, info:  info}
	return a, nil
}

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

func init_doc_readme_bytes() ([]byte, error) {
	return bindata_read(
		_init_doc_readme,
		"init-doc/readme",
	)
}

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

	info := bindata_file_info{name: "init-doc/readme", size: 1091, mode: os.FileMode(420), modTime: time.Unix(1430739633, 0)}
	a := &asset{bytes: bytes, info:  info}
	return a, nil
}

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

func init_doc_security_notes_bytes() ([]byte, error) {
	return bindata_read(
		_init_doc_security_notes,
		"init-doc/security-notes",
	)
}

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

	info := bindata_file_info{name: "init-doc/security-notes", size: 1016, mode: os.FileMode(420), modTime: time.Unix(1427804268, 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){
	"init-doc/about": init_doc_about,
	"init-doc/contact": init_doc_contact,
	"init-doc/help": init_doc_help,
	"init-doc/quick-start": init_doc_quick_start,
	"init-doc/readme": init_doc_readme,
	"init-doc/security-notes": init_doc_security_notes,
}

// 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_t struct {
	Func func() (*asset, error)
	Children map[string]*_bintree_t
}
var _bintree = &_bintree_t{nil, map[string]*_bintree_t{
	"init-doc": &_bintree_t{nil, map[string]*_bintree_t{
		"about": &_bintree_t{init_doc_about, map[string]*_bintree_t{
		}},
		"contact": &_bintree_t{init_doc_contact, map[string]*_bintree_t{
		}},
		"help": &_bintree_t{init_doc_help, map[string]*_bintree_t{
		}},
		"quick-start": &_bintree_t{init_doc_quick_start, map[string]*_bintree_t{
		}},
		"readme": &_bintree_t{init_doc_readme, map[string]*_bintree_t{
		}},
		"security-notes": &_bintree_t{init_doc_security_notes, map[string]*_bintree_t{
		}},
	}},
}}

// Restore 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, path.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
}

// Restore assets under the given directory recursively
func RestoreAssets(dir, name string) error {
        children, err := AssetDir(name)
        if err != nil { // File
                return RestoreAsset(dir, name)
        } else { // Dir
                for _, child := range children {
                        err = RestoreAssets(dir, path.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, "/")...)...)
}

