status-go/contracts/snt/snt.go

// Code generated - DO NOT EDIT.
// This file is a generated binding and any manual changes will be lost.

package snt

import (
	"math/big"
	"strings"

	ethereum "github.com/ethereum/go-ethereum"
	"github.com/ethereum/go-ethereum/accounts/abi"
	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/event"
)

// Reference imports to suppress errors if they are not otherwise used.
var (
	_ = big.NewInt
	_ = strings.NewReader
	_ = ethereum.NotFound
	_ = bind.Bind
	_ = common.Big1
	_ = types.BloomLookup
	_ = event.NewSubscription
)

// ApproveAndCallFallBackABI is the input ABI used to generate the binding from.
const ApproveAndCallFallBackABI = "[{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"_amount\",\"type\":\"uint256\"},{\"name\":\"_token\",\"type\":\"address\"},{\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"receiveApproval\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"

// ApproveAndCallFallBackFuncSigs maps the 4-byte function signature to its string representation.
var ApproveAndCallFallBackFuncSigs = map[string]string{
	"8f4ffcb1": "receiveApproval(address,uint256,address,bytes)",
}

// ApproveAndCallFallBack is an auto generated Go binding around an Ethereum contract.
type ApproveAndCallFallBack struct {
	ApproveAndCallFallBackCaller     // Read-only binding to the contract
	ApproveAndCallFallBackTransactor // Write-only binding to the contract
	ApproveAndCallFallBackFilterer   // Log filterer for contract events
}

// ApproveAndCallFallBackCaller is an auto generated read-only Go binding around an Ethereum contract.
type ApproveAndCallFallBackCaller struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// ApproveAndCallFallBackTransactor is an auto generated write-only Go binding around an Ethereum contract.
type ApproveAndCallFallBackTransactor struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// ApproveAndCallFallBackFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
type ApproveAndCallFallBackFilterer struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// ApproveAndCallFallBackSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type ApproveAndCallFallBackSession struct {
	Contract     *ApproveAndCallFallBack // Generic contract binding to set the session for
	CallOpts     bind.CallOpts           // Call options to use throughout this session
	TransactOpts bind.TransactOpts       // Transaction auth options to use throughout this session
}

// ApproveAndCallFallBackCallerSession is an auto generated read-only Go binding around an Ethereum contract,
// with pre-set call options.
type ApproveAndCallFallBackCallerSession struct {
	Contract *ApproveAndCallFallBackCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts                 // Call options to use throughout this session
}

// ApproveAndCallFallBackTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
// with pre-set transact options.
type ApproveAndCallFallBackTransactorSession struct {
	Contract     *ApproveAndCallFallBackTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts                 // Transaction auth options to use throughout this session
}

// ApproveAndCallFallBackRaw is an auto generated low-level Go binding around an Ethereum contract.
type ApproveAndCallFallBackRaw struct {
	Contract *ApproveAndCallFallBack // Generic contract binding to access the raw methods on
}

// ApproveAndCallFallBackCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
type ApproveAndCallFallBackCallerRaw struct {
	Contract *ApproveAndCallFallBackCaller // Generic read-only contract binding to access the raw methods on
}

// ApproveAndCallFallBackTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
type ApproveAndCallFallBackTransactorRaw struct {
	Contract *ApproveAndCallFallBackTransactor // Generic write-only contract binding to access the raw methods on
}

// NewApproveAndCallFallBack creates a new instance of ApproveAndCallFallBack, bound to a specific deployed contract.
func NewApproveAndCallFallBack(address common.Address, backend bind.ContractBackend) (*ApproveAndCallFallBack, error) {
	contract, err := bindApproveAndCallFallBack(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &ApproveAndCallFallBack{ApproveAndCallFallBackCaller: ApproveAndCallFallBackCaller{contract: contract}, ApproveAndCallFallBackTransactor: ApproveAndCallFallBackTransactor{contract: contract}, ApproveAndCallFallBackFilterer: ApproveAndCallFallBackFilterer{contract: contract}}, nil
}

// NewApproveAndCallFallBackCaller creates a new read-only instance of ApproveAndCallFallBack, bound to a specific deployed contract.
func NewApproveAndCallFallBackCaller(address common.Address, caller bind.ContractCaller) (*ApproveAndCallFallBackCaller, error) {
	contract, err := bindApproveAndCallFallBack(address, caller, nil, nil)
	if err != nil {
		return nil, err
	}
	return &ApproveAndCallFallBackCaller{contract: contract}, nil
}

// NewApproveAndCallFallBackTransactor creates a new write-only instance of ApproveAndCallFallBack, bound to a specific deployed contract.
func NewApproveAndCallFallBackTransactor(address common.Address, transactor bind.ContractTransactor) (*ApproveAndCallFallBackTransactor, error) {
	contract, err := bindApproveAndCallFallBack(address, nil, transactor, nil)
	if err != nil {
		return nil, err
	}
	return &ApproveAndCallFallBackTransactor{contract: contract}, nil
}

// NewApproveAndCallFallBackFilterer creates a new log filterer instance of ApproveAndCallFallBack, bound to a specific deployed contract.
func NewApproveAndCallFallBackFilterer(address common.Address, filterer bind.ContractFilterer) (*ApproveAndCallFallBackFilterer, error) {
	contract, err := bindApproveAndCallFallBack(address, nil, nil, filterer)
	if err != nil {
		return nil, err
	}
	return &ApproveAndCallFallBackFilterer{contract: contract}, nil
}

// bindApproveAndCallFallBack binds a generic wrapper to an already deployed contract.
func bindApproveAndCallFallBack(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(ApproveAndCallFallBackABI))
	if err != nil {
		return nil, err
	}
	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_ApproveAndCallFallBack *ApproveAndCallFallBackRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _ApproveAndCallFallBack.Contract.ApproveAndCallFallBackCaller.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_ApproveAndCallFallBack *ApproveAndCallFallBackRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _ApproveAndCallFallBack.Contract.ApproveAndCallFallBackTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_ApproveAndCallFallBack *ApproveAndCallFallBackRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _ApproveAndCallFallBack.Contract.ApproveAndCallFallBackTransactor.contract.Transact(opts, method, params...)
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_ApproveAndCallFallBack *ApproveAndCallFallBackCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _ApproveAndCallFallBack.Contract.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_ApproveAndCallFallBack *ApproveAndCallFallBackTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _ApproveAndCallFallBack.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_ApproveAndCallFallBack *ApproveAndCallFallBackTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _ApproveAndCallFallBack.Contract.contract.Transact(opts, method, params...)
}

// ReceiveApproval is a paid mutator transaction binding the contract method 0x8f4ffcb1.
//
// Solidity: function receiveApproval(address from, uint256 _amount, address _token, bytes _data) returns()
func (_ApproveAndCallFallBack *ApproveAndCallFallBackTransactor) ReceiveApproval(opts *bind.TransactOpts, from common.Address, _amount *big.Int, _token common.Address, _data []byte) (*types.Transaction, error) {
	return _ApproveAndCallFallBack.contract.Transact(opts, "receiveApproval", from, _amount, _token, _data)
}

// ReceiveApproval is a paid mutator transaction binding the contract method 0x8f4ffcb1.
//
// Solidity: function receiveApproval(address from, uint256 _amount, address _token, bytes _data) returns()
func (_ApproveAndCallFallBack *ApproveAndCallFallBackSession) ReceiveApproval(from common.Address, _amount *big.Int, _token common.Address, _data []byte) (*types.Transaction, error) {
	return _ApproveAndCallFallBack.Contract.ReceiveApproval(&_ApproveAndCallFallBack.TransactOpts, from, _amount, _token, _data)
}

// ReceiveApproval is a paid mutator transaction binding the contract method 0x8f4ffcb1.
//
// Solidity: function receiveApproval(address from, uint256 _amount, address _token, bytes _data) returns()
func (_ApproveAndCallFallBack *ApproveAndCallFallBackTransactorSession) ReceiveApproval(from common.Address, _amount *big.Int, _token common.Address, _data []byte) (*types.Transaction, error) {
	return _ApproveAndCallFallBack.Contract.ReceiveApproval(&_ApproveAndCallFallBack.TransactOpts, from, _amount, _token, _data)
}

// ControlledABI is the input ABI used to generate the binding from.
const ControlledABI = "[{\"constant\":false,\"inputs\":[{\"name\":\"_newController\",\"type\":\"address\"}],\"name\":\"changeController\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"controller\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}]"

// ControlledFuncSigs maps the 4-byte function signature to its string representation.
var ControlledFuncSigs = map[string]string{
	"3cebb823": "changeController(address)",
	"f77c4791": "controller()",
}

// ControlledBin is the compiled bytecode used for deploying new contracts.
var ControlledBin = "0x608060405234801561001057600080fd5b50610100806100206000396000f30060806040526004361060485763ffffffff7c01000000000000000000000000000000000000000000000000000000006000350416633cebb8238114604d578063f77c479114607a575b600080fd5b348015605857600080fd5b50607873ffffffffffffffffffffffffffffffffffffffff6004351660b5565b005b348015608557600080fd5b50608c60b8565b6040805173ffffffffffffffffffffffffffffffffffffffff9092168252519081900360200190f35b50565b60005473ffffffffffffffffffffffffffffffffffffffff16815600a165627a7a72305820fe8e3aeccba397cd6ed181c46c148a5ce1f4c75e6b15416b622abe4b1cf81a3d0029"

// DeployControlled deploys a new Ethereum contract, binding an instance of Controlled to it.
func DeployControlled(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Controlled, error) {
	parsed, err := abi.JSON(strings.NewReader(ControlledABI))
	if err != nil {
		return common.Address{}, nil, nil, err
	}

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ControlledBin), backend)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &Controlled{ControlledCaller: ControlledCaller{contract: contract}, ControlledTransactor: ControlledTransactor{contract: contract}, ControlledFilterer: ControlledFilterer{contract: contract}}, nil
}

// Controlled is an auto generated Go binding around an Ethereum contract.
type Controlled struct {
	ControlledCaller     // Read-only binding to the contract
	ControlledTransactor // Write-only binding to the contract
	ControlledFilterer   // Log filterer for contract events
}

// ControlledCaller is an auto generated read-only Go binding around an Ethereum contract.
type ControlledCaller struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// ControlledTransactor is an auto generated write-only Go binding around an Ethereum contract.
type ControlledTransactor struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// ControlledFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
type ControlledFilterer struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// ControlledSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type ControlledSession struct {
	Contract     *Controlled       // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

// ControlledCallerSession is an auto generated read-only Go binding around an Ethereum contract,
// with pre-set call options.
type ControlledCallerSession struct {
	Contract *ControlledCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts     // Call options to use throughout this session
}

// ControlledTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
// with pre-set transact options.
type ControlledTransactorSession struct {
	Contract     *ControlledTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts     // Transaction auth options to use throughout this session
}

// ControlledRaw is an auto generated low-level Go binding around an Ethereum contract.
type ControlledRaw struct {
	Contract *Controlled // Generic contract binding to access the raw methods on
}

// ControlledCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
type ControlledCallerRaw struct {
	Contract *ControlledCaller // Generic read-only contract binding to access the raw methods on
}

// ControlledTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
type ControlledTransactorRaw struct {
	Contract *ControlledTransactor // Generic write-only contract binding to access the raw methods on
}

// NewControlled creates a new instance of Controlled, bound to a specific deployed contract.
func NewControlled(address common.Address, backend bind.ContractBackend) (*Controlled, error) {
	contract, err := bindControlled(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &Controlled{ControlledCaller: ControlledCaller{contract: contract}, ControlledTransactor: ControlledTransactor{contract: contract}, ControlledFilterer: ControlledFilterer{contract: contract}}, nil
}

// NewControlledCaller creates a new read-only instance of Controlled, bound to a specific deployed contract.
func NewControlledCaller(address common.Address, caller bind.ContractCaller) (*ControlledCaller, error) {
	contract, err := bindControlled(address, caller, nil, nil)
	if err != nil {
		return nil, err
	}
	return &ControlledCaller{contract: contract}, nil
}

// NewControlledTransactor creates a new write-only instance of Controlled, bound to a specific deployed contract.
func NewControlledTransactor(address common.Address, transactor bind.ContractTransactor) (*ControlledTransactor, error) {
	contract, err := bindControlled(address, nil, transactor, nil)
	if err != nil {
		return nil, err
	}
	return &ControlledTransactor{contract: contract}, nil
}

// NewControlledFilterer creates a new log filterer instance of Controlled, bound to a specific deployed contract.
func NewControlledFilterer(address common.Address, filterer bind.ContractFilterer) (*ControlledFilterer, error) {
	contract, err := bindControlled(address, nil, nil, filterer)
	if err != nil {
		return nil, err
	}
	return &ControlledFilterer{contract: contract}, nil
}

// bindControlled binds a generic wrapper to an already deployed contract.
func bindControlled(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(ControlledABI))
	if err != nil {
		return nil, err
	}
	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_Controlled *ControlledRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _Controlled.Contract.ControlledCaller.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_Controlled *ControlledRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _Controlled.Contract.ControlledTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_Controlled *ControlledRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _Controlled.Contract.ControlledTransactor.contract.Transact(opts, method, params...)
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_Controlled *ControlledCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _Controlled.Contract.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_Controlled *ControlledTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _Controlled.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_Controlled *ControlledTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _Controlled.Contract.contract.Transact(opts, method, params...)
}

// Controller is a free data retrieval call binding the contract method 0xf77c4791.
//
// Solidity: function controller() view returns(address)
func (_Controlled *ControlledCaller) Controller(opts *bind.CallOpts) (common.Address, error) {
	var out []interface{}
	err := _Controlled.contract.Call(opts, &out, "controller")

	if err != nil {
		return *new(common.Address), err
	}

	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)

	return out0, err

}

// Controller is a free data retrieval call binding the contract method 0xf77c4791.
//
// Solidity: function controller() view returns(address)
func (_Controlled *ControlledSession) Controller() (common.Address, error) {
	return _Controlled.Contract.Controller(&_Controlled.CallOpts)
}

// Controller is a free data retrieval call binding the contract method 0xf77c4791.
//
// Solidity: function controller() view returns(address)
func (_Controlled *ControlledCallerSession) Controller() (common.Address, error) {
	return _Controlled.Contract.Controller(&_Controlled.CallOpts)
}

// ChangeController is a paid mutator transaction binding the contract method 0x3cebb823.
//
// Solidity: function changeController(address _newController) returns()
func (_Controlled *ControlledTransactor) ChangeController(opts *bind.TransactOpts, _newController common.Address) (*types.Transaction, error) {
	return _Controlled.contract.Transact(opts, "changeController", _newController)
}

// ChangeController is a paid mutator transaction binding the contract method 0x3cebb823.
//
// Solidity: function changeController(address _newController) returns()
func (_Controlled *ControlledSession) ChangeController(_newController common.Address) (*types.Transaction, error) {
	return _Controlled.Contract.ChangeController(&_Controlled.TransactOpts, _newController)
}

// ChangeController is a paid mutator transaction binding the contract method 0x3cebb823.
//
// Solidity: function changeController(address _newController) returns()
func (_Controlled *ControlledTransactorSession) ChangeController(_newController common.Address) (*types.Transaction, error) {
	return _Controlled.Contract.ChangeController(&_Controlled.TransactOpts, _newController)
}

// ERC20TokenABI is the input ABI used to generate the binding from.
const ERC20TokenABI = "[{\"constant\":false,\"inputs\":[{\"name\":\"_spender\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_from\",\"type\":\"address\"},{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"balance\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\"},{\"name\":\"_spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"name\":\"remaining\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"_from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"_to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"_owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"_spender\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"}]"

// ERC20TokenFuncSigs maps the 4-byte function signature to its string representation.
var ERC20TokenFuncSigs = map[string]string{
	"dd62ed3e": "allowance(address,address)",
	"095ea7b3": "approve(address,uint256)",
	"70a08231": "balanceOf(address)",
	"18160ddd": "totalSupply()",
	"a9059cbb": "transfer(address,uint256)",
	"23b872dd": "transferFrom(address,address,uint256)",
}

// ERC20Token is an auto generated Go binding around an Ethereum contract.
type ERC20Token struct {
	ERC20TokenCaller     // Read-only binding to the contract
	ERC20TokenTransactor // Write-only binding to the contract
	ERC20TokenFilterer   // Log filterer for contract events
}

// ERC20TokenCaller is an auto generated read-only Go binding around an Ethereum contract.
type ERC20TokenCaller struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// ERC20TokenTransactor is an auto generated write-only Go binding around an Ethereum contract.
type ERC20TokenTransactor struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// ERC20TokenFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
type ERC20TokenFilterer struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// ERC20TokenSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type ERC20TokenSession struct {
	Contract     *ERC20Token       // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

// ERC20TokenCallerSession is an auto generated read-only Go binding around an Ethereum contract,
// with pre-set call options.
type ERC20TokenCallerSession struct {
	Contract *ERC20TokenCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts     // Call options to use throughout this session
}

// ERC20TokenTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
// with pre-set transact options.
type ERC20TokenTransactorSession struct {
	Contract     *ERC20TokenTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts     // Transaction auth options to use throughout this session
}

// ERC20TokenRaw is an auto generated low-level Go binding around an Ethereum contract.
type ERC20TokenRaw struct {
	Contract *ERC20Token // Generic contract binding to access the raw methods on
}

// ERC20TokenCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
type ERC20TokenCallerRaw struct {
	Contract *ERC20TokenCaller // Generic read-only contract binding to access the raw methods on
}

// ERC20TokenTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
type ERC20TokenTransactorRaw struct {
	Contract *ERC20TokenTransactor // Generic write-only contract binding to access the raw methods on
}

// NewERC20Token creates a new instance of ERC20Token, bound to a specific deployed contract.
func NewERC20Token(address common.Address, backend bind.ContractBackend) (*ERC20Token, error) {
	contract, err := bindERC20Token(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &ERC20Token{ERC20TokenCaller: ERC20TokenCaller{contract: contract}, ERC20TokenTransactor: ERC20TokenTransactor{contract: contract}, ERC20TokenFilterer: ERC20TokenFilterer{contract: contract}}, nil
}

// NewERC20TokenCaller creates a new read-only instance of ERC20Token, bound to a specific deployed contract.
func NewERC20TokenCaller(address common.Address, caller bind.ContractCaller) (*ERC20TokenCaller, error) {
	contract, err := bindERC20Token(address, caller, nil, nil)
	if err != nil {
		return nil, err
	}
	return &ERC20TokenCaller{contract: contract}, nil
}

// NewERC20TokenTransactor creates a new write-only instance of ERC20Token, bound to a specific deployed contract.
func NewERC20TokenTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20TokenTransactor, error) {
	contract, err := bindERC20Token(address, nil, transactor, nil)
	if err != nil {
		return nil, err
	}
	return &ERC20TokenTransactor{contract: contract}, nil
}

