bindata.go

// Code generated by go-bindata. DO NOT EDIT.
// sources:
// html-templates/layout.tpl (165B)
// html-templates/login.tpl (869B)
// html-templates/recover_end.tpl (744B)
// html-templates/recover_start.tpl (300B)
// html-templates/recovery2fa.tpl (551B)
// html-templates/register.tpl (971B)
// html-templates/sms2fa_confirm.tpl (503B)
// html-templates/sms2fa_confirm_success.tpl (169B)
// html-templates/sms2fa_remove.tpl (635B)
// html-templates/sms2fa_remove_success.tpl (73B)
// html-templates/sms2fa_setup.tpl (385B)
// html-templates/sms2fa_validate.tpl (603B)
// html-templates/totp2fa_confirm.tpl (580B)
// html-templates/totp2fa_confirm_success.tpl (164B)
// html-templates/totp2fa_remove.tpl (604B)
// html-templates/totp2fa_remove_success.tpl (68B)
// html-templates/totp2fa_setup.tpl (246B)
// html-templates/totp2fa_validate.tpl (572B)
// html-templates/twofactor_verify.tpl (356B)
// email-templates/confirm_html.tpl (109B)
// email-templates/confirm_txt.tpl (95B)
// email-templates/recover_html.tpl (117B)
// email-templates/recover_txt.tpl (103B)
// email-templates/twofactor_verify_email_html.tpl (143B)
// email-templates/twofactor_verify_email_txt.tpl (111B)

package abrenderer

import (
	"bytes"
	"compress/gzip"
	"crypto/sha256"
	"fmt"
	"io"
	"io/ioutil"
	"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
	digest [sha256.Size]byte
}

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

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

var _htmlTemplatesLayoutTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb2\x51\x74\xf1\x77\x0e\x89\x0c\x70\x55\xc8\x28\xc9\xcd\xb1\xe3\xb2\x81\x50\x0a\x0a\x0a\x0a\x36\x19\xa9\x89\x29\x10\x26\x98\x5b\x92\x59\x92\x93\x6a\x57\x5d\x9d\x94\x93\x9f\x9c\xad\xa0\x04\xe6\x2a\x29\xe8\xd5\xd6\x56\x57\xa7\xe6\xa5\xd4\xd6\xda\xe8\x43\x54\x40\x34\xeb\x23\x74\xdb\x24\xe5\xa7\x54\x22\x0c\x82\x9b\x90\x58\x5a\x92\x91\x94\x5f\x5c\x8c\x6c\x08\x54\x33\x44\x87\x8d\x3e\xc4\x35\x80\x00\x00\x00\xff\xff\x8e\x27\x12\xb2\xa5\x00\x00\x00")

func htmlTemplatesLayoutTplBytes() ([]byte, error) {
	return bindataRead(
		_htmlTemplatesLayoutTpl,
		"html-templates/layout.tpl",
	)
}

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

	info := bindataFileInfo{name: "html-templates/layout.tpl", size: 165, mode: os.FileMode(0664), modTime: time.Unix(1521648822, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x27, 0x36, 0x4a, 0x13, 0x31, 0xda, 0x80, 0xcf, 0x4d, 0xc, 0xd4, 0x84, 0xed, 0x37, 0xc5, 0xb, 0xf, 0x7c, 0x88, 0xe2, 0xca, 0xca, 0x85, 0x18, 0x29, 0x8e, 0x78, 0x1f, 0x6c, 0x5b, 0x7, 0xc8}}
	return a, nil
}

var _htmlTemplatesLoginTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x92\xcd\x8a\xdc\x30\x0c\xc7\xcf\xdd\xa7\x10\xba\xcf\xe4\x05\x1c\x43\xa1\x3d\x14\x5a\xba\x6c\x4b\xaf\xc5\xb1\x35\x1b\xb3\xb1\x1d\x14\x65\x3f\x08\x7e\xf7\xe2\x7c\x74\x9a\x1d\x98\xe9\x29\xb1\xfc\x97\x7e\xfa\xcb\x52\xa7\xc4\x01\x8c\x15\x9f\x62\x8d\xd3\x14\xd2\x18\xa5\x37\xd2\x92\x03\xec\xd2\xa3\x8f\x98\x33\x42\x20\x69\x93\xab\xf1\xfe\xfb\x8f\x9f\xa8\xef\x00\x00\xa6\xe9\xc5\x4b\x0b\x47\x62\x4e\x9c\xf3\x34\x1d\x73\x56\x0d\x43\xa5\xa7\x89\xa2\xcb\x79\x56\x29\x1f\xfb\x51\x40\xde\x7a\xaa\x51\xe8\x55\x10\x6c\x67\x86\xa1\xc6\x02\x3e\xd8\x14\x85\x53\x87\x10\x4d\xa0\x1a\x29\x18\xdf\x21\xf4\x9d\xb1\xd4\xa6\xce\x11\xd7\xf8\xf9\xb0\x04\x9f\x4d\x37\x52\x69\xf1\xd8\xb3\x0f\x86\xdf\xbe\x7c\xfa\x55\x42\x39\xa3\x5e\xb8\x97\xc0\xde\x0c\xc3\x4b\x62\x77\x15\x7a\x16\xed\xb8\xf7\x5b\x78\xab\xfe\x61\x73\x6c\x07\x3e\xfd\x96\xf4\x44\x31\xe7\x1d\xae\xf5\xce\x51\xdc\xea\x9e\x65\xff\x36\x5f\xa6\xb9\x1f\xd1\x56\x36\x24\x37\x76\x34\x94\x51\x2e\x01\xa6\x40\xa1\x21\x7e\x47\xb1\x2d\xd9\xa7\x26\xbd\x6e\x1c\x0e\x7f\xeb\x0b\x8f\x84\x1a\x1e\xd6\x44\xf8\x46\xaa\x9a\x53\xf5\xee\x65\xe6\x0f\x1c\x72\x3e\x7b\x62\x72\xfe\x3d\x68\x6f\x67\x56\x5c\x77\xa2\x9a\x51\x24\xc5\x35\x7d\x18\x9b\xe0\x05\xf5\xd7\xb2\x45\xaa\x5a\xee\xf4\x2d\xcb\x36\x3d\xcf\x8e\xe7\x7e\x95\x81\x96\xe9\x74\xb1\x98\xab\xac\xac\xa6\x7e\x58\xfe\xe1\xa3\xb5\x45\xa2\x2a\x73\x69\xf3\x06\xf3\xd1\x0f\xf2\x3f\xd0\x45\xb7\x52\x97\xc3\x55\xac\xaa\xca\xbe\xe9\xbb\x3f\x01\x00\x00\xff\xff\x52\x73\xd5\x4b\x65\x03\x00\x00")

func htmlTemplatesLoginTplBytes() ([]byte, error) {
	return bindataRead(
		_htmlTemplatesLoginTpl,
		"html-templates/login.tpl",
	)
}

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

	info := bindataFileInfo{name: "html-templates/login.tpl", size: 869, mode: os.FileMode(0664), modTime: time.Unix(1535743555, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xfa, 0x27, 0xa9, 0x54, 0x2, 0xc7, 0xdc, 0x6d, 0xcb, 0x54, 0xd8, 0xa3, 0x6d, 0x72, 0x7, 0xcf, 0x73, 0x21, 0x42, 0x3a, 0xd5, 0x19, 0x4f, 0xca, 0x42, 0xfb, 0x18, 0x1a, 0x41, 0x4a, 0x90, 0xa0}}
	return a, nil
}

var _htmlTemplatesRecover_endTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x9c\x92\x4f\x72\xab\x30\x0c\xc6\xd7\x2f\xa7\xd0\x68\xf5\xba\x28\xbe\x80\xf1\x26\x07\x68\xa6\xed\x3e\xe3\x60\x51\x3c\x05\x9b\x11\x26\x69\xc7\xe3\xbb\x77\x08\xa6\xf4\xff\xa4\x5d\x21\xe9\x13\x1f\x3f\x09\xc9\xda\x73\x07\xba\x0a\xd6\xbb\x12\x63\xec\xfc\xe8\x42\xaf\x43\x43\x06\x90\xa9\xf2\x47\x62\x41\xce\x60\x4a\x08\x1d\x85\xc6\x9b\x12\x77\x37\x77\xf7\xa8\x36\xff\x62\x3c\xd9\xd0\x40\x41\xcc\x9e\x87\x94\x72\xfe\xdf\x3a\x43\x4f\x50\x00\xe2\xd5\x54\x64\xed\x1e\x08\x8a\x94\xe4\xd0\x6b\xa7\x62\x9c\x42\x71\x8e\xe5\x81\x41\xa8\x18\xc9\x99\xa9\x73\x7d\xc0\x75\x4a\x1b\x00\x00\x69\x5d\x3f\x06\x08\xcf\x3d\x95\xd8\xeb\x61\x38\x79\x36\x08\x4e\x77\xef\xf2\xbe\xd5\x15\x35\xbe\x35\xc4\x25\xee\x5e\xcb\x47\xdd\x8e\x54\x22\x82\xc8\x9f\xfa\x0a\x3a\xf3\x2d\x66\x97\x71\x5e\x06\x58\x79\x57\x5b\xee\xf6\xdf\x80\x6e\x67\x19\xfe\x06\xfc\xd1\xfc\xb7\xe0\x87\x31\x04\xef\x32\xf9\x30\x1e\x3a\x1b\x50\xdd\xce\xff\x5c\x8a\x59\x5d\x28\xce\x2f\x68\x68\x98\xea\x12\x05\xaa\xad\x76\x15\xb5\x52\x68\xf5\x79\x09\x8d\x35\x86\xdc\xb2\x82\xe0\x1f\xa7\x24\x0f\x16\x63\x91\xaf\x6a\x7f\x16\xa6\xb3\xca\xf6\xcb\x9c\xd5\xc0\xf5\x22\xfe\xe0\xbb\xb6\xbd\x35\x9f\xfd\xd6\x41\xa5\x98\x0e\x5c\x6d\x5e\x02\x00\x00\xff\xff\xa6\x15\x7c\x36\xe8\x02\x00\x00")

