assets.go

// Code generated by go-bindata.
// sources:
// xbm/arr_down.xbm
// xbm/arr_up.xbm
// xbm/bat-full.xbm
// xbm/bat-low.xbm
// xbm/bat-mid.xbm
// xbm/clock.xpm
// xbm/clock2.xbm
// xbm/disconnected.xbm
// xbm/load.xbm
// xbm/mail.xbm
// xbm/mem.xbm
// xbm/net-wired.xbm
// xbm/power-ac.xbm
// xbm/vol-hi.xbm
// xbm/vol-mute.xbm
// xbm/wifi-full.xbm
// xbm/wifi-low.xbm
// xbm/wifi-mid.xbm
// DO NOT EDIT!

package main

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

func bindataRead(data, name string) ([]byte, error) {
	gz, err := gzip.NewReader(strings.NewReader(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
}

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 _xbmArr_downXbm = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x52\x4e\x49\x4d\xcb\xcc\x4b\x55\x48\x2c\x2a\x8a\x4f\xc9\x2f\xcf\x8b\x2f\xcf\x4c\x29\xc9\x50\x30\x34\xe2\xc2\x90\xc9\x48\xcd\x4c\xcf\x28\x01\x49\x15\x97\x24\x96\x64\x26\x2b\x94\xe6\x15\x67\xa6\xe7\xa5\xa6\x28\x24\x67\x24\x16\x21\xd4\x25\x65\x96\x14\x47\xc7\x2a\xd8\x2a\x54\x73\x29\x28\x28\x18\x54\x18\x18\xe8\xc0\xc9\x54\x72\xd9\x10\xa3\x90\xa5\xd2\x2c\xc0\x6c\x63\x30\x1b\x22\x6e\x88\xae\xdd\x04\x89\x0d\x23\x6b\xad\xb9\x00\x01\x00\x00\xff\xff\xca\x82\xb0\x8d\xf5\x00\x00\x00"

func xbmArr_downXbmBytes() ([]byte, error) {
	return bindataRead(
		_xbmArr_downXbm,
		"xbm/arr_down.xbm",
	)
}

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

	info := bindataFileInfo{name: "xbm/arr_down.xbm", size: 245, mode: os.FileMode(420), modTime: time.Unix(1451768144, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xbmArr_upXbm = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x52\x4e\x49\x4d\xcb\xcc\x4b\x55\x48\x2c\x2a\x8a\x2f\x2d\x88\x2f\xcf\x4c\x29\xc9\x50\x30\x34\xe2\x42\x13\xcf\x48\xcd\x4c\xcf\x28\x01\x49\x14\x97\x24\x96\x64\x26\x2b\x94\xe6\x15\x67\xa6\xe7\xa5\xa6\x28\x24\x67\x24\x16\xc1\x54\x25\x65\x96\x14\x47\xc7\x2a\xd8\x2a\x54\x73\x29\x28\x28\x18\x54\x18\x18\xe8\xc0\x49\x13\x24\x76\x2a\x12\x3b\x0d\xc2\x36\x04\xb3\x2d\xc0\x6c\x63\x14\x35\x10\xa3\x52\x71\x68\x27\x86\x0d\x23\x6b\xad\xb9\x00\x01\x00\x00\xff\xff\x86\xff\x4c\xef\xef\x00\x00\x00"

func xbmArr_upXbmBytes() ([]byte, error) {
	return bindataRead(
		_xbmArr_upXbm,
		"xbm/arr_up.xbm",
	)
}

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

	info := bindataFileInfo{name: "xbm/arr_up.xbm", size: 239, mode: os.FileMode(420), modTime: time.Unix(1451768144, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xbmBatFullXbm = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x52\x4e\x49\x4d\xcb\xcc\x4b\x55\x48\x4a\x2c\x29\x49\x2d\xaa\x4c\x8b\x2f\xcf\x4c\x29\xc9\x50\x30\x34\xe1\xc2\x90\xc9\x48\xcd\x4c\xcf\x28\x51\xb0\xe4\x2a\x2e\x49\x2c\xc9\x4c\x56\x28\xcd\x2b\xce\x4c\xcf\x4b\x4d\x51\x48\xce\x48\x2c\x42\x28\x4b\xca\x2c\x29\x8e\x8e\x55\xb0\x55\xa8\xe6\x52\x50\x50\x30\xa8\x48\x4b\xd3\x51\x30\xa8\x30\x80\x90\x86\x60\xd2\x02\x44\xa6\xa5\x80\x48\xe3\x24\x04\xdb\x08\x37\x1b\x6a\x14\x92\x16\x14\xa3\xa0\x56\x28\xd4\x5a\x73\x01\x02\x00\x00\xff\xff\xfc\xce\x75\x67\xd1\x00\x00\x00"

func xbmBatFullXbmBytes() ([]byte, error) {
	return bindataRead(
		_xbmBatFullXbm,
		"xbm/bat-full.xbm",
	)
}

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

	info := bindataFileInfo{name: "xbm/bat-full.xbm", size: 209, mode: os.FileMode(420), modTime: time.Unix(1451768144, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xbmBatLowXbm = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x52\x4e\x49\x4d\xcb\xcc\x4b\x55\x48\x4a\x2c\x29\x49\x2d\xaa\x34\x88\x2f\xcf\x4c\x29\xc9\x50\x30\x34\xe1\xc2\x90\xc9\x48\xcd\x4c\xcf\x28\x51\xb0\xe4\x2a\x2e\x49\x2c\xc9\x4c\x56\x28\xcd\x2b\xce\x4c\xcf\x4b\x4d\x51\x48\xce\x48\x2c\x42\x28\x4b\xca\x2c\x29\x8e\x8e\x55\xb0\x55\xa8\xe6\x52\x50\x50\x30\xa8\x48\x4b\xd3\x51\x30\xa8\x30\x80\x90\x86\x60\xd2\x02\xc1\x36\x46\x62\x1b\xe1\x66\x43\x8c\xc2\xd4\x02\x31\x0a\x66\x85\x42\xad\x35\x17\x20\x00\x00\xff\xff\x9c\x0c\xd8\xa4\xd1\x00\x00\x00"

func xbmBatLowXbmBytes() ([]byte, error) {
	return bindataRead(
		_xbmBatLowXbm,
		"xbm/bat-low.xbm",
	)
}

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

	info := bindataFileInfo{name: "xbm/bat-low.xbm", size: 209, mode: os.FileMode(420), modTime: time.Unix(1451768144, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xbmBatMidXbm = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x52\x4e\x49\x4d\xcb\xcc\x4b\x55\x48\x4a\x2c\x29\x49\x2d\xaa\x34\x8f\x2f\xcf\x4c\x29\xc9\x50\x30\x34\xe1\xc2\x90\xc9\x48\xcd\x4c\xcf\x28\x51\xb0\xe4\x2a\x2e\x49\x2c\xc9\x4c\x56\x28\xcd\x2b\xce\x4c\xcf\x4b\x4d\x51\x48\xce\x48\x2c\x42\x28\x4b\xca\x2c\x29\x8e\x8e\x55\xb0\x55\xa8\xe6\x52\x50\x50\x30\xa8\x48\x4b\xd3\x51\x30\xa8\x30\x80\x90\x86\x60\xd2\x02\x44\x9a\xa7\x80\x48\x63\x24\xb6\x11\x6e\x36\xc4\x28\x64\x2d\xc8\x46\xc1\xac\x50\xa8\xb5\xe6\x02\x04\x00\x00\xff\xff\xd9\xc9\x87\x6e\xd1\x00\x00\x00"

func xbmBatMidXbmBytes() ([]byte, error) {
	return bindataRead(
		_xbmBatMidXbm,
		"xbm/bat-mid.xbm",
	)
}

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

	info := bindataFileInfo{name: "xbm/bat-mid.xbm", size: 209, mode: os.FileMode(420), modTime: time.Unix(1451768144, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xbmClockXpm = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x9c\x8f\x41\x8f\x82\x30\x10\x85\xcf\xed\xaf\x78\xe9\x11\x36\x65\x49\x58\xf6\xb0\xd9\x9f\xb0\x8b\xc7\x26\xc6\x98\x3a\x31\x82\xa0\x35\x40\xa2\xc6\xf8\xdf\x4d\x07\x50\x48\x38\xf9\x2e\xf0\xbe\x79\x33\xd3\x89\x02\x98\xc5\x1f\x82\x48\x36\xad\x6d\x0b\x02\xe5\xb6\x46\x80\x3d\x55\x8e\xca\xf5\xe5\x74\x58\xae\xf0\x8b\x9b\x54\x71\x82\x38\x41\x8a\x58\x7d\x48\x05\xd1\xe0\xdf\x1d\xb7\x82\xf8\xe3\x91\x16\x84\x5d\x6d\xaf\xc9\x97\x77\xa6\x77\xe9\xa7\x77\x4e\x10\xce\x79\xd1\x72\x30\xeb\x4b\xdf\x5c\x0a\x05\x61\x53\x59\x2a\x79\xac\x97\x36\xc6\x68\xfe\xc3\xc0\xb4\xf3\xd2\x63\x96\xb9\x4e\xd9\x8b\x71\x2a\x1c\x92\xcc\xba\xc6\x70\x68\x7f\x83\x3d\x07\x8e\x19\x43\x3d\xd9\xeb\x26\x7b\x67\xdf\x37\x7b\xc7\xec\xbd\x63\xa9\xfb\x8f\x7c\x04\x00\x00\xff\xff\x19\x96\x96\x71\xa6\x01\x00\x00"

func xbmClockXpmBytes() ([]byte, error) {
	return bindataRead(
		_xbmClockXpm,
		"xbm/clock.xpm",
	)
}

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

	info := bindataFileInfo{name: "xbm/clock.xpm", size: 422, mode: os.FileMode(420), modTime: time.Unix(1451768144, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xbmClock2Xbm = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x52\x4e\x49\x4d\xcb\xcc\x4b\x55\x48\xce\xc9\x4f\xce\x36\x89\x2f\xcf\x4c\x29\xc9\x50\xb0\xe0\x42\x13\xce\x48\xcd\x4c\xcf\x28\x51\xb0\xe0\x2a\x2e\x49\x2c\xc9\x4c\x56\x28\xcd\x2b\xce\x4c\xcf\x4b\x4d\x51\x48\xce\x48\x2c\x82\x29\x4a\xca\x2c\x29\x8e\x8e\x55\xb0\x55\xa8\xe6\x52\x50\x50\x30\xa8\x30\x30\xd0\x51\x30\xa8\x48\x4b\x05\x91\xa9\x48\xa4\x45\x2a\x42\x1c\x46\xd6\x5a\x73\x01\x02\x00\x00\xff\xff\x4c\xbd\xe0\x49\x8a\x00\x00\x00"

func xbmClock2XbmBytes() ([]byte, error) {
	return bindataRead(
		_xbmClock2Xbm,
		"xbm/clock2.xbm",
	)
}

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

	info := bindataFileInfo{name: "xbm/clock2.xbm", size: 138, mode: os.FileMode(420), modTime: time.Unix(1451768144, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xbmDisconnectedXbm = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x52\x4e\x49\x4d\xcb\xcc\x4b\x55\xc8\x4b\x2d\x29\xcf\x2f\xca\x8e\x4f\x2d\xc9\x30\x8a\x2f\xcf\x4c\x29\xc9\x50\x30\x34\xe3\xc2\x2a\x9b\x91\x9a\x99\x9e\x51\x02\x92\x2e\x2e\x49\x2c\xc9\x4c\x56\x28\xcd\x2b\xce\x4c\xcf\x4b\x4d\x51\x48\xce\x48\x2c\x42\x55\x9b\x94\x59\x52\x1c\x1d\xab\x60\xab\x50\xcd\xa5\xa0\xa0\x60\x50\x61\x60\xa0\x03\x27\xd3\x52\x41\xa4\x79\x1a\x58\xc4\x08\x44\x9a\x18\xa0\xb3\x93\x21\x6c\x63\x14\x36\xc4\x28\x64\xa9\x34\x08\x3b\x8d\x64\x36\xd4\x55\x38\x6c\x47\x71\x21\xd4\xe5\x0a\xb5\xd6\x5c\x80\x00\x00\x00\xff\xff\xa8\xba\x45\xca\x35\x01\x00\x00"

func xbmDisconnectedXbmBytes() ([]byte, error) {
	return bindataRead(
		_xbmDisconnectedXbm,
		"xbm/disconnected.xbm",
	)
}

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

	info := bindataFileInfo{name: "xbm/disconnected.xbm", size: 309, mode: os.FileMode(420), modTime: time.Unix(1460228710, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xbmLoadXbm = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x52\x4e\x49\x4d\xcb\xcc\x4b\x55\xc8\xc9\x4f\x4c\x89\x2f\xcf\x4c\x29\xc9\x50\x30\x34\xe3\x42\x11\xcd\x48\xcd\x4c\xcf\x28\x01\x09\x17\x97\x24\x96\x64\x26\x2b\x94\xe6\x15\x67\xa6\xe7\xa5\xa6\x28\x24\x67\x24\x16\x41\xd4\x24\x65\x96\x14\x47\xc7\x2a\xd8\x2a\x54\x73\x29\x28\x28\x18\x54\x18\x18\xe8\xc0\xc9\xb4\x54\x10\x69\x9e\x06\x16\x31\x02\x91\x26\x06\x44\xb1\xa1\x46\x41\xb8\x26\x48\x52\x89\x08\xb6\xb9\x21\x88\xb4\x48\x45\x68\x37\x45\x32\xca\x08\xab\x51\x18\x36\xa2\xb8\x10\xea\x72\x85\x5a\x6b\x2e\x40\x00\x00\x00\xff\xff\x78\x22\x5a\xd6\x1d\x01\x00\x00"

func xbmLoadXbmBytes() ([]byte, error) {
	return bindataRead(
		_xbmLoadXbm,
		"xbm/load.xbm",
	)
}

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

	info := bindataFileInfo{name: "xbm/load.xbm", size: 285, mode: os.FileMode(420), modTime: time.Unix(1451768144, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xbmMailXbm = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x52\x4e\x49\x4d\xcb\xcc\x4b\x55\xc8\x4d\xcc\xcc\x89\x2f\xcf\x4c\x29\xc9\x50\xb0\xe0\x42\x11\xcc\x48\xcd\x4c\xcf\x28\x51\xb0\xe0\x2a\x2e\x49\x2c\xc9\x4c\x56\x28\xcd\x2b\xce\x4c\xcf\x4b\x4d\x51\x48\xce\x48\x2c\x82\x28\x49\xca\x2c\x29\x8e\x8e\x55\xb0\x55\xa8\xe6\x52\x30\xa8\x30\x30\xd0\x51\x30\xa8\x70\x73\x03\x91\xe6\xae\x20\xd2\xc9\x05\x44\xba\x38\x81\x48\x57\x73\x84\xac\x81\x81\x42\xad\x35\x17\x20\x00\x00\xff\xff\xb1\x06\x57\xff\x83\x00\x00\x00"

func xbmMailXbmBytes() ([]byte, error) {
	return bindataRead(
		_xbmMailXbm,
		"xbm/mail.xbm",
	)
}

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

	info := bindataFileInfo{name: "xbm/mail.xbm", size: 131, mode: os.FileMode(420), modTime: time.Unix(1451768144, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xbmMemXbm = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x52\x4e\x49\x4d\xcb\xcc\x4b\x55\xc8\xc9\x4f\x4c\x89\xcf\x4d\xcd\x8d\x2f\xcf\x4c\x29\xc9\x50\x30\x34\xe3\xc2\x90\xc9\x48\xcd\x4c\xcf\x28\x01\x49\x15\x97\x24\x96\x64\x26\x2b\x94\xe6\x15\x67\xa6\xe7\xa5\xa6\x28\x24\x67\x24\x16\x21\xd4\x25\x65\x96\x14\x47\xc7\x2a\xd8\x2a\x54\x73\x29\x28\x28\x18\x54\x18\x18\xe8\x10\x24\x4d\x2c\x40\xa4\xa1\x11\x3a\x3b\x2d\x19\x44\x1a\xa7\xe9\x40\x8c\x82\x73\xc9\x60\xc3\x8d\x85\x18\x85\x6c\x0b\x21\x17\x2a\xd4\x5a\x73\x01\x02\x00\x00\xff\xff\x59\xdd\x52\x1f\x29\x01\x00\x00"

func xbmMemXbmBytes() ([]byte, error) {
	return bindataRead(
		_xbmMemXbm,
		"xbm/mem.xbm",
	)
}

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

	info := bindataFileInfo{name: "xbm/mem.xbm", size: 297, mode: os.FileMode(420), modTime: time.Unix(1451768144, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xbmNetWiredXbm = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x52\x4e\x49\x4d\xcb\xcc\x4b\x55\xc8\x4b\x2d\x29\xcf\x2f\xca\x8e\x4f\x2d\xc9\x30\x8c\x2f\xcf\x4c\x29\xc9\x50\x30\x34\xe3\xc2\x2a\x9b\x91\x9a\x99\x9e\x51\x02\x92\x2e\x2e\x49\x2c\xc9\x4c\x56\x28\xcd\x2b\xce\x4c\xcf\x4b\x4d\x51\x48\xce\x48\x2c\x42\x55\x9b\x94\x59\x52\x1c\x1d\xab\x60\xab\x50\xcd\xa5\xa0\xa0\x60\x50\x61\x60\xa0\x43\x90\x34\x81\xb0\x0d\x41\xa4\x19\x84\x6d\x0c\x22\xcd\x21\x6c\x73\x1d\x88\x51\xe6\x16\x60\x6e\x1a\x58\x0a\x17\x89\xac\x06\xa6\x1d\xd9\x58\x88\x51\xc8\x36\x12\x72\xa1\x42\xad\x35\x17\x20\x00\x00\xff\xff\x43\x85\xef\x58\x35\x01\x00\x00"

func xbmNetWiredXbmBytes() ([]byte, error) {
	return bindataRead(
		_xbmNetWiredXbm,
		"xbm/net-wired.xbm",
	)
}

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

	info := bindataFileInfo{name: "xbm/net-wired.xbm", size: 309, mode: os.FileMode(420), modTime: time.Unix(1451768144, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xbmPowerAcXbm = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x52\x4e\x49\x4d\xcb\xcc\x4b\x55\x28\xc8\x2f\x4f\x2d\x8a\x4f\x4c\x8e\x2f\xcf\x4c\x29\xc9\x50\x30\x34\xe3\xc2\x90\xc9\x48\xcd\x4c\xcf\x28\x01\x49\x15\x97\x24\x96\x64\x26\x2b\x94\xe6\x15\x67\xa6\xe7\xa5\xa6\x28\x24\x67\x24\x16\x21\xd4\x25\x65\x96\x14\x47\xc7\x2a\xd8\x2a\x54\x73\x29\x28\x28\x18\x54\x18\x18\xe8\x10\x4b\x9a\x83\x48\x0b\x24\x76\x32\x98\x6d\x9c\xa6\x03\x31\x2a\x15\x49\x2a\x2d\x19\x3b\x3b\x15\x9b\x76\x64\x63\x51\x5c\x65\x4e\x8c\xdb\x14\x6a\xad\xb9\x00\x01\x00\x00\xff\xff\x97\xe0\xbf\xd7\x29\x01\x00\x00"

func xbmPowerAcXbmBytes() ([]byte, error) {
	return bindataRead(
		_xbmPowerAcXbm,
		"xbm/power-ac.xbm",
	)
}

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

	info := bindataFileInfo{name: "xbm/power-ac.xbm", size: 297, mode: os.FileMode(420), modTime: time.Unix(1451768144, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xbmVolHiXbm = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x52\x4e\x49\x4d\xcb\xcc\x4b\x55\x28\xcb\xcf\x89\xcf\xc8\x34\x8a\x2f\xcf\x4c\x29\xc9\x50\x30\x34\xe3\x42\x97\xc8\x48\xcd\x4c\xcf\x28\x01\xc9\x14\x97\x24\x96\x64\x26\x2b\x94\xe6\x15\x67\xa6\xe7\xa5\xa6\x28\x24\x67\x24\x16\xc1\x95\x25\x65\x96\x14\x47\xc7\x2a\xd8\x2a\x54\x73\x29\x28\x28\x18\x54\x18\x18\xe8\xe0\x21\x0d\x0d\x41\xa4\x05\x98\x6d\x04\x66\x27\x83\xd9\x26\x96\x20\x32\x2d\x19\x44\x9a\x1a\xea\x40\x8c\x82\x72\x4d\x75\x48\x63\xa3\x1a\x0b\x31\x0a\xd9\x46\x64\x97\x60\x73\xa7\x42\xad\x35\x17\x20\x00\x00\xff\xff\x28\x61\xb1\xab\x26\x01\x00\x00"

func xbmVolHiXbmBytes() ([]byte, error) {
	return bindataRead(
		_xbmVolHiXbm,
		"xbm/vol-hi.xbm",
	)
}

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

	info := bindataFileInfo{name: "xbm/vol-hi.xbm", size: 294, mode: os.FileMode(420), modTime: time.Unix(1451768144, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xbmVolMuteXbm = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x52\x4e\x49\x4d\xcb\xcc\x4b\x55\x28\xcb\xcf\x89\xcf\x2d\x2d\x49\x35\x8a\x2f\xcf\x4c\x29\xc9\x50\x30\x34\xe3\xc2\x94\xca\x48\xcd\x4c\xcf\x28\x01\xc9\x15\x97\x24\x96\x64\x26\x2b\x94\xe6\x15\x67\xa6\xe7\xa5\xa6\x28\x24\x67\x24\x16\x21\x29\x4c\xca\x2c\x29\x8e\x8e\x55\xb0\x55\xa8\xe6\x52\x50\x50\x30\xa8\x30\x30\xd0\xc1\x47\x1a\x82\x48\x0b\x24\x76\x32\x12\x3b\x2d\x19\xca\x86\x18\x05\xe7\xc2\xd9\x46\x96\x08\xb6\x21\x0e\x71\x34\x63\x21\x46\x21\xdb\x68\x80\xc9\x46\x21\x15\x6a\xad\xb9\x00\x01\x00\x00\xff\xff\xba\x41\x15\xe3\x2c\x01\x00\x00"

func xbmVolMuteXbmBytes() ([]byte, error) {
	return bindataRead(
		_xbmVolMuteXbm,
		"xbm/vol-mute.xbm",
	)
}

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

	info := bindataFileInfo{name: "xbm/vol-mute.xbm", size: 300, mode: os.FileMode(420), modTime: time.Unix(1451768144, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xbmWifiFullXbm = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x52\x4e\x49\x4d\xcb\xcc\x4b\x55\x28\xcf\x2c\x4a\xcd\x49\x2d\x2e\x36\x8d\x2f\xcf\x4c\x29\xc9\x50\x30\x34\xe1\xc2\x94\xca\x48\xcd\x4c\xcf\x28\x51\xb0\xe4\x2a\x2e\x49\x2c\xc9\x4c\x56\x28\xcd\x2b\xce\x4c\xcf\x4b\x4d\x51\x48\xce\x48\x2c\x42\x52\x97\x94\x59\x52\x1c\x1d\xab\x60\xab\x50\xcd\xa5\xa0\xa0\x60\x50\x61\x60\xa0\xa3\x60\x50\x61\x0c\x26\xb1\xb0\xcd\xd0\xd9\xc9\xd8\xd8\x10\xa3\x52\x2c\x10\x52\x28\xec\x24\x08\x5b\xa1\xd6\x9a\x0b\x10\x00\x00\xff\xff\x7a\x6f\xe7\x97\xd4\x00\x00\x00"

func xbmWifiFullXbmBytes() ([]byte, error) {
	return bindataRead(
		_xbmWifiFullXbm,
		"xbm/wifi-full.xbm",
	)
}

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

	info := bindataFileInfo{name: "xbm/wifi-full.xbm", size: 212, mode: os.FileMode(420), modTime: time.Unix(1451768144, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xbmWifiLowXbm = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x52\x4e\x49\x4d\xcb\xcc\x4b\x55\x28\xcf\x2c\x4a\xcd\x49\x2d\x2e\x36\x8a\x2f\xcf\x4c\x29\xc9\x50\x30\x34\xe1\xc2\x94\xca\x48\xcd\x4c\xcf\x28\x51\xb0\xe4\x2a\x2e\x49\x2c\xc9\x4c\x56\x28\xcd\x2b\xce\x4c\xcf\x4b\x4d\x51\x48\xce\x48\x2c\x42\x52\x97\x94\x59\x52\x1c\x1d\xab\x60\xab\x50\xcd\xa5\xa0\xa0\x60\x50\x61\x60\xa0\x43\x39\x09\x31\xca\xd0\x02\x21\x88\xc2\x4e\x82\xb0\x15\x6a\xad\xb9\x00\x01\x00\x00\xff\xff\x50\xfe\xe3\xe4\xd4\x00\x00\x00"

func xbmWifiLowXbmBytes() ([]byte, error) {
	return bindataRead(
		_xbmWifiLowXbm,
		"xbm/wifi-low.xbm",
	)
}

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

	info := bindataFileInfo{name: "xbm/wifi-low.xbm", size: 212, mode: os.FileMode(420), modTime: time.Unix(1451768144, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _xbmWifiMidXbm = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x52\x4e\x49\x4d\xcb\xcc\x4b\x55\x28\xcf\x2c\x4a\xcd\x49\x2d\x2e\x36\x89\x2f\xcf\x4c\x29\xc9\x50\x30\x34\xe1\xc2\x94\xca\x48\xcd\x4c\xcf\x28\x51\xb0\xe4\x2a\x2e\x49\x2c\xc9\x4c\x56\x28\xcd\x2b\xce\x4c\xcf\x4b\x4d\x51\x48\xce\x48\x2c\x42\x52\x97\x94\x59\x52\x1c\x1d\xab\x60\xab\x50\xcd\xa5\xa0\xa0\x60\x50\x61\x60\xa0\x83\x8f\x34\x43\x67\x27\x63\x63\x43\x8c\x4a\xb1\x40\x48\xa1\xb0\x93\x20\x6c\x85\x5a\x6b\x2e\x40\x00\x00\x00\xff\xff\x7f\x02\x69\x8c\xd4\x00\x00\x00"

func xbmWifiMidXbmBytes() ([]byte, error) {
	return bindataRead(
		_xbmWifiMidXbm,
		"xbm/wifi-mid.xbm",
	)
}

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

	info := bindataFileInfo{name: "xbm/wifi-mid.xbm", size: 212, mode: os.FileMode(420), modTime: time.Unix(1451768144, 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){
	"xbm/arr_down.xbm": xbmArr_downXbm,
	"xbm/arr_up.xbm": xbmArr_upXbm,
	"xbm/bat-full.xbm": xbmBatFullXbm,
	"xbm/bat-low.xbm": xbmBatLowXbm,
	"xbm/bat-mid.xbm": xbmBatMidXbm,
	"xbm/clock.xpm": xbmClockXpm,
	"xbm/clock2.xbm": xbmClock2Xbm,
	"xbm/disconnected.xbm": xbmDisconnectedXbm,
	"xbm/load.xbm": xbmLoadXbm,
	"xbm/mail.xbm": xbmMailXbm,
	"xbm/mem.xbm": xbmMemXbm,
	"xbm/net-wired.xbm": xbmNetWiredXbm,
	"xbm/power-ac.xbm": xbmPowerAcXbm,
	"xbm/vol-hi.xbm": xbmVolHiXbm,
	"xbm/vol-mute.xbm": xbmVolMuteXbm,
	"xbm/wifi-full.xbm": xbmWifiFullXbm,
	"xbm/wifi-low.xbm": xbmWifiLowXbm,
	"xbm/wifi-mid.xbm": xbmWifiMidXbm,
}

// 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{
	"xbm": &bintree{nil, map[string]*bintree{
		"arr_down.xbm": &bintree{xbmArr_downXbm, map[string]*bintree{}},
		"arr_up.xbm": &bintree{xbmArr_upXbm, map[string]*bintree{}},
		"bat-full.xbm": &bintree{xbmBatFullXbm, map[string]*bintree{}},
		"bat-low.xbm": &bintree{xbmBatLowXbm, map[string]*bintree{}},
		"bat-mid.xbm": &bintree{xbmBatMidXbm, map[string]*bintree{}},
		"clock.xpm": &bintree{xbmClockXpm, map[string]*bintree{}},
		"clock2.xbm": &bintree{xbmClock2Xbm, map[string]*bintree{}},
		"disconnected.xbm": &bintree{xbmDisconnectedXbm, map[string]*bintree{}},
		"load.xbm": &bintree{xbmLoadXbm, map[string]*bintree{}},
		"mail.xbm": &bintree{xbmMailXbm, map[string]*bintree{}},
		"mem.xbm": &bintree{xbmMemXbm, map[string]*bintree{}},
		"net-wired.xbm": &bintree{xbmNetWiredXbm, map[string]*bintree{}},
		"power-ac.xbm": &bintree{xbmPowerAcXbm, map[string]*bintree{}},
		"vol-hi.xbm": &bintree{xbmVolHiXbm, map[string]*bintree{}},
		"vol-mute.xbm": &bintree{xbmVolMuteXbm, map[string]*bintree{}},
		"wifi-full.xbm": &bintree{xbmWifiFullXbm, map[string]*bintree{}},
		"wifi-low.xbm": &bintree{xbmWifiLowXbm, map[string]*bintree{}},
		"wifi-mid.xbm": &bintree{xbmWifiMidXbm, 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, "/")...)...)
}