// NewERC20TokenFilterer creates a new log filterer instance of ERC20Token, bound to a specific deployed contract.
func NewERC20TokenFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20TokenFilterer, error) {
	contract, err := bindERC20Token(address, nil, nil, filterer)
	if err != nil {
		return nil, err
	}
	return &ERC20TokenFilterer{contract: contract}, nil
}

// bindERC20Token binds a generic wrapper to an already deployed contract.
func bindERC20Token(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(ERC20TokenABI))
	if err != nil {
		return nil, err
	}
	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_ERC20Token *ERC20TokenRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _ERC20Token.Contract.ERC20TokenCaller.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_ERC20Token *ERC20TokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _ERC20Token.Contract.ERC20TokenTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_ERC20Token *ERC20TokenRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _ERC20Token.Contract.ERC20TokenTransactor.contract.Transact(opts, method, params...)
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_ERC20Token *ERC20TokenCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _ERC20Token.Contract.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_ERC20Token *ERC20TokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _ERC20Token.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_ERC20Token *ERC20TokenTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _ERC20Token.Contract.contract.Transact(opts, method, params...)
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address _owner, address _spender) view returns(uint256 remaining)
func (_ERC20Token *ERC20TokenCaller) Allowance(opts *bind.CallOpts, _owner common.Address, _spender common.Address) (*big.Int, error) {
	var out []interface{}
	err := _ERC20Token.contract.Call(opts, &out, "allowance", _owner, _spender)

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address _owner, address _spender) view returns(uint256 remaining)
func (_ERC20Token *ERC20TokenSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error) {
	return _ERC20Token.Contract.Allowance(&_ERC20Token.CallOpts, _owner, _spender)
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address _owner, address _spender) view returns(uint256 remaining)
func (_ERC20Token *ERC20TokenCallerSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error) {
	return _ERC20Token.Contract.Allowance(&_ERC20Token.CallOpts, _owner, _spender)
}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address _owner) view returns(uint256 balance)
func (_ERC20Token *ERC20TokenCaller) BalanceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error) {
	var out []interface{}
	err := _ERC20Token.contract.Call(opts, &out, "balanceOf", _owner)

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address _owner) view returns(uint256 balance)
func (_ERC20Token *ERC20TokenSession) BalanceOf(_owner common.Address) (*big.Int, error) {
	return _ERC20Token.Contract.BalanceOf(&_ERC20Token.CallOpts, _owner)
}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address _owner) view returns(uint256 balance)
func (_ERC20Token *ERC20TokenCallerSession) BalanceOf(_owner common.Address) (*big.Int, error) {
	return _ERC20Token.Contract.BalanceOf(&_ERC20Token.CallOpts, _owner)
}

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() view returns(uint256)
func (_ERC20Token *ERC20TokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
	var out []interface{}
	err := _ERC20Token.contract.Call(opts, &out, "totalSupply")

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() view returns(uint256)
func (_ERC20Token *ERC20TokenSession) TotalSupply() (*big.Int, error) {
	return _ERC20Token.Contract.TotalSupply(&_ERC20Token.CallOpts)
}

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() view returns(uint256)
func (_ERC20Token *ERC20TokenCallerSession) TotalSupply() (*big.Int, error) {
	return _ERC20Token.Contract.TotalSupply(&_ERC20Token.CallOpts)
}

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address _spender, uint256 _value) returns(bool success)
func (_ERC20Token *ERC20TokenTransactor) Approve(opts *bind.TransactOpts, _spender common.Address, _value *big.Int) (*types.Transaction, error) {
	return _ERC20Token.contract.Transact(opts, "approve", _spender, _value)
}

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address _spender, uint256 _value) returns(bool success)
func (_ERC20Token *ERC20TokenSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error) {
	return _ERC20Token.Contract.Approve(&_ERC20Token.TransactOpts, _spender, _value)
}

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address _spender, uint256 _value) returns(bool success)
func (_ERC20Token *ERC20TokenTransactorSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error) {
	return _ERC20Token.Contract.Approve(&_ERC20Token.TransactOpts, _spender, _value)
}

// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
//
// Solidity: function transfer(address _to, uint256 _value) returns(bool success)
func (_ERC20Token *ERC20TokenTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (*types.Transaction, error) {
	return _ERC20Token.contract.Transact(opts, "transfer", _to, _value)
}

// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
//
// Solidity: function transfer(address _to, uint256 _value) returns(bool success)
func (_ERC20Token *ERC20TokenSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) {
	return _ERC20Token.Contract.Transfer(&_ERC20Token.TransactOpts, _to, _value)
}

// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
//
// Solidity: function transfer(address _to, uint256 _value) returns(bool success)
func (_ERC20Token *ERC20TokenTransactorSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) {
	return _ERC20Token.Contract.Transfer(&_ERC20Token.TransactOpts, _to, _value)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool success)
func (_ERC20Token *ERC20TokenTransactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) {
	return _ERC20Token.contract.Transact(opts, "transferFrom", _from, _to, _value)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool success)
func (_ERC20Token *ERC20TokenSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) {
	return _ERC20Token.Contract.TransferFrom(&_ERC20Token.TransactOpts, _from, _to, _value)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool success)
func (_ERC20Token *ERC20TokenTransactorSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) {
	return _ERC20Token.Contract.TransferFrom(&_ERC20Token.TransactOpts, _from, _to, _value)
}

// ERC20TokenApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ERC20Token contract.
type ERC20TokenApprovalIterator struct {
	Event *ERC20TokenApproval // Event containing the contract specifics and raw log

	contract *bind.BoundContract // Generic contract to use for unpacking event data
	event    string              // Event name to use for unpacking event data

	logs chan types.Log        // Log channel receiving the found contract events
	sub  ethereum.Subscription // Subscription for errors, completion and termination
	done bool                  // Whether the subscription completed delivering logs
	fail error                 // Occurred error to stop iteration
}

// Next advances the iterator to the subsequent event, returning whether there
// are any more events found. In case of a retrieval or parsing error, false is
// returned and Error() can be queried for the exact failure.
func (it *ERC20TokenApprovalIterator) Next() bool {
	// If the iterator failed, stop iterating
	if it.fail != nil {
		return false
	}
	// If the iterator completed, deliver directly whatever's available
	if it.done {
		select {
		case log := <-it.logs:
			it.Event = new(ERC20TokenApproval)
			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
				it.fail = err
				return false
			}
			it.Event.Raw = log
			return true

		default:
			return false
		}
	}
	// Iterator still in progress, wait for either a data or an error event
	select {
	case log := <-it.logs:
		it.Event = new(ERC20TokenApproval)
		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
			it.fail = err
			return false
		}
		it.Event.Raw = log
		return true

	case err := <-it.sub.Err():
		it.done = true
		it.fail = err
		return it.Next()
	}
}

// Error returns any retrieval or parsing error occurred during filtering.
func (it *ERC20TokenApprovalIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *ERC20TokenApprovalIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// ERC20TokenApproval represents a Approval event raised by the ERC20Token contract.
type ERC20TokenApproval struct {
	Owner   common.Address
	Spender common.Address
	Value   *big.Int
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
//
// Solidity: event Approval(address indexed _owner, address indexed _spender, uint256 _value)
func (_ERC20Token *ERC20TokenFilterer) FilterApproval(opts *bind.FilterOpts, _owner []common.Address, _spender []common.Address) (*ERC20TokenApprovalIterator, error) {

	var _ownerRule []interface{}
	for _, _ownerItem := range _owner {
		_ownerRule = append(_ownerRule, _ownerItem)
	}
	var _spenderRule []interface{}
	for _, _spenderItem := range _spender {
		_spenderRule = append(_spenderRule, _spenderItem)
	}

	logs, sub, err := _ERC20Token.contract.FilterLogs(opts, "Approval", _ownerRule, _spenderRule)
	if err != nil {
		return nil, err
	}
	return &ERC20TokenApprovalIterator{contract: _ERC20Token.contract, event: "Approval", logs: logs, sub: sub}, nil
}

// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
//
// Solidity: event Approval(address indexed _owner, address indexed _spender, uint256 _value)
func (_ERC20Token *ERC20TokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20TokenApproval, _owner []common.Address, _spender []common.Address) (event.Subscription, error) {

	var _ownerRule []interface{}
	for _, _ownerItem := range _owner {
		_ownerRule = append(_ownerRule, _ownerItem)
	}
	var _spenderRule []interface{}
	for _, _spenderItem := range _spender {
		_spenderRule = append(_spenderRule, _spenderItem)
	}

	logs, sub, err := _ERC20Token.contract.WatchLogs(opts, "Approval", _ownerRule, _spenderRule)
	if err != nil {
		return nil, err
	}
	return event.NewSubscription(func(quit <-chan struct{}) error {
		defer sub.Unsubscribe()
		for {
			select {
			case log := <-logs:
				// New log arrived, parse the event and forward to the user
				event := new(ERC20TokenApproval)
				if err := _ERC20Token.contract.UnpackLog(event, "Approval", log); err != nil {
					return err
				}
				event.Raw = log

				select {
				case sink <- event:
				case err := <-sub.Err():
					return err
				case <-quit:
					return nil
				}
			case err := <-sub.Err():
				return err
			case <-quit:
				return nil
			}
		}
	}), nil
}

// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
//
// Solidity: event Approval(address indexed _owner, address indexed _spender, uint256 _value)
func (_ERC20Token *ERC20TokenFilterer) ParseApproval(log types.Log) (*ERC20TokenApproval, error) {
	event := new(ERC20TokenApproval)
	if err := _ERC20Token.contract.UnpackLog(event, "Approval", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// ERC20TokenTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC20Token contract.
type ERC20TokenTransferIterator struct {
	Event *ERC20TokenTransfer // Event containing the contract specifics and raw log

	contract *bind.BoundContract // Generic contract to use for unpacking event data
	event    string              // Event name to use for unpacking event data

	logs chan types.Log        // Log channel receiving the found contract events
	sub  ethereum.Subscription // Subscription for errors, completion and termination
	done bool                  // Whether the subscription completed delivering logs
	fail error                 // Occurred error to stop iteration
}

// Next advances the iterator to the subsequent event, returning whether there
// are any more events found. In case of a retrieval or parsing error, false is
// returned and Error() can be queried for the exact failure.
func (it *ERC20TokenTransferIterator) Next() bool {
	// If the iterator failed, stop iterating
	if it.fail != nil {
		return false
	}
	// If the iterator completed, deliver directly whatever's available
	if it.done {
		select {
		case log := <-it.logs:
			it.Event = new(ERC20TokenTransfer)
			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
				it.fail = err
				return false
			}
			it.Event.Raw = log
			return true

		default:
			return false
		}
	}
	// Iterator still in progress, wait for either a data or an error event
	select {
	case log := <-it.logs:
		it.Event = new(ERC20TokenTransfer)
		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
			it.fail = err
			return false
		}
		it.Event.Raw = log
		return true

	case err := <-it.sub.Err():
		it.done = true
		it.fail = err
		return it.Next()
	}
}

// Error returns any retrieval or parsing error occurred during filtering.
func (it *ERC20TokenTransferIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *ERC20TokenTransferIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// ERC20TokenTransfer represents a Transfer event raised by the ERC20Token contract.
type ERC20TokenTransfer struct {
	From  common.Address
	To    common.Address
	Value *big.Int
	Raw   types.Log // Blockchain specific contextual infos
}

// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
//
// Solidity: event Transfer(address indexed _from, address indexed _to, uint256 _value)
func (_ERC20Token *ERC20TokenFilterer) FilterTransfer(opts *bind.FilterOpts, _from []common.Address, _to []common.Address) (*ERC20TokenTransferIterator, error) {

	var _fromRule []interface{}
	for _, _fromItem := range _from {
		_fromRule = append(_fromRule, _fromItem)
	}
	var _toRule []interface{}
	for _, _toItem := range _to {
		_toRule = append(_toRule, _toItem)
	}

	logs, sub, err := _ERC20Token.contract.FilterLogs(opts, "Transfer", _fromRule, _toRule)
	if err != nil {
		return nil, err
	}
	return &ERC20TokenTransferIterator{contract: _ERC20Token.contract, event: "Transfer", logs: logs, sub: sub}, nil
}

// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
//
// Solidity: event Transfer(address indexed _from, address indexed _to, uint256 _value)
func (_ERC20Token *ERC20TokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20TokenTransfer, _from []common.Address, _to []common.Address) (event.Subscription, error) {

	var _fromRule []interface{}
	for _, _fromItem := range _from {
		_fromRule = append(_fromRule, _fromItem)
	}
	var _toRule []interface{}
	for _, _toItem := range _to {
		_toRule = append(_toRule, _toItem)
	}

	logs, sub, err := _ERC20Token.contract.WatchLogs(opts, "Transfer", _fromRule, _toRule)
	if err != nil {
		return nil, err
	}
	return event.NewSubscription(func(quit <-chan struct{}) error {
		defer sub.Unsubscribe()
		for {
			select {
			case log := <-logs:
				// New log arrived, parse the event and forward to the user
				event := new(ERC20TokenTransfer)
				if err := _ERC20Token.contract.UnpackLog(event, "Transfer", log); err != nil {
					return err
				}
				event.Raw = log

				select {
				case sink <- event:
				case err := <-sub.Err():
					return err
				case <-quit:
					return nil
				}
			case err := <-sub.Err():
				return err
			case <-quit:
				return nil
			}
		}
	}), nil
}

// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
//
// Solidity: event Transfer(address indexed _from, address indexed _to, uint256 _value)
func (_ERC20Token *ERC20TokenFilterer) ParseTransfer(log types.Log) (*ERC20TokenTransfer, error) {
	event := new(ERC20TokenTransfer)
	if err := _ERC20Token.contract.UnpackLog(event, "Transfer", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// MiniMeTokenABI is the input ABI used to generate the binding from.
const MiniMeTokenABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_spender\",\"type\":\"address\"},{\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"creationBlock\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_from\",\"type\":\"address\"},{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_newController\",\"type\":\"address\"}],\"name\":\"changeController\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\"},{\"name\":\"_blockNumber\",\"type\":\"uint256\"}],\"name\":\"balanceOfAt\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"version\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_cloneTokenName\",\"type\":\"string\"},{\"name\":\"_cloneDecimalUnits\",\"type\":\"uint8\"},{\"name\":\"_cloneTokenSymbol\",\"type\":\"string\"},{\"name\":\"_snapshotBlock\",\"type\":\"uint256\"},{\"name\":\"_transfersEnabled\",\"type\":\"bool\"}],\"name\":\"createCloneToken\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"balance\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"parentToken\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\"},{\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"generateTokens\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_blockNumber\",\"type\":\"uint256\"}],\"name\":\"totalSupplyAt\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"transfersEnabled\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"parentSnapShotBlock\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutab

// MiniMeTokenFuncSigs maps the 4-byte function signature to its string representation.
var MiniMeTokenFuncSigs = map[string]string{
	"dd62ed3e": "allowance(address,address)",
	"095ea7b3": "approve(address,uint256)",
	"cae9ca51": "approveAndCall(address,uint256,bytes)",
	"70a08231": "balanceOf(address)",
	"4ee2cd7e": "balanceOfAt(address,uint256)",
	"3cebb823": "changeController(address)",
	"df8de3e7": "claimTokens(address)",
	"f77c4791": "controller()",
	"6638c087": "createCloneToken(string,uint8,string,uint256,bool)",
	"17634514": "creationBlock()",
	"313ce567": "decimals()",
	"d3ce77fe": "destroyTokens(address,uint256)",
	"f41e60c5": "enableTransfers(bool)",
	"827f32c0": "generateTokens(address,uint256)",
	"06fdde03": "name()",
	"c5bcc4f1": "parentSnapShotBlock()",
	"80a54001": "parentToken()",
	"95d89b41": "symbol()",
	"e77772fe": "tokenFactory()",
	"18160ddd": "totalSupply()",
	"981b24d0": "totalSupplyAt(uint256)",
	"a9059cbb": "transfer(address,uint256)",
	"23b872dd": "transferFrom(address,address,uint256)",
	"bef97c87": "transfersEnabled()",
	"54fd4d50": "version()",
}

// MiniMeTokenBin is the compiled bytecode used for deploying new contracts.
var MiniMeTokenBin = "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

// DeployMiniMeToken deploys a new Ethereum contract, binding an instance of MiniMeToken to it.
func DeployMiniMeToken(auth *bind.TransactOpts, backend bind.ContractBackend, _tokenFactory common.Address, _parentToken common.Address, _parentSnapShotBlock *big.Int, _tokenName string, _decimalUnits uint8, _tokenSymbol string, _transfersEnabled bool) (common.Address, *types.Transaction, *MiniMeToken, error) {
	parsed, err := abi.JSON(strings.NewReader(MiniMeTokenABI))
	if err != nil {
		return common.Address{}, nil, nil, err
	}

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(MiniMeTokenBin), backend, _tokenFactory, _parentToken, _parentSnapShotBlock, _tokenName, _decimalUnits, _tokenSymbol, _transfersEnabled)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &MiniMeToken{MiniMeTokenCaller: MiniMeTokenCaller{contract: contract}, MiniMeTokenTransactor: MiniMeTokenTransactor{contract: contract}, MiniMeTokenFilterer: MiniMeTokenFilterer{contract: contract}}, nil
}

// MiniMeToken is an auto generated Go binding around an Ethereum contract.
type MiniMeToken struct {
	MiniMeTokenCaller     // Read-only binding to the contract
	MiniMeTokenTransactor // Write-only binding to the contract
	MiniMeTokenFilterer   // Log filterer for contract events
}

// MiniMeTokenCaller is an auto generated read-only Go binding around an Ethereum contract.
type MiniMeTokenCaller struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// MiniMeTokenTransactor is an auto generated write-only Go binding around an Ethereum contract.
type MiniMeTokenTransactor struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// MiniMeTokenFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
type MiniMeTokenFilterer struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// MiniMeTokenSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type MiniMeTokenSession struct {
	Contract     *MiniMeToken      // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

// MiniMeTokenCallerSession is an auto generated read-only Go binding around an Ethereum contract,
// with pre-set call options.
type MiniMeTokenCallerSession struct {
	Contract *MiniMeTokenCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts      // Call options to use throughout this session
}

// MiniMeTokenTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
// with pre-set transact options.
type MiniMeTokenTransactorSession struct {
	Contract     *MiniMeTokenTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts      // Transaction auth options to use throughout this session
}

// MiniMeTokenRaw is an auto generated low-level Go binding around an Ethereum contract.
type MiniMeTokenRaw struct {
	Contract *MiniMeToken // Generic contract binding to access the raw methods on
}

// MiniMeTokenCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
type MiniMeTokenCallerRaw struct {
	Contract *MiniMeTokenCaller // Generic read-only contract binding to access the raw methods on
}

// MiniMeTokenTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
type MiniMeTokenTransactorRaw struct {
	Contract *MiniMeTokenTransactor // Generic write-only contract binding to access the raw methods on
}

// NewMiniMeToken creates a new instance of MiniMeToken, bound to a specific deployed contract.
func NewMiniMeToken(address common.Address, backend bind.ContractBackend) (*MiniMeToken, error) {
	contract, err := bindMiniMeToken(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &MiniMeToken{MiniMeTokenCaller: MiniMeTokenCaller{contract: contract}, MiniMeTokenTransactor: MiniMeTokenTransactor{contract: contract}, MiniMeTokenFilterer: MiniMeTokenFilterer{contract: contract}}, nil
}

// NewMiniMeTokenCaller creates a new read-only instance of MiniMeToken, bound to a specific deployed contract.
func NewMiniMeTokenCaller(address common.Address, caller bind.ContractCaller) (*MiniMeTokenCaller, error) {
	contract, err := bindMiniMeToken(address, caller, nil, nil)
	if err != nil {
		return nil, err
	}
	return &MiniMeTokenCaller{contract: contract}, nil
}

// NewMiniMeTokenTransactor creates a new write-only instance of MiniMeToken, bound to a specific deployed contract.
func NewMiniMeTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*MiniMeTokenTransactor, error) {
	contract, err := bindMiniMeToken(address, nil, transactor, nil)
	if err != nil {
		return nil, err
	}
	return &MiniMeTokenTransactor{contract: contract}, nil
}

// NewMiniMeTokenFilterer creates a new log filterer instance of MiniMeToken, bound to a specific deployed contract.
func NewMiniMeTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*MiniMeTokenFilterer, error) {
	contract, err := bindMiniMeToken(address, nil, nil, filterer)
	if err != nil {
		return nil, err
	}
	return &MiniMeTokenFilterer{contract: contract}, nil
}

// bindMiniMeToken binds a generic wrapper to an already deployed contract.
func bindMiniMeToken(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(MiniMeTokenABI))
	if err != nil {
		return nil, err
	}
	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_MiniMeToken *MiniMeTokenRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _MiniMeToken.Contract.MiniMeTokenCaller.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_MiniMeToken *MiniMeTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _MiniMeToken.Contract.MiniMeTokenTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_MiniMeToken *MiniMeTokenRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _MiniMeToken.Contract.MiniMeTokenTransactor.contract.Transact(opts, method, params...)
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_MiniMeToken *MiniMeTokenCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _MiniMeToken.Contract.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_MiniMeToken *MiniMeTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _MiniMeToken.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_MiniMeToken *MiniMeTokenTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _MiniMeToken.Contract.contract.Transact(opts, method, params...)
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address _owner, address _spender) view returns(uint256 remaining)
func (_MiniMeToken *MiniMeTokenCaller) Allowance(opts *bind.CallOpts, _owner common.Address, _spender common.Address) (*big.Int, error) {
	var out []interface{}
	err := _MiniMeToken.contract.Call(opts, &out, "allowance", _owner, _spender)

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address _owner, address _spender) view returns(uint256 remaining)
func (_MiniMeToken *MiniMeTokenSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error) {
	return _MiniMeToken.Contract.Allowance(&_MiniMeToken.CallOpts, _owner, _spender)
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address _owner, address _spender) view returns(uint256 remaining)
func (_MiniMeToken *MiniMeTokenCallerSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error) {
	return _MiniMeToken.Contract.Allowance(&_MiniMeToken.CallOpts, _owner, _spender)
}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address _owner) view returns(uint256 balance)
func (_MiniMeToken *MiniMeTokenCaller) BalanceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error) {
	var out []interface{}
	err := _MiniMeToken.contract.Call(opts, &out, "balanceOf", _owner)

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address _owner) view returns(uint256 balance)
func (_MiniMeToken *MiniMeTokenSession) BalanceOf(_owner common.Address) (*big.Int, error) {
	return _MiniMeToken.Contract.BalanceOf(&_MiniMeToken.CallOpts, _owner)
}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address _owner) view returns(uint256 balance)
func (_MiniMeToken *MiniMeTokenCallerSession) BalanceOf(_owner common.Address) (*big.Int, error) {
	return _MiniMeToken.Contract.BalanceOf(&_MiniMeToken.CallOpts, _owner)
}