func htmlTemplatesRecover_endTplBytes() ([]byte, error) {
	return bindataRead(
		_htmlTemplatesRecover_endTpl,
		"html-templates/recover_end.tpl",
	)
}

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

	info := bindataFileInfo{name: "html-templates/recover_end.tpl", size: 744, mode: os.FileMode(0664), modTime: time.Unix(1525720604, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x7c, 0x96, 0x34, 0x5f, 0x16, 0xcc, 0xef, 0x65, 0xf1, 0xd9, 0xc9, 0xc1, 0x43, 0x55, 0xa9, 0x38, 0x77, 0x68, 0xe7, 0x86, 0x1, 0x2e, 0xa4, 0x22, 0x78, 0x78, 0x78, 0xba, 0xd6, 0x1f, 0x46, 0x7c}}
	return a, nil
}

var _htmlTemplatesRecover_startTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x54\x90\x41\x4e\x04\x21\x10\x45\xf7\x7d\x8a\x4a\xed\x67\xb8\x00\xb0\x31\xae\x35\xea\xde\xd0\x4d\xb5\x10\xa1\xe8\x30\xd5\xa3\x86\x70\x77\xd3\x41\xa3\xb3\xad\xfa\x79\x79\xff\xeb\xb5\xd4\x0c\x6e\x91\x58\xd8\x60\x6b\xb9\xec\x2c\x9b\x93\x40\x1e\xb0\xd2\x52\xae\x54\xb1\x77\x84\x4c\x12\x8a\x37\xf8\xf8\xf0\xfc\x82\x76\x02\x00\xd0\x91\xb7\x5d\x40\xbe\x36\x32\x28\xf4\x29\x08\xec\x32\x19\xa4\xec\x62\x42\xd8\x92\x5b\x28\x94\xe4\xa9\x1a\xbc\x3f\x8d\xa3\xb2\x7a\xae\xa0\x06\xa1\xb5\x8f\x28\x01\xce\xcb\xa5\xae\xaf\x52\xde\x89\x7b\xbf\xa1\x86\xe8\x3d\xf1\x2f\xf7\x2f\x86\x70\x75\x69\xa7\xc3\xf8\x7c\xd8\x29\xdb\x1a\xb1\x87\x53\xef\x43\x6d\xde\x45\x0a\xff\x50\x2e\xfb\x9c\xa3\xa0\x7d\x1a\x7d\xb4\x1a\xdf\xff\x26\xda\x41\xa8\xb4\x1a\x54\xa9\xbc\x45\x46\x7b\xe7\x78\xa1\xa4\x95\xb3\x93\x56\xc7\x48\x76\xfa\x0e\x00\x00\xff\xff\x06\x4c\x29\x0e\x2c\x01\x00\x00")

func htmlTemplatesRecover_startTplBytes() ([]byte, error) {
	return bindataRead(
		_htmlTemplatesRecover_startTpl,
		"html-templates/recover_start.tpl",
	)
}

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

	info := bindataFileInfo{name: "html-templates/recover_start.tpl", size: 300, mode: os.FileMode(0664), modTime: time.Unix(1525138168, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x4c, 0xf4, 0x67, 0xdf, 0x39, 0x26, 0xb, 0x51, 0xb3, 0x7f, 0x4f, 0xdf, 0x19, 0x19, 0x43, 0x7f, 0x6, 0xf8, 0xce, 0x3, 0xf2, 0xfe, 0xbe, 0x94, 0x7f, 0x53, 0x84, 0x7a, 0x93, 0x9a, 0xa8, 0x4c}}
	return a, nil
}

var _htmlTemplatesRecovery2faTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x64\x91\xc1\x6e\x83\x30\x10\x44\xef\xf9\x8a\x95\xef\xc5\x4a\x8f\x95\xe1\xd2\x0f\x68\x95\xf6\x1e\x19\xbc\x09\x56\xc3\x1a\x2d\x26\x55\x64\xed\xbf\x57\x60\x08\x69\x7b\x02\xd9\x33\xb3\xfb\xc6\x29\x7d\xfb\xd8\x42\xc1\xd8\x84\x2b\xf2\xed\xd8\x04\x87\x03\x3c\x89\xec\x00\x00\x4c\xbb\xaf\x0e\xcb\x15\xe4\x2b\xc6\x33\x12\xb2\x8d\xe8\x8c\x6e\xf7\x55\xd6\xf5\xf9\x3b\xff\x0f\xbd\xa5\xcd\xf5\x3a\xb9\x5e\x8c\x9e\x4f\x8d\xae\x79\x53\xa6\xc4\x96\xce\x08\xc5\x7d\xde\xe6\x4f\xa9\x10\x59\x5d\x35\x83\x7e\xb4\x21\xb9\x6d\x45\xdd\x57\xbb\x94\xf0\x32\xe0\x76\xb6\x46\xd0\xf1\x37\x98\x08\xf0\x5f\x9c\xce\x7a\xf2\x74\x2e\x96\x61\x39\xe0\x14\xb8\x03\xdb\x44\x1f\xa8\x54\x29\x75\x61\xa4\xd8\xdb\xd8\xa2\x03\xf5\x7c\xb2\x7a\x4d\xd1\x73\x1d\x4a\x44\x41\x87\xb1\x0d\xae\x54\xef\x6f\x1f\x9f\xea\x71\xdb\xdc\x30\x32\x07\x16\xc9\x5c\x33\xd0\xcc\xf1\x00\xbe\x2a\x9b\x81\x4f\xc7\x18\xbe\x90\x44\x8c\xa7\x7e\x8c\x10\x6f\x3d\x96\xaa\xf5\xce\x21\x29\x20\xdb\x61\xa9\x36\x99\x82\xab\xbd\x8c\x38\x2d\x5a\x4c\x9b\xfc\x8f\x36\xf5\x18\x63\xa0\x25\x67\x18\xeb\xce\x47\x55\x1d\xee\x4f\x69\x74\x16\x2c\xf4\x7a\xc2\x9f\x5b\x5d\x8a\xfe\x09\x00\x00\xff\xff\x33\x74\x67\x3b\x27\x02\x00\x00")

func htmlTemplatesRecovery2faTplBytes() ([]byte, error) {
	return bindataRead(
		_htmlTemplatesRecovery2faTpl,
		"html-templates/recovery2fa.tpl",
	)
}

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

	info := bindataFileInfo{name: "html-templates/recovery2fa.tpl", size: 551, mode: os.FileMode(0644), modTime: time.Unix(1535319925, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd3, 0xa5, 0xf7, 0xe0, 0xde, 0xc4, 0xdc, 0x33, 0x66, 0x5e, 0x6c, 0xd4, 0x2a, 0x76, 0x3e, 0xa5, 0xd, 0x47, 0xa3, 0x40, 0x54, 0x8b, 0x46, 0xd2, 0xb, 0x5, 0xc6, 0x43, 0xa, 0x18, 0xe0, 0x3e}}
	return a, nil
}

var _htmlTemplatesRegisterTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x9c\x93\xcd\x6e\xdc\x20\x10\x80\xcf\xeb\xa7\x18\xcd\xa9\x3d\xc4\xbe\x57\x98\x4b\xd4\x7b\xd4\x17\x88\x58\x33\x8e\x51\x6d\x40\x03\x4e\x52\x21\xde\xbd\x62\xfd\xd7\x4d\xfa\xb3\xcd\xc9\xcc\x78\x18\xbe\x0f\x0d\xa2\x77\x3c\x81\xea\xa2\x71\xb6\xc5\x94\x26\x37\xdb\xe8\x55\x1c\x48\x03\x32\x3d\x99\x10\x89\x31\x67\x84\x89\xe2\xe0\x74\x8b\xde\x85\x88\xb2\x3a\xa5\xf4\x62\xe2\x00\x35\x31\x3b\x0e\x39\xaf\xf1\x27\x63\x35\xbd\x42\x0d\x88\x9f\x4b\x92\x95\x7d\x22\xa8\x73\x16\xc1\x2b\x2b\x53\x2a\xcb\xe6\xb2\x16\x67\x86\x46\xa6\x44\x56\x97\xca\xe3\x03\x77\x39\x57\x27\x31\xaa\x33\x8d\xd0\x3b\x6e\x91\x26\x65\x46\x94\x5f\xef\xca\xf7\x8b\x68\x2e\xbf\x64\x75\x12\xc6\xfa\x39\x82\x55\x13\x6d\x45\x10\x7f\x78\x6a\x31\xd2\x6b\x44\x78\x56\xe3\x4c\xc5\x6b\x61\xf5\x4c\x81\xf8\x99\x76\xda\xfa\xb2\xa7\x84\xf5\x35\x42\x31\xf6\xa3\xea\x68\x70\xa3\x26\x6e\x71\x39\x1a\xa1\x59\xb1\x7f\x77\x01\xab\xeb\xda\xf3\x16\xe1\xf7\xa6\x5e\x85\xf0\xe2\x58\xa3\x7c\x58\x57\x7f\xd2\xdd\x2b\x57\xe3\x23\xbe\x02\x7f\xd8\xd3\x37\xa0\x6f\x3d\x3e\x4a\xdf\x39\xdb\x1b\x9e\x1e\x0f\x8b\xfb\x25\x03\xff\xb2\x79\xb7\xf3\xef\x56\x6f\xdb\xde\x64\xf7\xf6\x8c\xff\xb2\x5c\x60\x17\xa8\x30\x9f\x27\x73\x8c\xd7\xb7\xed\x9d\xec\x08\x42\xc1\xc0\xd4\xb7\xd8\xa0\xbc\x57\xb6\xa3\x51\x34\x4a\x56\x07\x5b\x17\xb8\x7f\x8c\xee\x3b\xd9\x9c\xaf\x5a\x0f\x46\x6b\xb2\xb8\xdd\xca\x5e\xf6\xcb\x2c\xd7\x65\x38\x77\xc6\x4a\x34\xe5\x0d\xcb\xea\x67\x00\x00\x00\xff\xff\xf4\x17\x43\xcb\xcb\x03\x00\x00")

func htmlTemplatesRegisterTplBytes() ([]byte, error) {
	return bindataRead(
		_htmlTemplatesRegisterTpl,
		"html-templates/register.tpl",
	)
}

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

	info := bindataFileInfo{name: "html-templates/register.tpl", size: 971, mode: os.FileMode(0664), modTime: time.Unix(1525368703, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xc8, 0xe3, 0x22, 0x0, 0x8b, 0x63, 0xbe, 0xca, 0xb6, 0x96, 0xaa, 0x3e, 0x9e, 0xe3, 0xef, 0x80, 0xa, 0x9f, 0x73, 0x25, 0x9e, 0xc8, 0x43, 0x91, 0xca, 0xae, 0x22, 0x99, 0x21, 0xd1, 0xe6, 0x77}}
	return a, nil
}

var _htmlTemplatesSms2fa_confirmTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x90\x41\x6f\xe3\x20\x10\x85\xef\xf9\x15\xa3\xb9\xc7\x56\xf6\x8c\xb9\xe4\x07\x64\xb5\xbb\xf7\x15\x81\x71\x6d\xc5\x30\x16\x0c\x6d\x23\xc4\x7f\xaf\x48\xd2\x54\x56\xa5\x9e\x40\xf0\xcd\x7b\xf3\x9e\x9a\x0e\xfa\xc8\x61\x9c\xa3\x87\x2b\xe7\x08\xc9\x27\xb0\xec\x08\x84\xc1\xb2\x5f\x17\x12\x82\x44\x92\x57\xd5\x4f\x07\xbd\x53\x23\x47\x0f\xc6\xca\xcc\x61\xc0\x52\x3c\xe7\x20\xab\x91\x89\x1c\xe0\xaf\xd1\xf4\xc9\xa7\xde\xde\x15\xb1\x56\x04\x4f\x32\xb1\x1b\xf0\xf7\xe9\xef\x3f\xd4\x3b\x00\x80\x52\xde\x66\x99\xa0\xa3\x18\x39\xd6\x5a\x4a\x57\xab\x3a\x47\xe8\x75\x29\x14\x5c\xad\xdf\xa9\xd4\xb0\x68\xc2\x0b\x41\xd7\xd6\xab\x55\xa5\xd5\x04\x7d\x9f\xed\x6f\xf7\x8d\xc4\xed\x80\xfd\x43\x4b\xcd\x61\xcd\x02\x72\x5d\x69\x40\xa1\x77\x41\xb0\x8b\x49\x69\xc0\x16\x67\x6f\x39\x48\xe4\x05\x21\x18\x4f\x03\x36\x03\x84\x75\x31\x96\x26\x5e\x1c\xc5\x01\x8f\xb7\x27\x93\x85\x3f\x4b\x19\x90\xc7\x11\x1f\xa6\x9b\x85\x6d\x8a\xe3\x7f\xe1\x0b\x85\x5a\x37\xc6\xd3\xec\x1c\x85\xa7\xcb\x13\x43\x78\x35\x4b\xa6\x56\x67\xd7\x2a\xdb\xf6\xa0\xce\x59\x84\xc3\x43\x23\xe5\xb3\x9f\x05\xf5\x1f\x4a\x14\x9c\xea\xef\x9f\xfa\x07\xf2\x74\xf9\xa2\x54\xdf\xf2\xea\xdd\x47\x00\x00\x00\xff\xff\xdc\x06\x74\x1c\xf7\x01\x00\x00")

func htmlTemplatesSms2fa_confirmTplBytes() ([]byte, error) {
	return bindataRead(
		_htmlTemplatesSms2fa_confirmTpl,
		"html-templates/sms2fa_confirm.tpl",
	)
}

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

	info := bindataFileInfo{name: "html-templates/sms2fa_confirm.tpl", size: 503, mode: os.FileMode(0644), modTime: time.Unix(1535998692, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xa3, 0xdd, 0xe7, 0xa6, 0xb9, 0xfc, 0x63, 0x29, 0x6, 0x6a, 0x39, 0x87, 0x15, 0xd9, 0x27, 0xc3, 0xd3, 0x7e, 0xb0, 0xd9, 0x74, 0x2b, 0x26, 0xf, 0xc6, 0x15, 0x1a, 0xa5, 0x3e, 0xf0, 0xbc, 0x1b}}
	return a, nil
}

var _htmlTemplatesSms2fa_confirm_successTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x4c\xcc\x41\xaa\xc2\x30\x10\xc6\xf1\x7d\x4e\x31\x17\x68\x43\xb7\x8f\x21\x9b\xb7\x76\x63\x0f\x20\x93\x64\x34\x05\x99\x84\x69\x54\x24\xe4\xee\x62\xb5\xe0\xf6\xe3\xf7\xff\x30\x4d\x6e\x3e\xcc\x50\x1f\x79\x38\x53\xa8\x59\x81\x6e\x35\xb1\xd4\x25\x50\x5d\xb2\x00\x0b\xf9\x2b\x47\xb4\x69\x72\x06\x8b\x33\x00\x00\xb8\x16\x12\x77\xe4\x90\xef\xac\x4f\xf8\xcf\x91\xd7\x3f\xb4\xdb\x8a\xd6\xeb\x47\xb5\xa6\x24\x17\x86\x51\xbf\xf0\x14\xde\x10\x86\xde\x7f\x5e\x5a\x1b\x7b\xdf\x5b\xaf\x60\xf7\x98\x25\x6e\x14\x6d\x71\xe6\x15\x00\x00\xff\xff\xc5\x45\x1e\x6f\xa9\x00\x00\x00")

func htmlTemplatesSms2fa_confirm_successTplBytes() ([]byte, error) {
	return bindataRead(
		_htmlTemplatesSms2fa_confirm_successTpl,
		"html-templates/sms2fa_confirm_success.tpl",
	)
}

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

	info := bindataFileInfo{name: "html-templates/sms2fa_confirm_success.tpl", size: 169, mode: os.FileMode(0644), modTime: time.Unix(1535998718, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x7c, 0x46, 0x73, 0xb0, 0x4d, 0xeb, 0xc5, 0x6f, 0x1c, 0xce, 0x3e, 0xbe, 0xdc, 0x6f, 0x67, 0xca, 0xec, 0xc, 0x31, 0xb4, 0x22, 0x8, 0x7b, 0xc9, 0x70, 0x52, 0x7f, 0xb4, 0xe2, 0xbb, 0xb3, 0x27}}
	return a, nil
}

var _htmlTemplatesSms2fa_removeTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x9c\x91\xc1\xae\xdb\x20\x10\x45\xf7\xf9\x8a\xd1\xec\x9f\xad\xf7\xd6\x98\x4d\x3e\x20\x55\xda\x7d\x44\x60\xa8\xad\x18\xc6\x82\x71\xda\x08\xf1\xef\x15\x89\x9b\x2a\x6a\x55\x55\x5d\x81\x98\xc3\xbd\x33\x77\xd4\xf8\xae\xf7\x1c\xfd\x94\x02\xdc\x78\x4d\x90\x43\x06\xcb\x8e\x40\x18\x12\x05\xbe\x12\x7c\x78\x03\x3e\xf1\x06\x18\x6b\x79\x8d\xa2\xfa\xf1\x5d\xef\x94\xe7\x14\xc0\x58\x99\x38\x0e\x58\x4a\x68\xa5\xc5\xc8\x48\x0e\xf0\xc3\x9b\x3e\x87\xdc\x3f\x64\xb0\x56\x84\x40\x32\xb2\x1b\xf0\xd3\xe1\xf3\x17\xd4\x3b\x00\x80\x52\xbe\x4d\x32\x42\x47\x29\x71\xaa\xb5\x94\xae\x56\x75\x4e\xd0\xeb\x52\x28\xba\x5a\x7f\xa7\x72\xc3\x92\x89\x5f\x09\xba\xd6\x6b\xad\x2a\x2f\x26\xea\xc7\xdf\xfe\x7e\x7f\x91\xb8\x1f\xf0\xb6\x69\xa9\x29\x2e\xab\x80\xdc\x16\x1a\x50\xe8\xbb\x20\xd8\xd9\xe4\x3c\x60\x9b\xe6\xcd\x72\x94\xc4\x33\x42\x34\x81\x06\x6c\x06\x08\xcb\x6c\x2c\x8d\x3c\x3b\x4a\x03\xee\xef\x4f\x66\x15\xb6\x1c\x96\x99\x84\x06\x64\xef\x71\x33\xfd\x0f\x93\x44\x96\xaf\x94\x6e\xa7\x3f\xb8\x1d\xb7\x1a\xfc\x8b\xed\xcf\x9c\x6c\x4e\xfe\x24\x7c\xa1\x58\xeb\x4b\x2b\xe3\xe4\x1c\xc5\xe7\x70\x4f\x0c\xe1\x6a\xe6\x95\xda\x12\xbb\xb6\xa9\xd7\xf8\xd5\x79\x15\xe1\xb8\x69\xe4\xf5\x1c\x26\x41\x7d\xa4\x4c\xd1\xa9\xfe\x51\xd4\x7f\x21\x0f\x97\x5f\x94\xea\x5b\x02\x7a\xf7\x23\x00\x00\xff\xff\x08\x3d\x55\x9e\x7b\x02\x00\x00")