// BalanceOfAt is a free data retrieval call binding the contract method 0x4ee2cd7e.
//
// Solidity: function balanceOfAt(address _owner, uint256 _blockNumber) view returns(uint256)
func (_MiniMeToken *MiniMeTokenCaller) BalanceOfAt(opts *bind.CallOpts, _owner common.Address, _blockNumber *big.Int) (*big.Int, error) {
	var out []interface{}
	err := _MiniMeToken.contract.Call(opts, &out, "balanceOfAt", _owner, _blockNumber)

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// BalanceOfAt is a free data retrieval call binding the contract method 0x4ee2cd7e.
//
// Solidity: function balanceOfAt(address _owner, uint256 _blockNumber) view returns(uint256)
func (_MiniMeToken *MiniMeTokenSession) BalanceOfAt(_owner common.Address, _blockNumber *big.Int) (*big.Int, error) {
	return _MiniMeToken.Contract.BalanceOfAt(&_MiniMeToken.CallOpts, _owner, _blockNumber)
}

// BalanceOfAt is a free data retrieval call binding the contract method 0x4ee2cd7e.
//
// Solidity: function balanceOfAt(address _owner, uint256 _blockNumber) view returns(uint256)
func (_MiniMeToken *MiniMeTokenCallerSession) BalanceOfAt(_owner common.Address, _blockNumber *big.Int) (*big.Int, error) {
	return _MiniMeToken.Contract.BalanceOfAt(&_MiniMeToken.CallOpts, _owner, _blockNumber)
}

// Controller is a free data retrieval call binding the contract method 0xf77c4791.
//
// Solidity: function controller() view returns(address)
func (_MiniMeToken *MiniMeTokenCaller) Controller(opts *bind.CallOpts) (common.Address, error) {
	var out []interface{}
	err := _MiniMeToken.contract.Call(opts, &out, "controller")

	if err != nil {
		return *new(common.Address), err
	}

	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)

	return out0, err

}

// Controller is a free data retrieval call binding the contract method 0xf77c4791.
//
// Solidity: function controller() view returns(address)
func (_MiniMeToken *MiniMeTokenSession) Controller() (common.Address, error) {
	return _MiniMeToken.Contract.Controller(&_MiniMeToken.CallOpts)
}

// Controller is a free data retrieval call binding the contract method 0xf77c4791.
//
// Solidity: function controller() view returns(address)
func (_MiniMeToken *MiniMeTokenCallerSession) Controller() (common.Address, error) {
	return _MiniMeToken.Contract.Controller(&_MiniMeToken.CallOpts)
}

// CreationBlock is a free data retrieval call binding the contract method 0x17634514.
//
// Solidity: function creationBlock() view returns(uint256)
func (_MiniMeToken *MiniMeTokenCaller) CreationBlock(opts *bind.CallOpts) (*big.Int, error) {
	var out []interface{}
	err := _MiniMeToken.contract.Call(opts, &out, "creationBlock")

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// CreationBlock is a free data retrieval call binding the contract method 0x17634514.
//
// Solidity: function creationBlock() view returns(uint256)
func (_MiniMeToken *MiniMeTokenSession) CreationBlock() (*big.Int, error) {
	return _MiniMeToken.Contract.CreationBlock(&_MiniMeToken.CallOpts)
}

// CreationBlock is a free data retrieval call binding the contract method 0x17634514.
//
// Solidity: function creationBlock() view returns(uint256)
func (_MiniMeToken *MiniMeTokenCallerSession) CreationBlock() (*big.Int, error) {
	return _MiniMeToken.Contract.CreationBlock(&_MiniMeToken.CallOpts)
}

// Decimals is a free data retrieval call binding the contract method 0x313ce567.
//
// Solidity: function decimals() view returns(uint8)
func (_MiniMeToken *MiniMeTokenCaller) Decimals(opts *bind.CallOpts) (uint8, error) {
	var out []interface{}
	err := _MiniMeToken.contract.Call(opts, &out, "decimals")

	if err != nil {
		return *new(uint8), err
	}

	out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8)

	return out0, err

}

// Decimals is a free data retrieval call binding the contract method 0x313ce567.
//
// Solidity: function decimals() view returns(uint8)
func (_MiniMeToken *MiniMeTokenSession) Decimals() (uint8, error) {
	return _MiniMeToken.Contract.Decimals(&_MiniMeToken.CallOpts)
}

// Decimals is a free data retrieval call binding the contract method 0x313ce567.
//
// Solidity: function decimals() view returns(uint8)
func (_MiniMeToken *MiniMeTokenCallerSession) Decimals() (uint8, error) {
	return _MiniMeToken.Contract.Decimals(&_MiniMeToken.CallOpts)
}

// Name is a free data retrieval call binding the contract method 0x06fdde03.
//
// Solidity: function name() view returns(string)
func (_MiniMeToken *MiniMeTokenCaller) Name(opts *bind.CallOpts) (string, error) {
	var out []interface{}
	err := _MiniMeToken.contract.Call(opts, &out, "name")

	if err != nil {
		return *new(string), err
	}

	out0 := *abi.ConvertType(out[0], new(string)).(*string)

	return out0, err

}

// Name is a free data retrieval call binding the contract method 0x06fdde03.
//
// Solidity: function name() view returns(string)
func (_MiniMeToken *MiniMeTokenSession) Name() (string, error) {
	return _MiniMeToken.Contract.Name(&_MiniMeToken.CallOpts)
}

// Name is a free data retrieval call binding the contract method 0x06fdde03.
//
// Solidity: function name() view returns(string)
func (_MiniMeToken *MiniMeTokenCallerSession) Name() (string, error) {
	return _MiniMeToken.Contract.Name(&_MiniMeToken.CallOpts)
}

// ParentSnapShotBlock is a free data retrieval call binding the contract method 0xc5bcc4f1.
//
// Solidity: function parentSnapShotBlock() view returns(uint256)
func (_MiniMeToken *MiniMeTokenCaller) ParentSnapShotBlock(opts *bind.CallOpts) (*big.Int, error) {
	var out []interface{}
	err := _MiniMeToken.contract.Call(opts, &out, "parentSnapShotBlock")

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// ParentSnapShotBlock is a free data retrieval call binding the contract method 0xc5bcc4f1.
//
// Solidity: function parentSnapShotBlock() view returns(uint256)
func (_MiniMeToken *MiniMeTokenSession) ParentSnapShotBlock() (*big.Int, error) {
	return _MiniMeToken.Contract.ParentSnapShotBlock(&_MiniMeToken.CallOpts)
}

// ParentSnapShotBlock is a free data retrieval call binding the contract method 0xc5bcc4f1.
//
// Solidity: function parentSnapShotBlock() view returns(uint256)
func (_MiniMeToken *MiniMeTokenCallerSession) ParentSnapShotBlock() (*big.Int, error) {
	return _MiniMeToken.Contract.ParentSnapShotBlock(&_MiniMeToken.CallOpts)
}

// ParentToken is a free data retrieval call binding the contract method 0x80a54001.
//
// Solidity: function parentToken() view returns(address)
func (_MiniMeToken *MiniMeTokenCaller) ParentToken(opts *bind.CallOpts) (common.Address, error) {
	var out []interface{}
	err := _MiniMeToken.contract.Call(opts, &out, "parentToken")

	if err != nil {
		return *new(common.Address), err
	}

	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)

	return out0, err

}

// ParentToken is a free data retrieval call binding the contract method 0x80a54001.
//
// Solidity: function parentToken() view returns(address)
func (_MiniMeToken *MiniMeTokenSession) ParentToken() (common.Address, error) {
	return _MiniMeToken.Contract.ParentToken(&_MiniMeToken.CallOpts)
}

// ParentToken is a free data retrieval call binding the contract method 0x80a54001.
//
// Solidity: function parentToken() view returns(address)
func (_MiniMeToken *MiniMeTokenCallerSession) ParentToken() (common.Address, error) {
	return _MiniMeToken.Contract.ParentToken(&_MiniMeToken.CallOpts)
}

// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
//
// Solidity: function symbol() view returns(string)
func (_MiniMeToken *MiniMeTokenCaller) Symbol(opts *bind.CallOpts) (string, error) {
	var out []interface{}
	err := _MiniMeToken.contract.Call(opts, &out, "symbol")

	if err != nil {
		return *new(string), err
	}

	out0 := *abi.ConvertType(out[0], new(string)).(*string)

	return out0, err

}

// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
//
// Solidity: function symbol() view returns(string)
func (_MiniMeToken *MiniMeTokenSession) Symbol() (string, error) {
	return _MiniMeToken.Contract.Symbol(&_MiniMeToken.CallOpts)
}

// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
//
// Solidity: function symbol() view returns(string)
func (_MiniMeToken *MiniMeTokenCallerSession) Symbol() (string, error) {
	return _MiniMeToken.Contract.Symbol(&_MiniMeToken.CallOpts)
}

// TokenFactory is a free data retrieval call binding the contract method 0xe77772fe.
//
// Solidity: function tokenFactory() view returns(address)
func (_MiniMeToken *MiniMeTokenCaller) TokenFactory(opts *bind.CallOpts) (common.Address, error) {
	var out []interface{}
	err := _MiniMeToken.contract.Call(opts, &out, "tokenFactory")

	if err != nil {
		return *new(common.Address), err
	}

	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)

	return out0, err

}

// TokenFactory is a free data retrieval call binding the contract method 0xe77772fe.
//
// Solidity: function tokenFactory() view returns(address)
func (_MiniMeToken *MiniMeTokenSession) TokenFactory() (common.Address, error) {
	return _MiniMeToken.Contract.TokenFactory(&_MiniMeToken.CallOpts)
}

// TokenFactory is a free data retrieval call binding the contract method 0xe77772fe.
//
// Solidity: function tokenFactory() view returns(address)
func (_MiniMeToken *MiniMeTokenCallerSession) TokenFactory() (common.Address, error) {
	return _MiniMeToken.Contract.TokenFactory(&_MiniMeToken.CallOpts)
}

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() view returns(uint256)
func (_MiniMeToken *MiniMeTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
	var out []interface{}
	err := _MiniMeToken.contract.Call(opts, &out, "totalSupply")

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() view returns(uint256)
func (_MiniMeToken *MiniMeTokenSession) TotalSupply() (*big.Int, error) {
	return _MiniMeToken.Contract.TotalSupply(&_MiniMeToken.CallOpts)
}

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() view returns(uint256)
func (_MiniMeToken *MiniMeTokenCallerSession) TotalSupply() (*big.Int, error) {
	return _MiniMeToken.Contract.TotalSupply(&_MiniMeToken.CallOpts)
}

// TotalSupplyAt is a free data retrieval call binding the contract method 0x981b24d0.
//
// Solidity: function totalSupplyAt(uint256 _blockNumber) view returns(uint256)
func (_MiniMeToken *MiniMeTokenCaller) TotalSupplyAt(opts *bind.CallOpts, _blockNumber *big.Int) (*big.Int, error) {
	var out []interface{}
	err := _MiniMeToken.contract.Call(opts, &out, "totalSupplyAt", _blockNumber)

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// TotalSupplyAt is a free data retrieval call binding the contract method 0x981b24d0.
//
// Solidity: function totalSupplyAt(uint256 _blockNumber) view returns(uint256)
func (_MiniMeToken *MiniMeTokenSession) TotalSupplyAt(_blockNumber *big.Int) (*big.Int, error) {
	return _MiniMeToken.Contract.TotalSupplyAt(&_MiniMeToken.CallOpts, _blockNumber)
}

// TotalSupplyAt is a free data retrieval call binding the contract method 0x981b24d0.
//
// Solidity: function totalSupplyAt(uint256 _blockNumber) view returns(uint256)
func (_MiniMeToken *MiniMeTokenCallerSession) TotalSupplyAt(_blockNumber *big.Int) (*big.Int, error) {
	return _MiniMeToken.Contract.TotalSupplyAt(&_MiniMeToken.CallOpts, _blockNumber)
}

// TransfersEnabled is a free data retrieval call binding the contract method 0xbef97c87.
//
// Solidity: function transfersEnabled() view returns(bool)
func (_MiniMeToken *MiniMeTokenCaller) TransfersEnabled(opts *bind.CallOpts) (bool, error) {
	var out []interface{}
	err := _MiniMeToken.contract.Call(opts, &out, "transfersEnabled")

	if err != nil {
		return *new(bool), err
	}

	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)

	return out0, err

}

// TransfersEnabled is a free data retrieval call binding the contract method 0xbef97c87.
//
// Solidity: function transfersEnabled() view returns(bool)
func (_MiniMeToken *MiniMeTokenSession) TransfersEnabled() (bool, error) {
	return _MiniMeToken.Contract.TransfersEnabled(&_MiniMeToken.CallOpts)
}

// TransfersEnabled is a free data retrieval call binding the contract method 0xbef97c87.
//
// Solidity: function transfersEnabled() view returns(bool)
func (_MiniMeToken *MiniMeTokenCallerSession) TransfersEnabled() (bool, error) {
	return _MiniMeToken.Contract.TransfersEnabled(&_MiniMeToken.CallOpts)
}

// Version is a free data retrieval call binding the contract method 0x54fd4d50.
//
// Solidity: function version() view returns(string)
func (_MiniMeToken *MiniMeTokenCaller) Version(opts *bind.CallOpts) (string, error) {
	var out []interface{}
	err := _MiniMeToken.contract.Call(opts, &out, "version")

	if err != nil {
		return *new(string), err
	}

	out0 := *abi.ConvertType(out[0], new(string)).(*string)

	return out0, err

}

// Version is a free data retrieval call binding the contract method 0x54fd4d50.
//
// Solidity: function version() view returns(string)
func (_MiniMeToken *MiniMeTokenSession) Version() (string, error) {
	return _MiniMeToken.Contract.Version(&_MiniMeToken.CallOpts)
}

// Version is a free data retrieval call binding the contract method 0x54fd4d50.
//
// Solidity: function version() view returns(string)
func (_MiniMeToken *MiniMeTokenCallerSession) Version() (string, error) {
	return _MiniMeToken.Contract.Version(&_MiniMeToken.CallOpts)
}

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address _spender, uint256 _amount) returns(bool success)
func (_MiniMeToken *MiniMeTokenTransactor) Approve(opts *bind.TransactOpts, _spender common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _MiniMeToken.contract.Transact(opts, "approve", _spender, _amount)
}

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address _spender, uint256 _amount) returns(bool success)
func (_MiniMeToken *MiniMeTokenSession) Approve(_spender common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _MiniMeToken.Contract.Approve(&_MiniMeToken.TransactOpts, _spender, _amount)
}

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address _spender, uint256 _amount) returns(bool success)
func (_MiniMeToken *MiniMeTokenTransactorSession) Approve(_spender common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _MiniMeToken.Contract.Approve(&_MiniMeToken.TransactOpts, _spender, _amount)
}

// ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
//
// Solidity: function approveAndCall(address _spender, uint256 _amount, bytes _extraData) returns(bool success)
func (_MiniMeToken *MiniMeTokenTransactor) ApproveAndCall(opts *bind.TransactOpts, _spender common.Address, _amount *big.Int, _extraData []byte) (*types.Transaction, error) {
	return _MiniMeToken.contract.Transact(opts, "approveAndCall", _spender, _amount, _extraData)
}

// ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
//
// Solidity: function approveAndCall(address _spender, uint256 _amount, bytes _extraData) returns(bool success)
func (_MiniMeToken *MiniMeTokenSession) ApproveAndCall(_spender common.Address, _amount *big.Int, _extraData []byte) (*types.Transaction, error) {
	return _MiniMeToken.Contract.ApproveAndCall(&_MiniMeToken.TransactOpts, _spender, _amount, _extraData)
}

// ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
//
// Solidity: function approveAndCall(address _spender, uint256 _amount, bytes _extraData) returns(bool success)
func (_MiniMeToken *MiniMeTokenTransactorSession) ApproveAndCall(_spender common.Address, _amount *big.Int, _extraData []byte) (*types.Transaction, error) {
	return _MiniMeToken.Contract.ApproveAndCall(&_MiniMeToken.TransactOpts, _spender, _amount, _extraData)
}

// ChangeController is a paid mutator transaction binding the contract method 0x3cebb823.
//
// Solidity: function changeController(address _newController) returns()
func (_MiniMeToken *MiniMeTokenTransactor) ChangeController(opts *bind.TransactOpts, _newController common.Address) (*types.Transaction, error) {
	return _MiniMeToken.contract.Transact(opts, "changeController", _newController)
}

// ChangeController is a paid mutator transaction binding the contract method 0x3cebb823.
//
// Solidity: function changeController(address _newController) returns()
func (_MiniMeToken *MiniMeTokenSession) ChangeController(_newController common.Address) (*types.Transaction, error) {
	return _MiniMeToken.Contract.ChangeController(&_MiniMeToken.TransactOpts, _newController)
}

// ChangeController is a paid mutator transaction binding the contract method 0x3cebb823.
//
// Solidity: function changeController(address _newController) returns()
func (_MiniMeToken *MiniMeTokenTransactorSession) ChangeController(_newController common.Address) (*types.Transaction, error) {
	return _MiniMeToken.Contract.ChangeController(&_MiniMeToken.TransactOpts, _newController)
}

// ClaimTokens is a paid mutator transaction binding the contract method 0xdf8de3e7.
//
// Solidity: function claimTokens(address _token) returns()
func (_MiniMeToken *MiniMeTokenTransactor) ClaimTokens(opts *bind.TransactOpts, _token common.Address) (*types.Transaction, error) {
	return _MiniMeToken.contract.Transact(opts, "claimTokens", _token)
}

// ClaimTokens is a paid mutator transaction binding the contract method 0xdf8de3e7.
//
// Solidity: function claimTokens(address _token) returns()
func (_MiniMeToken *MiniMeTokenSession) ClaimTokens(_token common.Address) (*types.Transaction, error) {
	return _MiniMeToken.Contract.ClaimTokens(&_MiniMeToken.TransactOpts, _token)
}

// ClaimTokens is a paid mutator transaction binding the contract method 0xdf8de3e7.
//
// Solidity: function claimTokens(address _token) returns()
func (_MiniMeToken *MiniMeTokenTransactorSession) ClaimTokens(_token common.Address) (*types.Transaction, error) {
	return _MiniMeToken.Contract.ClaimTokens(&_MiniMeToken.TransactOpts, _token)
}

// CreateCloneToken is a paid mutator transaction binding the contract method 0x6638c087.
//
// Solidity: function createCloneToken(string _cloneTokenName, uint8 _cloneDecimalUnits, string _cloneTokenSymbol, uint256 _snapshotBlock, bool _transfersEnabled) returns(address)
func (_MiniMeToken *MiniMeTokenTransactor) CreateCloneToken(opts *bind.TransactOpts, _cloneTokenName string, _cloneDecimalUnits uint8, _cloneTokenSymbol string, _snapshotBlock *big.Int, _transfersEnabled bool) (*types.Transaction, error) {
	return _MiniMeToken.contract.Transact(opts, "createCloneToken", _cloneTokenName, _cloneDecimalUnits, _cloneTokenSymbol, _snapshotBlock, _transfersEnabled)
}

// CreateCloneToken is a paid mutator transaction binding the contract method 0x6638c087.
//
// Solidity: function createCloneToken(string _cloneTokenName, uint8 _cloneDecimalUnits, string _cloneTokenSymbol, uint256 _snapshotBlock, bool _transfersEnabled) returns(address)
func (_MiniMeToken *MiniMeTokenSession) CreateCloneToken(_cloneTokenName string, _cloneDecimalUnits uint8, _cloneTokenSymbol string, _snapshotBlock *big.Int, _transfersEnabled bool) (*types.Transaction, error) {
	return _MiniMeToken.Contract.CreateCloneToken(&_MiniMeToken.TransactOpts, _cloneTokenName, _cloneDecimalUnits, _cloneTokenSymbol, _snapshotBlock, _transfersEnabled)
}

// CreateCloneToken is a paid mutator transaction binding the contract method 0x6638c087.
//
// Solidity: function createCloneToken(string _cloneTokenName, uint8 _cloneDecimalUnits, string _cloneTokenSymbol, uint256 _snapshotBlock, bool _transfersEnabled) returns(address)
func (_MiniMeToken *MiniMeTokenTransactorSession) CreateCloneToken(_cloneTokenName string, _cloneDecimalUnits uint8, _cloneTokenSymbol string, _snapshotBlock *big.Int, _transfersEnabled bool) (*types.Transaction, error) {
	return _MiniMeToken.Contract.CreateCloneToken(&_MiniMeToken.TransactOpts, _cloneTokenName, _cloneDecimalUnits, _cloneTokenSymbol, _snapshotBlock, _transfersEnabled)
}

// DestroyTokens is a paid mutator transaction binding the contract method 0xd3ce77fe.
//
// Solidity: function destroyTokens(address _owner, uint256 _amount) returns(bool)
func (_MiniMeToken *MiniMeTokenTransactor) DestroyTokens(opts *bind.TransactOpts, _owner common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _MiniMeToken.contract.Transact(opts, "destroyTokens", _owner, _amount)
}

// DestroyTokens is a paid mutator transaction binding the contract method 0xd3ce77fe.
//
// Solidity: function destroyTokens(address _owner, uint256 _amount) returns(bool)
func (_MiniMeToken *MiniMeTokenSession) DestroyTokens(_owner common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _MiniMeToken.Contract.DestroyTokens(&_MiniMeToken.TransactOpts, _owner, _amount)
}

// DestroyTokens is a paid mutator transaction binding the contract method 0xd3ce77fe.
//
// Solidity: function destroyTokens(address _owner, uint256 _amount) returns(bool)
func (_MiniMeToken *MiniMeTokenTransactorSession) DestroyTokens(_owner common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _MiniMeToken.Contract.DestroyTokens(&_MiniMeToken.TransactOpts, _owner, _amount)
}

// EnableTransfers is a paid mutator transaction binding the contract method 0xf41e60c5.
//
// Solidity: function enableTransfers(bool _transfersEnabled) returns()
func (_MiniMeToken *MiniMeTokenTransactor) EnableTransfers(opts *bind.TransactOpts, _transfersEnabled bool) (*types.Transaction, error) {
	return _MiniMeToken.contract.Transact(opts, "enableTransfers", _transfersEnabled)
}

// EnableTransfers is a paid mutator transaction binding the contract method 0xf41e60c5.
//
// Solidity: function enableTransfers(bool _transfersEnabled) returns()
func (_MiniMeToken *MiniMeTokenSession) EnableTransfers(_transfersEnabled bool) (*types.Transaction, error) {
	return _MiniMeToken.Contract.EnableTransfers(&_MiniMeToken.TransactOpts, _transfersEnabled)
}

// EnableTransfers is a paid mutator transaction binding the contract method 0xf41e60c5.
//
// Solidity: function enableTransfers(bool _transfersEnabled) returns()
func (_MiniMeToken *MiniMeTokenTransactorSession) EnableTransfers(_transfersEnabled bool) (*types.Transaction, error) {
	return _MiniMeToken.Contract.EnableTransfers(&_MiniMeToken.TransactOpts, _transfersEnabled)
}

// GenerateTokens is a paid mutator transaction binding the contract method 0x827f32c0.
//
// Solidity: function generateTokens(address _owner, uint256 _amount) returns(bool)
func (_MiniMeToken *MiniMeTokenTransactor) GenerateTokens(opts *bind.TransactOpts, _owner common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _MiniMeToken.contract.Transact(opts, "generateTokens", _owner, _amount)
}

// GenerateTokens is a paid mutator transaction binding the contract method 0x827f32c0.
//
// Solidity: function generateTokens(address _owner, uint256 _amount) returns(bool)
func (_MiniMeToken *MiniMeTokenSession) GenerateTokens(_owner common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _MiniMeToken.Contract.GenerateTokens(&_MiniMeToken.TransactOpts, _owner, _amount)
}

// GenerateTokens is a paid mutator transaction binding the contract method 0x827f32c0.
//
// Solidity: function generateTokens(address _owner, uint256 _amount) returns(bool)
func (_MiniMeToken *MiniMeTokenTransactorSession) GenerateTokens(_owner common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _MiniMeToken.Contract.GenerateTokens(&_MiniMeToken.TransactOpts, _owner, _amount)
}

// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
//
// Solidity: function transfer(address _to, uint256 _amount) returns(bool success)
func (_MiniMeToken *MiniMeTokenTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _MiniMeToken.contract.Transact(opts, "transfer", _to, _amount)
}

// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
//
// Solidity: function transfer(address _to, uint256 _amount) returns(bool success)
func (_MiniMeToken *MiniMeTokenSession) Transfer(_to common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _MiniMeToken.Contract.Transfer(&_MiniMeToken.TransactOpts, _to, _amount)
}

// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
//
// Solidity: function transfer(address _to, uint256 _amount) returns(bool success)
func (_MiniMeToken *MiniMeTokenTransactorSession) Transfer(_to common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _MiniMeToken.Contract.Transfer(&_MiniMeToken.TransactOpts, _to, _amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address _from, address _to, uint256 _amount) returns(bool success)
func (_MiniMeToken *MiniMeTokenTransactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _MiniMeToken.contract.Transact(opts, "transferFrom", _from, _to, _amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address _from, address _to, uint256 _amount) returns(bool success)
func (_MiniMeToken *MiniMeTokenSession) TransferFrom(_from common.Address, _to common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _MiniMeToken.Contract.TransferFrom(&_MiniMeToken.TransactOpts, _from, _to, _amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address _from, address _to, uint256 _amount) returns(bool success)
func (_MiniMeToken *MiniMeTokenTransactorSession) TransferFrom(_from common.Address, _to common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _MiniMeToken.Contract.TransferFrom(&_MiniMeToken.TransactOpts, _from, _to, _amount)
}

// Fallback is a paid mutator transaction binding the contract fallback function.
//
// Solidity: fallback() payable returns()
func (_MiniMeToken *MiniMeTokenTransactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error) {
	return _MiniMeToken.contract.RawTransact(opts, calldata)
}

// Fallback is a paid mutator transaction binding the contract fallback function.
//
// Solidity: fallback() payable returns()
func (_MiniMeToken *MiniMeTokenSession) Fallback(calldata []byte) (*types.Transaction, error) {
	return _MiniMeToken.Contract.Fallback(&_MiniMeToken.TransactOpts, calldata)
}

// Fallback is a paid mutator transaction binding the contract fallback function.
//
// Solidity: fallback() payable returns()
func (_MiniMeToken *MiniMeTokenTransactorSession) Fallback(calldata []byte) (*types.Transaction, error) {
	return _MiniMeToken.Contract.Fallback(&_MiniMeToken.TransactOpts, calldata)
}

// MiniMeTokenApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the MiniMeToken contract.
type MiniMeTokenApprovalIterator struct {
	Event *MiniMeTokenApproval // Event containing the contract specifics and raw log

	contract *bind.BoundContract // Generic contract to use for unpacking event data
	event    string              // Event name to use for unpacking event data

	logs chan types.Log        // Log channel receiving the found contract events
	sub  ethereum.Subscription // Subscription for errors, completion and termination
	done bool                  // Whether the subscription completed delivering logs
	fail error                 // Occurred error to stop iteration
}

// Next advances the iterator to the subsequent event, returning whether there
// are any more events found. In case of a retrieval or parsing error, false is
// returned and Error() can be queried for the exact failure.
func (it *MiniMeTokenApprovalIterator) Next() bool {
	// If the iterator failed, stop iterating
	if it.fail != nil {
		return false
	}
	// If the iterator completed, deliver directly whatever's available
	if it.done {
		select {
		case log := <-it.logs:
			it.Event = new(MiniMeTokenApproval)
			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
				it.fail = err
				return false
			}
			it.Event.Raw = log
			return true

		default:
			return false
		}
	}
	// Iterator still in progress, wait for either a data or an error event
	select {
	case log := <-it.logs:
		it.Event = new(MiniMeTokenApproval)
		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
			it.fail = err
			return false
		}
		it.Event.Raw = log
		return true

	case err := <-it.sub.Err():
		it.done = true
		it.fail = err
		return it.Next()
	}
}

// Error returns any retrieval or parsing error occurred during filtering.
func (it *MiniMeTokenApprovalIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *MiniMeTokenApprovalIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// MiniMeTokenApproval represents a Approval event raised by the MiniMeToken contract.
type MiniMeTokenApproval struct {
	Owner   common.Address
	Spender common.Address
	Amount  *big.Int
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
//
// Solidity: event Approval(address indexed _owner, address indexed _spender, uint256 _amount)
func (_MiniMeToken *MiniMeTokenFilterer) FilterApproval(opts *bind.FilterOpts, _owner []common.Address, _spender []common.Address) (*MiniMeTokenApprovalIterator, error) {

	var _ownerRule []interface{}
	for _, _ownerItem := range _owner {
		_ownerRule = append(_ownerRule, _ownerItem)
	}
	var _spenderRule []interface{}
	for _, _spenderItem := range _spender {
		_spenderRule = append(_spenderRule, _spenderItem)
	}

	logs, sub, err := _MiniMeToken.contract.FilterLogs(opts, "Approval", _ownerRule, _spenderRule)
	if err != nil {
		return nil, err
	}
	return &MiniMeTokenApprovalIterator{contract: _MiniMeToken.contract, event: "Approval", logs: logs, sub: sub}, nil
}

// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
//
// Solidity: event Approval(address indexed _owner, address indexed _spender, uint256 _amount)
func (_MiniMeToken *MiniMeTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *MiniMeTokenApproval, _owner []common.Address, _spender []common.Address) (event.Subscription, error) {

	var _ownerRule []interface{}
	for _, _ownerItem := range _owner {
		_ownerRule = append(_ownerRule, _ownerItem)
	}
	var _spenderRule []interface{}
	for _, _spenderItem := range _spender {
		_spenderRule = append(_spenderRule, _spenderItem)
	}

	logs, sub, err := _MiniMeToken.contract.WatchLogs(opts, "Approval", _ownerRule, _spenderRule)
	if err != nil {
		return nil, err
	}
	return event.NewSubscription(func(quit <-chan struct{}) error {
		defer sub.Unsubscribe()
		for {
			select {
			case log := <-logs:
				// New log arrived, parse the event and forward to the user
				event := new(MiniMeTokenApproval)
				if err := _MiniMeToken.contract.UnpackLog(event, "Approval", log); err != nil {
					return err
				}
				event.Raw = log

				select {
				case sink <- event:
				case err := <-sub.Err():
					return err
				case <-quit:
					return nil
				}
			case err := <-sub.Err():
				return err
			case <-quit:
				return nil
			}
		}
	}), nil
}

// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
//
// Solidity: event Approval(address indexed _owner, address indexed _spender, uint256 _amount)
func (_MiniMeToken *MiniMeTokenFilterer) ParseApproval(log types.Log) (*MiniMeTokenApproval, error) {
	event := new(MiniMeTokenApproval)
	if err := _MiniMeToken.contract.UnpackLog(event, "Approval", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// MiniMeTokenClaimedTokensIterator is returned from FilterClaimedTokens and is used to iterate over the raw logs and unpacked data for ClaimedTokens events raised by the MiniMeToken contract.
type MiniMeTokenClaimedTokensIterator struct {
	Event *MiniMeTokenClaimedTokens // Event containing the contract specifics and raw log

	contract *bind.BoundContract // Generic contract to use for unpacking event data
	event    string              // Event name to use for unpacking event data

	logs chan types.Log        // Log channel receiving the found contract events
	sub  ethereum.Subscription // Subscription for errors, completion and termination
	done bool                  // Whether the subscription completed delivering logs
	fail error                 // Occurred error to stop iteration
}

// Next advances the iterator to the subsequent event, returning whether there
// are any more events found. In case of a retrieval or parsing error, false is
// returned and Error() can be queried for the exact failure.
func (it *MiniMeTokenClaimedTokensIterator) Next() bool {
	// If the iterator failed, stop iterating
	if it.fail != nil {
		return false
	}
	// If the iterator completed, deliver directly whatever's available
	if it.done {
		select {
		case log := <-it.logs:
			it.Event = new(MiniMeTokenClaimedTokens)
			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
				it.fail = err
				return false
			}
			it.Event.Raw = log
			return true

		default:
			return false
		}
	}
	// Iterator still in progress, wait for either a data or an error event
	select {
	case log := <-it.logs:
		it.Event = new(MiniMeTokenClaimedTokens)
		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
			it.fail = err
			return false
		}
		it.Event.Raw = log
		return true

	case err := <-it.sub.Err():
		it.done = true
		it.fail = err
		return it.Next()
	}
}

// Error returns any retrieval or parsing error occurred during filtering.
func (it *MiniMeTokenClaimedTokensIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *MiniMeTokenClaimedTokensIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// MiniMeTokenClaimedTokens represents a ClaimedTokens event raised by the MiniMeToken contract.
type MiniMeTokenClaimedTokens struct {
	Token      common.Address
	Controller common.Address
	Amount     *big.Int
	Raw        types.Log // Blockchain specific contextual infos
}

// FilterClaimedTokens is a free log retrieval operation binding the contract event 0xf931edb47c50b4b4104c187b5814a9aef5f709e17e2ecf9617e860cacade929c.
//
// Solidity: event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount)
func (_MiniMeToken *MiniMeTokenFilterer) FilterClaimedTokens(opts *bind.FilterOpts, _token []common.Address, _controller []common.Address) (*MiniMeTokenClaimedTokensIterator, error) {

	var _tokenRule []interface{}
	for _, _tokenItem := range _token {
		_tokenRule = append(_tokenRule, _tokenItem)
	}
	var _controllerRule []interface{}
	for _, _controllerItem := range _controller {
		_controllerRule = append(_controllerRule, _controllerItem)
	}

	logs, sub, err := _MiniMeToken.contract.FilterLogs(opts, "ClaimedTokens", _tokenRule, _controllerRule)
	if err != nil {
		return nil, err
	}
	return &MiniMeTokenClaimedTokensIterator{contract: _MiniMeToken.contract, event: "ClaimedTokens", logs: logs, sub: sub}, nil
}

// WatchClaimedTokens is a free log subscription operation binding the contract event 0xf931edb47c50b4b4104c187b5814a9aef5f709e17e2ecf9617e860cacade929c.
//
// Solidity: event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount)
func (_MiniMeToken *MiniMeTokenFilterer) WatchClaimedTokens(opts *bind.WatchOpts, sink chan<- *MiniMeTokenClaimedTokens, _token []common.Address, _controller []common.Address) (event.Subscription, error) {

	var _tokenRule []interface{}
	for _, _tokenItem := range _token {
		_tokenRule = append(_tokenRule, _tokenItem)
	}
	var _controllerRule []interface{}
	for _, _controllerItem := range _controller {
		_controllerRule = append(_controllerRule, _controllerItem)
	}

	logs, sub, err := _MiniMeToken.contract.WatchLogs(opts, "ClaimedTokens", _tokenRule, _controllerRule)
	if err != nil {
		return nil, err
	}
	return event.NewSubscription(func(quit <-chan struct{}) error {
		defer sub.Unsubscribe()
		for {
			select {
			case log := <-logs:
				// New log arrived, parse the event and forward to the user
				event := new(MiniMeTokenClaimedTokens)
				if err := _MiniMeToken.contract.UnpackLog(event, "ClaimedTokens", log); err != nil {
					return err
				}
				event.Raw = log

				select {
				case sink <- event:
				case err := <-sub.Err():
					return err
				case <-quit:
					return nil
				}
			case err := <-sub.Err():
				return err
			case <-quit:
				return nil
			}
		}
	}), nil
}

// ParseClaimedTokens is a log parse operation binding the contract event 0xf931edb47c50b4b4104c187b5814a9aef5f709e17e2ecf9617e860cacade929c.
//
// Solidity: event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount)
func (_MiniMeToken *MiniMeTokenFilterer) ParseClaimedTokens(log types.Log) (*MiniMeTokenClaimedTokens, error) {
	event := new(MiniMeTokenClaimedTokens)
	if err := _MiniMeToken.contract.UnpackLog(event, "ClaimedTokens", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// MiniMeTokenNewCloneTokenIterator is returned from FilterNewCloneToken and is used to iterate over the raw logs and unpacked data for NewCloneToken events raised by the MiniMeToken contract.
type MiniMeTokenNewCloneTokenIterator struct {
	Event *MiniMeTokenNewCloneToken // Event containing the contract specifics and raw log

	contract *bind.BoundContract // Generic contract to use for unpacking event data
	event    string              // Event name to use for unpacking event data

	logs chan types.Log        // Log channel receiving the found contract events
	sub  ethereum.Subscription // Subscription for errors, completion and termination
	done bool                  // Whether the subscription completed delivering logs
	fail error                 // Occurred error to stop iteration
}

// Next advances the iterator to the subsequent event, returning whether there
// are any more events found. In case of a retrieval or parsing error, false is
// returned and Error() can be queried for the exact failure.
func (it *MiniMeTokenNewCloneTokenIterator) Next() bool {
	// If the iterator failed, stop iterating
	if it.fail != nil {
		return false
	}
	// If the iterator completed, deliver directly whatever's available
	if it.done {
		select {
		case log := <-it.logs:
			it.Event = new(MiniMeTokenNewCloneToken)
			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
				it.fail = err
				return false
			}
			it.Event.Raw = log
			return true

		default:
			return false
		}
	}
	// Iterator still in progress, wait for either a data or an error event
	select {
	case log := <-it.logs:
		it.Event = new(MiniMeTokenNewCloneToken)
		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
			it.fail = err
			return false
		}
		it.Event.Raw = log
		return true

	case err := <-it.sub.Err():
		it.done = true
		it.fail = err
		return it.Next()
	}
}

// Error returns any retrieval or parsing error occurred during filtering.
func (it *MiniMeTokenNewCloneTokenIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *MiniMeTokenNewCloneTokenIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// MiniMeTokenNewCloneToken represents a NewCloneToken event raised by the MiniMeToken contract.
type MiniMeTokenNewCloneToken struct {
	CloneToken    common.Address
	SnapshotBlock *big.Int
	Raw           types.Log // Blockchain specific contextual infos
}

// FilterNewCloneToken is a free log retrieval operation binding the contract event 0x086c875b377f900b07ce03575813022f05dd10ed7640b5282cf6d3c3fc352ade.
//
// Solidity: event NewCloneToken(address indexed _cloneToken, uint256 _snapshotBlock)
func (_MiniMeToken *MiniMeTokenFilterer) FilterNewCloneToken(opts *bind.FilterOpts, _cloneToken []common.Address) (*MiniMeTokenNewCloneTokenIterator, error) {

	var _cloneTokenRule []interface{}
	for _, _cloneTokenItem := range _cloneToken {
		_cloneTokenRule = append(_cloneTokenRule, _cloneTokenItem)
	}

	logs, sub, err := _MiniMeToken.contract.FilterLogs(opts, "NewCloneToken", _cloneTokenRule)
	if err != nil {
		return nil, err
	}
	return &MiniMeTokenNewCloneTokenIterator{contract: _MiniMeToken.contract, event: "NewCloneToken", logs: logs, sub: sub}, nil
}

// WatchNewCloneToken is a free log subscription operation binding the contract event 0x086c875b377f900b07ce03575813022f05dd10ed7640b5282cf6d3c3fc352ade.
//
// Solidity: event NewCloneToken(address indexed _cloneToken, uint256 _snapshotBlock)
func (_MiniMeToken *MiniMeTokenFilterer) WatchNewCloneToken(opts *bind.WatchOpts, sink chan<- *MiniMeTokenNewCloneToken, _cloneToken []common.Address) (event.Subscription, error) {

	var _cloneTokenRule []interface{}
	for _, _cloneTokenItem := range _cloneToken {
		_cloneTokenRule = append(_cloneTokenRule, _cloneTokenItem)
	}

	logs, sub, err := _MiniMeToken.contract.WatchLogs(opts, "NewCloneToken", _cloneTokenRule)
	if err != nil {
		return nil, err
	}
	return event.NewSubscription(func(quit <-chan struct{}) error {
		defer sub.Unsubscribe()
		for {
			select {
			case log := <-logs:
				// New log arrived, parse the event and forward to the user
				event := new(MiniMeTokenNewCloneToken)
				if err := _MiniMeToken.contract.UnpackLog(event, "NewCloneToken", log); err != nil {
					return err
				}
				event.Raw = log

				select {
				case sink <- event:
				case err := <-sub.Err():
					return err
				case <-quit:
					return nil
				}
			case err := <-sub.Err():
				return err
			case <-quit:
				return nil
			}
		}
	}), nil
}

// ParseNewCloneToken is a log parse operation binding the contract event 0x086c875b377f900b07ce03575813022f05dd10ed7640b5282cf6d3c3fc352ade.
//
// Solidity: event NewCloneToken(address indexed _cloneToken, uint256 _snapshotBlock)
func (_MiniMeToken *MiniMeTokenFilterer) ParseNewCloneToken(log types.Log) (*MiniMeTokenNewCloneToken, error) {
	event := new(MiniMeTokenNewCloneToken)
	if err := _MiniMeToken.contract.UnpackLog(event, "NewCloneToken", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// MiniMeTokenTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the MiniMeToken contract.
type MiniMeTokenTransferIterator struct {
	Event *MiniMeTokenTransfer // Event containing the contract specifics and raw log

	contract *bind.BoundContract // Generic contract to use for unpacking event data
	event    string              // Event name to use for unpacking event data

	logs chan types.Log        // Log channel receiving the found contract events
	sub  ethereum.Subscription // Subscription for errors, completion and termination
	done bool                  // Whether the subscription completed delivering logs
	fail error                 // Occurred error to stop iteration
}

// Next advances the iterator to the subsequent event, returning whether there
// are any more events found. In case of a retrieval or parsing error, false is
// returned and Error() can be queried for the exact failure.
func (it *MiniMeTokenTransferIterator) Next() bool {
	// If the iterator failed, stop iterating
	if it.fail != nil {
		return false
	}
	// If the iterator completed, deliver directly whatever's available
	if it.done {
		select {
		case log := <-it.logs:
			it.Event = new(MiniMeTokenTransfer)
			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
				it.fail = err
				return false
			}
			it.Event.Raw = log
			return true

		default:
			return false
		}
	}
	// Iterator still in progress, wait for either a data or an error event
	select {
	case log := <-it.logs:
		it.Event = new(MiniMeTokenTransfer)
		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
			it.fail = err
			return false
		}
		it.Event.Raw = log
		return true

	case err := <-it.sub.Err():
		it.done = true
		it.fail = err
		return it.Next()
	}
}

// Error returns any retrieval or parsing error occurred during filtering.
func (it *MiniMeTokenTransferIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *MiniMeTokenTransferIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// MiniMeTokenTransfer represents a Transfer event raised by the MiniMeToken contract.
type MiniMeTokenTransfer struct {
	From   common.Address
	To     common.Address
	Amount *big.Int
	Raw    types.Log // Blockchain specific contextual infos
}

// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
//
// Solidity: event Transfer(address indexed _from, address indexed _to, uint256 _amount)
func (_MiniMeToken *MiniMeTokenFilterer) FilterTransfer(opts *bind.FilterOpts, _from []common.Address, _to []common.Address) (*MiniMeTokenTransferIterator, error) {

	var _fromRule []interface{}
	for _, _fromItem := range _from {
		_fromRule = append(_fromRule, _fromItem)
	}
	var _toRule []interface{}
	for _, _toItem := range _to {
		_toRule = append(_toRule, _toItem)
	}

	logs, sub, err := _MiniMeToken.contract.FilterLogs(opts, "Transfer", _fromRule, _toRule)
	if err != nil {
		return nil, err
	}
	return &MiniMeTokenTransferIterator{contract: _MiniMeToken.contract, event: "Transfer", logs: logs, sub: sub}, nil
}

// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
//
// Solidity: event Transfer(address indexed _from, address indexed _to, uint256 _amount)
func (_MiniMeToken *MiniMeTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *MiniMeTokenTransfer, _from []common.Address, _to []common.Address) (event.Subscription, error) {

	var _fromRule []interface{}
	for _, _fromItem := range _from {
		_fromRule = append(_fromRule, _fromItem)
	}
	var _toRule []interface{}
	for _, _toItem := range _to {
		_toRule = append(_toRule, _toItem)
	}

	logs, sub, err := _MiniMeToken.contract.WatchLogs(opts, "Transfer", _fromRule, _toRule)
	if err != nil {
		return nil, err
	}
	return event.NewSubscription(func(quit <-chan struct{}) error {
		defer sub.Unsubscribe()
		for {
			select {
			case log := <-logs:
				// New log arrived, parse the event and forward to the user
				event := new(MiniMeTokenTransfer)
				if err := _MiniMeToken.contract.UnpackLog(event, "Transfer", log); err != nil {
					return err
				}
				event.Raw = log

				select {
				case sink <- event:
				case err := <-sub.Err():
					return err
				case <-quit:
					return nil
				}
			case err := <-sub.Err():
				return err
			case <-quit:
				return nil
			}
		}
	}), nil
}

// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
//
// Solidity: event Transfer(address indexed _from, address indexed _to, uint256 _amount)
func (_MiniMeToken *MiniMeTokenFilterer) ParseTransfer(log types.Log) (*MiniMeTokenTransfer, error) {
	event := new(MiniMeTokenTransfer)
	if err := _MiniMeToken.contract.UnpackLog(event, "Transfer", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// MiniMeTokenFactoryABI is the input ABI used to generate the binding from.
const MiniMeTokenFactoryABI = "[{\"constant\":false,\"inputs\":[{\"name\":\"_parentToken\",\"type\":\"address\"},{\"name\":\"_snapshotBlock\",\"type\":\"uint256\"},{\"name\":\"_tokenName\",\"type\":\"string\"},{\"name\":\"_decimalUnits\",\"type\":\"uint8\"},{\"name\":\"_tokenSymbol\",\"type\":\"string\"},{\"name\":\"_transfersEnabled\",\"type\":\"bool\"}],\"name\":\"createCloneToken\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"

// MiniMeTokenFactoryFuncSigs maps the 4-byte function signature to its string representation.
var MiniMeTokenFactoryFuncSigs = map[string]string{
	"5b7b72c1": "createCloneToken(address,uint256,string,uint8,string,bool)",
}

// MiniMeTokenFactory is an auto generated Go binding around an Ethereum contract.
type MiniMeTokenFactory struct {
	MiniMeTokenFactoryCaller     // Read-only binding to the contract
	MiniMeTokenFactoryTransactor // Write-only binding to the contract
	MiniMeTokenFactoryFilterer   // Log filterer for contract events
}

// MiniMeTokenFactoryCaller is an auto generated read-only Go binding around an Ethereum contract.
type MiniMeTokenFactoryCaller struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// MiniMeTokenFactoryTransactor is an auto generated write-only Go binding around an Ethereum contract.
type MiniMeTokenFactoryTransactor struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// MiniMeTokenFactoryFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
type MiniMeTokenFactoryFilterer struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// MiniMeTokenFactorySession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type MiniMeTokenFactorySession struct {
	Contract     *MiniMeTokenFactory // Generic contract binding to set the session for
	CallOpts     bind.CallOpts       // Call options to use throughout this session
	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
}

// MiniMeTokenFactoryCallerSession is an auto generated read-only Go binding around an Ethereum contract,
// with pre-set call options.
type MiniMeTokenFactoryCallerSession struct {
	Contract *MiniMeTokenFactoryCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts             // Call options to use throughout this session
}

// MiniMeTokenFactoryTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
// with pre-set transact options.
type MiniMeTokenFactoryTransactorSession struct {
	Contract     *MiniMeTokenFactoryTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts             // Transaction auth options to use throughout this session
}

// MiniMeTokenFactoryRaw is an auto generated low-level Go binding around an Ethereum contract.
type MiniMeTokenFactoryRaw struct {
	Contract *MiniMeTokenFactory // Generic contract binding to access the raw methods on
}

// MiniMeTokenFactoryCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
type MiniMeTokenFactoryCallerRaw struct {
	Contract *MiniMeTokenFactoryCaller // Generic read-only contract binding to access the raw methods on
}

// MiniMeTokenFactoryTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
type MiniMeTokenFactoryTransactorRaw struct {
	Contract *MiniMeTokenFactoryTransactor // Generic write-only contract binding to access the raw methods on
}

// NewMiniMeTokenFactory creates a new instance of MiniMeTokenFactory, bound to a specific deployed contract.
func NewMiniMeTokenFactory(address common.Address, backend bind.ContractBackend) (*MiniMeTokenFactory, error) {
	contract, err := bindMiniMeTokenFactory(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &MiniMeTokenFactory{MiniMeTokenFactoryCaller: MiniMeTokenFactoryCaller{contract: contract}, MiniMeTokenFactoryTransactor: MiniMeTokenFactoryTransactor{contract: contract}, MiniMeTokenFactoryFilterer: MiniMeTokenFactoryFilterer{contract: contract}}, nil
}

// NewMiniMeTokenFactoryCaller creates a new read-only instance of MiniMeTokenFactory, bound to a specific deployed contract.
func NewMiniMeTokenFactoryCaller(address common.Address, caller bind.ContractCaller) (*MiniMeTokenFactoryCaller, error) {
	contract, err := bindMiniMeTokenFactory(address, caller, nil, nil)
	if err != nil {
		return nil, err
	}
	return &MiniMeTokenFactoryCaller{contract: contract}, nil
}

// NewMiniMeTokenFactoryTransactor creates a new write-only instance of MiniMeTokenFactory, bound to a specific deployed contract.
func NewMiniMeTokenFactoryTransactor(address common.Address, transactor bind.ContractTransactor) (*MiniMeTokenFactoryTransactor, error) {
	contract, err := bindMiniMeTokenFactory(address, nil, transactor, nil)
	if err != nil {
		return nil, err
	}
	return &MiniMeTokenFactoryTransactor{contract: contract}, nil
}

// NewMiniMeTokenFactoryFilterer creates a new log filterer instance of MiniMeTokenFactory, bound to a specific deployed contract.
func NewMiniMeTokenFactoryFilterer(address common.Address, filterer bind.ContractFilterer) (*MiniMeTokenFactoryFilterer, error) {
	contract, err := bindMiniMeTokenFactory(address, nil, nil, filterer)
	if err != nil {
		return nil, err
	}
	return &MiniMeTokenFactoryFilterer{contract: contract}, nil
}

// bindMiniMeTokenFactory binds a generic wrapper to an already deployed contract.
func bindMiniMeTokenFactory(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(MiniMeTokenFactoryABI))
	if err != nil {
		return nil, err
	}
	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_MiniMeTokenFactory *MiniMeTokenFactoryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _MiniMeTokenFactory.Contract.MiniMeTokenFactoryCaller.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_MiniMeTokenFactory *MiniMeTokenFactoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _MiniMeTokenFactory.Contract.MiniMeTokenFactoryTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_MiniMeTokenFactory *MiniMeTokenFactoryRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _MiniMeTokenFactory.Contract.MiniMeTokenFactoryTransactor.contract.Transact(opts, method, params...)
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_MiniMeTokenFactory *MiniMeTokenFactoryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _MiniMeTokenFactory.Contract.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_MiniMeTokenFactory *MiniMeTokenFactoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _MiniMeTokenFactory.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_MiniMeTokenFactory *MiniMeTokenFactoryTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _MiniMeTokenFactory.Contract.contract.Transact(opts, method, params...)
}

// CreateCloneToken is a paid mutator transaction binding the contract method 0x5b7b72c1.
//
// Solidity: function createCloneToken(address _parentToken, uint256 _snapshotBlock, string _tokenName, uint8 _decimalUnits, string _tokenSymbol, bool _transfersEnabled) returns(address)
func (_MiniMeTokenFactory *MiniMeTokenFactoryTransactor) CreateCloneToken(opts *bind.TransactOpts, _parentToken common.Address, _snapshotBlock *big.Int, _tokenName string, _decimalUnits uint8, _tokenSymbol string, _transfersEnabled bool) (*types.Transaction, error) {
	return _MiniMeTokenFactory.contract.Transact(opts, "createCloneToken", _parentToken, _snapshotBlock, _tokenName, _decimalUnits, _tokenSymbol, _transfersEnabled)
}

// CreateCloneToken is a paid mutator transaction binding the contract method 0x5b7b72c1.
//
// Solidity: function createCloneToken(address _parentToken, uint256 _snapshotBlock, string _tokenName, uint8 _decimalUnits, string _tokenSymbol, bool _transfersEnabled) returns(address)
func (_MiniMeTokenFactory *MiniMeTokenFactorySession) CreateCloneToken(_parentToken common.Address, _snapshotBlock *big.Int, _tokenName string, _decimalUnits uint8, _tokenSymbol string, _transfersEnabled bool) (*types.Transaction, error) {
	return _MiniMeTokenFactory.Contract.CreateCloneToken(&_MiniMeTokenFactory.TransactOpts, _parentToken, _snapshotBlock, _tokenName, _decimalUnits, _tokenSymbol, _transfersEnabled)
}

// CreateCloneToken is a paid mutator transaction binding the contract method 0x5b7b72c1.
//
// Solidity: function createCloneToken(address _parentToken, uint256 _snapshotBlock, string _tokenName, uint8 _decimalUnits, string _tokenSymbol, bool _transfersEnabled) returns(address)
func (_MiniMeTokenFactory *MiniMeTokenFactoryTransactorSession) CreateCloneToken(_parentToken common.Address, _snapshotBlock *big.Int, _tokenName string, _decimalUnits uint8, _tokenSymbol string, _transfersEnabled bool) (*types.Transaction, error) {
	return _MiniMeTokenFactory.Contract.CreateCloneToken(&_MiniMeTokenFactory.TransactOpts, _parentToken, _snapshotBlock, _tokenName, _decimalUnits, _tokenSymbol, _transfersEnabled)
}

// SNTABI is the input ABI used to generate the binding from.
const SNTABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_spender\",\"type\":\"address\"},{\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"creationBlock\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_from\",\"type\":\"address\"},{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_newController\",\"type\":\"address\"}],\"name\":\"changeController\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\"},{\"name\":\"_blockNumber\",\"type\":\"uint256\"}],\"name\":\"balanceOfAt\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"version\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_cloneTokenName\",\"type\":\"string\"},{\"name\":\"_cloneDecimalUnits\",\"type\":\"uint8\"},{\"name\":\"_cloneTokenSymbol\",\"type\":\"string\"},{\"name\":\"_snapshotBlock\",\"type\":\"uint256\"},{\"name\":\"_transfersEnabled\",\"type\":\"bool\"}],\"name\":\"createCloneToken\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"balance\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"parentToken\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\"},{\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"generateTokens\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_blockNumber\",\"type\":\"uint256\"}],\"name\":\"totalSupplyAt\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"transfersEnabled\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"parentSnapShotBlock\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":

// SNTFuncSigs maps the 4-byte function signature to its string representation.
var SNTFuncSigs = map[string]string{
	"dd62ed3e": "allowance(address,address)",
	"095ea7b3": "approve(address,uint256)",
	"cae9ca51": "approveAndCall(address,uint256,bytes)",
	"70a08231": "balanceOf(address)",
	"4ee2cd7e": "balanceOfAt(address,uint256)",
	"3cebb823": "changeController(address)",
	"df8de3e7": "claimTokens(address)",
	"f77c4791": "controller()",
	"6638c087": "createCloneToken(string,uint8,string,uint256,bool)",
	"17634514": "creationBlock()",
	"313ce567": "decimals()",
	"d3ce77fe": "destroyTokens(address,uint256)",
	"f41e60c5": "enableTransfers(bool)",
	"827f32c0": "generateTokens(address,uint256)",
	"06fdde03": "name()",
	"c5bcc4f1": "parentSnapShotBlock()",
	"80a54001": "parentToken()",
	"95d89b41": "symbol()",
	"e77772fe": "tokenFactory()",
	"18160ddd": "totalSupply()",
	"981b24d0": "totalSupplyAt(uint256)",
	"a9059cbb": "transfer(address,uint256)",
	"23b872dd": "transferFrom(address,address,uint256)",
	"bef97c87": "transfersEnabled()",
	"54fd4d50": "version()",
}

// SNT is an auto generated Go binding around an Ethereum contract.
type SNT struct {
	SNTCaller     // Read-only binding to the contract
	SNTTransactor // Write-only binding to the contract
	SNTFilterer   // Log filterer for contract events
}

// SNTCaller is an auto generated read-only Go binding around an Ethereum contract.
type SNTCaller struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// SNTTransactor is an auto generated write-only Go binding around an Ethereum contract.
type SNTTransactor struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// SNTFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
type SNTFilterer struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// SNTSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type SNTSession struct {
	Contract     *SNT              // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

// SNTCallerSession is an auto generated read-only Go binding around an Ethereum contract,
// with pre-set call options.
type SNTCallerSession struct {
	Contract *SNTCaller    // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts // Call options to use throughout this session
}

// SNTTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
// with pre-set transact options.
type SNTTransactorSession struct {
	Contract     *SNTTransactor    // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

// SNTRaw is an auto generated low-level Go binding around an Ethereum contract.
type SNTRaw struct {
	Contract *SNT // Generic contract binding to access the raw methods on
}

// SNTCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
type SNTCallerRaw struct {
	Contract *SNTCaller // Generic read-only contract binding to access the raw methods on
}

// SNTTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
type SNTTransactorRaw struct {
	Contract *SNTTransactor // Generic write-only contract binding to access the raw methods on
}

// NewSNT creates a new instance of SNT, bound to a specific deployed contract.
func NewSNT(address common.Address, backend bind.ContractBackend) (*SNT, error) {
	contract, err := bindSNT(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &SNT{SNTCaller: SNTCaller{contract: contract}, SNTTransactor: SNTTransactor{contract: contract}, SNTFilterer: SNTFilterer{contract: contract}}, nil
}

// NewSNTCaller creates a new read-only instance of SNT, bound to a specific deployed contract.
func NewSNTCaller(address common.Address, caller bind.ContractCaller) (*SNTCaller, error) {
	contract, err := bindSNT(address, caller, nil, nil)
	if err != nil {
		return nil, err
	}
	return &SNTCaller{contract: contract}, nil
}

// NewSNTTransactor creates a new write-only instance of SNT, bound to a specific deployed contract.
func NewSNTTransactor(address common.Address, transactor bind.ContractTransactor) (*SNTTransactor, error) {
	contract, err := bindSNT(address, nil, transactor, nil)
	if err != nil {
		return nil, err
	}
	return &SNTTransactor{contract: contract}, nil
}

// NewSNTFilterer creates a new log filterer instance of SNT, bound to a specific deployed contract.
func NewSNTFilterer(address common.Address, filterer bind.ContractFilterer) (*SNTFilterer, error) {
	contract, err := bindSNT(address, nil, nil, filterer)
	if err != nil {
		return nil, err
	}
	return &SNTFilterer{contract: contract}, nil
}

// bindSNT binds a generic wrapper to an already deployed contract.
func bindSNT(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(SNTABI))
	if err != nil {
		return nil, err
	}
	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_SNT *SNTRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _SNT.Contract.SNTCaller.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_SNT *SNTRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _SNT.Contract.SNTTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_SNT *SNTRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _SNT.Contract.SNTTransactor.contract.Transact(opts, method, params...)
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_SNT *SNTCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _SNT.Contract.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_SNT *SNTTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _SNT.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_SNT *SNTTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _SNT.Contract.contract.Transact(opts, method, params...)
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address _owner, address _spender) view returns(uint256 remaining)
func (_SNT *SNTCaller) Allowance(opts *bind.CallOpts, _owner common.Address, _spender common.Address) (*big.Int, error) {
	var out []interface{}
	err := _SNT.contract.Call(opts, &out, "allowance", _owner, _spender)

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address _owner, address _spender) view returns(uint256 remaining)
func (_SNT *SNTSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error) {
	return _SNT.Contract.Allowance(&_SNT.CallOpts, _owner, _spender)
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address _owner, address _spender) view returns(uint256 remaining)
func (_SNT *SNTCallerSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error) {
	return _SNT.Contract.Allowance(&_SNT.CallOpts, _owner, _spender)
}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address _owner) view returns(uint256 balance)
func (_SNT *SNTCaller) BalanceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error) {
	var out []interface{}
	err := _SNT.contract.Call(opts, &out, "balanceOf", _owner)

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address _owner) view returns(uint256 balance)
func (_SNT *SNTSession) BalanceOf(_owner common.Address) (*big.Int, error) {
	return _SNT.Contract.BalanceOf(&_SNT.CallOpts, _owner)
}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address _owner) view returns(uint256 balance)
func (_SNT *SNTCallerSession) BalanceOf(_owner common.Address) (*big.Int, error) {
	return _SNT.Contract.BalanceOf(&_SNT.CallOpts, _owner)
}

// BalanceOfAt is a free data retrieval call binding the contract method 0x4ee2cd7e.
//
// Solidity: function balanceOfAt(address _owner, uint256 _blockNumber) view returns(uint256)
func (_SNT *SNTCaller) BalanceOfAt(opts *bind.CallOpts, _owner common.Address, _blockNumber *big.Int) (*big.Int, error) {
	var out []interface{}
	err := _SNT.contract.Call(opts, &out, "balanceOfAt", _owner, _blockNumber)

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// BalanceOfAt is a free data retrieval call binding the contract method 0x4ee2cd7e.
//
// Solidity: function balanceOfAt(address _owner, uint256 _blockNumber) view returns(uint256)
func (_SNT *SNTSession) BalanceOfAt(_owner common.Address, _blockNumber *big.Int) (*big.Int, error) {
	return _SNT.Contract.BalanceOfAt(&_SNT.CallOpts, _owner, _blockNumber)
}

// BalanceOfAt is a free data retrieval call binding the contract method 0x4ee2cd7e.
//
// Solidity: function balanceOfAt(address _owner, uint256 _blockNumber) view returns(uint256)
func (_SNT *SNTCallerSession) BalanceOfAt(_owner common.Address, _blockNumber *big.Int) (*big.Int, error) {
	return _SNT.Contract.BalanceOfAt(&_SNT.CallOpts, _owner, _blockNumber)
}

// Controller is a free data retrieval call binding the contract method 0xf77c4791.
//
// Solidity: function controller() view returns(address)
func (_SNT *SNTCaller) Controller(opts *bind.CallOpts) (common.Address, error) {
	var out []interface{}
	err := _SNT.contract.Call(opts, &out, "controller")

	if err != nil {
		return *new(common.Address), err
	}

	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)

	return out0, err

}

// Controller is a free data retrieval call binding the contract method 0xf77c4791.
//
// Solidity: function controller() view returns(address)
func (_SNT *SNTSession) Controller() (common.Address, error) {
	return _SNT.Contract.Controller(&_SNT.CallOpts)
}

// Controller is a free data retrieval call binding the contract method 0xf77c4791.
//
// Solidity: function controller() view returns(address)
func (_SNT *SNTCallerSession) Controller() (common.Address, error) {
	return _SNT.Contract.Controller(&_SNT.CallOpts)
}

// CreationBlock is a free data retrieval call binding the contract method 0x17634514.
//
// Solidity: function creationBlock() view returns(uint256)
func (_SNT *SNTCaller) CreationBlock(opts *bind.CallOpts) (*big.Int, error) {
	var out []interface{}
	err := _SNT.contract.Call(opts, &out, "creationBlock")

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// CreationBlock is a free data retrieval call binding the contract method 0x17634514.
//
// Solidity: function creationBlock() view returns(uint256)
func (_SNT *SNTSession) CreationBlock() (*big.Int, error) {
	return _SNT.Contract.CreationBlock(&_SNT.CallOpts)
}

// CreationBlock is a free data retrieval call binding the contract method 0x17634514.
//
// Solidity: function creationBlock() view returns(uint256)
func (_SNT *SNTCallerSession) CreationBlock() (*big.Int, error) {
	return _SNT.Contract.CreationBlock(&_SNT.CallOpts)
}

// Decimals is a free data retrieval call binding the contract method 0x313ce567.
//
// Solidity: function decimals() view returns(uint8)
func (_SNT *SNTCaller) Decimals(opts *bind.CallOpts) (uint8, error) {
	var out []interface{}
	err := _SNT.contract.Call(opts, &out, "decimals")

	if err != nil {
		return *new(uint8), err
	}

	out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8)

	return out0, err

}

// Decimals is a free data retrieval call binding the contract method 0x313ce567.
//
// Solidity: function decimals() view returns(uint8)
func (_SNT *SNTSession) Decimals() (uint8, error) {
	return _SNT.Contract.Decimals(&_SNT.CallOpts)
}

// Decimals is a free data retrieval call binding the contract method 0x313ce567.
//
// Solidity: function decimals() view returns(uint8)
func (_SNT *SNTCallerSession) Decimals() (uint8, error) {
	return _SNT.Contract.Decimals(&_SNT.CallOpts)
}

// Name is a free data retrieval call binding the contract method 0x06fdde03.
//
// Solidity: function name() view returns(string)
func (_SNT *SNTCaller) Name(opts *bind.CallOpts) (string, error) {
	var out []interface{}
	err := _SNT.contract.Call(opts, &out, "name")

	if err != nil {
		return *new(string), err
	}

	out0 := *abi.ConvertType(out[0], new(string)).(*string)

	return out0, err

}

// Name is a free data retrieval call binding the contract method 0x06fdde03.
//
// Solidity: function name() view returns(string)
func (_SNT *SNTSession) Name() (string, error) {
	return _SNT.Contract.Name(&_SNT.CallOpts)
}

// Name is a free data retrieval call binding the contract method 0x06fdde03.
//
// Solidity: function name() view returns(string)
func (_SNT *SNTCallerSession) Name() (string, error) {
	return _SNT.Contract.Name(&_SNT.CallOpts)
}

// ParentSnapShotBlock is a free data retrieval call binding the contract method 0xc5bcc4f1.
//
// Solidity: function parentSnapShotBlock() view returns(uint256)
func (_SNT *SNTCaller) ParentSnapShotBlock(opts *bind.CallOpts) (*big.Int, error) {
	var out []interface{}
	err := _SNT.contract.Call(opts, &out, "parentSnapShotBlock")

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// ParentSnapShotBlock is a free data retrieval call binding the contract method 0xc5bcc4f1.
//
// Solidity: function parentSnapShotBlock() view returns(uint256)
func (_SNT *SNTSession) ParentSnapShotBlock() (*big.Int, error) {
	return _SNT.Contract.ParentSnapShotBlock(&_SNT.CallOpts)
}

// ParentSnapShotBlock is a free data retrieval call binding the contract method 0xc5bcc4f1.
//
// Solidity: function parentSnapShotBlock() view returns(uint256)
func (_SNT *SNTCallerSession) ParentSnapShotBlock() (*big.Int, error) {
	return _SNT.Contract.ParentSnapShotBlock(&_SNT.CallOpts)
}

// ParentToken is a free data retrieval call binding the contract method 0x80a54001.
//
// Solidity: function parentToken() view returns(address)
func (_SNT *SNTCaller) ParentToken(opts *bind.CallOpts) (common.Address, error) {
	var out []interface{}
	err := _SNT.contract.Call(opts, &out, "parentToken")

	if err != nil {
		return *new(common.Address), err
	}

	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)

	return out0, err

}

// ParentToken is a free data retrieval call binding the contract method 0x80a54001.
//
// Solidity: function parentToken() view returns(address)
func (_SNT *SNTSession) ParentToken() (common.Address, error) {
	return _SNT.Contract.ParentToken(&_SNT.CallOpts)
}

// ParentToken is a free data retrieval call binding the contract method 0x80a54001.
//
// Solidity: function parentToken() view returns(address)
func (_SNT *SNTCallerSession) ParentToken() (common.Address, error) {
	return _SNT.Contract.ParentToken(&_SNT.CallOpts)
}

// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
//
// Solidity: function symbol() view returns(string)
func (_SNT *SNTCaller) Symbol(opts *bind.CallOpts) (string, error) {
	var out []interface{}
	err := _SNT.contract.Call(opts, &out, "symbol")

	if err != nil {
		return *new(string), err
	}

	out0 := *abi.ConvertType(out[0], new(string)).(*string)

	return out0, err

}

// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
//
// Solidity: function symbol() view returns(string)
func (_SNT *SNTSession) Symbol() (string, error) {
	return _SNT.Contract.Symbol(&_SNT.CallOpts)
}

// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
//
// Solidity: function symbol() view returns(string)
func (_SNT *SNTCallerSession) Symbol() (string, error) {
	return _SNT.Contract.Symbol(&_SNT.CallOpts)
}

// TokenFactory is a free data retrieval call binding the contract method 0xe77772fe.
//
// Solidity: function tokenFactory() view returns(address)
func (_SNT *SNTCaller) TokenFactory(opts *bind.CallOpts) (common.Address, error) {
	var out []interface{}
	err := _SNT.contract.Call(opts, &out, "tokenFactory")

	if err != nil {
		return *new(common.Address), err
	}

	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)

	return out0, err

}

// TokenFactory is a free data retrieval call binding the contract method 0xe77772fe.
//
// Solidity: function tokenFactory() view returns(address)
func (_SNT *SNTSession) TokenFactory() (common.Address, error) {
	return _SNT.Contract.TokenFactory(&_SNT.CallOpts)
}

// TokenFactory is a free data retrieval call binding the contract method 0xe77772fe.
//
// Solidity: function tokenFactory() view returns(address)
func (_SNT *SNTCallerSession) TokenFactory() (common.Address, error) {
	return _SNT.Contract.TokenFactory(&_SNT.CallOpts)
}

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() view returns(uint256)
func (_SNT *SNTCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
	var out []interface{}
	err := _SNT.contract.Call(opts, &out, "totalSupply")

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() view returns(uint256)
func (_SNT *SNTSession) TotalSupply() (*big.Int, error) {
	return _SNT.Contract.TotalSupply(&_SNT.CallOpts)
}

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() view returns(uint256)
func (_SNT *SNTCallerSession) TotalSupply() (*big.Int, error) {
	return _SNT.Contract.TotalSupply(&_SNT.CallOpts)
}

// TotalSupplyAt is a free data retrieval call binding the contract method 0x981b24d0.
//
// Solidity: function totalSupplyAt(uint256 _blockNumber) view returns(uint256)
func (_SNT *SNTCaller) TotalSupplyAt(opts *bind.CallOpts, _blockNumber *big.Int) (*big.Int, error) {
	var out []interface{}
	err := _SNT.contract.Call(opts, &out, "totalSupplyAt", _blockNumber)

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// TotalSupplyAt is a free data retrieval call binding the contract method 0x981b24d0.
//
// Solidity: function totalSupplyAt(uint256 _blockNumber) view returns(uint256)
func (_SNT *SNTSession) TotalSupplyAt(_blockNumber *big.Int) (*big.Int, error) {
	return _SNT.Contract.TotalSupplyAt(&_SNT.CallOpts, _blockNumber)
}

// TotalSupplyAt is a free data retrieval call binding the contract method 0x981b24d0.
//
// Solidity: function totalSupplyAt(uint256 _blockNumber) view returns(uint256)
func (_SNT *SNTCallerSession) TotalSupplyAt(_blockNumber *big.Int) (*big.Int, error) {
	return _SNT.Contract.TotalSupplyAt(&_SNT.CallOpts, _blockNumber)
}

// TransfersEnabled is a free data retrieval call binding the contract method 0xbef97c87.
//
// Solidity: function transfersEnabled() view returns(bool)
func (_SNT *SNTCaller) TransfersEnabled(opts *bind.CallOpts) (bool, error) {
	var out []interface{}
	err := _SNT.contract.Call(opts, &out, "transfersEnabled")

	if err != nil {
		return *new(bool), err
	}

	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)

	return out0, err

}

// TransfersEnabled is a free data retrieval call binding the contract method 0xbef97c87.
//
// Solidity: function transfersEnabled() view returns(bool)
func (_SNT *SNTSession) TransfersEnabled() (bool, error) {
	return _SNT.Contract.TransfersEnabled(&_SNT.CallOpts)
}

// TransfersEnabled is a free data retrieval call binding the contract method 0xbef97c87.
//
// Solidity: function transfersEnabled() view returns(bool)
func (_SNT *SNTCallerSession) TransfersEnabled() (bool, error) {
	return _SNT.Contract.TransfersEnabled(&_SNT.CallOpts)
}

// Version is a free data retrieval call binding the contract method 0x54fd4d50.
//
// Solidity: function version() view returns(string)
func (_SNT *SNTCaller) Version(opts *bind.CallOpts) (string, error) {
	var out []interface{}
	err := _SNT.contract.Call(opts, &out, "version")

	if err != nil {
		return *new(string), err
	}

	out0 := *abi.ConvertType(out[0], new(string)).(*string)

	return out0, err

}

// Version is a free data retrieval call binding the contract method 0x54fd4d50.
//
// Solidity: function version() view returns(string)
func (_SNT *SNTSession) Version() (string, error) {
	return _SNT.Contract.Version(&_SNT.CallOpts)
}

// Version is a free data retrieval call binding the contract method 0x54fd4d50.
//
// Solidity: function version() view returns(string)
func (_SNT *SNTCallerSession) Version() (string, error) {
	return _SNT.Contract.Version(&_SNT.CallOpts)
}

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address _spender, uint256 _amount) returns(bool success)
func (_SNT *SNTTransactor) Approve(opts *bind.TransactOpts, _spender common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _SNT.contract.Transact(opts, "approve", _spender, _amount)
}

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address _spender, uint256 _amount) returns(bool success)
func (_SNT *SNTSession) Approve(_spender common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _SNT.Contract.Approve(&_SNT.TransactOpts, _spender, _amount)
}

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address _spender, uint256 _amount) returns(bool success)
func (_SNT *SNTTransactorSession) Approve(_spender common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _SNT.Contract.Approve(&_SNT.TransactOpts, _spender, _amount)
}

// ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
//
// Solidity: function approveAndCall(address _spender, uint256 _amount, bytes _extraData) returns(bool success)
func (_SNT *SNTTransactor) ApproveAndCall(opts *bind.TransactOpts, _spender common.Address, _amount *big.Int, _extraData []byte) (*types.Transaction, error) {
	return _SNT.contract.Transact(opts, "approveAndCall", _spender, _amount, _extraData)
}

// ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
//
// Solidity: function approveAndCall(address _spender, uint256 _amount, bytes _extraData) returns(bool success)
func (_SNT *SNTSession) ApproveAndCall(_spender common.Address, _amount *big.Int, _extraData []byte) (*types.Transaction, error) {
	return _SNT.Contract.ApproveAndCall(&_SNT.TransactOpts, _spender, _amount, _extraData)
}

// ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
//
// Solidity: function approveAndCall(address _spender, uint256 _amount, bytes _extraData) returns(bool success)
func (_SNT *SNTTransactorSession) ApproveAndCall(_spender common.Address, _amount *big.Int, _extraData []byte) (*types.Transaction, error) {
	return _SNT.Contract.ApproveAndCall(&_SNT.TransactOpts, _spender, _amount, _extraData)
}

// ChangeController is a paid mutator transaction binding the contract method 0x3cebb823.
//
// Solidity: function changeController(address _newController) returns()
func (_SNT *SNTTransactor) ChangeController(opts *bind.TransactOpts, _newController common.Address) (*types.Transaction, error) {
	return _SNT.contract.Transact(opts, "changeController", _newController)
}

// ChangeController is a paid mutator transaction binding the contract method 0x3cebb823.
//
// Solidity: function changeController(address _newController) returns()
func (_SNT *SNTSession) ChangeController(_newController common.Address) (*types.Transaction, error) {
	return _SNT.Contract.ChangeController(&_SNT.TransactOpts, _newController)
}

// ChangeController is a paid mutator transaction binding the contract method 0x3cebb823.
//
// Solidity: function changeController(address _newController) returns()
func (_SNT *SNTTransactorSession) ChangeController(_newController common.Address) (*types.Transaction, error) {
	return _SNT.Contract.ChangeController(&_SNT.TransactOpts, _newController)
}

// ClaimTokens is a paid mutator transaction binding the contract method 0xdf8de3e7.
//
// Solidity: function claimTokens(address _token) returns()
func (_SNT *SNTTransactor) ClaimTokens(opts *bind.TransactOpts, _token common.Address) (*types.Transaction, error) {
	return _SNT.contract.Transact(opts, "claimTokens", _token)
}

// ClaimTokens is a paid mutator transaction binding the contract method 0xdf8de3e7.
//
// Solidity: function claimTokens(address _token) returns()
func (_SNT *SNTSession) ClaimTokens(_token common.Address) (*types.Transaction, error) {
	return _SNT.Contract.ClaimTokens(&_SNT.TransactOpts, _token)
}

// ClaimTokens is a paid mutator transaction binding the contract method 0xdf8de3e7.
//
// Solidity: function claimTokens(address _token) returns()
func (_SNT *SNTTransactorSession) ClaimTokens(_token common.Address) (*types.Transaction, error) {
	return _SNT.Contract.ClaimTokens(&_SNT.TransactOpts, _token)
}

// CreateCloneToken is a paid mutator transaction binding the contract method 0x6638c087.
//
// Solidity: function createCloneToken(string _cloneTokenName, uint8 _cloneDecimalUnits, string _cloneTokenSymbol, uint256 _snapshotBlock, bool _transfersEnabled) returns(address)
func (_SNT *SNTTransactor) CreateCloneToken(opts *bind.TransactOpts, _cloneTokenName string, _cloneDecimalUnits uint8, _cloneTokenSymbol string, _snapshotBlock *big.Int, _transfersEnabled bool) (*types.Transaction, error) {
	return _SNT.contract.Transact(opts, "createCloneToken", _cloneTokenName, _cloneDecimalUnits, _cloneTokenSymbol, _snapshotBlock, _transfersEnabled)
}

// CreateCloneToken is a paid mutator transaction binding the contract method 0x6638c087.
//
// Solidity: function createCloneToken(string _cloneTokenName, uint8 _cloneDecimalUnits, string _cloneTokenSymbol, uint256 _snapshotBlock, bool _transfersEnabled) returns(address)
func (_SNT *SNTSession) CreateCloneToken(_cloneTokenName string, _cloneDecimalUnits uint8, _cloneTokenSymbol string, _snapshotBlock *big.Int, _transfersEnabled bool) (*types.Transaction, error) {
	return _SNT.Contract.CreateCloneToken(&_SNT.TransactOpts, _cloneTokenName, _cloneDecimalUnits, _cloneTokenSymbol, _snapshotBlock, _transfersEnabled)
}

// CreateCloneToken is a paid mutator transaction binding the contract method 0x6638c087.
//
// Solidity: function createCloneToken(string _cloneTokenName, uint8 _cloneDecimalUnits, string _cloneTokenSymbol, uint256 _snapshotBlock, bool _transfersEnabled) returns(address)
func (_SNT *SNTTransactorSession) CreateCloneToken(_cloneTokenName string, _cloneDecimalUnits uint8, _cloneTokenSymbol string, _snapshotBlock *big.Int, _transfersEnabled bool) (*types.Transaction, error) {
	return _SNT.Contract.CreateCloneToken(&_SNT.TransactOpts, _cloneTokenName, _cloneDecimalUnits, _cloneTokenSymbol, _snapshotBlock, _transfersEnabled)
}

// DestroyTokens is a paid mutator transaction binding the contract method 0xd3ce77fe.
//
// Solidity: function destroyTokens(address _owner, uint256 _amount) returns(bool)
func (_SNT *SNTTransactor) DestroyTokens(opts *bind.TransactOpts, _owner common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _SNT.contract.Transact(opts, "destroyTokens", _owner, _amount)
}

// DestroyTokens is a paid mutator transaction binding the contract method 0xd3ce77fe.
//
// Solidity: function destroyTokens(address _owner, uint256 _amount) returns(bool)
func (_SNT *SNTSession) DestroyTokens(_owner common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _SNT.Contract.DestroyTokens(&_SNT.TransactOpts, _owner, _amount)
}

// DestroyTokens is a paid mutator transaction binding the contract method 0xd3ce77fe.
//
// Solidity: function destroyTokens(address _owner, uint256 _amount) returns(bool)
func (_SNT *SNTTransactorSession) DestroyTokens(_owner common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _SNT.Contract.DestroyTokens(&_SNT.TransactOpts, _owner, _amount)
}

// EnableTransfers is a paid mutator transaction binding the contract method 0xf41e60c5.
//
// Solidity: function enableTransfers(bool _transfersEnabled) returns()
func (_SNT *SNTTransactor) EnableTransfers(opts *bind.TransactOpts, _transfersEnabled bool) (*types.Transaction, error) {
	return _SNT.contract.Transact(opts, "enableTransfers", _transfersEnabled)
}

// EnableTransfers is a paid mutator transaction binding the contract method 0xf41e60c5.
//
// Solidity: function enableTransfers(bool _transfersEnabled) returns()
func (_SNT *SNTSession) EnableTransfers(_transfersEnabled bool) (*types.Transaction, error) {
	return _SNT.Contract.EnableTransfers(&_SNT.TransactOpts, _transfersEnabled)
}

// EnableTransfers is a paid mutator transaction binding the contract method 0xf41e60c5.
//
// Solidity: function enableTransfers(bool _transfersEnabled) returns()
func (_SNT *SNTTransactorSession) EnableTransfers(_transfersEnabled bool) (*types.Transaction, error) {
	return _SNT.Contract.EnableTransfers(&_SNT.TransactOpts, _transfersEnabled)
}

// GenerateTokens is a paid mutator transaction binding the contract method 0x827f32c0.
//
// Solidity: function generateTokens(address _owner, uint256 _amount) returns(bool)
func (_SNT *SNTTransactor) GenerateTokens(opts *bind.TransactOpts, _owner common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _SNT.contract.Transact(opts, "generateTokens", _owner, _amount)
}

// GenerateTokens is a paid mutator transaction binding the contract method 0x827f32c0.
//
// Solidity: function generateTokens(address _owner, uint256 _amount) returns(bool)
func (_SNT *SNTSession) GenerateTokens(_owner common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _SNT.Contract.GenerateTokens(&_SNT.TransactOpts, _owner, _amount)
}

// GenerateTokens is a paid mutator transaction binding the contract method 0x827f32c0.
//
// Solidity: function generateTokens(address _owner, uint256 _amount) returns(bool)
func (_SNT *SNTTransactorSession) GenerateTokens(_owner common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _SNT.Contract.GenerateTokens(&_SNT.TransactOpts, _owner, _amount)
}

// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
//
// Solidity: function transfer(address _to, uint256 _amount) returns(bool success)
func (_SNT *SNTTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _SNT.contract.Transact(opts, "transfer", _to, _amount)
}

// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
//
// Solidity: function transfer(address _to, uint256 _amount) returns(bool success)
func (_SNT *SNTSession) Transfer(_to common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _SNT.Contract.Transfer(&_SNT.TransactOpts, _to, _amount)
}

// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
//
// Solidity: function transfer(address _to, uint256 _amount) returns(bool success)
func (_SNT *SNTTransactorSession) Transfer(_to common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _SNT.Contract.Transfer(&_SNT.TransactOpts, _to, _amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address _from, address _to, uint256 _amount) returns(bool success)
func (_SNT *SNTTransactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _SNT.contract.Transact(opts, "transferFrom", _from, _to, _amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address _from, address _to, uint256 _amount) returns(bool success)
func (_SNT *SNTSession) TransferFrom(_from common.Address, _to common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _SNT.Contract.TransferFrom(&_SNT.TransactOpts, _from, _to, _amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address _from, address _to, uint256 _amount) returns(bool success)
func (_SNT *SNTTransactorSession) TransferFrom(_from common.Address, _to common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _SNT.Contract.TransferFrom(&_SNT.TransactOpts, _from, _to, _amount)
}

// Fallback is a paid mutator transaction binding the contract fallback function.
//
// Solidity: fallback() payable returns()
func (_SNT *SNTTransactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error) {
	return _SNT.contract.RawTransact(opts, calldata)
}

// Fallback is a paid mutator transaction binding the contract fallback function.
//
// Solidity: fallback() payable returns()
func (_SNT *SNTSession) Fallback(calldata []byte) (*types.Transaction, error) {
	return _SNT.Contract.Fallback(&_SNT.TransactOpts, calldata)
}

// Fallback is a paid mutator transaction binding the contract fallback function.
//
// Solidity: fallback() payable returns()
func (_SNT *SNTTransactorSession) Fallback(calldata []byte) (*types.Transaction, error) {
	return _SNT.Contract.Fallback(&_SNT.TransactOpts, calldata)
}

// SNTApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the SNT contract.
type SNTApprovalIterator struct {
	Event *SNTApproval // Event containing the contract specifics and raw log

	contract *bind.BoundContract // Generic contract to use for unpacking event data
	event    string              // Event name to use for unpacking event data

	logs chan types.Log        // Log channel receiving the found contract events
	sub  ethereum.Subscription // Subscription for errors, completion and termination
	done bool                  // Whether the subscription completed delivering logs
	fail error                 // Occurred error to stop iteration
}

// Next advances the iterator to the subsequent event, returning whether there
// are any more events found. In case of a retrieval or parsing error, false is
// returned and Error() can be queried for the exact failure.
func (it *SNTApprovalIterator) Next() bool {
	// If the iterator failed, stop iterating
	if it.fail != nil {
		return false
	}
	// If the iterator completed, deliver directly whatever's available
	if it.done {
		select {
		case log := <-it.logs:
			it.Event = new(SNTApproval)
			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
				it.fail = err
				return false
			}
			it.Event.Raw = log
			return true

		default:
			return false
		}
	}
	// Iterator still in progress, wait for either a data or an error event
	select {
	case log := <-it.logs:
		it.Event = new(SNTApproval)
		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
			it.fail = err
			return false
		}
		it.Event.Raw = log
		return true

	case err := <-it.sub.Err():
		it.done = true
		it.fail = err
		return it.Next()
	}
}

// Error returns any retrieval or parsing error occurred during filtering.
func (it *SNTApprovalIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *SNTApprovalIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// SNTApproval represents a Approval event raised by the SNT contract.
type SNTApproval struct {
	Owner   common.Address
	Spender common.Address
	Amount  *big.Int
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
//
// Solidity: event Approval(address indexed _owner, address indexed _spender, uint256 _amount)
func (_SNT *SNTFilterer) FilterApproval(opts *bind.FilterOpts, _owner []common.Address, _spender []common.Address) (*SNTApprovalIterator, error) {

	var _ownerRule []interface{}
	for _, _ownerItem := range _owner {
		_ownerRule = append(_ownerRule, _ownerItem)
	}
	var _spenderRule []interface{}
	for _, _spenderItem := range _spender {
		_spenderRule = append(_spenderRule, _spenderItem)
	}

	logs, sub, err := _SNT.contract.FilterLogs(opts, "Approval", _ownerRule, _spenderRule)
	if err != nil {
		return nil, err
	}
	return &SNTApprovalIterator{contract: _SNT.contract, event: "Approval", logs: logs, sub: sub}, nil
}

// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
//
// Solidity: event Approval(address indexed _owner, address indexed _spender, uint256 _amount)
func (_SNT *SNTFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *SNTApproval, _owner []common.Address, _spender []common.Address) (event.Subscription, error) {

	var _ownerRule []interface{}
	for _, _ownerItem := range _owner {
		_ownerRule = append(_ownerRule, _ownerItem)
	}
	var _spenderRule []interface{}
	for _, _spenderItem := range _spender {
		_spenderRule = append(_spenderRule, _spenderItem)
	}

	logs, sub, err := _SNT.contract.WatchLogs(opts, "Approval", _ownerRule, _spenderRule)
	if err != nil {
		return nil, err
	}
	return event.NewSubscription(func(quit <-chan struct{}) error {
		defer sub.Unsubscribe()
		for {
			select {
			case log := <-logs:
				// New log arrived, parse the event and forward to the user
				event := new(SNTApproval)
				if err := _SNT.contract.UnpackLog(event, "Approval", log); err != nil {
					return err
				}
				event.Raw = log

				select {
				case sink <- event:
				case err := <-sub.Err():
					return err
				case <-quit:
					return nil
				}
			case err := <-sub.Err():
				return err
			case <-quit:
				return nil
			}
		}
	}), nil
}

// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
//
// Solidity: event Approval(address indexed _owner, address indexed _spender, uint256 _amount)
func (_SNT *SNTFilterer) ParseApproval(log types.Log) (*SNTApproval, error) {
	event := new(SNTApproval)
	if err := _SNT.contract.UnpackLog(event, "Approval", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// SNTClaimedTokensIterator is returned from FilterClaimedTokens and is used to iterate over the raw logs and unpacked data for ClaimedTokens events raised by the SNT contract.
type SNTClaimedTokensIterator struct {
	Event *SNTClaimedTokens // Event containing the contract specifics and raw log

	contract *bind.BoundContract // Generic contract to use for unpacking event data
	event    string              // Event name to use for unpacking event data

	logs chan types.Log        // Log channel receiving the found contract events
	sub  ethereum.Subscription // Subscription for errors, completion and termination
	done bool                  // Whether the subscription completed delivering logs
	fail error                 // Occurred error to stop iteration
}

// Next advances the iterator to the subsequent event, returning whether there
// are any more events found. In case of a retrieval or parsing error, false is
// returned and Error() can be queried for the exact failure.
func (it *SNTClaimedTokensIterator) Next() bool {
	// If the iterator failed, stop iterating
	if it.fail != nil {
		return false
	}
	// If the iterator completed, deliver directly whatever's available
	if it.done {
		select {
		case log := <-it.logs:
			it.Event = new(SNTClaimedTokens)
			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
				it.fail = err
				return false
			}
			it.Event.Raw = log
			return true

		default:
			return false
		}
	}
	// Iterator still in progress, wait for either a data or an error event
	select {
	case log := <-it.logs:
		it.Event = new(SNTClaimedTokens)
		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
			it.fail = err
			return false
		}
		it.Event.Raw = log
		return true

	case err := <-it.sub.Err():
		it.done = true
		it.fail = err
		return it.Next()
	}
}

// Error returns any retrieval or parsing error occurred during filtering.
func (it *SNTClaimedTokensIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *SNTClaimedTokensIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// SNTClaimedTokens represents a ClaimedTokens event raised by the SNT contract.
type SNTClaimedTokens struct {
	Token      common.Address
	Controller common.Address
	Amount     *big.Int
	Raw        types.Log // Blockchain specific contextual infos
}

// FilterClaimedTokens is a free log retrieval operation binding the contract event 0xf931edb47c50b4b4104c187b5814a9aef5f709e17e2ecf9617e860cacade929c.
//
// Solidity: event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount)
func (_SNT *SNTFilterer) FilterClaimedTokens(opts *bind.FilterOpts, _token []common.Address, _controller []common.Address) (*SNTClaimedTokensIterator, error) {

	var _tokenRule []interface{}
	for _, _tokenItem := range _token {
		_tokenRule = append(_tokenRule, _tokenItem)
	}
	var _controllerRule []interface{}
	for _, _controllerItem := range _controller {
		_controllerRule = append(_controllerRule, _controllerItem)
	}

	logs, sub, err := _SNT.contract.FilterLogs(opts, "ClaimedTokens", _tokenRule, _controllerRule)
	if err != nil {
		return nil, err
	}
	return &SNTClaimedTokensIterator{contract: _SNT.contract, event: "ClaimedTokens", logs: logs, sub: sub}, nil
}

// WatchClaimedTokens is a free log subscription operation binding the contract event 0xf931edb47c50b4b4104c187b5814a9aef5f709e17e2ecf9617e860cacade929c.
//
// Solidity: event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount)
func (_SNT *SNTFilterer) WatchClaimedTokens(opts *bind.WatchOpts, sink chan<- *SNTClaimedTokens, _token []common.Address, _controller []common.Address) (event.Subscription, error) {

	var _tokenRule []interface{}
	for _, _tokenItem := range _token {
		_tokenRule = append(_tokenRule, _tokenItem)
	}
	var _controllerRule []interface{}
	for _, _controllerItem := range _controller {
		_controllerRule = append(_controllerRule, _controllerItem)
	}

	logs, sub, err := _SNT.contract.WatchLogs(opts, "ClaimedTokens", _tokenRule, _controllerRule)
	if err != nil {
		return nil, err
	}
	return event.NewSubscription(func(quit <-chan struct{}) error {
		defer sub.Unsubscribe()
		for {
			select {
			case log := <-logs:
				// New log arrived, parse the event and forward to the user
				event := new(SNTClaimedTokens)
				if err := _SNT.contract.UnpackLog(event, "ClaimedTokens", log); err != nil {
					return err
				}
				event.Raw = log

				select {
				case sink <- event:
				case err := <-sub.Err():
					return err
				case <-quit:
					return nil
				}
			case err := <-sub.Err():
				return err
			case <-quit:
				return nil
			}
		}
	}), nil
}

// ParseClaimedTokens is a log parse operation binding the contract event 0xf931edb47c50b4b4104c187b5814a9aef5f709e17e2ecf9617e860cacade929c.
//
// Solidity: event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount)
func (_SNT *SNTFilterer) ParseClaimedTokens(log types.Log) (*SNTClaimedTokens, error) {
	event := new(SNTClaimedTokens)
	if err := _SNT.contract.UnpackLog(event, "ClaimedTokens", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// SNTNewCloneTokenIterator is returned from FilterNewCloneToken and is used to iterate over the raw logs and unpacked data for NewCloneToken events raised by the SNT contract.
type SNTNewCloneTokenIterator struct {
	Event *SNTNewCloneToken // Event containing the contract specifics and raw log

	contract *bind.BoundContract // Generic contract to use for unpacking event data
	event    string              // Event name to use for unpacking event data

	logs chan types.Log        // Log channel receiving the found contract events
	sub  ethereum.Subscription // Subscription for errors, completion and termination
	done bool                  // Whether the subscription completed delivering logs
	fail error                 // Occurred error to stop iteration
}

// Next advances the iterator to the subsequent event, returning whether there
// are any more events found. In case of a retrieval or parsing error, false is
// returned and Error() can be queried for the exact failure.
func (it *SNTNewCloneTokenIterator) Next() bool {
	// If the iterator failed, stop iterating
	if it.fail != nil {
		return false
	}
	// If the iterator completed, deliver directly whatever's available
	if it.done {
		select {
		case log := <-it.logs:
			it.Event = new(SNTNewCloneToken)
			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
				it.fail = err
				return false
			}
			it.Event.Raw = log
			return true

		default:
			return false
		}
	}
	// Iterator still in progress, wait for either a data or an error event
	select {
	case log := <-it.logs:
		it.Event = new(SNTNewCloneToken)
		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
			it.fail = err
			return false
		}
		it.Event.Raw = log
		return true

	case err := <-it.sub.Err():
		it.done = true
		it.fail = err
		return it.Next()
	}
}

// Error returns any retrieval or parsing error occurred during filtering.
func (it *SNTNewCloneTokenIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *SNTNewCloneTokenIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// SNTNewCloneToken represents a NewCloneToken event raised by the SNT contract.
type SNTNewCloneToken struct {
	CloneToken    common.Address
	SnapshotBlock *big.Int
	Raw           types.Log // Blockchain specific contextual infos
}

// FilterNewCloneToken is a free log retrieval operation binding the contract event 0x086c875b377f900b07ce03575813022f05dd10ed7640b5282cf6d3c3fc352ade.
//
// Solidity: event NewCloneToken(address indexed _cloneToken, uint256 _snapshotBlock)
func (_SNT *SNTFilterer) FilterNewCloneToken(opts *bind.FilterOpts, _cloneToken []common.Address) (*SNTNewCloneTokenIterator, error) {

	var _cloneTokenRule []interface{}
	for _, _cloneTokenItem := range _cloneToken {
		_cloneTokenRule = append(_cloneTokenRule, _cloneTokenItem)
	}

	logs, sub, err := _SNT.contract.FilterLogs(opts, "NewCloneToken", _cloneTokenRule)
	if err != nil {
		return nil, err
	}
	return &SNTNewCloneTokenIterator{contract: _SNT.contract, event: "NewCloneToken", logs: logs, sub: sub}, nil
}

// WatchNewCloneToken is a free log subscription operation binding the contract event 0x086c875b377f900b07ce03575813022f05dd10ed7640b5282cf6d3c3fc352ade.
//
// Solidity: event NewCloneToken(address indexed _cloneToken, uint256 _snapshotBlock)
func (_SNT *SNTFilterer) WatchNewCloneToken(opts *bind.WatchOpts, sink chan<- *SNTNewCloneToken, _cloneToken []common.Address) (event.Subscription, error) {

	var _cloneTokenRule []interface{}
	for _, _cloneTokenItem := range _cloneToken {
		_cloneTokenRule = append(_cloneTokenRule, _cloneTokenItem)
	}

	logs, sub, err := _SNT.contract.WatchLogs(opts, "NewCloneToken", _cloneTokenRule)
	if err != nil {
		return nil, err
	}
	return event.NewSubscription(func(quit <-chan struct{}) error {
		defer sub.Unsubscribe()
		for {
			select {
			case log := <-logs:
				// New log arrived, parse the event and forward to the user
				event := new(SNTNewCloneToken)
				if err := _SNT.contract.UnpackLog(event, "NewCloneToken", log); err != nil {
					return err
				}
				event.Raw = log

				select {
				case sink <- event:
				case err := <-sub.Err():
					return err
				case <-quit:
					return nil
				}
			case err := <-sub.Err():
				return err
			case <-quit:
				return nil
			}
		}
	}), nil
}

// ParseNewCloneToken is a log parse operation binding the contract event 0x086c875b377f900b07ce03575813022f05dd10ed7640b5282cf6d3c3fc352ade.
//
// Solidity: event NewCloneToken(address indexed _cloneToken, uint256 _snapshotBlock)
func (_SNT *SNTFilterer) ParseNewCloneToken(log types.Log) (*SNTNewCloneToken, error) {
	event := new(SNTNewCloneToken)
	if err := _SNT.contract.UnpackLog(event, "NewCloneToken", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// SNTTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the SNT contract.
type SNTTransferIterator struct {
	Event *SNTTransfer // Event containing the contract specifics and raw log

	contract *bind.BoundContract // Generic contract to use for unpacking event data
	event    string              // Event name to use for unpacking event data

	logs chan types.Log        // Log channel receiving the found contract events
	sub  ethereum.Subscription // Subscription for errors, completion and termination
	done bool                  // Whether the subscription completed delivering logs
	fail error                 // Occurred error to stop iteration
}

// Next advances the iterator to the subsequent event, returning whether there
// are any more events found. In case of a retrieval or parsing error, false is
// returned and Error() can be queried for the exact failure.
func (it *SNTTransferIterator) Next() bool {
	// If the iterator failed, stop iterating
	if it.fail != nil {
		return false
	}
	// If the iterator completed, deliver directly whatever's available
	if it.done {
		select {
		case log := <-it.logs:
			it.Event = new(SNTTransfer)
			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
				it.fail = err
				return false
			}
			it.Event.Raw = log
			return true

		default:
			return false
		}
	}
	// Iterator still in progress, wait for either a data or an error event
	select {
	case log := <-it.logs:
		it.Event = new(SNTTransfer)
		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
			it.fail = err
			return false
		}
		it.Event.Raw = log
		return true

	case err := <-it.sub.Err():
		it.done = true
		it.fail = err
		return it.Next()
	}
}

// Error returns any retrieval or parsing error occurred during filtering.
func (it *SNTTransferIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *SNTTransferIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// SNTTransfer represents a Transfer event raised by the SNT contract.
type SNTTransfer struct {
	From   common.Address
	To     common.Address
	Amount *big.Int
	Raw    types.Log // Blockchain specific contextual infos
}

// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
//
// Solidity: event Transfer(address indexed _from, address indexed _to, uint256 _amount)
func (_SNT *SNTFilterer) FilterTransfer(opts *bind.FilterOpts, _from []common.Address, _to []common.Address) (*SNTTransferIterator, error) {

	var _fromRule []interface{}
	for _, _fromItem := range _from {
		_fromRule = append(_fromRule, _fromItem)
	}
	var _toRule []interface{}
	for _, _toItem := range _to {
		_toRule = append(_toRule, _toItem)
	}

	logs, sub, err := _SNT.contract.FilterLogs(opts, "Transfer", _fromRule, _toRule)
	if err != nil {
		return nil, err
	}
	return &SNTTransferIterator{contract: _SNT.contract, event: "Transfer", logs: logs, sub: sub}, nil
}

// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
//
// Solidity: event Transfer(address indexed _from, address indexed _to, uint256 _amount)
func (_SNT *SNTFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *SNTTransfer, _from []common.Address, _to []common.Address) (event.Subscription, error) {

	var _fromRule []interface{}
	for _, _fromItem := range _from {
		_fromRule = append(_fromRule, _fromItem)
	}
	var _toRule []interface{}
	for _, _toItem := range _to {
		_toRule = append(_toRule, _toItem)
	}

	logs, sub, err := _SNT.contract.WatchLogs(opts, "Transfer", _fromRule, _toRule)
	if err != nil {
		return nil, err
	}
	return event.NewSubscription(func(quit <-chan struct{}) error {
		defer sub.Unsubscribe()
		for {
			select {
			case log := <-logs:
				// New log arrived, parse the event and forward to the user
				event := new(SNTTransfer)
				if err := _SNT.contract.UnpackLog(event, "Transfer", log); err != nil {
					return err
				}
				event.Raw = log

				select {
				case sink <- event:
				case err := <-sub.Err():
					return err
				case <-quit:
					return nil
				}
			case err := <-sub.Err():
				return err
			case <-quit:
				return nil
			}
		}
	}), nil
}

// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
//
// Solidity: event Transfer(address indexed _from, address indexed _to, uint256 _amount)
func (_SNT *SNTFilterer) ParseTransfer(log types.Log) (*SNTTransfer, error) {
	event := new(SNTTransfer)
	if err := _SNT.contract.UnpackLog(event, "Transfer", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// TokenControllerABI is the input ABI used to generate the binding from.
const TokenControllerABI = "[{\"constant\":false,\"inputs\":[{\"name\":\"_from\",\"type\":\"address\"},{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"onTransfer\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\"},{\"name\":\"_spender\",\"type\":\"address\"},{\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"onApprove\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"proxyPayment\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":true,\"stateMutability\":\"payable\",\"type\":\"function\"}]"

// TokenControllerFuncSigs maps the 4-byte function signature to its string representation.
var TokenControllerFuncSigs = map[string]string{
	"da682aeb": "onApprove(address,address,uint256)",
	"4a393149": "onTransfer(address,address,uint256)",
	"f48c3054": "proxyPayment(address)",
}

// TokenController is an auto generated Go binding around an Ethereum contract.
type TokenController struct {
	TokenControllerCaller     // Read-only binding to the contract
	TokenControllerTransactor // Write-only binding to the contract
	TokenControllerFilterer   // Log filterer for contract events
}

// TokenControllerCaller is an auto generated read-only Go binding around an Ethereum contract.
type TokenControllerCaller struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// TokenControllerTransactor is an auto generated write-only Go binding around an Ethereum contract.
type TokenControllerTransactor struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// TokenControllerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
type TokenControllerFilterer struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// TokenControllerSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type TokenControllerSession struct {
	Contract     *TokenController  // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

// TokenControllerCallerSession is an auto generated read-only Go binding around an Ethereum contract,
// with pre-set call options.
type TokenControllerCallerSession struct {
	Contract *TokenControllerCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts          // Call options to use throughout this session
}

// TokenControllerTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
// with pre-set transact options.
type TokenControllerTransactorSession struct {
	Contract     *TokenControllerTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts          // Transaction auth options to use throughout this session
}

// TokenControllerRaw is an auto generated low-level Go binding around an Ethereum contract.
type TokenControllerRaw struct {
	Contract *TokenController // Generic contract binding to access the raw methods on
}

// TokenControllerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
type TokenControllerCallerRaw struct {
	Contract *TokenControllerCaller // Generic read-only contract binding to access the raw methods on
}

// TokenControllerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
type TokenControllerTransactorRaw struct {
	Contract *TokenControllerTransactor // Generic write-only contract binding to access the raw methods on
}

// NewTokenController creates a new instance of TokenController, bound to a specific deployed contract.
func NewTokenController(address common.Address, backend bind.ContractBackend) (*TokenController, error) {
	contract, err := bindTokenController(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &TokenController{TokenControllerCaller: TokenControllerCaller{contract: contract}, TokenControllerTransactor: TokenControllerTransactor{contract: contract}, TokenControllerFilterer: TokenControllerFilterer{contract: contract}}, nil
}

// NewTokenControllerCaller creates a new read-only instance of TokenController, bound to a specific deployed contract.
func NewTokenControllerCaller(address common.Address, caller bind.ContractCaller) (*TokenControllerCaller, error) {
	contract, err := bindTokenController(address, caller, nil, nil)
	if err != nil {
		return nil, err
	}
	return &TokenControllerCaller{contract: contract}, nil
}

// NewTokenControllerTransactor creates a new write-only instance of TokenController, bound to a specific deployed contract.
func NewTokenControllerTransactor(address common.Address, transactor bind.ContractTransactor) (*TokenControllerTransactor, error) {
	contract, err := bindTokenController(address, nil, transactor, nil)
	if err != nil {
		return nil, err
	}
	return &TokenControllerTransactor{contract: contract}, nil
}

// NewTokenControllerFilterer creates a new log filterer instance of TokenController, bound to a specific deployed contract.
func NewTokenControllerFilterer(address common.Address, filterer bind.ContractFilterer) (*TokenControllerFilterer, error) {
	contract, err := bindTokenController(address, nil, nil, filterer)
	if err != nil {
		return nil, err
	}
	return &TokenControllerFilterer{contract: contract}, nil
}

// bindTokenController binds a generic wrapper to an already deployed contract.
func bindTokenController(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(TokenControllerABI))
	if err != nil {
		return nil, err
	}
	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_TokenController *TokenControllerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _TokenController.Contract.TokenControllerCaller.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_TokenController *TokenControllerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _TokenController.Contract.TokenControllerTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_TokenController *TokenControllerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _TokenController.Contract.TokenControllerTransactor.contract.Transact(opts, method, params...)
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_TokenController *TokenControllerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _TokenController.Contract.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_TokenController *TokenControllerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _TokenController.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_TokenController *TokenControllerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _TokenController.Contract.contract.Transact(opts, method, params...)
}

// OnApprove is a paid mutator transaction binding the contract method 0xda682aeb.
//
// Solidity: function onApprove(address _owner, address _spender, uint256 _amount) returns(bool)
func (_TokenController *TokenControllerTransactor) OnApprove(opts *bind.TransactOpts, _owner common.Address, _spender common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _TokenController.contract.Transact(opts, "onApprove", _owner, _spender, _amount)
}

// OnApprove is a paid mutator transaction binding the contract method 0xda682aeb.
//
// Solidity: function onApprove(address _owner, address _spender, uint256 _amount) returns(bool)
func (_TokenController *TokenControllerSession) OnApprove(_owner common.Address, _spender common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _TokenController.Contract.OnApprove(&_TokenController.TransactOpts, _owner, _spender, _amount)
}

// OnApprove is a paid mutator transaction binding the contract method 0xda682aeb.
//
// Solidity: function onApprove(address _owner, address _spender, uint256 _amount) returns(bool)
func (_TokenController *TokenControllerTransactorSession) OnApprove(_owner common.Address, _spender common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _TokenController.Contract.OnApprove(&_TokenController.TransactOpts, _owner, _spender, _amount)
}

// OnTransfer is a paid mutator transaction binding the contract method 0x4a393149.
//
// Solidity: function onTransfer(address _from, address _to, uint256 _amount) returns(bool)
func (_TokenController *TokenControllerTransactor) OnTransfer(opts *bind.TransactOpts, _from common.Address, _to common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _TokenController.contract.Transact(opts, "onTransfer", _from, _to, _amount)
}

// OnTransfer is a paid mutator transaction binding the contract method 0x4a393149.
//
// Solidity: function onTransfer(address _from, address _to, uint256 _amount) returns(bool)
func (_TokenController *TokenControllerSession) OnTransfer(_from common.Address, _to common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _TokenController.Contract.OnTransfer(&_TokenController.TransactOpts, _from, _to, _amount)
}

// OnTransfer is a paid mutator transaction binding the contract method 0x4a393149.
//
// Solidity: function onTransfer(address _from, address _to, uint256 _amount) returns(bool)
func (_TokenController *TokenControllerTransactorSession) OnTransfer(_from common.Address, _to common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _TokenController.Contract.OnTransfer(&_TokenController.TransactOpts, _from, _to, _amount)
}

// ProxyPayment is a paid mutator transaction binding the contract method 0xf48c3054.
//
// Solidity: function proxyPayment(address _owner) payable returns(bool)
func (_TokenController *TokenControllerTransactor) ProxyPayment(opts *bind.TransactOpts, _owner common.Address) (*types.Transaction, error) {
	return _TokenController.contract.Transact(opts, "proxyPayment", _owner)
}

// ProxyPayment is a paid mutator transaction binding the contract method 0xf48c3054.
//
// Solidity: function proxyPayment(address _owner) payable returns(bool)
func (_TokenController *TokenControllerSession) ProxyPayment(_owner common.Address) (*types.Transaction, error) {
	return _TokenController.Contract.ProxyPayment(&_TokenController.TransactOpts, _owner)
}

// ProxyPayment is a paid mutator transaction binding the contract method 0xf48c3054.
//
// Solidity: function proxyPayment(address _owner) payable returns(bool)
func (_TokenController *TokenControllerTransactorSession) ProxyPayment(_owner common.Address) (*types.Transaction, error) {
	return _TokenController.Contract.ProxyPayment(&_TokenController.TransactOpts, _owner)
}