func htmlTemplatesSms2fa_removeTplBytes() ([]byte, error) {
	return bindataRead(
		_htmlTemplatesSms2fa_removeTpl,
		"html-templates/sms2fa_remove.tpl",
	)
}

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

	info := bindataFileInfo{name: "html-templates/sms2fa_remove.tpl", size: 635, mode: os.FileMode(0644), modTime: time.Unix(1535998858, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x20, 0x2e, 0xe9, 0x6c, 0x66, 0x6a, 0x48, 0x9b, 0xda, 0xad, 0xe4, 0x6c, 0xd0, 0x4c, 0xf4, 0xa5, 0xc, 0x54, 0xcb, 0x1e, 0x0, 0xc3, 0x54, 0x87, 0xcc, 0x16, 0x76, 0x85, 0x7d, 0x57, 0x6b, 0xf}}
	return a, nil
}

var _htmlTemplatesSms2fa_remove_successTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x04\xc0\xc1\x09\xc5\x20\x0c\x06\xe0\xfb\x9b\x22\x0b\x3c\x8a\x77\x71\x83\x9e\x9c\x20\xa4\x11\x05\x35\xa0\x7f\x5a\xba\x7d\xbf\x58\x43\xca\x67\x26\x3c\xf6\x2f\x2c\xb0\x45\xec\xa8\x3a\xd1\x84\xd1\x6c\xd2\x76\x11\xdd\xbb\x78\xef\x2f\x2d\x1d\x76\xeb\x45\x65\xd9\x20\x16\x31\x9f\x88\x47\x0d\xe9\xf7\x05\x00\x00\xff\xff\xe9\x0e\xb1\x81\x49\x00\x00\x00")

func htmlTemplatesSms2fa_remove_successTplBytes() ([]byte, error) {
	return bindataRead(
		_htmlTemplatesSms2fa_remove_successTpl,
		"html-templates/sms2fa_remove_success.tpl",
	)
}

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

	info := bindataFileInfo{name: "html-templates/sms2fa_remove_success.tpl", size: 73, mode: os.FileMode(0644), modTime: time.Unix(1535998728, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xdf, 0x2a, 0xe3, 0x11, 0xa2, 0xa7, 0x2, 0x8f, 0x62, 0xf6, 0x11, 0xd1, 0xe2, 0xca, 0xc0, 0x9e, 0xd8, 0x2e, 0xa, 0x90, 0x4a, 0xb8, 0xab, 0xf6, 0xd6, 0xf2, 0x3a, 0xb6, 0x0, 0x64, 0xa0, 0x37}}
	return a, nil
}

var _htmlTemplatesSms2fa_setupTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x54\x90\x41\x4f\xc3\x30\x0c\x85\xef\xfd\x15\x96\xef\x5b\x34\xce\x6d\x0f\xfc\x00\x98\x34\xee\x53\x96\xba\x24\xa2\xb1\xab\xc6\x61\xa0\x2a\xff\x1d\x85\x75\x82\x5d\xfd\x9e\x9f\xbf\xe7\xd6\x1f\xfa\x13\x69\x9e\x41\xaf\xb2\x1b\xad\x53\x59\xc0\x66\xf5\xc4\x1a\x9c\xd5\x20\xdc\x1a\x7f\xe8\x9b\x76\x94\x25\x82\x75\x75\xd2\xe1\xba\x46\xc9\xac\xb3\x55\x4f\x03\xe0\xd3\x68\x4d\x8a\xc9\xa4\x9a\x84\xa5\x20\x44\x52\x2f\x43\x87\xc7\xd7\xd3\x1b\xf6\x0d\x00\x40\x1b\x78\xce\x0a\xfa\x3d\x53\x87\x4a\x5f\x8a\xe0\x26\x9b\x52\x87\x35\x7a\xe7\x84\x75\x91\x09\x81\x6d\xa4\x0e\x67\x2f\x4c\x67\xce\xf1\x42\x0b\xc2\x3c\x59\x47\x5e\xa6\x81\x96\x0e\x8f\x55\x82\x97\x4d\x5a\xd7\x6b\x50\x0f\xfb\x14\xd3\xf9\xff\x52\x29\x9f\x76\xca\x54\x59\xf7\xa5\xe0\xba\x12\x0f\xa5\x98\x8d\xe5\x92\x55\x85\x37\x98\x94\x2f\x31\x28\xf6\xcf\xf4\x1e\x18\x7e\xdf\xd1\x9a\x9b\xe3\x66\xbf\xdf\x70\x69\x19\xcf\x2a\x1f\xc4\xa5\x3c\xd4\xf1\x61\x18\x88\xef\xec\x7f\x36\x84\x07\x08\x30\xfd\xc6\xd1\xb4\xa6\xb6\xee\x9b\x9f\x00\x00\x00\xff\xff\xac\xdc\x7f\xaf\x81\x01\x00\x00")

func htmlTemplatesSms2fa_setupTplBytes() ([]byte, error) {
	return bindataRead(
		_htmlTemplatesSms2fa_setupTpl,
		"html-templates/sms2fa_setup.tpl",
	)
}

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

	info := bindataFileInfo{name: "html-templates/sms2fa_setup.tpl", size: 385, mode: os.FileMode(0644), modTime: time.Unix(1535998709, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xc7, 0x36, 0x44, 0x75, 0xf0, 0x3, 0x18, 0xed, 0xc5, 0x88, 0x23, 0xc9, 0xa6, 0x8b, 0xd4, 0x7a, 0x92, 0x8e, 0xc3, 0x75, 0x6f, 0x2, 0x64, 0x3, 0x65, 0x78, 0x82, 0xc9, 0x27, 0x33, 0xa0, 0x22}}
	return a, nil
}

var _htmlTemplatesSms2fa_validateTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x9c\x91\x41\x6b\xfb\x30\x0c\xc5\xef\xfd\x14\x42\xf7\x26\xf4\x7f\x76\x7c\xf9\xb3\x73\x47\xb7\x7b\x71\x6d\x65\x09\x8d\xad\x60\x2b\xdd\x8a\xf1\x77\x1f\x69\xb3\x8e\xb2\x31\xc6\x4e\x36\xd6\xf3\xfb\x49\x4f\xaa\xdb\xe8\x87\x20\x14\xe1\xcc\x53\x84\xe4\x13\x58\x76\xa4\xea\x6e\xa3\x57\xaa\xe5\xe8\xc1\x58\xe9\x39\x34\x98\xb3\xe7\x29\xc8\x68\xa4\x23\x07\xf8\xaf\x35\x75\xf2\xa9\x3e\x99\xa1\x77\x46\x08\x4b\x41\xf0\x24\x1d\xbb\x06\x1f\xb7\x4f\xcf\xa8\x57\x00\x00\x39\xbf\xf6\xd2\x41\x45\x31\x72\x2c\x25\xe7\xaa\x14\x75\x88\x50\xeb\x9c\x29\xb8\x52\xbe\xaa\xd2\x2c\x8b\x26\xbc\x10\x54\x73\x37\xa5\xa8\x34\x9a\xa0\xaf\x7f\xeb\xcb\xfd\xce\xe2\x72\xc0\x7a\xf1\x52\x7d\x18\x27\x01\x39\x8f\xd4\xa0\xd0\x9b\x20\xd8\xc1\xa4\xd4\xe0\x3c\xcf\xda\x72\x90\xc8\x03\x42\x30\x9e\x1a\x9c\x01\x08\xe3\x60\x2c\x75\x3c\x38\x8a\x0d\xfe\xbf\x3c\x99\x49\xd8\xb2\x1f\x07\x12\x6a\x90\xdb\x16\x17\xe8\x1f\x20\x91\x2c\x9f\x28\x9e\xf7\xdf\xd0\x76\x4b\x0d\x7e\x83\xfd\xc8\xc9\xa6\xd8\xee\x85\x8f\x14\x4a\xb9\x6b\xa5\xeb\x9d\xa3\x70\x1b\xee\x26\x43\x38\x99\x61\xa2\x79\x8d\xd5\xbc\xa9\xfb\xf8\xd5\x61\x12\xe1\xb0\x78\xa4\xe9\xe0\x7b\x41\xbd\xa3\x44\xc1\xa9\xfa\x5a\xd4\x3f\x28\xb7\xc7\x4f\x95\xaa\xe7\x04\xf4\xea\x3d\x00\x00\xff\xff\x8d\xf4\xf3\x5e\x5b\x02\x00\x00")

func htmlTemplatesSms2fa_validateTplBytes() ([]byte, error) {
	return bindataRead(
		_htmlTemplatesSms2fa_validateTpl,
		"html-templates/sms2fa_validate.tpl",
	)
}

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

	info := bindataFileInfo{name: "html-templates/sms2fa_validate.tpl", size: 603, mode: os.FileMode(0644), modTime: time.Unix(1535998758, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x30, 0xaf, 0xd3, 0x47, 0x62, 0x33, 0xee, 0xd6, 0x90, 0x5f, 0x7f, 0x36, 0x39, 0x42, 0x8a, 0x45, 0xa8, 0x7e, 0x4a, 0xae, 0xea, 0x55, 0x86, 0xa3, 0x13, 0xec, 0xed, 0xe8, 0xe9, 0xf2, 0xfa, 0x40}}
	return a, nil
}

var _htmlTemplatesTotp2fa_confirmTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x74\x51\x3f\x6f\xdd\x20\x10\xdf\xfd\x29\x4e\xb7\xc7\x56\x3a\x56\x98\x25\x63\x87\x54\x6a\xf7\x8a\x87\xcf\xb1\x15\xc3\x11\x38\xda\x3e\x21\xbe\x7b\x85\x49\x9e\xfa\x54\x75\x42\xba\xbb\xdf\x5f\xd4\xf6\xa8\x9f\xd8\xaf\x7b\x74\x70\xe5\x1c\xc1\x64\xd9\xc8\xcb\x6e\x8d\x70\x04\xcb\x0b\x81\x30\x58\x76\xe1\x20\x21\x48\x24\x39\xa8\x69\x7b\xd4\x83\xda\xdd\x0b\xa4\x68\x67\x2c\xc5\x71\xf6\x12\x8c\x6c\xb4\x00\x7e\x5a\xcd\x24\x2c\x61\x7a\x8b\x58\x2b\x82\x39\x64\x6e\xc3\x0e\x86\xb7\x4e\x8b\x30\x69\x75\x89\x30\xe9\x41\xa5\x60\xbc\xfe\x42\xd7\xcf\x50\xca\xd8\xa0\x89\x6c\x24\xa9\x55\x4d\xe7\x6a\x50\x2b\x47\x07\xc6\xca\xce\xfe\xff\x7a\xb6\x07\x39\x45\x1d\xc9\xc6\xcb\x8c\x5f\x9f\xbf\x7d\x47\x3d\x00\x00\x94\xf2\x6b\x97\x0d\x46\x8a\x91\x63\xad\xa5\x8c\xb5\x76\x07\xa5\x90\x5f\x6a\xfd\xf7\x2a\xb5\xb3\x68\xfc\x0b\xc1\xd8\x4c\xd7\xda\xbd\x76\x6c\x37\x77\x47\x71\x3e\xf0\xf0\xce\xa5\x76\x1f\xb2\x80\x5c\x03\xcd\x28\xf4\x5b\x10\xec\x61\x52\x9a\xb1\xe5\x79\xb0\xec\x25\xf2\x81\xe0\x8d\xa3\x19\x7b\x2b\xe1\x30\x96\x36\x3e\x16\x8a\x33\x3e\x9d\x23\x93\x85\x3f\x7e\x60\x46\x5e\x57\xfc\x68\xee\x6f\xc3\x36\xc5\xf5\x87\xf0\x2b\xf9\x5a\xef\x84\xb7\x7d\x59\xc8\xdf\x54\x6e\x67\x08\x3f\xcd\x91\xa9\xf5\x39\xb6\xca\xee\x7b\x50\x97\x2c\xc2\xfe\x9d\x23\xe5\x8b\xdb\x05\xf5\xf3\xab\x9a\xfa\x42\x0f\x6a\x6a\x29\xf4\xf0\x27\x00\x00\xff\xff\x51\xc2\xb8\xc0\x44\x02\x00\x00")

func htmlTemplatesTotp2fa_confirmTplBytes() ([]byte, error) {
	return bindataRead(
		_htmlTemplatesTotp2fa_confirmTpl,
		"html-templates/totp2fa_confirm.tpl",
	)
}

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

	info := bindataFileInfo{name: "html-templates/totp2fa_confirm.tpl", size: 580, mode: os.FileMode(0644), modTime: time.Unix(1535998512, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xaf, 0xf7, 0xb4, 0xf6, 0x1, 0x28, 0x9c, 0xdc, 0xd0, 0x80, 0xbd, 0xc2, 0xce, 0x50, 0x29, 0x27, 0x93, 0x9, 0x31, 0x61, 0x1b, 0x45, 0xc4, 0x20, 0xa2, 0x94, 0x3, 0x97, 0xf5, 0x49, 0x2b, 0x58}}
	return a, nil
}

var _htmlTemplatesTotp2fa_confirm_successTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x4c\xcc\x51\x0a\xc2\x30\x0c\xc6\xf1\xf7\x9e\x22\x17\xd8\xca\x5e\x25\x14\xc4\x1b\x78\x01\x49\xdb\x68\x05\x49\x4b\x56\x15\x29\xbd\xbb\x6c\x3a\xd8\x5b\x08\xbf\xff\x87\x69\x72\xc7\x67\x4d\x2c\xf5\x1e\xa8\x66\x85\xfa\xce\xc3\x95\xc2\x72\xb2\x90\x7f\x70\x44\x9b\x26\x67\xb0\x38\x03\x00\x80\x73\x21\x71\x67\x0e\xf9\xc5\xfa\x81\x53\x8e\x3c\x1f\xd0\xae\x5f\xb4\x5e\x7f\xaa\x35\x25\xb9\x31\x8c\xfa\x87\x97\xb0\x40\x18\x7a\xdf\xad\xb4\x36\xf6\xbe\xb5\x5e\xc1\x6e\x31\x4b\x5c\x29\xda\xe2\xcc\x37\x00\x00\xff\xff\x4d\x57\xa2\xdf\xa4\x00\x00\x00")

func htmlTemplatesTotp2fa_confirm_successTplBytes() ([]byte, error) {
	return bindataRead(
		_htmlTemplatesTotp2fa_confirm_successTpl,
		"html-templates/totp2fa_confirm_success.tpl",
	)
}

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

	info := bindataFileInfo{name: "html-templates/totp2fa_confirm_success.tpl", size: 164, mode: os.FileMode(0644), modTime: time.Unix(1535998540, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x9f, 0xd2, 0xdf, 0x38, 0xb1, 0x14, 0x2a, 0x63, 0x76, 0x1, 0xcc, 0x22, 0x4, 0x83, 0x21, 0x4d, 0xe0, 0x56, 0x2d, 0x76, 0x91, 0x3a, 0x2f, 0x4f, 0xe, 0xbe, 0x70, 0xe7, 0xe9, 0xd8, 0x41, 0xa6}}
	return a, nil
}

var _htmlTemplatesTotp2fa_removeTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x9c\x91\xc1\x8e\x1b\x21\x0c\x86\xef\x79\x0a\xcb\xf7\xcd\x68\xf7\xcc\x70\xd9\x07\xd8\xaa\xed\x7d\x45\x18\x53\x46\x3b\xe0\x91\xc7\xa4\x8d\x10\xef\x5e\x91\xcc\x46\x8a\xda\x43\xd5\x13\x08\xff\xfc\x9f\x7f\xdb\xc4\x67\xfb\xca\x39\xcc\x92\xe0\xc2\x45\xc0\x15\x8d\x94\x75\xf6\x4e\x59\xc0\xf3\x44\xa0\x0c\x42\x89\xcf\x04\x2f\xc1\x41\x10\xfe\x94\x7a\xcf\x25\xab\x19\xe2\xb3\x3d\x98\xc0\x92\xc0\x79\x9d\x39\x8f\x58\x6b\xea\xa5\xd5\x69\xa4\x09\xf0\x25\xb8\x41\x59\xd7\xe1\xe6\x83\xad\x21\x24\xd2\xc8\xd3\x88\x5f\xde\xbe\x7d\x47\x7b\x00\x00\xa8\xf5\xe7\xac\x11\x8e\x24\xc2\xd2\x5a\xad\xc7\xd6\xcc\x49\x60\xb0\xb5\x52\x9e\x5a\xfb\x53\xb5\x75\x99\xb8\xfc\x83\xe0\xd8\x9b\x6d\xcd\x6c\xab\xcb\xf6\xf6\x77\xb8\xde\x1f\x2c\xae\x07\x3c\xed\x5e\x66\xce\x6b\x51\xd0\xcb\x4a\x23\x2a\xfd\x52\x04\xbf\xb8\x6d\x1b\xb1\xc7\x79\xf2\x9c\x55\x78\x41\xc8\x2e\xd1\x88\x1d\x80\xb0\x2e\xce\x53\xe4\x65\x22\x19\xf1\xf5\xfa\xe4\x8a\xb2\xe7\xb4\x2e\xa4\x34\x22\x87\x80\x3b\xf4\x3f\x20\x42\x9e\xcf\x24\x97\xf7\xbf\xd0\xbe\xee\x35\xf8\x17\xec\xe7\x9c\xfc\x26\xe1\x5d\xf9\x83\x72\x6b\x0f\xad\xc4\x79\x9a\x28\xdf\xc3\xdd\x65\x08\x67\xb7\x14\xea\x5b\x3c\xf6\x4d\x3d\x8e\xdf\x9c\x8a\x2a\xe7\xdd\x63\x2b\xa7\x34\x2b\xda\xb7\x0f\x33\xdc\x0a\xf6\x60\x86\x9e\xcb\x1e\x7e\x07\x00\x00\xff\xff\x96\xa3\xdc\x41\x5c\x02\x00\x00")

func htmlTemplatesTotp2fa_removeTplBytes() ([]byte, error) {
	return bindataRead(
		_htmlTemplatesTotp2fa_removeTpl,
		"html-templates/totp2fa_remove.tpl",
	)
}

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

	info := bindataFileInfo{name: "html-templates/totp2fa_remove.tpl", size: 604, mode: os.FileMode(0644), modTime: time.Unix(1535998484, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x91, 0xf0, 0x7b, 0x90, 0x6f, 0xae, 0x51, 0x47, 0xbc, 0x47, 0x97, 0x39, 0xd1, 0x34, 0x48, 0xa4, 0xc8, 0x42, 0x8e, 0x1c, 0x3f, 0x84, 0x6, 0x4f, 0x64, 0xfe, 0xc6, 0x22, 0xfa, 0x3b, 0x89, 0x41}}
	return a, nil
}

var _htmlTemplatesTotp2fa_remove_successTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb2\xc9\x30\xb4\x73\x2c\x2d\xc9\x48\xcd\x2b\xc9\x4c\x4e\x2c\xc9\x2f\x52\x28\x29\xcf\xd7\x4d\x4b\x4c\x06\x31\x8b\x4b\x93\x93\x53\x8b\x8b\xd3\x4a\x73\x72\x2a\x15\x8a\x52\x73\xf3\xcb\x52\x53\x14\xd2\x8a\xf2\x73\x15\x12\x93\x93\xf3\x4b\xf3\x4a\x6c\xf4\x33\x0c\xed\xb8\x00\x01\x00\x00\xff\xff\x44\x9c\xf0\x24\x44\x00\x00\x00")

func htmlTemplatesTotp2fa_remove_successTplBytes() ([]byte, error) {
	return bindataRead(
		_htmlTemplatesTotp2fa_remove_successTpl,
		"html-templates/totp2fa_remove_success.tpl",
	)
}

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

	info := bindataFileInfo{name: "html-templates/totp2fa_remove_success.tpl", size: 68, mode: os.FileMode(0644), modTime: time.Unix(1535998829, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x88, 0x41, 0x8b, 0xa2, 0x51, 0x3c, 0x39, 0x98, 0xaa, 0x89, 0x7f, 0x22, 0xa3, 0xcf, 0x66, 0x33, 0x98, 0x87, 0xa0, 0xf8, 0x60, 0x9c, 0xba, 0x8a, 0x17, 0xf5, 0x62, 0xea, 0x92, 0xf2, 0x6b, 0xdd}}
	return a, nil
}

var _htmlTemplatesTotp2fa_setupTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x44\x8f\xc1\x4a\xc4\x30\x14\x45\xf7\xfd\x8a\xc7\xdb\x3b\x61\x5c\xa7\x59\xf8\x03\x0a\xe3\x5e\x32\xed\xab\x09\x9a\x97\xd0\xde\x38\x48\xc8\xbf\x4b\x1c\xc1\xed\xe5\x70\x38\xd7\x86\xb3\xbb\x08\x6a\x21\xdc\xf2\xc3\xe6\x17\xe4\x9d\x7c\x45\x10\x45\x5c\x3c\x62\x56\x6b\xc2\xd9\x4d\x76\xcb\x7b\x22\xbf\x8c\x65\xe6\xd6\x52\xae\x8a\xe2\x11\x64\x25\x7e\xdc\xbc\x41\x46\x31\xc7\x50\x71\xef\x4c\x49\x10\xf2\x3a\xf3\xcb\xf3\xe5\x95\xdd\x44\x44\x64\xaf\x15\xc8\x4a\xf8\x2e\x32\xf3\x51\xaf\x29\x82\xdd\x93\xbc\x47\xa5\xdf\x06\x6b\xee\xc4\x1d\x6f\xed\x16\x11\xe8\xb4\x1c\xfb\xf6\x86\xfc\x21\xda\xbb\x8d\x5a\x2a\xfe\x0c\x21\xae\xab\x28\x93\xfa\x24\x33\xff\x63\x4c\x5f\xfe\xb3\xca\xa8\x3c\x8d\x14\xe3\x5a\x13\x5d\x7b\x9f\xac\x19\x2f\xdc\xf4\x13\x00\x00\xff\xff\xf9\xee\x63\x1f\xf6\x00\x00\x00")

func htmlTemplatesTotp2fa_setupTplBytes() ([]byte, error) {
	return bindataRead(
		_htmlTemplatesTotp2fa_setupTpl,
		"html-templates/totp2fa_setup.tpl",
	)
}

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

	info := bindataFileInfo{name: "html-templates/totp2fa_setup.tpl", size: 246, mode: os.FileMode(0644), modTime: time.Unix(1535998293, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xfc, 0xe5, 0xe0, 0xae, 0xce, 0xde, 0x68, 0x76, 0xc6, 0x51, 0x96, 0x95, 0xea, 0x8d, 0xd, 0x2e, 0x16, 0x97, 0xde, 0x46, 0xbd, 0xc4, 0xfa, 0xf9, 0xc4, 0xd5, 0x74, 0x56, 0xfe, 0xf2, 0x1b, 0x82}}
	return a, nil
}

var _htmlTemplatesTotp2fa_validateTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x9c\x91\x41\x4f\xc3\x30\x0c\x85\xef\xfd\x15\x96\xef\x6b\x35\xce\x69\x2e\x88\xf3\x10\x70\x9f\xb2\xc4\x25\xd5\xda\xb8\x4a\x9d\xc1\x14\xe5\xbf\xa3\x6e\x65\xd2\x04\x07\xc4\x29\x51\xfc\xf2\x3e\x3f\x5b\xf9\xad\x7e\x0a\x42\x11\xce\x9c\x22\x98\x24\x9e\x82\xf4\xd6\x08\x47\xb0\xec\x48\x35\x7e\xab\x2b\xd5\x71\x1c\xc1\x58\xe9\x39\xb4\x98\xf3\xc8\x29\xc8\x64\xc4\x93\x03\x7c\xe8\x4c\x23\x2c\x53\x73\x32\x43\xef\x8c\x10\x96\x82\x30\x92\x78\x76\x2d\x3e\xef\x5e\xdf\x50\x57\x00\x00\x39\x7f\xf4\xe2\xa1\xa6\x18\x39\x96\x92\x73\x5d\x8a\x3a\x44\x68\x74\xce\x14\x5c\x29\x3f\x55\xf3\x22\x8b\x26\xbc\x13\xd4\x4b\x3b\xa5\xa8\x79\x32\x41\x5f\xff\x36\x97\xfb\x9d\xc5\xe5\x80\xcd\xea\xa5\xfa\x30\x25\x01\x39\x4f\xd4\xa2\xd0\xa7\x20\xd8\xc1\xcc\x73\x8b\x4b\xa0\x8d\xe5\x20\x91\x07\x84\x60\x46\x6a\x71\x01\x20\x4c\x83\xb1\xe4\x79\x70\x14\x5b\x7c\xbc\x3c\x99\x24\x6c\x79\x9c\x06\x12\x6a\x91\xbb\x0e\x57\xe8\x3f\x20\x91\x2c\x9f\x28\x9e\xf7\xbf\xd0\x5e\xd6\x1a\xfc\x05\xfb\x3d\x27\x3b\xc7\x6e\x2f\x7c\xa4\x50\xca\x5d\x2b\xbe\x77\x8e\xc2\x2d\xdc\x4d\x86\x70\x32\x43\xa2\x65\x8f\xf5\xb2\xa9\xfb\xf1\xab\x43\x12\xe1\xb0\x7a\xcc\xe9\x30\xf6\x82\x7a\x77\x54\xcd\xb5\xa0\x2b\xd5\x2c\xb9\x74\xf5\x15\x00\x00\xff\xff\x05\x85\x94\x9f\x3c\x02\x00\x00")

func htmlTemplatesTotp2fa_validateTplBytes() ([]byte, error) {
	return bindataRead(
		_htmlTemplatesTotp2fa_validateTpl,
		"html-templates/totp2fa_validate.tpl",
	)
}

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

	info := bindataFileInfo{name: "html-templates/totp2fa_validate.tpl", size: 572, mode: os.FileMode(0644), modTime: time.Unix(1535998464, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x18, 0x4a, 0x50, 0xbd, 0xe4, 0x93, 0xa6, 0x51, 0x2f, 0x52, 0x7b, 0x6c, 0x9b, 0x86, 0x43, 0x56, 0x17, 0xce, 0x15, 0xe9, 0xb, 0xf3, 0x3b, 0xda, 0xb8, 0x86, 0x40, 0x97, 0xb1, 0x1f, 0x79, 0xdf}}
	return a, nil
}

var _htmlTemplatesTwofactor_verifyTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x54\x8f\xc1\x4e\xf3\x30\x10\x06\xef\x79\x8a\xd5\xde\xdb\xa8\xff\xd9\xb6\xf4\x1f\x38\x17\x09\xee\xc8\xb1\x37\xd8\xaa\xe3\x8d\x9c\x35\x50\x2c\xbf\x3b\x0a\x45\x15\x9c\x77\xbf\xd1\x8c\x0a\x27\xf3\xbf\x4a\xe0\x12\x3f\x09\xac\xf7\x31\xbf\xc2\xbf\xd9\x82\x30\x5c\xb9\x16\xb0\xce\x71\xcd\xa2\xc6\x70\x32\x83\x9a\xb9\x2c\x60\x9d\x44\xce\x1a\x5b\x3b\xd6\x92\x7a\x47\x58\x48\x02\x7b\x8d\x8f\xe7\xa7\x67\x34\x03\x00\x80\x8a\x79\xad\x02\x72\x5d\x49\xa3\xd0\x87\x20\xb8\x64\xb7\x4d\xe3\xce\x38\x38\xce\x52\x38\x21\x64\xbb\x90\x46\xc7\x9e\x10\xd6\x64\x1d\x05\x4e\x9e\x8a\xc6\x87\xc3\x62\x63\x42\xf0\x71\xb3\x53\x22\xaf\x51\x4a\x25\x04\x5b\x85\x1d\x2f\x6b\x22\x21\x8d\x3c\xcf\x08\x6f\x36\x55\xfa\xf6\xa1\x7d\xd3\x3b\x1a\x35\x15\x18\x6f\x26\xad\xbd\x47\x09\x70\x74\x5b\x99\x5f\x84\x2f\x94\x7b\xff\x63\x17\xa2\xf7\x94\xef\x2a\xf7\xb7\xdf\xe0\xbd\x72\x34\xad\x51\xf6\xbd\xdf\x02\xa7\x2a\xc2\xf9\x87\xb1\xd5\x69\x89\x82\xe6\x7c\x51\xe3\xed\x60\x06\x35\xee\xa9\x66\xf8\x0a\x00\x00\xff\xff\x49\xe7\xd3\x02\x64\x01\x00\x00")

func htmlTemplatesTwofactor_verifyTplBytes() ([]byte, error) {
	return bindataRead(
		_htmlTemplatesTwofactor_verifyTpl,
		"html-templates/twofactor_verify.tpl",
	)
}

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

	info := bindataFileInfo{name: "html-templates/twofactor_verify.tpl", size: 356, mode: os.FileMode(0644), modTime: time.Unix(1541397352, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x86, 0x9a, 0xdf, 0x29, 0x99, 0xa0, 0xdd, 0x95, 0xd3, 0xe7, 0x7, 0x2b, 0x89, 0x9b, 0x2c, 0x46, 0xbe, 0xfc, 0xb4, 0xbe, 0xff, 0xc8, 0xd4, 0xd7, 0x2e, 0x83, 0xae, 0x67, 0x63, 0x89, 0x72, 0x3e}}
	return a, nil
}

var _emailTemplatesConfirm_htmlTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x6c\xcc\xc1\x0d\xc2\x30\x0c\x05\xd0\x7b\xa6\xf8\xea\x00\x44\xbd\x1b\x5f\x58\x80\x15\x8c\xe5\xca\x15\xa1\xae\x4c\x73\x40\x55\x76\x67\x81\x2e\xf0\xc8\x67\x7e\xc4\xb6\xac\xf9\xc1\x2f\x7a\x42\x54\xa3\x6f\x07\x55\x9f\xb9\xd0\x2b\x51\xb9\xd0\xce\xcf\x66\xf2\x35\x68\x5b\xf5\x0d\x12\x78\xda\x72\x9f\xce\xf3\xd6\xb3\x8d\x31\xb1\x5b\x1a\x55\x61\x1c\x01\xbd\xf4\x76\x2e\xff\x00\x00\x00\xff\xff\x9c\x6e\xd6\xd5\x6d\x00\x00\x00")

func emailTemplatesConfirm_htmlTplBytes() ([]byte, error) {
	return bindataRead(
		_emailTemplatesConfirm_htmlTpl,
		"email-templates/confirm_html.tpl",
	)
}

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

	info := bindataFileInfo{name: "email-templates/confirm_html.tpl", size: 109, mode: os.FileMode(0644), modTime: time.Unix(1574987272, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xed, 0x54, 0x85, 0xe2, 0x95, 0xd4, 0x6e, 0x7e, 0x18, 0x8b, 0x65, 0x87, 0x43, 0xaa, 0x37, 0xe5, 0x67, 0xac, 0x93, 0xb5, 0x3e, 0x67, 0xf2, 0xc1, 0x16, 0x5c, 0xc1, 0xd, 0xe1, 0xab, 0x9e, 0xff}}
	return a, nil
}

var _emailTemplatesConfirm_txtTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x24\xc8\xb1\x0d\xc2\x30\x10\x05\xd0\x9e\x29\xfe\x04\xcc\xc2\x00\x69\x8c\xb9\x80\xc5\xf1\x7f\x74\x3e\x2b\x8a\x22\xef\x4e\x91\xf6\x3d\xdc\x4a\x37\x54\x6d\x07\x0a\x5f\xd8\x4a\x4f\x43\x7e\x0c\xab\xdc\xb5\x37\xbe\xe1\x8d\x5f\x34\xa6\x70\x68\x04\x9e\xa1\xbd\x5b\x20\x85\x2a\xae\x2d\x7e\x97\x97\x5a\x35\x98\x0b\x17\x9e\xe7\x7d\x84\xcf\x79\xfb\x07\x00\x00\xff\xff\x07\x81\x24\x0a\x5f\x00\x00\x00")

func emailTemplatesConfirm_txtTplBytes() ([]byte, error) {
	return bindataRead(
		_emailTemplatesConfirm_txtTpl,
		"email-templates/confirm_txt.tpl",
	)
}

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

	info := bindataFileInfo{name: "email-templates/confirm_txt.tpl", size: 95, mode: os.FileMode(0644), modTime: time.Unix(1541397320, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x12, 0x4b, 0xfa, 0x79, 0x6f, 0x99, 0x6e, 0x4d, 0x20, 0xec, 0xd2, 0x4e, 0x25, 0xab, 0x6, 0x6a, 0xac, 0xb8, 0xa9, 0x97, 0xac, 0x1e, 0x1e, 0x2f, 0x93, 0x47, 0xa3, 0x52, 0x77, 0xdc, 0xf, 0x5}}
	return a, nil
}

var _emailTemplatesRecover_htmlTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x6c\xcc\xc1\x09\xc2\x40\x10\x05\xd0\xfb\x56\xf1\x49\x01\x2e\xb9\x8f\x53\x83\xd8\x80\xac\xc3\xc8\x88\x8b\x13\xbe\x59\x41\x42\x7a\xf7\xe0\xd5\x02\xde\x93\x98\xf5\xec\x96\x6f\x27\x3e\x39\x88\x66\x96\xe3\xb9\x4a\x8d\x59\x8b\x5c\x89\xaa\x45\x16\x3d\x75\x6f\x2f\x87\xf5\xbb\x3d\x20\x0d\x41\xbf\x1d\xa7\x6d\x3b\xf0\x87\x2f\x83\x7d\xdf\x27\x0d\xa7\x4b\x6d\x8a\x35\xc1\xbf\xef\xa2\xe5\x1b\x00\x00\xff\xff\xb0\x69\x4e\x28\x75\x00\x00\x00")

func emailTemplatesRecover_htmlTplBytes() ([]byte, error) {
	return bindataRead(
		_emailTemplatesRecover_htmlTpl,
		"email-templates/recover_html.tpl",
	)
}

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

	info := bindataFileInfo{name: "email-templates/recover_html.tpl", size: 117, mode: os.FileMode(0644), modTime: time.Unix(1570664914, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xb4, 0x1a, 0xb, 0xf8, 0x27, 0x99, 0x20, 0x4d, 0x6e, 0xe, 0xa6, 0x29, 0xc9, 0x39, 0x3a, 0x88, 0x79, 0xb0, 0xd, 0x4a, 0x85, 0x7, 0xf1, 0x21, 0xc, 0x5c, 0x3e, 0x83, 0x89, 0x23, 0xf7, 0xa6}}
	return a, nil
}

var _emailTemplatesRecover_txtTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x24\xc8\x41\x0e\x82\x40\x0c\x05\xd0\xbd\xa7\xf8\x27\xf0\x2c\x1e\x80\xc4\x8c\xb5\x68\x63\xed\x27\x9d\x8e\x84\x10\xee\xee\x82\xed\xbb\xb9\xb6\xae\x10\x2e\x1b\x5a\x3c\xb1\xb4\x5e\x8a\x7a\x2b\x66\xba\x73\xb5\x78\xc1\x2d\x3e\xb0\x28\x62\xe3\x48\x3c\x92\x6b\xd7\x44\x11\xc2\x98\x2d\xbf\xa7\x37\x11\x8e\xa8\x29\xa6\xd8\xf7\x6b\xaa\xf0\xa7\x79\x1f\xe9\xc7\x71\xf9\x07\x00\x00\xff\xff\x7f\x48\x0e\x70\x67\x00\x00\x00")

func emailTemplatesRecover_txtTplBytes() ([]byte, error) {
	return bindataRead(
		_emailTemplatesRecover_txtTpl,
		"email-templates/recover_txt.tpl",
	)
}

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

	info := bindataFileInfo{name: "email-templates/recover_txt.tpl", size: 103, mode: os.FileMode(0664), modTime: time.Unix(1525719558, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x22, 0x57, 0x52, 0x4b, 0x75, 0x56, 0x90, 0x3d, 0x38, 0x67, 0xe7, 0x6c, 0x9a, 0xa6, 0xca, 0xc, 0x16, 0xec, 0xc1, 0x8e, 0x73, 0xe4, 0x5f, 0xa4, 0xf3, 0xe6, 0x5d, 0x35, 0x85, 0x26, 0x87, 0x7}}
	return a, nil
}

var _emailTemplatesTwofactor_verify_email_htmlTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\xcd\xc1\x0d\xc2\x30\x0c\x05\xd0\x7b\xa6\xf8\xea\x00\x44\xe5\x6c\x2c\xb1\x01\x2b\x98\xd4\xc5\x11\x51\x53\x99\xe4\x00\x55\x76\x47\x6c\xc0\x02\xef\x91\xcd\x7c\xed\xcd\xaa\xe7\x8f\x42\x96\x25\x6f\x0f\x9c\x57\x41\xab\x78\xd7\xee\x90\x94\x6a\xdf\x1a\x45\x9b\x39\xd0\xdd\x11\x39\xd0\xce\xb7\xa2\xf2\x52\xa4\x92\xd3\x13\x24\x30\xd7\xf5\x32\x1d\xc7\xa9\x7b\x19\x63\x42\x64\x53\x57\x8a\xc2\x3f\x49\xfe\x1a\x76\x0e\xdf\x00\x00\x00\xff\xff\xa3\xae\xcf\x44\x8f\x00\x00\x00")

func emailTemplatesTwofactor_verify_email_htmlTplBytes() ([]byte, error) {
	return bindataRead(
		_emailTemplatesTwofactor_verify_email_htmlTpl,
		"email-templates/twofactor_verify_email_html.tpl",
	)
}

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

	info := bindataFileInfo{name: "email-templates/twofactor_verify_email_html.tpl", size: 143, mode: os.FileMode(0644), modTime: time.Unix(1541397312, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x57, 0x7d, 0xed, 0x5, 0xa8, 0xf9, 0x20, 0x37, 0x41, 0x51, 0xd6, 0x5e, 0xda, 0x8a, 0xbb, 0x7, 0xa8, 0x1b, 0xdf, 0x17, 0x6b, 0x96, 0xa2, 0xb3, 0x5d, 0xa3, 0x84, 0xa6, 0xf, 0xb0, 0x3a, 0xf8}}
	return a, nil
}

var _emailTemplatesTwofactor_verify_email_txtTpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x34\xca\xb1\x0d\xc2\x40\x0c\x05\xd0\x9e\x29\xfe\x04\x14\x4c\xc2\x00\x69\xcc\x9d\x43\x4e\x58\xfe\x91\xcf\xa7\x28\x44\xd9\x1d\x51\xa4\x7f\x4f\x53\xe9\x8a\xc2\x75\x87\x78\xc5\x2a\x3d\x15\xb9\x28\x66\x9a\x71\x6b\xfe\x86\x35\xff\xa0\x79\x12\x3b\x47\xe0\x15\xdc\xba\x06\x92\x90\x91\x0b\xa3\x7d\x15\x52\xeb\x9f\x3e\x66\xc1\xe5\xa4\x14\x0e\xcf\xc9\x27\x3f\x8e\xfb\x08\x3b\xcf\xdb\x2f\x00\x00\xff\xff\x5b\x3c\x47\xec\x6f\x00\x00\x00")

func emailTemplatesTwofactor_verify_email_txtTplBytes() ([]byte, error) {
	return bindataRead(
		_emailTemplatesTwofactor_verify_email_txtTpl,
		"email-templates/twofactor_verify_email_txt.tpl",
	)
}

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

	info := bindataFileInfo{name: "email-templates/twofactor_verify_email_txt.tpl", size: 111, mode: os.FileMode(0644), modTime: time.Unix(1541397304, 0)}
	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x22, 0xf5, 0x36, 0x91, 0x8a, 0x89, 0xe0, 0x1a, 0x91, 0x5c, 0x82, 0x6c, 0x56, 0xf, 0xc3, 0x10, 0x45, 0xb8, 0xcb, 0x6f, 0x28, 0xcc, 0xb8, 0xea, 0x77, 0xe6, 0xa4, 0xca, 0xdc, 0xe7, 0x2c, 0xf4}}
	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) {
	canonicalName := strings.Replace(name, "\\", "/", -1)
	if f, ok := _bindata[canonicalName]; 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)
}

// AssetString returns the asset contents as a string (instead of a []byte).
func AssetString(name string) (string, error) {
	data, err := Asset(name)
	return string(data), err
}

// 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
}

// MustAssetString is like AssetString but panics when Asset would return an
// error. It simplifies safe initialization of global variables.
func MustAssetString(name string) string {
	return string(MustAsset(name))
}

// 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) {
	canonicalName := strings.Replace(name, "\\", "/", -1)
	if f, ok := _bindata[canonicalName]; 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)
}

// AssetDigest returns the digest of the file with the given name. It returns an
// error if the asset could not be found or the digest could not be loaded.
func AssetDigest(name string) ([sha256.Size]byte, error) {
	canonicalName := strings.Replace(name, "\\", "/", -1)
	if f, ok := _bindata[canonicalName]; ok {
		a, err := f()
		if err != nil {
			return [sha256.Size]byte{}, fmt.Errorf("AssetDigest %s can't read by error: %v", name, err)
		}
		return a.digest, nil
	}
	return [sha256.Size]byte{}, fmt.Errorf("AssetDigest %s not found", name)
}

// Digests returns a map of all known files and their checksums.
func Digests() (map[string][sha256.Size]byte, error) {
	mp := make(map[string][sha256.Size]byte, len(_bindata))
	for name := range _bindata {
		a, err := _bindata[name]()
		if err != nil {
			return nil, err
		}
		mp[name] = a.digest
	}
	return mp, nil
}

// 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){
	"html-templates/layout.tpl":                       htmlTemplatesLayoutTpl,
	"html-templates/login.tpl":                        htmlTemplatesLoginTpl,
	"html-templates/recover_end.tpl":                  htmlTemplatesRecover_endTpl,
	"html-templates/recover_start.tpl":                htmlTemplatesRecover_startTpl,
	"html-templates/recovery2fa.tpl":                  htmlTemplatesRecovery2faTpl,
	"html-templates/register.tpl":                     htmlTemplatesRegisterTpl,
	"html-templates/sms2fa_confirm.tpl":               htmlTemplatesSms2fa_confirmTpl,
	"html-templates/sms2fa_confirm_success.tpl":       htmlTemplatesSms2fa_confirm_successTpl,
	"html-templates/sms2fa_remove.tpl":                htmlTemplatesSms2fa_removeTpl,
	"html-templates/sms2fa_remove_success.tpl":        htmlTemplatesSms2fa_remove_successTpl,
	"html-templates/sms2fa_setup.tpl":                 htmlTemplatesSms2fa_setupTpl,
	"html-templates/sms2fa_validate.tpl":              htmlTemplatesSms2fa_validateTpl,
	"html-templates/totp2fa_confirm.tpl":              htmlTemplatesTotp2fa_confirmTpl,
	"html-templates/totp2fa_confirm_success.tpl":      htmlTemplatesTotp2fa_confirm_successTpl,
	"html-templates/totp2fa_remove.tpl":               htmlTemplatesTotp2fa_removeTpl,
	"html-templates/totp2fa_remove_success.tpl":       htmlTemplatesTotp2fa_remove_successTpl,
	"html-templates/totp2fa_setup.tpl":                htmlTemplatesTotp2fa_setupTpl,
	"html-templates/totp2fa_validate.tpl":             htmlTemplatesTotp2fa_validateTpl,
	"html-templates/twofactor_verify.tpl":             htmlTemplatesTwofactor_verifyTpl,
	"email-templates/confirm_html.tpl":                emailTemplatesConfirm_htmlTpl,
	"email-templates/confirm_txt.tpl":                 emailTemplatesConfirm_txtTpl,
	"email-templates/recover_html.tpl":                emailTemplatesRecover_htmlTpl,
	"email-templates/recover_txt.tpl":                 emailTemplatesRecover_txtTpl,
	"email-templates/twofactor_verify_email_html.tpl": emailTemplatesTwofactor_verify_email_htmlTpl,
	"email-templates/twofactor_verify_email_txt.tpl":  emailTemplatesTwofactor_verify_email_txtTpl,
}

// 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, and
// AssetDir("") will return []string{"data"}.
func AssetDir(name string) ([]string, error) {
	node := _bintree
	if len(name) != 0 {
		canonicalName := strings.Replace(name, "\\", "/", -1)
		pathList := strings.Split(canonicalName, "/")
		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{
	"email-templates": &bintree{nil, map[string]*bintree{
		"confirm_html.tpl":                &bintree{emailTemplatesConfirm_htmlTpl, map[string]*bintree{}},
		"confirm_txt.tpl":                 &bintree{emailTemplatesConfirm_txtTpl, map[string]*bintree{}},
		"recover_html.tpl":                &bintree{emailTemplatesRecover_htmlTpl, map[string]*bintree{}},
		"recover_txt.tpl":                 &bintree{emailTemplatesRecover_txtTpl, map[string]*bintree{}},
		"twofactor_verify_email_html.tpl": &bintree{emailTemplatesTwofactor_verify_email_htmlTpl, map[string]*bintree{}},
		"twofactor_verify_email_txt.tpl":  &bintree{emailTemplatesTwofactor_verify_email_txtTpl, map[string]*bintree{}},
	}},
	"html-templates": &bintree{nil, map[string]*bintree{
		"layout.tpl":                  &bintree{htmlTemplatesLayoutTpl, map[string]*bintree{}},
		"login.tpl":                   &bintree{htmlTemplatesLoginTpl, map[string]*bintree{}},
		"recover_end.tpl":             &bintree{htmlTemplatesRecover_endTpl, map[string]*bintree{}},
		"recover_start.tpl":           &bintree{htmlTemplatesRecover_startTpl, map[string]*bintree{}},
		"recovery2fa.tpl":             &bintree{htmlTemplatesRecovery2faTpl, map[string]*bintree{}},
		"register.tpl":                &bintree{htmlTemplatesRegisterTpl, map[string]*bintree{}},
		"sms2fa_confirm.tpl":          &bintree{htmlTemplatesSms2fa_confirmTpl, map[string]*bintree{}},
		"sms2fa_confirm_success.tpl":  &bintree{htmlTemplatesSms2fa_confirm_successTpl, map[string]*bintree{}},
		"sms2fa_remove.tpl":           &bintree{htmlTemplatesSms2fa_removeTpl, map[string]*bintree{}},
		"sms2fa_remove_success.tpl":   &bintree{htmlTemplatesSms2fa_remove_successTpl, map[string]*bintree{}},
		"sms2fa_setup.tpl":            &bintree{htmlTemplatesSms2fa_setupTpl, map[string]*bintree{}},
		"sms2fa_validate.tpl":         &bintree{htmlTemplatesSms2fa_validateTpl, map[string]*bintree{}},
		"totp2fa_confirm.tpl":         &bintree{htmlTemplatesTotp2fa_confirmTpl, map[string]*bintree{}},
		"totp2fa_confirm_success.tpl": &bintree{htmlTemplatesTotp2fa_confirm_successTpl, map[string]*bintree{}},
		"totp2fa_remove.tpl":          &bintree{htmlTemplatesTotp2fa_removeTpl, map[string]*bintree{}},
		"totp2fa_remove_success.tpl":  &bintree{htmlTemplatesTotp2fa_remove_successTpl, map[string]*bintree{}},
		"totp2fa_setup.tpl":           &bintree{htmlTemplatesTotp2fa_setupTpl, map[string]*bintree{}},
		"totp2fa_validate.tpl":        &bintree{htmlTemplatesTotp2fa_validateTpl, map[string]*bintree{}},
		"twofactor_verify.tpl":        &bintree{htmlTemplatesTwofactor_verifyTpl, 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
	}
	return os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
}

// 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 {
	canonicalName := strings.Replace(name, "\\", "/", -1)
	return filepath.Join(append([]string{dir}, strings.Split(canonicalName, "/")...)...)
}