github.com/Onther-Tech/plasma-evm@v0.0.0-rc7.7/contracts/plasma/seigmanager/seigmanager.go

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

package seigmanager

import (
	"math/big"
	"strings"

	"github.com/Onther-Tech/plasma-evm"
	"github.com/Onther-Tech/plasma-evm/accounts/abi"
	"github.com/Onther-Tech/plasma-evm/accounts/abi/bind"
	"github.com/Onther-Tech/plasma-evm/common"
	"github.com/Onther-Tech/plasma-evm/core/types"
	"github.com/Onther-Tech/plasma-evm/event"
)

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

// AddressABI is the input ABI used to generate the binding from.
const AddressABI = "[]"

// AddressBin is the compiled bytecode used for deploying new contracts.
var AddressBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a72315820caa83848f6f3a88a061ce398577e989d5da9a19232f9e00175de410a704b86e164736f6c634300050c0032"

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

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(AddressBin), backend)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &Address{AddressCaller: AddressCaller{contract: contract}, AddressTransactor: AddressTransactor{contract: contract}, AddressFilterer: AddressFilterer{contract: contract}}, nil
}

// Address is an auto generated Go binding around an Ethereum contract.
type Address struct {
	AddressCaller     // Read-only binding to the contract
	AddressTransactor // Write-only binding to the contract
	AddressFilterer   // Log filterer for contract events
}

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

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

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

// AddressSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type AddressSession struct {
	Contract     *Address          // 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
}

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

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

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

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

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

// NewAddress creates a new instance of Address, bound to a specific deployed contract.
func NewAddress(address common.Address, backend bind.ContractBackend) (*Address, error) {
	contract, err := bindAddress(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &Address{AddressCaller: AddressCaller{contract: contract}, AddressTransactor: AddressTransactor{contract: contract}, AddressFilterer: AddressFilterer{contract: contract}}, nil
}

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

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

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

// bindAddress binds a generic wrapper to an already deployed contract.
func bindAddress(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(AddressABI))
	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 (_Address *AddressRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _Address.Contract.AddressCaller.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 (_Address *AddressRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _Address.Contract.AddressTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_Address *AddressRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _Address.Contract.AddressTransactor.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 (_Address *AddressCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _Address.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 (_Address *AddressTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _Address.Contract.contract.Transfer(opts)
}

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

// ApproveAndCallFallBackABI is the input ABI used to generate the binding from.
const ApproveAndCallFallBackABI = "[{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"_token\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"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)
}

// AuthControllerABI is the input ABI used to generate the binding from.
const AuthControllerABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[],\"name\":\"isOwner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renouncePauser\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"

// AuthControllerFuncSigs maps the 4-byte function signature to its string representation.
var AuthControllerFuncSigs = map[string]string{
	"8f32d59b": "isOwner()",
	"8da5cb5b": "owner()",
	"5f112c68": "renounceMinter(address)",
	"715018a6": "renounceOwnership()",
	"38bf3cfa": "renounceOwnership(address)",
	"41eb24bb": "renouncePauser(address)",
	"f2fde38b": "transferOwnership(address)",
	"6d435421": "transferOwnership(address,address)",
}

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

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

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(AuthControllerBin), backend)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &AuthController{AuthControllerCaller: AuthControllerCaller{contract: contract}, AuthControllerTransactor: AuthControllerTransactor{contract: contract}, AuthControllerFilterer: AuthControllerFilterer{contract: contract}}, nil
}

// AuthController is an auto generated Go binding around an Ethereum contract.
type AuthController struct {
	AuthControllerCaller     // Read-only binding to the contract
	AuthControllerTransactor // Write-only binding to the contract
	AuthControllerFilterer   // Log filterer for contract events
}

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

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

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

// AuthControllerSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type AuthControllerSession struct {
	Contract     *AuthController   // 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
}

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

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

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

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

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

// NewAuthController creates a new instance of AuthController, bound to a specific deployed contract.
func NewAuthController(address common.Address, backend bind.ContractBackend) (*AuthController, error) {
	contract, err := bindAuthController(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &AuthController{AuthControllerCaller: AuthControllerCaller{contract: contract}, AuthControllerTransactor: AuthControllerTransactor{contract: contract}, AuthControllerFilterer: AuthControllerFilterer{contract: contract}}, nil
}

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

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

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

// bindAuthController binds a generic wrapper to an already deployed contract.
func bindAuthController(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(AuthControllerABI))
	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 (_AuthController *AuthControllerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _AuthController.Contract.AuthControllerCaller.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 (_AuthController *AuthControllerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _AuthController.Contract.AuthControllerTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_AuthController *AuthControllerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _AuthController.Contract.AuthControllerTransactor.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 (_AuthController *AuthControllerCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _AuthController.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 (_AuthController *AuthControllerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _AuthController.Contract.contract.Transfer(opts)
}

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

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_AuthController *AuthControllerCaller) IsOwner(opts *bind.CallOpts) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _AuthController.contract.Call(opts, out, "isOwner")
	return *ret0, err
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_AuthController *AuthControllerSession) IsOwner() (bool, error) {
	return _AuthController.Contract.IsOwner(&_AuthController.CallOpts)
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_AuthController *AuthControllerCallerSession) IsOwner() (bool, error) {
	return _AuthController.Contract.IsOwner(&_AuthController.CallOpts)
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_AuthController *AuthControllerCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _AuthController.contract.Call(opts, out, "owner")
	return *ret0, err
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_AuthController *AuthControllerSession) Owner() (common.Address, error) {
	return _AuthController.Contract.Owner(&_AuthController.CallOpts)
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_AuthController *AuthControllerCallerSession) Owner() (common.Address, error) {
	return _AuthController.Contract.Owner(&_AuthController.CallOpts)
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
//
// Solidity: function renounceMinter(address target) returns()
func (_AuthController *AuthControllerTransactor) RenounceMinter(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
	return _AuthController.contract.Transact(opts, "renounceMinter", target)
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
//
// Solidity: function renounceMinter(address target) returns()
func (_AuthController *AuthControllerSession) RenounceMinter(target common.Address) (*types.Transaction, error) {
	return _AuthController.Contract.RenounceMinter(&_AuthController.TransactOpts, target)
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
//
// Solidity: function renounceMinter(address target) returns()
func (_AuthController *AuthControllerTransactorSession) RenounceMinter(target common.Address) (*types.Transaction, error) {
	return _AuthController.Contract.RenounceMinter(&_AuthController.TransactOpts, target)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
//
// Solidity: function renounceOwnership(address target) returns()
func (_AuthController *AuthControllerTransactor) RenounceOwnership(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
	return _AuthController.contract.Transact(opts, "renounceOwnership", target)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
//
// Solidity: function renounceOwnership(address target) returns()
func (_AuthController *AuthControllerSession) RenounceOwnership(target common.Address) (*types.Transaction, error) {
	return _AuthController.Contract.RenounceOwnership(&_AuthController.TransactOpts, target)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
//
// Solidity: function renounceOwnership(address target) returns()
func (_AuthController *AuthControllerTransactorSession) RenounceOwnership(target common.Address) (*types.Transaction, error) {
	return _AuthController.Contract.RenounceOwnership(&_AuthController.TransactOpts, target)
}

// RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_AuthController *AuthControllerTransactor) RenounceOwnership0(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _AuthController.contract.Transact(opts, "renounceOwnership0")
}

// RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_AuthController *AuthControllerSession) RenounceOwnership0() (*types.Transaction, error) {
	return _AuthController.Contract.RenounceOwnership0(&_AuthController.TransactOpts)
}

// RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_AuthController *AuthControllerTransactorSession) RenounceOwnership0() (*types.Transaction, error) {
	return _AuthController.Contract.RenounceOwnership0(&_AuthController.TransactOpts)
}

// RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
//
// Solidity: function renouncePauser(address target) returns()
func (_AuthController *AuthControllerTransactor) RenouncePauser(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
	return _AuthController.contract.Transact(opts, "renouncePauser", target)
}

// RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
//
// Solidity: function renouncePauser(address target) returns()
func (_AuthController *AuthControllerSession) RenouncePauser(target common.Address) (*types.Transaction, error) {
	return _AuthController.Contract.RenouncePauser(&_AuthController.TransactOpts, target)
}

// RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
//
// Solidity: function renouncePauser(address target) returns()
func (_AuthController *AuthControllerTransactorSession) RenouncePauser(target common.Address) (*types.Transaction, error) {
	return _AuthController.Contract.RenouncePauser(&_AuthController.TransactOpts, target)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
//
// Solidity: function transferOwnership(address target, address newOwner) returns()
func (_AuthController *AuthControllerTransactor) TransferOwnership(opts *bind.TransactOpts, target common.Address, newOwner common.Address) (*types.Transaction, error) {
	return _AuthController.contract.Transact(opts, "transferOwnership", target, newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
//
// Solidity: function transferOwnership(address target, address newOwner) returns()
func (_AuthController *AuthControllerSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) {
	return _AuthController.Contract.TransferOwnership(&_AuthController.TransactOpts, target, newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
//
// Solidity: function transferOwnership(address target, address newOwner) returns()
func (_AuthController *AuthControllerTransactorSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) {
	return _AuthController.Contract.TransferOwnership(&_AuthController.TransactOpts, target, newOwner)
}

// TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_AuthController *AuthControllerTransactor) TransferOwnership0(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
	return _AuthController.contract.Transact(opts, "transferOwnership0", newOwner)
}

// TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_AuthController *AuthControllerSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) {
	return _AuthController.Contract.TransferOwnership0(&_AuthController.TransactOpts, newOwner)
}

// TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_AuthController *AuthControllerTransactorSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) {
	return _AuthController.Contract.TransferOwnership0(&_AuthController.TransactOpts, newOwner)
}

// AuthControllerOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the AuthController contract.
type AuthControllerOwnershipTransferredIterator struct {
	Event *AuthControllerOwnershipTransferred // 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 *AuthControllerOwnershipTransferredIterator) 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(AuthControllerOwnershipTransferred)
			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(AuthControllerOwnershipTransferred)
		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 *AuthControllerOwnershipTransferredIterator) Error() error {
	return it.fail
}

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

// AuthControllerOwnershipTransferred represents a OwnershipTransferred event raised by the AuthController contract.
type AuthControllerOwnershipTransferred struct {
	PreviousOwner common.Address
	NewOwner      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_AuthController *AuthControllerFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*AuthControllerOwnershipTransferredIterator, error) {

	var previousOwnerRule []interface{}
	for _, previousOwnerItem := range previousOwner {
		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
	}
	var newOwnerRule []interface{}
	for _, newOwnerItem := range newOwner {
		newOwnerRule = append(newOwnerRule, newOwnerItem)
	}

	logs, sub, err := _AuthController.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
	if err != nil {
		return nil, err
	}
	return &AuthControllerOwnershipTransferredIterator{contract: _AuthController.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
}

// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_AuthController *AuthControllerFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *AuthControllerOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {

	var previousOwnerRule []interface{}
	for _, previousOwnerItem := range previousOwner {
		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
	}
	var newOwnerRule []interface{}
	for _, newOwnerItem := range newOwner {
		newOwnerRule = append(newOwnerRule, newOwnerItem)
	}

	logs, sub, err := _AuthController.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
	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(AuthControllerOwnershipTransferred)
				if err := _AuthController.contract.UnpackLog(event, "OwnershipTransferred", 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
}

// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_AuthController *AuthControllerFilterer) ParseOwnershipTransferred(log types.Log) (*AuthControllerOwnershipTransferred, error) {
	event := new(AuthControllerOwnershipTransferred)
	if err := _AuthController.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
		return nil, err
	}
	return event, nil
}

// AutoIncrementCoinageABI is the input ABI used to generate the binding from.
const AutoIncrementCoinageABI = "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"factor\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"factorIncrement\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"transfersEnabled\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"factor\",\"type\":\"uint256\"}],\"name\":\"FactorIncreased\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"bool\",\"name\":\"v\",\"type\":\"bool\"}],\"name\":\"enableTransfers\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"factor\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"factorIncrement\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"isOwner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"lastBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"transfersEnabled\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"

// AutoIncrementCoinageFuncSigs maps the 4-byte function signature to its string representation.
var AutoIncrementCoinageFuncSigs = map[string]string{
	"dd62ed3e": "allowance(address,address)",
	"095ea7b3": "approve(address,uint256)",
	"70a08231": "balanceOf(address)",
	"313ce567": "decimals()",
	"a457c2d7": "decreaseAllowance(address,uint256)",
	"f41e60c5": "enableTransfers(bool)",
	"54f703f8": "factor()",
	"d4132ee2": "factorIncrement()",
	"39509351": "increaseAllowance(address,uint256)",
	"8f32d59b": "isOwner()",
	"806b984f": "lastBlock()",
	"06fdde03": "name()",
	"8da5cb5b": "owner()",
	"715018a6": "renounceOwnership()",
	"95d89b41": "symbol()",
	"18160ddd": "totalSupply()",
	"a9059cbb": "transfer(address,uint256)",
	"23b872dd": "transferFrom(address,address,uint256)",
	"f2fde38b": "transferOwnership(address)",
	"bef97c87": "transfersEnabled()",
}

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

// DeployAutoIncrementCoinage deploys a new Ethereum contract, binding an instance of AutoIncrementCoinage to it.
func DeployAutoIncrementCoinage(auth *bind.TransactOpts, backend bind.ContractBackend, name string, symbol string, factor *big.Int, factorIncrement *big.Int, transfersEnabled bool) (common.Address, *types.Transaction, *AutoIncrementCoinage, error) {
	parsed, err := abi.JSON(strings.NewReader(AutoIncrementCoinageABI))
	if err != nil {
		return common.Address{}, nil, nil, err
	}

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(AutoIncrementCoinageBin), backend, name, symbol, factor, factorIncrement, transfersEnabled)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &AutoIncrementCoinage{AutoIncrementCoinageCaller: AutoIncrementCoinageCaller{contract: contract}, AutoIncrementCoinageTransactor: AutoIncrementCoinageTransactor{contract: contract}, AutoIncrementCoinageFilterer: AutoIncrementCoinageFilterer{contract: contract}}, nil
}

// AutoIncrementCoinage is an auto generated Go binding around an Ethereum contract.
type AutoIncrementCoinage struct {
	AutoIncrementCoinageCaller     // Read-only binding to the contract
	AutoIncrementCoinageTransactor // Write-only binding to the contract
	AutoIncrementCoinageFilterer   // Log filterer for contract events
}

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

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

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

// AutoIncrementCoinageSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type AutoIncrementCoinageSession struct {
	Contract     *AutoIncrementCoinage // 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
}

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

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

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

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

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

// NewAutoIncrementCoinage creates a new instance of AutoIncrementCoinage, bound to a specific deployed contract.
func NewAutoIncrementCoinage(address common.Address, backend bind.ContractBackend) (*AutoIncrementCoinage, error) {
	contract, err := bindAutoIncrementCoinage(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &AutoIncrementCoinage{AutoIncrementCoinageCaller: AutoIncrementCoinageCaller{contract: contract}, AutoIncrementCoinageTransactor: AutoIncrementCoinageTransactor{contract: contract}, AutoIncrementCoinageFilterer: AutoIncrementCoinageFilterer{contract: contract}}, nil
}

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

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

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

// bindAutoIncrementCoinage binds a generic wrapper to an already deployed contract.
func bindAutoIncrementCoinage(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(AutoIncrementCoinageABI))
	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 (_AutoIncrementCoinage *AutoIncrementCoinageRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _AutoIncrementCoinage.Contract.AutoIncrementCoinageCaller.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 (_AutoIncrementCoinage *AutoIncrementCoinageRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _AutoIncrementCoinage.Contract.AutoIncrementCoinageTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_AutoIncrementCoinage *AutoIncrementCoinageRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _AutoIncrementCoinage.Contract.AutoIncrementCoinageTransactor.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 (_AutoIncrementCoinage *AutoIncrementCoinageCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _AutoIncrementCoinage.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 (_AutoIncrementCoinage *AutoIncrementCoinageTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _AutoIncrementCoinage.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_AutoIncrementCoinage *AutoIncrementCoinageTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _AutoIncrementCoinage.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) constant returns(uint256)
func (_AutoIncrementCoinage *AutoIncrementCoinageCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinage.contract.Call(opts, out, "allowance", owner, spender)
	return *ret0, err
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_AutoIncrementCoinage *AutoIncrementCoinageSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _AutoIncrementCoinage.Contract.Allowance(&_AutoIncrementCoinage.CallOpts, owner, spender)
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_AutoIncrementCoinage *AutoIncrementCoinageCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _AutoIncrementCoinage.Contract.Allowance(&_AutoIncrementCoinage.CallOpts, owner, spender)
}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address account) constant returns(uint256)
func (_AutoIncrementCoinage *AutoIncrementCoinageCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinage.contract.Call(opts, out, "balanceOf", account)
	return *ret0, err
}

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

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

// Decimals is a free data retrieval call binding the contract method 0x313ce567.
//
// Solidity: function decimals() constant returns(uint8)
func (_AutoIncrementCoinage *AutoIncrementCoinageCaller) Decimals(opts *bind.CallOpts) (uint8, error) {
	var (
		ret0 = new(uint8)
	)
	out := ret0
	err := _AutoIncrementCoinage.contract.Call(opts, out, "decimals")
	return *ret0, err
}

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

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

// Factor is a free data retrieval call binding the contract method 0x54f703f8.
//
// Solidity: function factor() constant returns(uint256)
func (_AutoIncrementCoinage *AutoIncrementCoinageCaller) Factor(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinage.contract.Call(opts, out, "factor")
	return *ret0, err
}

// Factor is a free data retrieval call binding the contract method 0x54f703f8.
//
// Solidity: function factor() constant returns(uint256)
func (_AutoIncrementCoinage *AutoIncrementCoinageSession) Factor() (*big.Int, error) {
	return _AutoIncrementCoinage.Contract.Factor(&_AutoIncrementCoinage.CallOpts)
}

// Factor is a free data retrieval call binding the contract method 0x54f703f8.
//
// Solidity: function factor() constant returns(uint256)
func (_AutoIncrementCoinage *AutoIncrementCoinageCallerSession) Factor() (*big.Int, error) {
	return _AutoIncrementCoinage.Contract.Factor(&_AutoIncrementCoinage.CallOpts)
}

// FactorIncrement is a free data retrieval call binding the contract method 0xd4132ee2.
//
// Solidity: function factorIncrement() constant returns(uint256)
func (_AutoIncrementCoinage *AutoIncrementCoinageCaller) FactorIncrement(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinage.contract.Call(opts, out, "factorIncrement")
	return *ret0, err
}

// FactorIncrement is a free data retrieval call binding the contract method 0xd4132ee2.
//
// Solidity: function factorIncrement() constant returns(uint256)
func (_AutoIncrementCoinage *AutoIncrementCoinageSession) FactorIncrement() (*big.Int, error) {
	return _AutoIncrementCoinage.Contract.FactorIncrement(&_AutoIncrementCoinage.CallOpts)
}

// FactorIncrement is a free data retrieval call binding the contract method 0xd4132ee2.
//
// Solidity: function factorIncrement() constant returns(uint256)
func (_AutoIncrementCoinage *AutoIncrementCoinageCallerSession) FactorIncrement() (*big.Int, error) {
	return _AutoIncrementCoinage.Contract.FactorIncrement(&_AutoIncrementCoinage.CallOpts)
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_AutoIncrementCoinage *AutoIncrementCoinageCaller) IsOwner(opts *bind.CallOpts) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _AutoIncrementCoinage.contract.Call(opts, out, "isOwner")
	return *ret0, err
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_AutoIncrementCoinage *AutoIncrementCoinageSession) IsOwner() (bool, error) {
	return _AutoIncrementCoinage.Contract.IsOwner(&_AutoIncrementCoinage.CallOpts)
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_AutoIncrementCoinage *AutoIncrementCoinageCallerSession) IsOwner() (bool, error) {
	return _AutoIncrementCoinage.Contract.IsOwner(&_AutoIncrementCoinage.CallOpts)
}

// LastBlock is a free data retrieval call binding the contract method 0x806b984f.
//
// Solidity: function lastBlock() constant returns(uint256)
func (_AutoIncrementCoinage *AutoIncrementCoinageCaller) LastBlock(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinage.contract.Call(opts, out, "lastBlock")
	return *ret0, err
}

// LastBlock is a free data retrieval call binding the contract method 0x806b984f.
//
// Solidity: function lastBlock() constant returns(uint256)
func (_AutoIncrementCoinage *AutoIncrementCoinageSession) LastBlock() (*big.Int, error) {
	return _AutoIncrementCoinage.Contract.LastBlock(&_AutoIncrementCoinage.CallOpts)
}

// LastBlock is a free data retrieval call binding the contract method 0x806b984f.
//
// Solidity: function lastBlock() constant returns(uint256)
func (_AutoIncrementCoinage *AutoIncrementCoinageCallerSession) LastBlock() (*big.Int, error) {
	return _AutoIncrementCoinage.Contract.LastBlock(&_AutoIncrementCoinage.CallOpts)
}

// Name is a free data retrieval call binding the contract method 0x06fdde03.
//
// Solidity: function name() constant returns(string)
func (_AutoIncrementCoinage *AutoIncrementCoinageCaller) Name(opts *bind.CallOpts) (string, error) {
	var (
		ret0 = new(string)
	)
	out := ret0
	err := _AutoIncrementCoinage.contract.Call(opts, out, "name")
	return *ret0, err
}

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

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

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_AutoIncrementCoinage *AutoIncrementCoinageCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _AutoIncrementCoinage.contract.Call(opts, out, "owner")
	return *ret0, err
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_AutoIncrementCoinage *AutoIncrementCoinageSession) Owner() (common.Address, error) {
	return _AutoIncrementCoinage.Contract.Owner(&_AutoIncrementCoinage.CallOpts)
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_AutoIncrementCoinage *AutoIncrementCoinageCallerSession) Owner() (common.Address, error) {
	return _AutoIncrementCoinage.Contract.Owner(&_AutoIncrementCoinage.CallOpts)
}

// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
//
// Solidity: function symbol() constant returns(string)
func (_AutoIncrementCoinage *AutoIncrementCoinageCaller) Symbol(opts *bind.CallOpts) (string, error) {
	var (
		ret0 = new(string)
	)
	out := ret0
	err := _AutoIncrementCoinage.contract.Call(opts, out, "symbol")
	return *ret0, err
}

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

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

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() constant returns(uint256)
func (_AutoIncrementCoinage *AutoIncrementCoinageCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinage.contract.Call(opts, out, "totalSupply")
	return *ret0, err
}

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

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

// TransfersEnabled is a free data retrieval call binding the contract method 0xbef97c87.
//
// Solidity: function transfersEnabled() constant returns(bool)
func (_AutoIncrementCoinage *AutoIncrementCoinageCaller) TransfersEnabled(opts *bind.CallOpts) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _AutoIncrementCoinage.contract.Call(opts, out, "transfersEnabled")
	return *ret0, err
}

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

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

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address spender, uint256 amount) returns(bool)
func (_AutoIncrementCoinage *AutoIncrementCoinageTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinage.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)
func (_AutoIncrementCoinage *AutoIncrementCoinageSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinage.Contract.Approve(&_AutoIncrementCoinage.TransactOpts, spender, amount)
}

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

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_AutoIncrementCoinage *AutoIncrementCoinageTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinage.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_AutoIncrementCoinage *AutoIncrementCoinageSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinage.Contract.DecreaseAllowance(&_AutoIncrementCoinage.TransactOpts, spender, subtractedValue)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_AutoIncrementCoinage *AutoIncrementCoinageTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinage.Contract.DecreaseAllowance(&_AutoIncrementCoinage.TransactOpts, spender, subtractedValue)
}

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

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

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

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_AutoIncrementCoinage *AutoIncrementCoinageTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinage.contract.Transact(opts, "increaseAllowance", spender, addedValue)
}

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_AutoIncrementCoinage *AutoIncrementCoinageSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinage.Contract.IncreaseAllowance(&_AutoIncrementCoinage.TransactOpts, spender, addedValue)
}

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_AutoIncrementCoinage *AutoIncrementCoinageTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinage.Contract.IncreaseAllowance(&_AutoIncrementCoinage.TransactOpts, spender, addedValue)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_AutoIncrementCoinage *AutoIncrementCoinageTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _AutoIncrementCoinage.contract.Transact(opts, "renounceOwnership")
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_AutoIncrementCoinage *AutoIncrementCoinageSession) RenounceOwnership() (*types.Transaction, error) {
	return _AutoIncrementCoinage.Contract.RenounceOwnership(&_AutoIncrementCoinage.TransactOpts)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_AutoIncrementCoinage *AutoIncrementCoinageTransactorSession) RenounceOwnership() (*types.Transaction, error) {
	return _AutoIncrementCoinage.Contract.RenounceOwnership(&_AutoIncrementCoinage.TransactOpts)
}

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

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

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

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_AutoIncrementCoinage *AutoIncrementCoinageTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinage.contract.Transact(opts, "transferFrom", sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_AutoIncrementCoinage *AutoIncrementCoinageSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinage.Contract.TransferFrom(&_AutoIncrementCoinage.TransactOpts, sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_AutoIncrementCoinage *AutoIncrementCoinageTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinage.Contract.TransferFrom(&_AutoIncrementCoinage.TransactOpts, sender, recipient, amount)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_AutoIncrementCoinage *AutoIncrementCoinageTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
	return _AutoIncrementCoinage.contract.Transact(opts, "transferOwnership", newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_AutoIncrementCoinage *AutoIncrementCoinageSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
	return _AutoIncrementCoinage.Contract.TransferOwnership(&_AutoIncrementCoinage.TransactOpts, newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_AutoIncrementCoinage *AutoIncrementCoinageTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
	return _AutoIncrementCoinage.Contract.TransferOwnership(&_AutoIncrementCoinage.TransactOpts, newOwner)
}

// AutoIncrementCoinageApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the AutoIncrementCoinage contract.
type AutoIncrementCoinageApprovalIterator struct {
	Event *AutoIncrementCoinageApproval // 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 *AutoIncrementCoinageApprovalIterator) 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(AutoIncrementCoinageApproval)
			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(AutoIncrementCoinageApproval)
		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 *AutoIncrementCoinageApprovalIterator) Error() error {
	return it.fail
}

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

// AutoIncrementCoinageApproval represents a Approval event raised by the AutoIncrementCoinage contract.
type AutoIncrementCoinageApproval 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 (_AutoIncrementCoinage *AutoIncrementCoinageFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*AutoIncrementCoinageApprovalIterator, 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 := _AutoIncrementCoinage.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
	if err != nil {
		return nil, err
	}
	return &AutoIncrementCoinageApprovalIterator{contract: _AutoIncrementCoinage.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 (_AutoIncrementCoinage *AutoIncrementCoinageFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *AutoIncrementCoinageApproval, 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 := _AutoIncrementCoinage.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(AutoIncrementCoinageApproval)
				if err := _AutoIncrementCoinage.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 (_AutoIncrementCoinage *AutoIncrementCoinageFilterer) ParseApproval(log types.Log) (*AutoIncrementCoinageApproval, error) {
	event := new(AutoIncrementCoinageApproval)
	if err := _AutoIncrementCoinage.contract.UnpackLog(event, "Approval", log); err != nil {
		return nil, err
	}
	return event, nil
}

// AutoIncrementCoinageFactorIncreasedIterator is returned from FilterFactorIncreased and is used to iterate over the raw logs and unpacked data for FactorIncreased events raised by the AutoIncrementCoinage contract.
type AutoIncrementCoinageFactorIncreasedIterator struct {
	Event *AutoIncrementCoinageFactorIncreased // 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 *AutoIncrementCoinageFactorIncreasedIterator) 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(AutoIncrementCoinageFactorIncreased)
			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(AutoIncrementCoinageFactorIncreased)
		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 *AutoIncrementCoinageFactorIncreasedIterator) Error() error {
	return it.fail
}

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

// AutoIncrementCoinageFactorIncreased represents a FactorIncreased event raised by the AutoIncrementCoinage contract.
type AutoIncrementCoinageFactorIncreased struct {
	Factor *big.Int
	Raw    types.Log // Blockchain specific contextual infos
}

// FilterFactorIncreased is a free log retrieval operation binding the contract event 0xe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb6.
//
// Solidity: event FactorIncreased(uint256 factor)
func (_AutoIncrementCoinage *AutoIncrementCoinageFilterer) FilterFactorIncreased(opts *bind.FilterOpts) (*AutoIncrementCoinageFactorIncreasedIterator, error) {

	logs, sub, err := _AutoIncrementCoinage.contract.FilterLogs(opts, "FactorIncreased")
	if err != nil {
		return nil, err
	}
	return &AutoIncrementCoinageFactorIncreasedIterator{contract: _AutoIncrementCoinage.contract, event: "FactorIncreased", logs: logs, sub: sub}, nil
}

// WatchFactorIncreased is a free log subscription operation binding the contract event 0xe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb6.
//
// Solidity: event FactorIncreased(uint256 factor)
func (_AutoIncrementCoinage *AutoIncrementCoinageFilterer) WatchFactorIncreased(opts *bind.WatchOpts, sink chan<- *AutoIncrementCoinageFactorIncreased) (event.Subscription, error) {

	logs, sub, err := _AutoIncrementCoinage.contract.WatchLogs(opts, "FactorIncreased")
	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(AutoIncrementCoinageFactorIncreased)
				if err := _AutoIncrementCoinage.contract.UnpackLog(event, "FactorIncreased", 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
}

// ParseFactorIncreased is a log parse operation binding the contract event 0xe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb6.
//
// Solidity: event FactorIncreased(uint256 factor)
func (_AutoIncrementCoinage *AutoIncrementCoinageFilterer) ParseFactorIncreased(log types.Log) (*AutoIncrementCoinageFactorIncreased, error) {
	event := new(AutoIncrementCoinageFactorIncreased)
	if err := _AutoIncrementCoinage.contract.UnpackLog(event, "FactorIncreased", log); err != nil {
		return nil, err
	}
	return event, nil
}

// AutoIncrementCoinageOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the AutoIncrementCoinage contract.
type AutoIncrementCoinageOwnershipTransferredIterator struct {
	Event *AutoIncrementCoinageOwnershipTransferred // 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 *AutoIncrementCoinageOwnershipTransferredIterator) 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(AutoIncrementCoinageOwnershipTransferred)
			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(AutoIncrementCoinageOwnershipTransferred)
		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 *AutoIncrementCoinageOwnershipTransferredIterator) Error() error {
	return it.fail
}

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

// AutoIncrementCoinageOwnershipTransferred represents a OwnershipTransferred event raised by the AutoIncrementCoinage contract.
type AutoIncrementCoinageOwnershipTransferred struct {
	PreviousOwner common.Address
	NewOwner      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_AutoIncrementCoinage *AutoIncrementCoinageFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*AutoIncrementCoinageOwnershipTransferredIterator, error) {

	var previousOwnerRule []interface{}
	for _, previousOwnerItem := range previousOwner {
		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
	}
	var newOwnerRule []interface{}
	for _, newOwnerItem := range newOwner {
		newOwnerRule = append(newOwnerRule, newOwnerItem)
	}

	logs, sub, err := _AutoIncrementCoinage.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
	if err != nil {
		return nil, err
	}
	return &AutoIncrementCoinageOwnershipTransferredIterator{contract: _AutoIncrementCoinage.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
}

// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_AutoIncrementCoinage *AutoIncrementCoinageFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *AutoIncrementCoinageOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {

	var previousOwnerRule []interface{}
	for _, previousOwnerItem := range previousOwner {
		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
	}
	var newOwnerRule []interface{}
	for _, newOwnerItem := range newOwner {
		newOwnerRule = append(newOwnerRule, newOwnerItem)
	}

	logs, sub, err := _AutoIncrementCoinage.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
	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(AutoIncrementCoinageOwnershipTransferred)
				if err := _AutoIncrementCoinage.contract.UnpackLog(event, "OwnershipTransferred", 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
}

// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_AutoIncrementCoinage *AutoIncrementCoinageFilterer) ParseOwnershipTransferred(log types.Log) (*AutoIncrementCoinageOwnershipTransferred, error) {
	event := new(AutoIncrementCoinageOwnershipTransferred)
	if err := _AutoIncrementCoinage.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
		return nil, err
	}
	return event, nil
}

// AutoIncrementCoinageTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the AutoIncrementCoinage contract.
type AutoIncrementCoinageTransferIterator struct {
	Event *AutoIncrementCoinageTransfer // 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 *AutoIncrementCoinageTransferIterator) 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(AutoIncrementCoinageTransfer)
			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(AutoIncrementCoinageTransfer)
		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 *AutoIncrementCoinageTransferIterator) Error() error {
	return it.fail
}

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

// AutoIncrementCoinageTransfer represents a Transfer event raised by the AutoIncrementCoinage contract.
type AutoIncrementCoinageTransfer 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 (_AutoIncrementCoinage *AutoIncrementCoinageFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*AutoIncrementCoinageTransferIterator, 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 := _AutoIncrementCoinage.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
	if err != nil {
		return nil, err
	}
	return &AutoIncrementCoinageTransferIterator{contract: _AutoIncrementCoinage.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 (_AutoIncrementCoinage *AutoIncrementCoinageFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *AutoIncrementCoinageTransfer, 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 := _AutoIncrementCoinage.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(AutoIncrementCoinageTransfer)
				if err := _AutoIncrementCoinage.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 (_AutoIncrementCoinage *AutoIncrementCoinageFilterer) ParseTransfer(log types.Log) (*AutoIncrementCoinageTransfer, error) {
	event := new(AutoIncrementCoinageTransfer)
	if err := _AutoIncrementCoinage.contract.UnpackLog(event, "Transfer", log); err != nil {
		return nil, err
	}
	return event, nil
}

// AutoIncrementCoinageMockABI is the input ABI used to generate the binding from.
const AutoIncrementCoinageMockABI = "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"factor\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"factorIncrement\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"transfersEnabled\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"factor\",\"type\":\"uint256\"}],\"name\":\"FactorIncreased\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterRemoved\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"addMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burnFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"bool\",\"name\":\"v\",\"type\":\"bool\"}],\"name\":\"enableTransfers\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"factor\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"factorIncrement\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isMinter\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"isOwner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"lastBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"transfersEnabled\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"

// AutoIncrementCoinageMockFuncSigs maps the 4-byte function signature to its string representation.
var AutoIncrementCoinageMockFuncSigs = map[string]string{
	"983b2d56": "addMinter(address)",
	"dd62ed3e": "allowance(address,address)",
	"095ea7b3": "approve(address,uint256)",
	"70a08231": "balanceOf(address)",
	"42966c68": "burn(uint256)",
	"79cc6790": "burnFrom(address,uint256)",
	"313ce567": "decimals()",
	"a457c2d7": "decreaseAllowance(address,uint256)",
	"f41e60c5": "enableTransfers(bool)",
	"54f703f8": "factor()",
	"d4132ee2": "factorIncrement()",
	"39509351": "increaseAllowance(address,uint256)",
	"aa271e1a": "isMinter(address)",
	"8f32d59b": "isOwner()",
	"806b984f": "lastBlock()",
	"40c10f19": "mint(address,uint256)",
	"06fdde03": "name()",
	"8da5cb5b": "owner()",
	"98650275": "renounceMinter()",
	"715018a6": "renounceOwnership()",
	"95d89b41": "symbol()",
	"18160ddd": "totalSupply()",
	"a9059cbb": "transfer(address,uint256)",
	"23b872dd": "transferFrom(address,address,uint256)",
	"f2fde38b": "transferOwnership(address)",
	"bef97c87": "transfersEnabled()",
}

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

// DeployAutoIncrementCoinageMock deploys a new Ethereum contract, binding an instance of AutoIncrementCoinageMock to it.
func DeployAutoIncrementCoinageMock(auth *bind.TransactOpts, backend bind.ContractBackend, name string, symbol string, factor *big.Int, factorIncrement *big.Int, transfersEnabled bool) (common.Address, *types.Transaction, *AutoIncrementCoinageMock, error) {
	parsed, err := abi.JSON(strings.NewReader(AutoIncrementCoinageMockABI))
	if err != nil {
		return common.Address{}, nil, nil, err
	}

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(AutoIncrementCoinageMockBin), backend, name, symbol, factor, factorIncrement, transfersEnabled)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &AutoIncrementCoinageMock{AutoIncrementCoinageMockCaller: AutoIncrementCoinageMockCaller{contract: contract}, AutoIncrementCoinageMockTransactor: AutoIncrementCoinageMockTransactor{contract: contract}, AutoIncrementCoinageMockFilterer: AutoIncrementCoinageMockFilterer{contract: contract}}, nil
}

// AutoIncrementCoinageMock is an auto generated Go binding around an Ethereum contract.
type AutoIncrementCoinageMock struct {
	AutoIncrementCoinageMockCaller     // Read-only binding to the contract
	AutoIncrementCoinageMockTransactor // Write-only binding to the contract
	AutoIncrementCoinageMockFilterer   // Log filterer for contract events
}

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

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

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

// AutoIncrementCoinageMockSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type AutoIncrementCoinageMockSession struct {
	Contract     *AutoIncrementCoinageMock // 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
}

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

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

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

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

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

// NewAutoIncrementCoinageMock creates a new instance of AutoIncrementCoinageMock, bound to a specific deployed contract.
func NewAutoIncrementCoinageMock(address common.Address, backend bind.ContractBackend) (*AutoIncrementCoinageMock, error) {
	contract, err := bindAutoIncrementCoinageMock(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &AutoIncrementCoinageMock{AutoIncrementCoinageMockCaller: AutoIncrementCoinageMockCaller{contract: contract}, AutoIncrementCoinageMockTransactor: AutoIncrementCoinageMockTransactor{contract: contract}, AutoIncrementCoinageMockFilterer: AutoIncrementCoinageMockFilterer{contract: contract}}, nil
}

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

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

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

// bindAutoIncrementCoinageMock binds a generic wrapper to an already deployed contract.
func bindAutoIncrementCoinageMock(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(AutoIncrementCoinageMockABI))
	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 (_AutoIncrementCoinageMock *AutoIncrementCoinageMockRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _AutoIncrementCoinageMock.Contract.AutoIncrementCoinageMockCaller.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 (_AutoIncrementCoinageMock *AutoIncrementCoinageMockRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.AutoIncrementCoinageMockTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.AutoIncrementCoinageMockTransactor.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 (_AutoIncrementCoinageMock *AutoIncrementCoinageMockCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _AutoIncrementCoinageMock.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 (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.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) constant returns(uint256)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinageMock.contract.Call(opts, out, "allowance", owner, spender)
	return *ret0, err
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _AutoIncrementCoinageMock.Contract.Allowance(&_AutoIncrementCoinageMock.CallOpts, owner, spender)
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _AutoIncrementCoinageMock.Contract.Allowance(&_AutoIncrementCoinageMock.CallOpts, owner, spender)
}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address account) constant returns(uint256)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinageMock.contract.Call(opts, out, "balanceOf", account)
	return *ret0, err
}

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

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

// Decimals is a free data retrieval call binding the contract method 0x313ce567.
//
// Solidity: function decimals() constant returns(uint8)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockCaller) Decimals(opts *bind.CallOpts) (uint8, error) {
	var (
		ret0 = new(uint8)
	)
	out := ret0
	err := _AutoIncrementCoinageMock.contract.Call(opts, out, "decimals")
	return *ret0, err
}

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

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

// Factor is a free data retrieval call binding the contract method 0x54f703f8.
//
// Solidity: function factor() constant returns(uint256)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockCaller) Factor(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinageMock.contract.Call(opts, out, "factor")
	return *ret0, err
}

// Factor is a free data retrieval call binding the contract method 0x54f703f8.
//
// Solidity: function factor() constant returns(uint256)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockSession) Factor() (*big.Int, error) {
	return _AutoIncrementCoinageMock.Contract.Factor(&_AutoIncrementCoinageMock.CallOpts)
}

// Factor is a free data retrieval call binding the contract method 0x54f703f8.
//
// Solidity: function factor() constant returns(uint256)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockCallerSession) Factor() (*big.Int, error) {
	return _AutoIncrementCoinageMock.Contract.Factor(&_AutoIncrementCoinageMock.CallOpts)
}

// FactorIncrement is a free data retrieval call binding the contract method 0xd4132ee2.
//
// Solidity: function factorIncrement() constant returns(uint256)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockCaller) FactorIncrement(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinageMock.contract.Call(opts, out, "factorIncrement")
	return *ret0, err
}

// FactorIncrement is a free data retrieval call binding the contract method 0xd4132ee2.
//
// Solidity: function factorIncrement() constant returns(uint256)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockSession) FactorIncrement() (*big.Int, error) {
	return _AutoIncrementCoinageMock.Contract.FactorIncrement(&_AutoIncrementCoinageMock.CallOpts)
}

// FactorIncrement is a free data retrieval call binding the contract method 0xd4132ee2.
//
// Solidity: function factorIncrement() constant returns(uint256)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockCallerSession) FactorIncrement() (*big.Int, error) {
	return _AutoIncrementCoinageMock.Contract.FactorIncrement(&_AutoIncrementCoinageMock.CallOpts)
}

// IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
//
// Solidity: function isMinter(address account) constant returns(bool)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _AutoIncrementCoinageMock.contract.Call(opts, out, "isMinter", account)
	return *ret0, err
}

// IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
//
// Solidity: function isMinter(address account) constant returns(bool)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockSession) IsMinter(account common.Address) (bool, error) {
	return _AutoIncrementCoinageMock.Contract.IsMinter(&_AutoIncrementCoinageMock.CallOpts, account)
}

// IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
//
// Solidity: function isMinter(address account) constant returns(bool)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockCallerSession) IsMinter(account common.Address) (bool, error) {
	return _AutoIncrementCoinageMock.Contract.IsMinter(&_AutoIncrementCoinageMock.CallOpts, account)
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockCaller) IsOwner(opts *bind.CallOpts) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _AutoIncrementCoinageMock.contract.Call(opts, out, "isOwner")
	return *ret0, err
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockSession) IsOwner() (bool, error) {
	return _AutoIncrementCoinageMock.Contract.IsOwner(&_AutoIncrementCoinageMock.CallOpts)
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockCallerSession) IsOwner() (bool, error) {
	return _AutoIncrementCoinageMock.Contract.IsOwner(&_AutoIncrementCoinageMock.CallOpts)
}

// LastBlock is a free data retrieval call binding the contract method 0x806b984f.
//
// Solidity: function lastBlock() constant returns(uint256)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockCaller) LastBlock(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinageMock.contract.Call(opts, out, "lastBlock")
	return *ret0, err
}

// LastBlock is a free data retrieval call binding the contract method 0x806b984f.
//
// Solidity: function lastBlock() constant returns(uint256)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockSession) LastBlock() (*big.Int, error) {
	return _AutoIncrementCoinageMock.Contract.LastBlock(&_AutoIncrementCoinageMock.CallOpts)
}

// LastBlock is a free data retrieval call binding the contract method 0x806b984f.
//
// Solidity: function lastBlock() constant returns(uint256)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockCallerSession) LastBlock() (*big.Int, error) {
	return _AutoIncrementCoinageMock.Contract.LastBlock(&_AutoIncrementCoinageMock.CallOpts)
}

// Name is a free data retrieval call binding the contract method 0x06fdde03.
//
// Solidity: function name() constant returns(string)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockCaller) Name(opts *bind.CallOpts) (string, error) {
	var (
		ret0 = new(string)
	)
	out := ret0
	err := _AutoIncrementCoinageMock.contract.Call(opts, out, "name")
	return *ret0, err
}

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

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

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _AutoIncrementCoinageMock.contract.Call(opts, out, "owner")
	return *ret0, err
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockSession) Owner() (common.Address, error) {
	return _AutoIncrementCoinageMock.Contract.Owner(&_AutoIncrementCoinageMock.CallOpts)
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockCallerSession) Owner() (common.Address, error) {
	return _AutoIncrementCoinageMock.Contract.Owner(&_AutoIncrementCoinageMock.CallOpts)
}

// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
//
// Solidity: function symbol() constant returns(string)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockCaller) Symbol(opts *bind.CallOpts) (string, error) {
	var (
		ret0 = new(string)
	)
	out := ret0
	err := _AutoIncrementCoinageMock.contract.Call(opts, out, "symbol")
	return *ret0, err
}

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

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

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() constant returns(uint256)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinageMock.contract.Call(opts, out, "totalSupply")
	return *ret0, err
}

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

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

// TransfersEnabled is a free data retrieval call binding the contract method 0xbef97c87.
//
// Solidity: function transfersEnabled() constant returns(bool)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockCaller) TransfersEnabled(opts *bind.CallOpts) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _AutoIncrementCoinageMock.contract.Call(opts, out, "transfersEnabled")
	return *ret0, err
}

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

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

// AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
//
// Solidity: function addMinter(address account) returns()
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.contract.Transact(opts, "addMinter", account)
}

// AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
//
// Solidity: function addMinter(address account) returns()
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockSession) AddMinter(account common.Address) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.AddMinter(&_AutoIncrementCoinageMock.TransactOpts, account)
}

// AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
//
// Solidity: function addMinter(address account) returns()
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactorSession) AddMinter(account common.Address) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.AddMinter(&_AutoIncrementCoinageMock.TransactOpts, account)
}

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address spender, uint256 amount) returns(bool)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.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)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.Approve(&_AutoIncrementCoinageMock.TransactOpts, spender, amount)
}

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

// Burn is a paid mutator transaction binding the contract method 0x42966c68.
//
// Solidity: function burn(uint256 amount) returns()
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactor) Burn(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.contract.Transact(opts, "burn", amount)
}

// Burn is a paid mutator transaction binding the contract method 0x42966c68.
//
// Solidity: function burn(uint256 amount) returns()
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockSession) Burn(amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.Burn(&_AutoIncrementCoinageMock.TransactOpts, amount)
}

// Burn is a paid mutator transaction binding the contract method 0x42966c68.
//
// Solidity: function burn(uint256 amount) returns()
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactorSession) Burn(amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.Burn(&_AutoIncrementCoinageMock.TransactOpts, amount)
}

// BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790.
//
// Solidity: function burnFrom(address account, uint256 amount) returns()
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactor) BurnFrom(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.contract.Transact(opts, "burnFrom", account, amount)
}

// BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790.
//
// Solidity: function burnFrom(address account, uint256 amount) returns()
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.BurnFrom(&_AutoIncrementCoinageMock.TransactOpts, account, amount)
}

// BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790.
//
// Solidity: function burnFrom(address account, uint256 amount) returns()
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactorSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.BurnFrom(&_AutoIncrementCoinageMock.TransactOpts, account, amount)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.DecreaseAllowance(&_AutoIncrementCoinageMock.TransactOpts, spender, subtractedValue)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.DecreaseAllowance(&_AutoIncrementCoinageMock.TransactOpts, spender, subtractedValue)
}

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

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

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

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.contract.Transact(opts, "increaseAllowance", spender, addedValue)
}

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.IncreaseAllowance(&_AutoIncrementCoinageMock.TransactOpts, spender, addedValue)
}

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.IncreaseAllowance(&_AutoIncrementCoinageMock.TransactOpts, spender, addedValue)
}

// Mint is a paid mutator transaction binding the contract method 0x40c10f19.
//
// Solidity: function mint(address account, uint256 amount) returns(bool)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactor) Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.contract.Transact(opts, "mint", account, amount)
}

// Mint is a paid mutator transaction binding the contract method 0x40c10f19.
//
// Solidity: function mint(address account, uint256 amount) returns(bool)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.Mint(&_AutoIncrementCoinageMock.TransactOpts, account, amount)
}

// Mint is a paid mutator transaction binding the contract method 0x40c10f19.
//
// Solidity: function mint(address account, uint256 amount) returns(bool)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactorSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.Mint(&_AutoIncrementCoinageMock.TransactOpts, account, amount)
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
//
// Solidity: function renounceMinter() returns()
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.contract.Transact(opts, "renounceMinter")
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
//
// Solidity: function renounceMinter() returns()
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockSession) RenounceMinter() (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.RenounceMinter(&_AutoIncrementCoinageMock.TransactOpts)
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
//
// Solidity: function renounceMinter() returns()
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactorSession) RenounceMinter() (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.RenounceMinter(&_AutoIncrementCoinageMock.TransactOpts)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.contract.Transact(opts, "renounceOwnership")
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockSession) RenounceOwnership() (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.RenounceOwnership(&_AutoIncrementCoinageMock.TransactOpts)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactorSession) RenounceOwnership() (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.RenounceOwnership(&_AutoIncrementCoinageMock.TransactOpts)
}

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

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

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

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.contract.Transact(opts, "transferFrom", sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.TransferFrom(&_AutoIncrementCoinageMock.TransactOpts, sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.TransferFrom(&_AutoIncrementCoinageMock.TransactOpts, sender, recipient, amount)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.contract.Transact(opts, "transferOwnership", newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.TransferOwnership(&_AutoIncrementCoinageMock.TransactOpts, newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
	return _AutoIncrementCoinageMock.Contract.TransferOwnership(&_AutoIncrementCoinageMock.TransactOpts, newOwner)
}

// AutoIncrementCoinageMockApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the AutoIncrementCoinageMock contract.
type AutoIncrementCoinageMockApprovalIterator struct {
	Event *AutoIncrementCoinageMockApproval // 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 *AutoIncrementCoinageMockApprovalIterator) 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(AutoIncrementCoinageMockApproval)
			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(AutoIncrementCoinageMockApproval)
		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 *AutoIncrementCoinageMockApprovalIterator) Error() error {
	return it.fail
}

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

// AutoIncrementCoinageMockApproval represents a Approval event raised by the AutoIncrementCoinageMock contract.
type AutoIncrementCoinageMockApproval 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 (_AutoIncrementCoinageMock *AutoIncrementCoinageMockFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*AutoIncrementCoinageMockApprovalIterator, 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 := _AutoIncrementCoinageMock.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
	if err != nil {
		return nil, err
	}
	return &AutoIncrementCoinageMockApprovalIterator{contract: _AutoIncrementCoinageMock.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 (_AutoIncrementCoinageMock *AutoIncrementCoinageMockFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *AutoIncrementCoinageMockApproval, 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 := _AutoIncrementCoinageMock.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(AutoIncrementCoinageMockApproval)
				if err := _AutoIncrementCoinageMock.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 (_AutoIncrementCoinageMock *AutoIncrementCoinageMockFilterer) ParseApproval(log types.Log) (*AutoIncrementCoinageMockApproval, error) {
	event := new(AutoIncrementCoinageMockApproval)
	if err := _AutoIncrementCoinageMock.contract.UnpackLog(event, "Approval", log); err != nil {
		return nil, err
	}
	return event, nil
}

// AutoIncrementCoinageMockFactorIncreasedIterator is returned from FilterFactorIncreased and is used to iterate over the raw logs and unpacked data for FactorIncreased events raised by the AutoIncrementCoinageMock contract.
type AutoIncrementCoinageMockFactorIncreasedIterator struct {
	Event *AutoIncrementCoinageMockFactorIncreased // 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 *AutoIncrementCoinageMockFactorIncreasedIterator) 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(AutoIncrementCoinageMockFactorIncreased)
			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(AutoIncrementCoinageMockFactorIncreased)
		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 *AutoIncrementCoinageMockFactorIncreasedIterator) Error() error {
	return it.fail
}

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

// AutoIncrementCoinageMockFactorIncreased represents a FactorIncreased event raised by the AutoIncrementCoinageMock contract.
type AutoIncrementCoinageMockFactorIncreased struct {
	Factor *big.Int
	Raw    types.Log // Blockchain specific contextual infos
}

// FilterFactorIncreased is a free log retrieval operation binding the contract event 0xe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb6.
//
// Solidity: event FactorIncreased(uint256 factor)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockFilterer) FilterFactorIncreased(opts *bind.FilterOpts) (*AutoIncrementCoinageMockFactorIncreasedIterator, error) {

	logs, sub, err := _AutoIncrementCoinageMock.contract.FilterLogs(opts, "FactorIncreased")
	if err != nil {
		return nil, err
	}
	return &AutoIncrementCoinageMockFactorIncreasedIterator{contract: _AutoIncrementCoinageMock.contract, event: "FactorIncreased", logs: logs, sub: sub}, nil
}

// WatchFactorIncreased is a free log subscription operation binding the contract event 0xe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb6.
//
// Solidity: event FactorIncreased(uint256 factor)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockFilterer) WatchFactorIncreased(opts *bind.WatchOpts, sink chan<- *AutoIncrementCoinageMockFactorIncreased) (event.Subscription, error) {

	logs, sub, err := _AutoIncrementCoinageMock.contract.WatchLogs(opts, "FactorIncreased")
	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(AutoIncrementCoinageMockFactorIncreased)
				if err := _AutoIncrementCoinageMock.contract.UnpackLog(event, "FactorIncreased", 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
}

// ParseFactorIncreased is a log parse operation binding the contract event 0xe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb6.
//
// Solidity: event FactorIncreased(uint256 factor)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockFilterer) ParseFactorIncreased(log types.Log) (*AutoIncrementCoinageMockFactorIncreased, error) {
	event := new(AutoIncrementCoinageMockFactorIncreased)
	if err := _AutoIncrementCoinageMock.contract.UnpackLog(event, "FactorIncreased", log); err != nil {
		return nil, err
	}
	return event, nil
}

// AutoIncrementCoinageMockMinterAddedIterator is returned from FilterMinterAdded and is used to iterate over the raw logs and unpacked data for MinterAdded events raised by the AutoIncrementCoinageMock contract.
type AutoIncrementCoinageMockMinterAddedIterator struct {
	Event *AutoIncrementCoinageMockMinterAdded // 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 *AutoIncrementCoinageMockMinterAddedIterator) 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(AutoIncrementCoinageMockMinterAdded)
			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(AutoIncrementCoinageMockMinterAdded)
		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 *AutoIncrementCoinageMockMinterAddedIterator) Error() error {
	return it.fail
}

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

// AutoIncrementCoinageMockMinterAdded represents a MinterAdded event raised by the AutoIncrementCoinageMock contract.
type AutoIncrementCoinageMockMinterAdded struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterMinterAdded is a free log retrieval operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
//
// Solidity: event MinterAdded(address indexed account)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*AutoIncrementCoinageMockMinterAddedIterator, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _AutoIncrementCoinageMock.contract.FilterLogs(opts, "MinterAdded", accountRule)
	if err != nil {
		return nil, err
	}
	return &AutoIncrementCoinageMockMinterAddedIterator{contract: _AutoIncrementCoinageMock.contract, event: "MinterAdded", logs: logs, sub: sub}, nil
}

// WatchMinterAdded is a free log subscription operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
//
// Solidity: event MinterAdded(address indexed account)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *AutoIncrementCoinageMockMinterAdded, account []common.Address) (event.Subscription, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _AutoIncrementCoinageMock.contract.WatchLogs(opts, "MinterAdded", accountRule)
	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(AutoIncrementCoinageMockMinterAdded)
				if err := _AutoIncrementCoinageMock.contract.UnpackLog(event, "MinterAdded", 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
}

// ParseMinterAdded is a log parse operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
//
// Solidity: event MinterAdded(address indexed account)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockFilterer) ParseMinterAdded(log types.Log) (*AutoIncrementCoinageMockMinterAdded, error) {
	event := new(AutoIncrementCoinageMockMinterAdded)
	if err := _AutoIncrementCoinageMock.contract.UnpackLog(event, "MinterAdded", log); err != nil {
		return nil, err
	}
	return event, nil
}

// AutoIncrementCoinageMockMinterRemovedIterator is returned from FilterMinterRemoved and is used to iterate over the raw logs and unpacked data for MinterRemoved events raised by the AutoIncrementCoinageMock contract.
type AutoIncrementCoinageMockMinterRemovedIterator struct {
	Event *AutoIncrementCoinageMockMinterRemoved // 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 *AutoIncrementCoinageMockMinterRemovedIterator) 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(AutoIncrementCoinageMockMinterRemoved)
			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(AutoIncrementCoinageMockMinterRemoved)
		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 *AutoIncrementCoinageMockMinterRemovedIterator) Error() error {
	return it.fail
}

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

// AutoIncrementCoinageMockMinterRemoved represents a MinterRemoved event raised by the AutoIncrementCoinageMock contract.
type AutoIncrementCoinageMockMinterRemoved struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterMinterRemoved is a free log retrieval operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
//
// Solidity: event MinterRemoved(address indexed account)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*AutoIncrementCoinageMockMinterRemovedIterator, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _AutoIncrementCoinageMock.contract.FilterLogs(opts, "MinterRemoved", accountRule)
	if err != nil {
		return nil, err
	}
	return &AutoIncrementCoinageMockMinterRemovedIterator{contract: _AutoIncrementCoinageMock.contract, event: "MinterRemoved", logs: logs, sub: sub}, nil
}

// WatchMinterRemoved is a free log subscription operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
//
// Solidity: event MinterRemoved(address indexed account)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *AutoIncrementCoinageMockMinterRemoved, account []common.Address) (event.Subscription, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _AutoIncrementCoinageMock.contract.WatchLogs(opts, "MinterRemoved", accountRule)
	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(AutoIncrementCoinageMockMinterRemoved)
				if err := _AutoIncrementCoinageMock.contract.UnpackLog(event, "MinterRemoved", 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
}

// ParseMinterRemoved is a log parse operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
//
// Solidity: event MinterRemoved(address indexed account)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockFilterer) ParseMinterRemoved(log types.Log) (*AutoIncrementCoinageMockMinterRemoved, error) {
	event := new(AutoIncrementCoinageMockMinterRemoved)
	if err := _AutoIncrementCoinageMock.contract.UnpackLog(event, "MinterRemoved", log); err != nil {
		return nil, err
	}
	return event, nil
}

// AutoIncrementCoinageMockOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the AutoIncrementCoinageMock contract.
type AutoIncrementCoinageMockOwnershipTransferredIterator struct {
	Event *AutoIncrementCoinageMockOwnershipTransferred // 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 *AutoIncrementCoinageMockOwnershipTransferredIterator) 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(AutoIncrementCoinageMockOwnershipTransferred)
			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(AutoIncrementCoinageMockOwnershipTransferred)
		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 *AutoIncrementCoinageMockOwnershipTransferredIterator) Error() error {
	return it.fail
}

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

// AutoIncrementCoinageMockOwnershipTransferred represents a OwnershipTransferred event raised by the AutoIncrementCoinageMock contract.
type AutoIncrementCoinageMockOwnershipTransferred struct {
	PreviousOwner common.Address
	NewOwner      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*AutoIncrementCoinageMockOwnershipTransferredIterator, error) {

	var previousOwnerRule []interface{}
	for _, previousOwnerItem := range previousOwner {
		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
	}
	var newOwnerRule []interface{}
	for _, newOwnerItem := range newOwner {
		newOwnerRule = append(newOwnerRule, newOwnerItem)
	}

	logs, sub, err := _AutoIncrementCoinageMock.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
	if err != nil {
		return nil, err
	}
	return &AutoIncrementCoinageMockOwnershipTransferredIterator{contract: _AutoIncrementCoinageMock.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
}

// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *AutoIncrementCoinageMockOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {

	var previousOwnerRule []interface{}
	for _, previousOwnerItem := range previousOwner {
		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
	}
	var newOwnerRule []interface{}
	for _, newOwnerItem := range newOwner {
		newOwnerRule = append(newOwnerRule, newOwnerItem)
	}

	logs, sub, err := _AutoIncrementCoinageMock.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
	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(AutoIncrementCoinageMockOwnershipTransferred)
				if err := _AutoIncrementCoinageMock.contract.UnpackLog(event, "OwnershipTransferred", 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
}

// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_AutoIncrementCoinageMock *AutoIncrementCoinageMockFilterer) ParseOwnershipTransferred(log types.Log) (*AutoIncrementCoinageMockOwnershipTransferred, error) {
	event := new(AutoIncrementCoinageMockOwnershipTransferred)
	if err := _AutoIncrementCoinageMock.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
		return nil, err
	}
	return event, nil
}

// AutoIncrementCoinageMockTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the AutoIncrementCoinageMock contract.
type AutoIncrementCoinageMockTransferIterator struct {
	Event *AutoIncrementCoinageMockTransfer // 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 *AutoIncrementCoinageMockTransferIterator) 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(AutoIncrementCoinageMockTransfer)
			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(AutoIncrementCoinageMockTransfer)
		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 *AutoIncrementCoinageMockTransferIterator) Error() error {
	return it.fail
}

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

// AutoIncrementCoinageMockTransfer represents a Transfer event raised by the AutoIncrementCoinageMock contract.
type AutoIncrementCoinageMockTransfer 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 (_AutoIncrementCoinageMock *AutoIncrementCoinageMockFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*AutoIncrementCoinageMockTransferIterator, 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 := _AutoIncrementCoinageMock.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
	if err != nil {
		return nil, err
	}
	return &AutoIncrementCoinageMockTransferIterator{contract: _AutoIncrementCoinageMock.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 (_AutoIncrementCoinageMock *AutoIncrementCoinageMockFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *AutoIncrementCoinageMockTransfer, 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 := _AutoIncrementCoinageMock.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(AutoIncrementCoinageMockTransfer)
				if err := _AutoIncrementCoinageMock.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 (_AutoIncrementCoinageMock *AutoIncrementCoinageMockFilterer) ParseTransfer(log types.Log) (*AutoIncrementCoinageMockTransfer, error) {
	event := new(AutoIncrementCoinageMockTransfer)
	if err := _AutoIncrementCoinageMock.contract.UnpackLog(event, "Transfer", log); err != nil {
		return nil, err
	}
	return event, nil
}

// AutoIncrementCoinageSnapshotABI is the input ABI used to generate the binding from.
const AutoIncrementCoinageSnapshotABI = "[{\"inputs\":[{\"internalType\":\"addresspayable\",\"name\":\"_tokenFactory\",\"type\":\"address\"},{\"internalType\":\"addresspayable\",\"name\":\"_parentToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_parentSnapShotBlock\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"_tokenName\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"_tokenSymbol\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"_factor\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_factorIncrement\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"_transfersEnabled\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"controller\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"ClaimedTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"factor\",\"type\":\"uint256\"}],\"name\":\"FactorIncreased\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"cloneToken\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"snapshotBlock\",\"type\":\"uint256\"}],\"name\":\"NewCloneToken\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"payable\":true,\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"remaining\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"_extraData\",\"type\":\"bytes\"}],\"name\":\"approveAndCall\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"balance\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_blockNumber\",\"type\":\"uint256\"}],\"name\":\"balanceOfAt\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_blockNumber\",\"type\":\"uint256\"}],\"name\":\"basedBalanceOfAt\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_blockNumber\",\"type\":\"uint256\"}],\"name\":\"basedTotalSupplyAt\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"addresspayable\",\"name\":\"_newController\",\"type\":\"address\"}],\"name\":\"changeController\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"addresspayable\",\"name\":\"_token\",\"type\":\"address\"}],\"name\":\"claimTokens\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"controller\",\"outputs\":[{\"internalType\":\"addresspayable\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"string\",\"name\":\"_cloneTokenName\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"_cloneTokenSymbol\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"_factor\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_factorIncrement\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_snapshotBlock\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"_transfersEnabled\",\"type\":\"bool\"}],\"name\":\"createCloneToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"creationBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"defaultFactor\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"destroyTokens\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"bool\",\"name\":\"_transfersEnabled\",\"type\":\"bool\"}],\"name\":\"enableTransfers\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"factor\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_blockNumber\",\"type\":\"uint256\"}],\"name\":\"factorAt\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"factorIncrement\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"generateTokens\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"parentSnapShotBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"parentToken\",\"outputs\":[{\"internalType\":\"contractAutoIncrementCoinageSnapshot\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"tokenFactory\",\"outputs\":[{\"internalType\":\"contractAutoIncrementCoinageSnapshotFactory\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_blockNumber\",\"type\":\"uint256\"}],\"name\":\"totalSupplyAt\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"transfersEnabled\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"version\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"

// AutoIncrementCoinageSnapshotFuncSigs maps the 4-byte function signature to its string representation.
var AutoIncrementCoinageSnapshotFuncSigs = map[string]string{
	"dd62ed3e": "allowance(address,address)",
	"095ea7b3": "approve(address,uint256)",
	"cae9ca51": "approveAndCall(address,uint256,bytes)",
	"70a08231": "balanceOf(address)",
	"4ee2cd7e": "balanceOfAt(address,uint256)",
	"ab1e8543": "basedBalanceOfAt(address,uint256)",
	"11b38ebb": "basedTotalSupplyAt(uint256)",
	"3cebb823": "changeController(address)",
	"df8de3e7": "claimTokens(address)",
	"f77c4791": "controller()",
	"6c634905": "createCloneToken(string,string,uint256,uint256,uint256,bool)",
	"17634514": "creationBlock()",
	"313ce567": "decimals()",
	"2c6add4b": "defaultFactor()",
	"d3ce77fe": "destroyTokens(address,uint256)",
	"f41e60c5": "enableTransfers(bool)",
	"54f703f8": "factor()",
	"713a4965": "factorAt(uint256)",
	"d4132ee2": "factorIncrement()",
	"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()",
}

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

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

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(AutoIncrementCoinageSnapshotBin), backend, _tokenFactory, _parentToken, _parentSnapShotBlock, _tokenName, _tokenSymbol, _factor, _factorIncrement, _transfersEnabled)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &AutoIncrementCoinageSnapshot{AutoIncrementCoinageSnapshotCaller: AutoIncrementCoinageSnapshotCaller{contract: contract}, AutoIncrementCoinageSnapshotTransactor: AutoIncrementCoinageSnapshotTransactor{contract: contract}, AutoIncrementCoinageSnapshotFilterer: AutoIncrementCoinageSnapshotFilterer{contract: contract}}, nil
}

// AutoIncrementCoinageSnapshot is an auto generated Go binding around an Ethereum contract.
type AutoIncrementCoinageSnapshot struct {
	AutoIncrementCoinageSnapshotCaller     // Read-only binding to the contract
	AutoIncrementCoinageSnapshotTransactor // Write-only binding to the contract
	AutoIncrementCoinageSnapshotFilterer   // Log filterer for contract events
}

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

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

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

// AutoIncrementCoinageSnapshotSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type AutoIncrementCoinageSnapshotSession struct {
	Contract     *AutoIncrementCoinageSnapshot // 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
}

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

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

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

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

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

// NewAutoIncrementCoinageSnapshot creates a new instance of AutoIncrementCoinageSnapshot, bound to a specific deployed contract.
func NewAutoIncrementCoinageSnapshot(address common.Address, backend bind.ContractBackend) (*AutoIncrementCoinageSnapshot, error) {
	contract, err := bindAutoIncrementCoinageSnapshot(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &AutoIncrementCoinageSnapshot{AutoIncrementCoinageSnapshotCaller: AutoIncrementCoinageSnapshotCaller{contract: contract}, AutoIncrementCoinageSnapshotTransactor: AutoIncrementCoinageSnapshotTransactor{contract: contract}, AutoIncrementCoinageSnapshotFilterer: AutoIncrementCoinageSnapshotFilterer{contract: contract}}, nil
}

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

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

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

// bindAutoIncrementCoinageSnapshot binds a generic wrapper to an already deployed contract.
func bindAutoIncrementCoinageSnapshot(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(AutoIncrementCoinageSnapshotABI))
	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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _AutoIncrementCoinageSnapshot.Contract.AutoIncrementCoinageSnapshotCaller.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshot.Contract.AutoIncrementCoinageSnapshotTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshot.Contract.AutoIncrementCoinageSnapshotTransactor.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _AutoIncrementCoinageSnapshot.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshot.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshot.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) constant returns(uint256 remaining)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCaller) Allowance(opts *bind.CallOpts, _owner common.Address, _spender common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinageSnapshot.contract.Call(opts, out, "allowance", _owner, _spender)
	return *ret0, err
}

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

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

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address _owner) constant returns(uint256 balance)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCaller) BalanceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinageSnapshot.contract.Call(opts, out, "balanceOf", _owner)
	return *ret0, err
}

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

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

// BalanceOfAt is a free data retrieval call binding the contract method 0x4ee2cd7e.
//
// Solidity: function balanceOfAt(address _owner, uint256 _blockNumber) constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCaller) BalanceOfAt(opts *bind.CallOpts, _owner common.Address, _blockNumber *big.Int) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinageSnapshot.contract.Call(opts, out, "balanceOfAt", _owner, _blockNumber)
	return *ret0, err
}

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

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

// BasedBalanceOfAt is a free data retrieval call binding the contract method 0xab1e8543.
//
// Solidity: function basedBalanceOfAt(address _owner, uint256 _blockNumber) constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCaller) BasedBalanceOfAt(opts *bind.CallOpts, _owner common.Address, _blockNumber *big.Int) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinageSnapshot.contract.Call(opts, out, "basedBalanceOfAt", _owner, _blockNumber)
	return *ret0, err
}

// BasedBalanceOfAt is a free data retrieval call binding the contract method 0xab1e8543.
//
// Solidity: function basedBalanceOfAt(address _owner, uint256 _blockNumber) constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotSession) BasedBalanceOfAt(_owner common.Address, _blockNumber *big.Int) (*big.Int, error) {
	return _AutoIncrementCoinageSnapshot.Contract.BasedBalanceOfAt(&_AutoIncrementCoinageSnapshot.CallOpts, _owner, _blockNumber)
}

// BasedBalanceOfAt is a free data retrieval call binding the contract method 0xab1e8543.
//
// Solidity: function basedBalanceOfAt(address _owner, uint256 _blockNumber) constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCallerSession) BasedBalanceOfAt(_owner common.Address, _blockNumber *big.Int) (*big.Int, error) {
	return _AutoIncrementCoinageSnapshot.Contract.BasedBalanceOfAt(&_AutoIncrementCoinageSnapshot.CallOpts, _owner, _blockNumber)
}

// BasedTotalSupplyAt is a free data retrieval call binding the contract method 0x11b38ebb.
//
// Solidity: function basedTotalSupplyAt(uint256 _blockNumber) constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCaller) BasedTotalSupplyAt(opts *bind.CallOpts, _blockNumber *big.Int) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinageSnapshot.contract.Call(opts, out, "basedTotalSupplyAt", _blockNumber)
	return *ret0, err
}

// BasedTotalSupplyAt is a free data retrieval call binding the contract method 0x11b38ebb.
//
// Solidity: function basedTotalSupplyAt(uint256 _blockNumber) constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotSession) BasedTotalSupplyAt(_blockNumber *big.Int) (*big.Int, error) {
	return _AutoIncrementCoinageSnapshot.Contract.BasedTotalSupplyAt(&_AutoIncrementCoinageSnapshot.CallOpts, _blockNumber)
}

// BasedTotalSupplyAt is a free data retrieval call binding the contract method 0x11b38ebb.
//
// Solidity: function basedTotalSupplyAt(uint256 _blockNumber) constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCallerSession) BasedTotalSupplyAt(_blockNumber *big.Int) (*big.Int, error) {
	return _AutoIncrementCoinageSnapshot.Contract.BasedTotalSupplyAt(&_AutoIncrementCoinageSnapshot.CallOpts, _blockNumber)
}

// Controller is a free data retrieval call binding the contract method 0xf77c4791.
//
// Solidity: function controller() constant returns(address)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCaller) Controller(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _AutoIncrementCoinageSnapshot.contract.Call(opts, out, "controller")
	return *ret0, err
}

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

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

// CreationBlock is a free data retrieval call binding the contract method 0x17634514.
//
// Solidity: function creationBlock() constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCaller) CreationBlock(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinageSnapshot.contract.Call(opts, out, "creationBlock")
	return *ret0, err
}

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

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

// Decimals is a free data retrieval call binding the contract method 0x313ce567.
//
// Solidity: function decimals() constant returns(uint8)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCaller) Decimals(opts *bind.CallOpts) (uint8, error) {
	var (
		ret0 = new(uint8)
	)
	out := ret0
	err := _AutoIncrementCoinageSnapshot.contract.Call(opts, out, "decimals")
	return *ret0, err
}

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

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

// DefaultFactor is a free data retrieval call binding the contract method 0x2c6add4b.
//
// Solidity: function defaultFactor() constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCaller) DefaultFactor(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinageSnapshot.contract.Call(opts, out, "defaultFactor")
	return *ret0, err
}

// DefaultFactor is a free data retrieval call binding the contract method 0x2c6add4b.
//
// Solidity: function defaultFactor() constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotSession) DefaultFactor() (*big.Int, error) {
	return _AutoIncrementCoinageSnapshot.Contract.DefaultFactor(&_AutoIncrementCoinageSnapshot.CallOpts)
}

// DefaultFactor is a free data retrieval call binding the contract method 0x2c6add4b.
//
// Solidity: function defaultFactor() constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCallerSession) DefaultFactor() (*big.Int, error) {
	return _AutoIncrementCoinageSnapshot.Contract.DefaultFactor(&_AutoIncrementCoinageSnapshot.CallOpts)
}

// Factor is a free data retrieval call binding the contract method 0x54f703f8.
//
// Solidity: function factor() constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCaller) Factor(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinageSnapshot.contract.Call(opts, out, "factor")
	return *ret0, err
}

// Factor is a free data retrieval call binding the contract method 0x54f703f8.
//
// Solidity: function factor() constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotSession) Factor() (*big.Int, error) {
	return _AutoIncrementCoinageSnapshot.Contract.Factor(&_AutoIncrementCoinageSnapshot.CallOpts)
}

// Factor is a free data retrieval call binding the contract method 0x54f703f8.
//
// Solidity: function factor() constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCallerSession) Factor() (*big.Int, error) {
	return _AutoIncrementCoinageSnapshot.Contract.Factor(&_AutoIncrementCoinageSnapshot.CallOpts)
}

// FactorAt is a free data retrieval call binding the contract method 0x713a4965.
//
// Solidity: function factorAt(uint256 _blockNumber) constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCaller) FactorAt(opts *bind.CallOpts, _blockNumber *big.Int) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinageSnapshot.contract.Call(opts, out, "factorAt", _blockNumber)
	return *ret0, err
}

// FactorAt is a free data retrieval call binding the contract method 0x713a4965.
//
// Solidity: function factorAt(uint256 _blockNumber) constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotSession) FactorAt(_blockNumber *big.Int) (*big.Int, error) {
	return _AutoIncrementCoinageSnapshot.Contract.FactorAt(&_AutoIncrementCoinageSnapshot.CallOpts, _blockNumber)
}

// FactorAt is a free data retrieval call binding the contract method 0x713a4965.
//
// Solidity: function factorAt(uint256 _blockNumber) constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCallerSession) FactorAt(_blockNumber *big.Int) (*big.Int, error) {
	return _AutoIncrementCoinageSnapshot.Contract.FactorAt(&_AutoIncrementCoinageSnapshot.CallOpts, _blockNumber)
}

// FactorIncrement is a free data retrieval call binding the contract method 0xd4132ee2.
//
// Solidity: function factorIncrement() constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCaller) FactorIncrement(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinageSnapshot.contract.Call(opts, out, "factorIncrement")
	return *ret0, err
}

// FactorIncrement is a free data retrieval call binding the contract method 0xd4132ee2.
//
// Solidity: function factorIncrement() constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotSession) FactorIncrement() (*big.Int, error) {
	return _AutoIncrementCoinageSnapshot.Contract.FactorIncrement(&_AutoIncrementCoinageSnapshot.CallOpts)
}

// FactorIncrement is a free data retrieval call binding the contract method 0xd4132ee2.
//
// Solidity: function factorIncrement() constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCallerSession) FactorIncrement() (*big.Int, error) {
	return _AutoIncrementCoinageSnapshot.Contract.FactorIncrement(&_AutoIncrementCoinageSnapshot.CallOpts)
}

// Name is a free data retrieval call binding the contract method 0x06fdde03.
//
// Solidity: function name() constant returns(string)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCaller) Name(opts *bind.CallOpts) (string, error) {
	var (
		ret0 = new(string)
	)
	out := ret0
	err := _AutoIncrementCoinageSnapshot.contract.Call(opts, out, "name")
	return *ret0, err
}

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

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

// ParentSnapShotBlock is a free data retrieval call binding the contract method 0xc5bcc4f1.
//
// Solidity: function parentSnapShotBlock() constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCaller) ParentSnapShotBlock(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinageSnapshot.contract.Call(opts, out, "parentSnapShotBlock")
	return *ret0, err
}

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

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

// ParentToken is a free data retrieval call binding the contract method 0x80a54001.
//
// Solidity: function parentToken() constant returns(address)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCaller) ParentToken(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _AutoIncrementCoinageSnapshot.contract.Call(opts, out, "parentToken")
	return *ret0, err
}

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

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

// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
//
// Solidity: function symbol() constant returns(string)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCaller) Symbol(opts *bind.CallOpts) (string, error) {
	var (
		ret0 = new(string)
	)
	out := ret0
	err := _AutoIncrementCoinageSnapshot.contract.Call(opts, out, "symbol")
	return *ret0, err
}

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

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

// TokenFactory is a free data retrieval call binding the contract method 0xe77772fe.
//
// Solidity: function tokenFactory() constant returns(address)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCaller) TokenFactory(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _AutoIncrementCoinageSnapshot.contract.Call(opts, out, "tokenFactory")
	return *ret0, err
}

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

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

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinageSnapshot.contract.Call(opts, out, "totalSupply")
	return *ret0, err
}

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

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

// TotalSupplyAt is a free data retrieval call binding the contract method 0x981b24d0.
//
// Solidity: function totalSupplyAt(uint256 _blockNumber) constant returns(uint256)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCaller) TotalSupplyAt(opts *bind.CallOpts, _blockNumber *big.Int) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _AutoIncrementCoinageSnapshot.contract.Call(opts, out, "totalSupplyAt", _blockNumber)
	return *ret0, err
}

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

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

// TransfersEnabled is a free data retrieval call binding the contract method 0xbef97c87.
//
// Solidity: function transfersEnabled() constant returns(bool)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCaller) TransfersEnabled(opts *bind.CallOpts) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _AutoIncrementCoinageSnapshot.contract.Call(opts, out, "transfersEnabled")
	return *ret0, err
}

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

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

// Version is a free data retrieval call binding the contract method 0x54fd4d50.
//
// Solidity: function version() constant returns(string)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotCaller) Version(opts *bind.CallOpts) (string, error) {
	var (
		ret0 = new(string)
	)
	out := ret0
	err := _AutoIncrementCoinageSnapshot.contract.Call(opts, out, "version")
	return *ret0, err
}

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

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

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address _spender, uint256 _amount) returns(bool success)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotTransactor) Approve(opts *bind.TransactOpts, _spender common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshot.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotSession) Approve(_spender common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshot.Contract.Approve(&_AutoIncrementCoinageSnapshot.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotTransactorSession) Approve(_spender common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshot.Contract.Approve(&_AutoIncrementCoinageSnapshot.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotTransactor) ApproveAndCall(opts *bind.TransactOpts, _spender common.Address, _amount *big.Int, _extraData []byte) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshot.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotSession) ApproveAndCall(_spender common.Address, _amount *big.Int, _extraData []byte) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshot.Contract.ApproveAndCall(&_AutoIncrementCoinageSnapshot.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotTransactorSession) ApproveAndCall(_spender common.Address, _amount *big.Int, _extraData []byte) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshot.Contract.ApproveAndCall(&_AutoIncrementCoinageSnapshot.TransactOpts, _spender, _amount, _extraData)
}

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

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

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

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

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

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

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

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

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

// DestroyTokens is a paid mutator transaction binding the contract method 0xd3ce77fe.
//
// Solidity: function destroyTokens(address _owner, uint256 _amount) returns(bool)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotTransactor) DestroyTokens(opts *bind.TransactOpts, _owner common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshot.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotSession) DestroyTokens(_owner common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshot.Contract.DestroyTokens(&_AutoIncrementCoinageSnapshot.TransactOpts, _owner, _amount)
}

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

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

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

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

// GenerateTokens is a paid mutator transaction binding the contract method 0x827f32c0.
//
// Solidity: function generateTokens(address _owner, uint256 _amount) returns(bool)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotTransactor) GenerateTokens(opts *bind.TransactOpts, _owner common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshot.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotSession) GenerateTokens(_owner common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshot.Contract.GenerateTokens(&_AutoIncrementCoinageSnapshot.TransactOpts, _owner, _amount)
}

// GenerateTokens is a paid mutator transaction binding the contract method 0x827f32c0.
//
// Solidity: function generateTokens(address _owner, uint256 _amount) returns(bool)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotTransactorSession) GenerateTokens(_owner common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshot.Contract.GenerateTokens(&_AutoIncrementCoinageSnapshot.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshot.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotSession) Transfer(_to common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshot.Contract.Transfer(&_AutoIncrementCoinageSnapshot.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotTransactorSession) Transfer(_to common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshot.Contract.Transfer(&_AutoIncrementCoinageSnapshot.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotTransactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshot.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotSession) TransferFrom(_from common.Address, _to common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshot.Contract.TransferFrom(&_AutoIncrementCoinageSnapshot.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotTransactorSession) TransferFrom(_from common.Address, _to common.Address, _amount *big.Int) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshot.Contract.TransferFrom(&_AutoIncrementCoinageSnapshot.TransactOpts, _from, _to, _amount)
}

// AutoIncrementCoinageSnapshotApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the AutoIncrementCoinageSnapshot contract.
type AutoIncrementCoinageSnapshotApprovalIterator struct {
	Event *AutoIncrementCoinageSnapshotApproval // 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 *AutoIncrementCoinageSnapshotApprovalIterator) 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(AutoIncrementCoinageSnapshotApproval)
			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(AutoIncrementCoinageSnapshotApproval)
		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 *AutoIncrementCoinageSnapshotApprovalIterator) Error() error {
	return it.fail
}

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

// AutoIncrementCoinageSnapshotApproval represents a Approval event raised by the AutoIncrementCoinageSnapshot contract.
type AutoIncrementCoinageSnapshotApproval 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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*AutoIncrementCoinageSnapshotApprovalIterator, 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 := _AutoIncrementCoinageSnapshot.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
	if err != nil {
		return nil, err
	}
	return &AutoIncrementCoinageSnapshotApprovalIterator{contract: _AutoIncrementCoinageSnapshot.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *AutoIncrementCoinageSnapshotApproval, 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 := _AutoIncrementCoinageSnapshot.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(AutoIncrementCoinageSnapshotApproval)
				if err := _AutoIncrementCoinageSnapshot.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotFilterer) ParseApproval(log types.Log) (*AutoIncrementCoinageSnapshotApproval, error) {
	event := new(AutoIncrementCoinageSnapshotApproval)
	if err := _AutoIncrementCoinageSnapshot.contract.UnpackLog(event, "Approval", log); err != nil {
		return nil, err
	}
	return event, nil
}

// AutoIncrementCoinageSnapshotClaimedTokensIterator is returned from FilterClaimedTokens and is used to iterate over the raw logs and unpacked data for ClaimedTokens events raised by the AutoIncrementCoinageSnapshot contract.
type AutoIncrementCoinageSnapshotClaimedTokensIterator struct {
	Event *AutoIncrementCoinageSnapshotClaimedTokens // 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 *AutoIncrementCoinageSnapshotClaimedTokensIterator) 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(AutoIncrementCoinageSnapshotClaimedTokens)
			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(AutoIncrementCoinageSnapshotClaimedTokens)
		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 *AutoIncrementCoinageSnapshotClaimedTokensIterator) Error() error {
	return it.fail
}

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

// AutoIncrementCoinageSnapshotClaimedTokens represents a ClaimedTokens event raised by the AutoIncrementCoinageSnapshot contract.
type AutoIncrementCoinageSnapshotClaimedTokens struct {
	Token      common.Address
	Controller common.Address
	Value      *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 value)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotFilterer) FilterClaimedTokens(opts *bind.FilterOpts, token []common.Address, controller []common.Address) (*AutoIncrementCoinageSnapshotClaimedTokensIterator, 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 := _AutoIncrementCoinageSnapshot.contract.FilterLogs(opts, "ClaimedTokens", tokenRule, controllerRule)
	if err != nil {
		return nil, err
	}
	return &AutoIncrementCoinageSnapshotClaimedTokensIterator{contract: _AutoIncrementCoinageSnapshot.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 value)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotFilterer) WatchClaimedTokens(opts *bind.WatchOpts, sink chan<- *AutoIncrementCoinageSnapshotClaimedTokens, 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 := _AutoIncrementCoinageSnapshot.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(AutoIncrementCoinageSnapshotClaimedTokens)
				if err := _AutoIncrementCoinageSnapshot.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 value)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotFilterer) ParseClaimedTokens(log types.Log) (*AutoIncrementCoinageSnapshotClaimedTokens, error) {
	event := new(AutoIncrementCoinageSnapshotClaimedTokens)
	if err := _AutoIncrementCoinageSnapshot.contract.UnpackLog(event, "ClaimedTokens", log); err != nil {
		return nil, err
	}
	return event, nil
}

// AutoIncrementCoinageSnapshotFactorIncreasedIterator is returned from FilterFactorIncreased and is used to iterate over the raw logs and unpacked data for FactorIncreased events raised by the AutoIncrementCoinageSnapshot contract.
type AutoIncrementCoinageSnapshotFactorIncreasedIterator struct {
	Event *AutoIncrementCoinageSnapshotFactorIncreased // 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 *AutoIncrementCoinageSnapshotFactorIncreasedIterator) 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(AutoIncrementCoinageSnapshotFactorIncreased)
			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(AutoIncrementCoinageSnapshotFactorIncreased)
		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 *AutoIncrementCoinageSnapshotFactorIncreasedIterator) Error() error {
	return it.fail
}

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

// AutoIncrementCoinageSnapshotFactorIncreased represents a FactorIncreased event raised by the AutoIncrementCoinageSnapshot contract.
type AutoIncrementCoinageSnapshotFactorIncreased struct {
	Factor *big.Int
	Raw    types.Log // Blockchain specific contextual infos
}

// FilterFactorIncreased is a free log retrieval operation binding the contract event 0xe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb6.
//
// Solidity: event FactorIncreased(uint256 factor)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotFilterer) FilterFactorIncreased(opts *bind.FilterOpts) (*AutoIncrementCoinageSnapshotFactorIncreasedIterator, error) {

	logs, sub, err := _AutoIncrementCoinageSnapshot.contract.FilterLogs(opts, "FactorIncreased")
	if err != nil {
		return nil, err
	}
	return &AutoIncrementCoinageSnapshotFactorIncreasedIterator{contract: _AutoIncrementCoinageSnapshot.contract, event: "FactorIncreased", logs: logs, sub: sub}, nil
}

// WatchFactorIncreased is a free log subscription operation binding the contract event 0xe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb6.
//
// Solidity: event FactorIncreased(uint256 factor)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotFilterer) WatchFactorIncreased(opts *bind.WatchOpts, sink chan<- *AutoIncrementCoinageSnapshotFactorIncreased) (event.Subscription, error) {

	logs, sub, err := _AutoIncrementCoinageSnapshot.contract.WatchLogs(opts, "FactorIncreased")
	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(AutoIncrementCoinageSnapshotFactorIncreased)
				if err := _AutoIncrementCoinageSnapshot.contract.UnpackLog(event, "FactorIncreased", 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
}

// ParseFactorIncreased is a log parse operation binding the contract event 0xe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb6.
//
// Solidity: event FactorIncreased(uint256 factor)
func (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotFilterer) ParseFactorIncreased(log types.Log) (*AutoIncrementCoinageSnapshotFactorIncreased, error) {
	event := new(AutoIncrementCoinageSnapshotFactorIncreased)
	if err := _AutoIncrementCoinageSnapshot.contract.UnpackLog(event, "FactorIncreased", log); err != nil {
		return nil, err
	}
	return event, nil
}

// AutoIncrementCoinageSnapshotNewCloneTokenIterator is returned from FilterNewCloneToken and is used to iterate over the raw logs and unpacked data for NewCloneToken events raised by the AutoIncrementCoinageSnapshot contract.
type AutoIncrementCoinageSnapshotNewCloneTokenIterator struct {
	Event *AutoIncrementCoinageSnapshotNewCloneToken // 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 *AutoIncrementCoinageSnapshotNewCloneTokenIterator) 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(AutoIncrementCoinageSnapshotNewCloneToken)
			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(AutoIncrementCoinageSnapshotNewCloneToken)
		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 *AutoIncrementCoinageSnapshotNewCloneTokenIterator) Error() error {
	return it.fail
}

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

// AutoIncrementCoinageSnapshotNewCloneToken represents a NewCloneToken event raised by the AutoIncrementCoinageSnapshot contract.
type AutoIncrementCoinageSnapshotNewCloneToken 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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotFilterer) FilterNewCloneToken(opts *bind.FilterOpts, cloneToken []common.Address) (*AutoIncrementCoinageSnapshotNewCloneTokenIterator, error) {

	var cloneTokenRule []interface{}
	for _, cloneTokenItem := range cloneToken {
		cloneTokenRule = append(cloneTokenRule, cloneTokenItem)
	}

	logs, sub, err := _AutoIncrementCoinageSnapshot.contract.FilterLogs(opts, "NewCloneToken", cloneTokenRule)
	if err != nil {
		return nil, err
	}
	return &AutoIncrementCoinageSnapshotNewCloneTokenIterator{contract: _AutoIncrementCoinageSnapshot.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotFilterer) WatchNewCloneToken(opts *bind.WatchOpts, sink chan<- *AutoIncrementCoinageSnapshotNewCloneToken, cloneToken []common.Address) (event.Subscription, error) {

	var cloneTokenRule []interface{}
	for _, cloneTokenItem := range cloneToken {
		cloneTokenRule = append(cloneTokenRule, cloneTokenItem)
	}

	logs, sub, err := _AutoIncrementCoinageSnapshot.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(AutoIncrementCoinageSnapshotNewCloneToken)
				if err := _AutoIncrementCoinageSnapshot.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotFilterer) ParseNewCloneToken(log types.Log) (*AutoIncrementCoinageSnapshotNewCloneToken, error) {
	event := new(AutoIncrementCoinageSnapshotNewCloneToken)
	if err := _AutoIncrementCoinageSnapshot.contract.UnpackLog(event, "NewCloneToken", log); err != nil {
		return nil, err
	}
	return event, nil
}

// AutoIncrementCoinageSnapshotTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the AutoIncrementCoinageSnapshot contract.
type AutoIncrementCoinageSnapshotTransferIterator struct {
	Event *AutoIncrementCoinageSnapshotTransfer // 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 *AutoIncrementCoinageSnapshotTransferIterator) 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(AutoIncrementCoinageSnapshotTransfer)
			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(AutoIncrementCoinageSnapshotTransfer)
		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 *AutoIncrementCoinageSnapshotTransferIterator) Error() error {
	return it.fail
}

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

// AutoIncrementCoinageSnapshotTransfer represents a Transfer event raised by the AutoIncrementCoinageSnapshot contract.
type AutoIncrementCoinageSnapshotTransfer 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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*AutoIncrementCoinageSnapshotTransferIterator, 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 := _AutoIncrementCoinageSnapshot.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
	if err != nil {
		return nil, err
	}
	return &AutoIncrementCoinageSnapshotTransferIterator{contract: _AutoIncrementCoinageSnapshot.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *AutoIncrementCoinageSnapshotTransfer, 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 := _AutoIncrementCoinageSnapshot.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(AutoIncrementCoinageSnapshotTransfer)
				if err := _AutoIncrementCoinageSnapshot.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 (_AutoIncrementCoinageSnapshot *AutoIncrementCoinageSnapshotFilterer) ParseTransfer(log types.Log) (*AutoIncrementCoinageSnapshotTransfer, error) {
	event := new(AutoIncrementCoinageSnapshotTransfer)
	if err := _AutoIncrementCoinageSnapshot.contract.UnpackLog(event, "Transfer", log); err != nil {
		return nil, err
	}
	return event, nil
}

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

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

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

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

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(AutoIncrementCoinageSnapshotFactoryBin), backend)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &AutoIncrementCoinageSnapshotFactory{AutoIncrementCoinageSnapshotFactoryCaller: AutoIncrementCoinageSnapshotFactoryCaller{contract: contract}, AutoIncrementCoinageSnapshotFactoryTransactor: AutoIncrementCoinageSnapshotFactoryTransactor{contract: contract}, AutoIncrementCoinageSnapshotFactoryFilterer: AutoIncrementCoinageSnapshotFactoryFilterer{contract: contract}}, nil
}

// AutoIncrementCoinageSnapshotFactory is an auto generated Go binding around an Ethereum contract.
type AutoIncrementCoinageSnapshotFactory struct {
	AutoIncrementCoinageSnapshotFactoryCaller     // Read-only binding to the contract
	AutoIncrementCoinageSnapshotFactoryTransactor // Write-only binding to the contract
	AutoIncrementCoinageSnapshotFactoryFilterer   // Log filterer for contract events
}

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

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

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

// AutoIncrementCoinageSnapshotFactorySession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type AutoIncrementCoinageSnapshotFactorySession struct {
	Contract     *AutoIncrementCoinageSnapshotFactory // 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
}

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

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

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

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

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

// NewAutoIncrementCoinageSnapshotFactory creates a new instance of AutoIncrementCoinageSnapshotFactory, bound to a specific deployed contract.
func NewAutoIncrementCoinageSnapshotFactory(address common.Address, backend bind.ContractBackend) (*AutoIncrementCoinageSnapshotFactory, error) {
	contract, err := bindAutoIncrementCoinageSnapshotFactory(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &AutoIncrementCoinageSnapshotFactory{AutoIncrementCoinageSnapshotFactoryCaller: AutoIncrementCoinageSnapshotFactoryCaller{contract: contract}, AutoIncrementCoinageSnapshotFactoryTransactor: AutoIncrementCoinageSnapshotFactoryTransactor{contract: contract}, AutoIncrementCoinageSnapshotFactoryFilterer: AutoIncrementCoinageSnapshotFactoryFilterer{contract: contract}}, nil
}

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

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

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

// bindAutoIncrementCoinageSnapshotFactory binds a generic wrapper to an already deployed contract.
func bindAutoIncrementCoinageSnapshotFactory(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(AutoIncrementCoinageSnapshotFactoryABI))
	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 (_AutoIncrementCoinageSnapshotFactory *AutoIncrementCoinageSnapshotFactoryRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _AutoIncrementCoinageSnapshotFactory.Contract.AutoIncrementCoinageSnapshotFactoryCaller.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 (_AutoIncrementCoinageSnapshotFactory *AutoIncrementCoinageSnapshotFactoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshotFactory.Contract.AutoIncrementCoinageSnapshotFactoryTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_AutoIncrementCoinageSnapshotFactory *AutoIncrementCoinageSnapshotFactoryRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshotFactory.Contract.AutoIncrementCoinageSnapshotFactoryTransactor.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 (_AutoIncrementCoinageSnapshotFactory *AutoIncrementCoinageSnapshotFactoryCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _AutoIncrementCoinageSnapshotFactory.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 (_AutoIncrementCoinageSnapshotFactory *AutoIncrementCoinageSnapshotFactoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _AutoIncrementCoinageSnapshotFactory.Contract.contract.Transfer(opts)
}

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

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

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

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

// ContextABI is the input ABI used to generate the binding from.
const ContextABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}]"

// Context is an auto generated Go binding around an Ethereum contract.
type Context struct {
	ContextCaller     // Read-only binding to the contract
	ContextTransactor // Write-only binding to the contract
	ContextFilterer   // Log filterer for contract events
}

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

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

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

// ContextSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type ContextSession struct {
	Contract     *Context          // 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
}

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

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

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

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

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

// NewContext creates a new instance of Context, bound to a specific deployed contract.
func NewContext(address common.Address, backend bind.ContractBackend) (*Context, error) {
	contract, err := bindContext(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &Context{ContextCaller: ContextCaller{contract: contract}, ContextTransactor: ContextTransactor{contract: contract}, ContextFilterer: ContextFilterer{contract: contract}}, nil
}

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

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

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

// bindContext binds a generic wrapper to an already deployed contract.
func bindContext(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(ContextABI))
	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 (_Context *ContextRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _Context.Contract.ContextCaller.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 (_Context *ContextRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _Context.Contract.ContextTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_Context *ContextRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _Context.Contract.ContextTransactor.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 (_Context *ContextCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _Context.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 (_Context *ContextTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _Context.Contract.contract.Transfer(opts)
}

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

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

// 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 = "0x608060405234801561001057600080fd5b50600080546001600160a01b0319163317905560fa806100316000396000f3fe6080604052348015600f57600080fd5b506004361060325760003560e01c80633cebb823146037578063f77c479114605c575b600080fd5b605a60048036036020811015604b57600080fd5b50356001600160a01b0316607e565b005b606260b6565b604080516001600160a01b039092168252519081900360200190f35b6000546001600160a01b03163314609457600080fd5b600080546001600160a01b0319166001600160a01b0392909216919091179055565b6000546001600160a01b03168156fea265627a7a72315820bd5a1001fe40436fac6f4b558c0efe5f9b52127067f376011e85be7fc00cd70064736f6c634300050c0032"

// 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() constant returns(address)
func (_Controlled *ControlledCaller) Controller(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _Controlled.contract.Call(opts, out, "controller")
	return *ret0, err
}

// Controller is a free data retrieval call binding the contract method 0xf77c4791.
//
// Solidity: function controller() constant 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() constant 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)
}

// CustomIncrementCoinageABI is the input ABI used to generate the binding from.
const CustomIncrementCoinageABI = "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"factor\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"transfersEnabled\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"factor\",\"type\":\"uint256\"}],\"name\":\"FactorIncreased\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"previous\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"current\",\"type\":\"uint256\"}],\"name\":\"FactorSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"bool\",\"name\":\"v\",\"type\":\"bool\"}],\"name\":\"enableTransfers\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"factor\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"factorIncrement\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"isOwner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"lastBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"factor\",\"type\":\"uint256\"}],\"name\":\"setFactor\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"transfersEnabled\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"

// CustomIncrementCoinageFuncSigs maps the 4-byte function signature to its string representation.
var CustomIncrementCoinageFuncSigs = map[string]string{
	"dd62ed3e": "allowance(address,address)",
	"095ea7b3": "approve(address,uint256)",
	"70a08231": "balanceOf(address)",
	"313ce567": "decimals()",
	"a457c2d7": "decreaseAllowance(address,uint256)",
	"f41e60c5": "enableTransfers(bool)",
	"54f703f8": "factor()",
	"d4132ee2": "factorIncrement()",
	"39509351": "increaseAllowance(address,uint256)",
	"8f32d59b": "isOwner()",
	"806b984f": "lastBlock()",
	"06fdde03": "name()",
	"8da5cb5b": "owner()",
	"715018a6": "renounceOwnership()",
	"817e9d31": "setFactor(uint256)",
	"95d89b41": "symbol()",
	"18160ddd": "totalSupply()",
	"a9059cbb": "transfer(address,uint256)",
	"23b872dd": "transferFrom(address,address,uint256)",
	"f2fde38b": "transferOwnership(address)",
	"bef97c87": "transfersEnabled()",
}

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

// DeployCustomIncrementCoinage deploys a new Ethereum contract, binding an instance of CustomIncrementCoinage to it.
func DeployCustomIncrementCoinage(auth *bind.TransactOpts, backend bind.ContractBackend, name string, symbol string, factor *big.Int, transfersEnabled bool) (common.Address, *types.Transaction, *CustomIncrementCoinage, error) {
	parsed, err := abi.JSON(strings.NewReader(CustomIncrementCoinageABI))
	if err != nil {
		return common.Address{}, nil, nil, err
	}

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(CustomIncrementCoinageBin), backend, name, symbol, factor, transfersEnabled)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &CustomIncrementCoinage{CustomIncrementCoinageCaller: CustomIncrementCoinageCaller{contract: contract}, CustomIncrementCoinageTransactor: CustomIncrementCoinageTransactor{contract: contract}, CustomIncrementCoinageFilterer: CustomIncrementCoinageFilterer{contract: contract}}, nil
}

// CustomIncrementCoinage is an auto generated Go binding around an Ethereum contract.
type CustomIncrementCoinage struct {
	CustomIncrementCoinageCaller     // Read-only binding to the contract
	CustomIncrementCoinageTransactor // Write-only binding to the contract
	CustomIncrementCoinageFilterer   // Log filterer for contract events
}

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

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

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

// CustomIncrementCoinageSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type CustomIncrementCoinageSession struct {
	Contract     *CustomIncrementCoinage // 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
}

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

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

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

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

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

// NewCustomIncrementCoinage creates a new instance of CustomIncrementCoinage, bound to a specific deployed contract.
func NewCustomIncrementCoinage(address common.Address, backend bind.ContractBackend) (*CustomIncrementCoinage, error) {
	contract, err := bindCustomIncrementCoinage(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &CustomIncrementCoinage{CustomIncrementCoinageCaller: CustomIncrementCoinageCaller{contract: contract}, CustomIncrementCoinageTransactor: CustomIncrementCoinageTransactor{contract: contract}, CustomIncrementCoinageFilterer: CustomIncrementCoinageFilterer{contract: contract}}, nil
}

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

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

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

// bindCustomIncrementCoinage binds a generic wrapper to an already deployed contract.
func bindCustomIncrementCoinage(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(CustomIncrementCoinageABI))
	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 (_CustomIncrementCoinage *CustomIncrementCoinageRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _CustomIncrementCoinage.Contract.CustomIncrementCoinageCaller.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 (_CustomIncrementCoinage *CustomIncrementCoinageRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _CustomIncrementCoinage.Contract.CustomIncrementCoinageTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_CustomIncrementCoinage *CustomIncrementCoinageRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _CustomIncrementCoinage.Contract.CustomIncrementCoinageTransactor.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 (_CustomIncrementCoinage *CustomIncrementCoinageCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _CustomIncrementCoinage.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 (_CustomIncrementCoinage *CustomIncrementCoinageTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _CustomIncrementCoinage.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_CustomIncrementCoinage *CustomIncrementCoinageTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _CustomIncrementCoinage.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) constant returns(uint256)
func (_CustomIncrementCoinage *CustomIncrementCoinageCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _CustomIncrementCoinage.contract.Call(opts, out, "allowance", owner, spender)
	return *ret0, err
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_CustomIncrementCoinage *CustomIncrementCoinageSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _CustomIncrementCoinage.Contract.Allowance(&_CustomIncrementCoinage.CallOpts, owner, spender)
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_CustomIncrementCoinage *CustomIncrementCoinageCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _CustomIncrementCoinage.Contract.Allowance(&_CustomIncrementCoinage.CallOpts, owner, spender)
}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address account) constant returns(uint256)
func (_CustomIncrementCoinage *CustomIncrementCoinageCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _CustomIncrementCoinage.contract.Call(opts, out, "balanceOf", account)
	return *ret0, err
}

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

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

// Decimals is a free data retrieval call binding the contract method 0x313ce567.
//
// Solidity: function decimals() constant returns(uint8)
func (_CustomIncrementCoinage *CustomIncrementCoinageCaller) Decimals(opts *bind.CallOpts) (uint8, error) {
	var (
		ret0 = new(uint8)
	)
	out := ret0
	err := _CustomIncrementCoinage.contract.Call(opts, out, "decimals")
	return *ret0, err
}

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

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

// Factor is a free data retrieval call binding the contract method 0x54f703f8.
//
// Solidity: function factor() constant returns(uint256)
func (_CustomIncrementCoinage *CustomIncrementCoinageCaller) Factor(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _CustomIncrementCoinage.contract.Call(opts, out, "factor")
	return *ret0, err
}

// Factor is a free data retrieval call binding the contract method 0x54f703f8.
//
// Solidity: function factor() constant returns(uint256)
func (_CustomIncrementCoinage *CustomIncrementCoinageSession) Factor() (*big.Int, error) {
	return _CustomIncrementCoinage.Contract.Factor(&_CustomIncrementCoinage.CallOpts)
}

// Factor is a free data retrieval call binding the contract method 0x54f703f8.
//
// Solidity: function factor() constant returns(uint256)
func (_CustomIncrementCoinage *CustomIncrementCoinageCallerSession) Factor() (*big.Int, error) {
	return _CustomIncrementCoinage.Contract.Factor(&_CustomIncrementCoinage.CallOpts)
}

// FactorIncrement is a free data retrieval call binding the contract method 0xd4132ee2.
//
// Solidity: function factorIncrement() constant returns(uint256)
func (_CustomIncrementCoinage *CustomIncrementCoinageCaller) FactorIncrement(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _CustomIncrementCoinage.contract.Call(opts, out, "factorIncrement")
	return *ret0, err
}

// FactorIncrement is a free data retrieval call binding the contract method 0xd4132ee2.
//
// Solidity: function factorIncrement() constant returns(uint256)
func (_CustomIncrementCoinage *CustomIncrementCoinageSession) FactorIncrement() (*big.Int, error) {
	return _CustomIncrementCoinage.Contract.FactorIncrement(&_CustomIncrementCoinage.CallOpts)
}

// FactorIncrement is a free data retrieval call binding the contract method 0xd4132ee2.
//
// Solidity: function factorIncrement() constant returns(uint256)
func (_CustomIncrementCoinage *CustomIncrementCoinageCallerSession) FactorIncrement() (*big.Int, error) {
	return _CustomIncrementCoinage.Contract.FactorIncrement(&_CustomIncrementCoinage.CallOpts)
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_CustomIncrementCoinage *CustomIncrementCoinageCaller) IsOwner(opts *bind.CallOpts) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _CustomIncrementCoinage.contract.Call(opts, out, "isOwner")
	return *ret0, err
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_CustomIncrementCoinage *CustomIncrementCoinageSession) IsOwner() (bool, error) {
	return _CustomIncrementCoinage.Contract.IsOwner(&_CustomIncrementCoinage.CallOpts)
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_CustomIncrementCoinage *CustomIncrementCoinageCallerSession) IsOwner() (bool, error) {
	return _CustomIncrementCoinage.Contract.IsOwner(&_CustomIncrementCoinage.CallOpts)
}

// LastBlock is a free data retrieval call binding the contract method 0x806b984f.
//
// Solidity: function lastBlock() constant returns(uint256)
func (_CustomIncrementCoinage *CustomIncrementCoinageCaller) LastBlock(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _CustomIncrementCoinage.contract.Call(opts, out, "lastBlock")
	return *ret0, err
}

// LastBlock is a free data retrieval call binding the contract method 0x806b984f.
//
// Solidity: function lastBlock() constant returns(uint256)
func (_CustomIncrementCoinage *CustomIncrementCoinageSession) LastBlock() (*big.Int, error) {
	return _CustomIncrementCoinage.Contract.LastBlock(&_CustomIncrementCoinage.CallOpts)
}

// LastBlock is a free data retrieval call binding the contract method 0x806b984f.
//
// Solidity: function lastBlock() constant returns(uint256)
func (_CustomIncrementCoinage *CustomIncrementCoinageCallerSession) LastBlock() (*big.Int, error) {
	return _CustomIncrementCoinage.Contract.LastBlock(&_CustomIncrementCoinage.CallOpts)
}

// Name is a free data retrieval call binding the contract method 0x06fdde03.
//
// Solidity: function name() constant returns(string)
func (_CustomIncrementCoinage *CustomIncrementCoinageCaller) Name(opts *bind.CallOpts) (string, error) {
	var (
		ret0 = new(string)
	)
	out := ret0
	err := _CustomIncrementCoinage.contract.Call(opts, out, "name")
	return *ret0, err
}

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

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

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_CustomIncrementCoinage *CustomIncrementCoinageCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _CustomIncrementCoinage.contract.Call(opts, out, "owner")
	return *ret0, err
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_CustomIncrementCoinage *CustomIncrementCoinageSession) Owner() (common.Address, error) {
	return _CustomIncrementCoinage.Contract.Owner(&_CustomIncrementCoinage.CallOpts)
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_CustomIncrementCoinage *CustomIncrementCoinageCallerSession) Owner() (common.Address, error) {
	return _CustomIncrementCoinage.Contract.Owner(&_CustomIncrementCoinage.CallOpts)
}

// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
//
// Solidity: function symbol() constant returns(string)
func (_CustomIncrementCoinage *CustomIncrementCoinageCaller) Symbol(opts *bind.CallOpts) (string, error) {
	var (
		ret0 = new(string)
	)
	out := ret0
	err := _CustomIncrementCoinage.contract.Call(opts, out, "symbol")
	return *ret0, err
}

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

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

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() constant returns(uint256)
func (_CustomIncrementCoinage *CustomIncrementCoinageCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _CustomIncrementCoinage.contract.Call(opts, out, "totalSupply")
	return *ret0, err
}

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

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

// TransfersEnabled is a free data retrieval call binding the contract method 0xbef97c87.
//
// Solidity: function transfersEnabled() constant returns(bool)
func (_CustomIncrementCoinage *CustomIncrementCoinageCaller) TransfersEnabled(opts *bind.CallOpts) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _CustomIncrementCoinage.contract.Call(opts, out, "transfersEnabled")
	return *ret0, err
}

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

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

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address spender, uint256 amount) returns(bool)
func (_CustomIncrementCoinage *CustomIncrementCoinageTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinage.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)
func (_CustomIncrementCoinage *CustomIncrementCoinageSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinage.Contract.Approve(&_CustomIncrementCoinage.TransactOpts, spender, amount)
}

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

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_CustomIncrementCoinage *CustomIncrementCoinageTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinage.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_CustomIncrementCoinage *CustomIncrementCoinageSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinage.Contract.DecreaseAllowance(&_CustomIncrementCoinage.TransactOpts, spender, subtractedValue)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_CustomIncrementCoinage *CustomIncrementCoinageTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinage.Contract.DecreaseAllowance(&_CustomIncrementCoinage.TransactOpts, spender, subtractedValue)
}

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

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

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

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_CustomIncrementCoinage *CustomIncrementCoinageTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinage.contract.Transact(opts, "increaseAllowance", spender, addedValue)
}

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_CustomIncrementCoinage *CustomIncrementCoinageSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinage.Contract.IncreaseAllowance(&_CustomIncrementCoinage.TransactOpts, spender, addedValue)
}

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_CustomIncrementCoinage *CustomIncrementCoinageTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinage.Contract.IncreaseAllowance(&_CustomIncrementCoinage.TransactOpts, spender, addedValue)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_CustomIncrementCoinage *CustomIncrementCoinageTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _CustomIncrementCoinage.contract.Transact(opts, "renounceOwnership")
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_CustomIncrementCoinage *CustomIncrementCoinageSession) RenounceOwnership() (*types.Transaction, error) {
	return _CustomIncrementCoinage.Contract.RenounceOwnership(&_CustomIncrementCoinage.TransactOpts)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_CustomIncrementCoinage *CustomIncrementCoinageTransactorSession) RenounceOwnership() (*types.Transaction, error) {
	return _CustomIncrementCoinage.Contract.RenounceOwnership(&_CustomIncrementCoinage.TransactOpts)
}

// SetFactor is a paid mutator transaction binding the contract method 0x817e9d31.
//
// Solidity: function setFactor(uint256 factor) returns(bool)
func (_CustomIncrementCoinage *CustomIncrementCoinageTransactor) SetFactor(opts *bind.TransactOpts, factor *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinage.contract.Transact(opts, "setFactor", factor)
}

// SetFactor is a paid mutator transaction binding the contract method 0x817e9d31.
//
// Solidity: function setFactor(uint256 factor) returns(bool)
func (_CustomIncrementCoinage *CustomIncrementCoinageSession) SetFactor(factor *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinage.Contract.SetFactor(&_CustomIncrementCoinage.TransactOpts, factor)
}

// SetFactor is a paid mutator transaction binding the contract method 0x817e9d31.
//
// Solidity: function setFactor(uint256 factor) returns(bool)
func (_CustomIncrementCoinage *CustomIncrementCoinageTransactorSession) SetFactor(factor *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinage.Contract.SetFactor(&_CustomIncrementCoinage.TransactOpts, factor)
}

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

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

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

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_CustomIncrementCoinage *CustomIncrementCoinageTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinage.contract.Transact(opts, "transferFrom", sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_CustomIncrementCoinage *CustomIncrementCoinageSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinage.Contract.TransferFrom(&_CustomIncrementCoinage.TransactOpts, sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_CustomIncrementCoinage *CustomIncrementCoinageTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinage.Contract.TransferFrom(&_CustomIncrementCoinage.TransactOpts, sender, recipient, amount)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_CustomIncrementCoinage *CustomIncrementCoinageTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
	return _CustomIncrementCoinage.contract.Transact(opts, "transferOwnership", newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_CustomIncrementCoinage *CustomIncrementCoinageSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
	return _CustomIncrementCoinage.Contract.TransferOwnership(&_CustomIncrementCoinage.TransactOpts, newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_CustomIncrementCoinage *CustomIncrementCoinageTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
	return _CustomIncrementCoinage.Contract.TransferOwnership(&_CustomIncrementCoinage.TransactOpts, newOwner)
}

// CustomIncrementCoinageApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the CustomIncrementCoinage contract.
type CustomIncrementCoinageApprovalIterator struct {
	Event *CustomIncrementCoinageApproval // 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 *CustomIncrementCoinageApprovalIterator) 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(CustomIncrementCoinageApproval)
			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(CustomIncrementCoinageApproval)
		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 *CustomIncrementCoinageApprovalIterator) Error() error {
	return it.fail
}

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

// CustomIncrementCoinageApproval represents a Approval event raised by the CustomIncrementCoinage contract.
type CustomIncrementCoinageApproval 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 (_CustomIncrementCoinage *CustomIncrementCoinageFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*CustomIncrementCoinageApprovalIterator, 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 := _CustomIncrementCoinage.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
	if err != nil {
		return nil, err
	}
	return &CustomIncrementCoinageApprovalIterator{contract: _CustomIncrementCoinage.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 (_CustomIncrementCoinage *CustomIncrementCoinageFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *CustomIncrementCoinageApproval, 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 := _CustomIncrementCoinage.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(CustomIncrementCoinageApproval)
				if err := _CustomIncrementCoinage.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 (_CustomIncrementCoinage *CustomIncrementCoinageFilterer) ParseApproval(log types.Log) (*CustomIncrementCoinageApproval, error) {
	event := new(CustomIncrementCoinageApproval)
	if err := _CustomIncrementCoinage.contract.UnpackLog(event, "Approval", log); err != nil {
		return nil, err
	}
	return event, nil
}

// CustomIncrementCoinageFactorIncreasedIterator is returned from FilterFactorIncreased and is used to iterate over the raw logs and unpacked data for FactorIncreased events raised by the CustomIncrementCoinage contract.
type CustomIncrementCoinageFactorIncreasedIterator struct {
	Event *CustomIncrementCoinageFactorIncreased // 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 *CustomIncrementCoinageFactorIncreasedIterator) 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(CustomIncrementCoinageFactorIncreased)
			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(CustomIncrementCoinageFactorIncreased)
		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 *CustomIncrementCoinageFactorIncreasedIterator) Error() error {
	return it.fail
}

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

// CustomIncrementCoinageFactorIncreased represents a FactorIncreased event raised by the CustomIncrementCoinage contract.
type CustomIncrementCoinageFactorIncreased struct {
	Factor *big.Int
	Raw    types.Log // Blockchain specific contextual infos
}

// FilterFactorIncreased is a free log retrieval operation binding the contract event 0xe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb6.
//
// Solidity: event FactorIncreased(uint256 factor)
func (_CustomIncrementCoinage *CustomIncrementCoinageFilterer) FilterFactorIncreased(opts *bind.FilterOpts) (*CustomIncrementCoinageFactorIncreasedIterator, error) {

	logs, sub, err := _CustomIncrementCoinage.contract.FilterLogs(opts, "FactorIncreased")
	if err != nil {
		return nil, err
	}
	return &CustomIncrementCoinageFactorIncreasedIterator{contract: _CustomIncrementCoinage.contract, event: "FactorIncreased", logs: logs, sub: sub}, nil
}

// WatchFactorIncreased is a free log subscription operation binding the contract event 0xe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb6.
//
// Solidity: event FactorIncreased(uint256 factor)
func (_CustomIncrementCoinage *CustomIncrementCoinageFilterer) WatchFactorIncreased(opts *bind.WatchOpts, sink chan<- *CustomIncrementCoinageFactorIncreased) (event.Subscription, error) {

	logs, sub, err := _CustomIncrementCoinage.contract.WatchLogs(opts, "FactorIncreased")
	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(CustomIncrementCoinageFactorIncreased)
				if err := _CustomIncrementCoinage.contract.UnpackLog(event, "FactorIncreased", 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
}

// ParseFactorIncreased is a log parse operation binding the contract event 0xe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb6.
//
// Solidity: event FactorIncreased(uint256 factor)
func (_CustomIncrementCoinage *CustomIncrementCoinageFilterer) ParseFactorIncreased(log types.Log) (*CustomIncrementCoinageFactorIncreased, error) {
	event := new(CustomIncrementCoinageFactorIncreased)
	if err := _CustomIncrementCoinage.contract.UnpackLog(event, "FactorIncreased", log); err != nil {
		return nil, err
	}
	return event, nil
}

// CustomIncrementCoinageFactorSetIterator is returned from FilterFactorSet and is used to iterate over the raw logs and unpacked data for FactorSet events raised by the CustomIncrementCoinage contract.
type CustomIncrementCoinageFactorSetIterator struct {
	Event *CustomIncrementCoinageFactorSet // 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 *CustomIncrementCoinageFactorSetIterator) 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(CustomIncrementCoinageFactorSet)
			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(CustomIncrementCoinageFactorSet)
		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 *CustomIncrementCoinageFactorSetIterator) Error() error {
	return it.fail
}

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

// CustomIncrementCoinageFactorSet represents a FactorSet event raised by the CustomIncrementCoinage contract.
type CustomIncrementCoinageFactorSet struct {
	Previous *big.Int
	Current  *big.Int
	Raw      types.Log // Blockchain specific contextual infos
}

// FilterFactorSet is a free log retrieval operation binding the contract event 0xafc9085bb15d79bc1e9d87807e2fc5f4c2b631088cb3e38c86cb627c12a0e430.
//
// Solidity: event FactorSet(uint256 previous, uint256 current)
func (_CustomIncrementCoinage *CustomIncrementCoinageFilterer) FilterFactorSet(opts *bind.FilterOpts) (*CustomIncrementCoinageFactorSetIterator, error) {

	logs, sub, err := _CustomIncrementCoinage.contract.FilterLogs(opts, "FactorSet")
	if err != nil {
		return nil, err
	}
	return &CustomIncrementCoinageFactorSetIterator{contract: _CustomIncrementCoinage.contract, event: "FactorSet", logs: logs, sub: sub}, nil
}

// WatchFactorSet is a free log subscription operation binding the contract event 0xafc9085bb15d79bc1e9d87807e2fc5f4c2b631088cb3e38c86cb627c12a0e430.
//
// Solidity: event FactorSet(uint256 previous, uint256 current)
func (_CustomIncrementCoinage *CustomIncrementCoinageFilterer) WatchFactorSet(opts *bind.WatchOpts, sink chan<- *CustomIncrementCoinageFactorSet) (event.Subscription, error) {

	logs, sub, err := _CustomIncrementCoinage.contract.WatchLogs(opts, "FactorSet")
	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(CustomIncrementCoinageFactorSet)
				if err := _CustomIncrementCoinage.contract.UnpackLog(event, "FactorSet", 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
}

// ParseFactorSet is a log parse operation binding the contract event 0xafc9085bb15d79bc1e9d87807e2fc5f4c2b631088cb3e38c86cb627c12a0e430.
//
// Solidity: event FactorSet(uint256 previous, uint256 current)
func (_CustomIncrementCoinage *CustomIncrementCoinageFilterer) ParseFactorSet(log types.Log) (*CustomIncrementCoinageFactorSet, error) {
	event := new(CustomIncrementCoinageFactorSet)
	if err := _CustomIncrementCoinage.contract.UnpackLog(event, "FactorSet", log); err != nil {
		return nil, err
	}
	return event, nil
}

// CustomIncrementCoinageOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the CustomIncrementCoinage contract.
type CustomIncrementCoinageOwnershipTransferredIterator struct {
	Event *CustomIncrementCoinageOwnershipTransferred // 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 *CustomIncrementCoinageOwnershipTransferredIterator) 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(CustomIncrementCoinageOwnershipTransferred)
			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(CustomIncrementCoinageOwnershipTransferred)
		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 *CustomIncrementCoinageOwnershipTransferredIterator) Error() error {
	return it.fail
}

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

// CustomIncrementCoinageOwnershipTransferred represents a OwnershipTransferred event raised by the CustomIncrementCoinage contract.
type CustomIncrementCoinageOwnershipTransferred struct {
	PreviousOwner common.Address
	NewOwner      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_CustomIncrementCoinage *CustomIncrementCoinageFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*CustomIncrementCoinageOwnershipTransferredIterator, error) {

	var previousOwnerRule []interface{}
	for _, previousOwnerItem := range previousOwner {
		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
	}
	var newOwnerRule []interface{}
	for _, newOwnerItem := range newOwner {
		newOwnerRule = append(newOwnerRule, newOwnerItem)
	}

	logs, sub, err := _CustomIncrementCoinage.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
	if err != nil {
		return nil, err
	}
	return &CustomIncrementCoinageOwnershipTransferredIterator{contract: _CustomIncrementCoinage.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
}

// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_CustomIncrementCoinage *CustomIncrementCoinageFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *CustomIncrementCoinageOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {

	var previousOwnerRule []interface{}
	for _, previousOwnerItem := range previousOwner {
		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
	}
	var newOwnerRule []interface{}
	for _, newOwnerItem := range newOwner {
		newOwnerRule = append(newOwnerRule, newOwnerItem)
	}

	logs, sub, err := _CustomIncrementCoinage.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
	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(CustomIncrementCoinageOwnershipTransferred)
				if err := _CustomIncrementCoinage.contract.UnpackLog(event, "OwnershipTransferred", 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
}

// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_CustomIncrementCoinage *CustomIncrementCoinageFilterer) ParseOwnershipTransferred(log types.Log) (*CustomIncrementCoinageOwnershipTransferred, error) {
	event := new(CustomIncrementCoinageOwnershipTransferred)
	if err := _CustomIncrementCoinage.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
		return nil, err
	}
	return event, nil
}

// CustomIncrementCoinageTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the CustomIncrementCoinage contract.
type CustomIncrementCoinageTransferIterator struct {
	Event *CustomIncrementCoinageTransfer // 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 *CustomIncrementCoinageTransferIterator) 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(CustomIncrementCoinageTransfer)
			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(CustomIncrementCoinageTransfer)
		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 *CustomIncrementCoinageTransferIterator) Error() error {
	return it.fail
}

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

// CustomIncrementCoinageTransfer represents a Transfer event raised by the CustomIncrementCoinage contract.
type CustomIncrementCoinageTransfer 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 (_CustomIncrementCoinage *CustomIncrementCoinageFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*CustomIncrementCoinageTransferIterator, 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 := _CustomIncrementCoinage.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
	if err != nil {
		return nil, err
	}
	return &CustomIncrementCoinageTransferIterator{contract: _CustomIncrementCoinage.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 (_CustomIncrementCoinage *CustomIncrementCoinageFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *CustomIncrementCoinageTransfer, 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 := _CustomIncrementCoinage.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(CustomIncrementCoinageTransfer)
				if err := _CustomIncrementCoinage.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 (_CustomIncrementCoinage *CustomIncrementCoinageFilterer) ParseTransfer(log types.Log) (*CustomIncrementCoinageTransfer, error) {
	event := new(CustomIncrementCoinageTransfer)
	if err := _CustomIncrementCoinage.contract.UnpackLog(event, "Transfer", log); err != nil {
		return nil, err
	}
	return event, nil
}

// CustomIncrementCoinageMockABI is the input ABI used to generate the binding from.
const CustomIncrementCoinageMockABI = "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"factor\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"transfersEnabled\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"factor\",\"type\":\"uint256\"}],\"name\":\"FactorIncreased\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"previous\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"current\",\"type\":\"uint256\"}],\"name\":\"FactorSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterRemoved\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"addMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burnFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"bool\",\"name\":\"v\",\"type\":\"bool\"}],\"name\":\"enableTransfers\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"factor\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"factorIncrement\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isMinter\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"isOwner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"lastBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"factor\",\"type\":\"uint256\"}],\"name\":\"setFactor\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"transfersEnabled\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"

// CustomIncrementCoinageMockFuncSigs maps the 4-byte function signature to its string representation.
var CustomIncrementCoinageMockFuncSigs = map[string]string{
	"983b2d56": "addMinter(address)",
	"dd62ed3e": "allowance(address,address)",
	"095ea7b3": "approve(address,uint256)",
	"70a08231": "balanceOf(address)",
	"42966c68": "burn(uint256)",
	"79cc6790": "burnFrom(address,uint256)",
	"313ce567": "decimals()",
	"a457c2d7": "decreaseAllowance(address,uint256)",
	"f41e60c5": "enableTransfers(bool)",
	"54f703f8": "factor()",
	"d4132ee2": "factorIncrement()",
	"39509351": "increaseAllowance(address,uint256)",
	"aa271e1a": "isMinter(address)",
	"8f32d59b": "isOwner()",
	"806b984f": "lastBlock()",
	"40c10f19": "mint(address,uint256)",
	"06fdde03": "name()",
	"8da5cb5b": "owner()",
	"98650275": "renounceMinter()",
	"715018a6": "renounceOwnership()",
	"817e9d31": "setFactor(uint256)",
	"95d89b41": "symbol()",
	"18160ddd": "totalSupply()",
	"a9059cbb": "transfer(address,uint256)",
	"23b872dd": "transferFrom(address,address,uint256)",
	"f2fde38b": "transferOwnership(address)",
	"bef97c87": "transfersEnabled()",
}

// CustomIncrementCoinageMockBin is the compiled bytecode used for deploying new contracts.
var CustomIncrementCoinageMockBin = "0x60806040523480156200001157600080fd5b5060405162001e8f38038062001e8f833981810160405260808110156200003757600080fd5b81019080805160405193929190846401000000008211156200005857600080fd5b9083019060208201858111156200006e57600080fd5b82516401000000008111828201881017156200008957600080fd5b82525081516020918201929091019080838360005b83811015620000b85781810151838201526020016200009e565b50505050905090810190601f168015620000e65780820380516001836020036101000a031916815260200191505b50604052602001805160405193929190846401000000008211156200010a57600080fd5b9083019060208201858111156200012057600080fd5b82516401000000008111828201881017156200013b57600080fd5b82525081516020918201929091019080838360005b838110156200016a57818101518382015260200162000150565b50505050905090810190601f168015620001985780820380516001836020036101000a031916815260200191505b50604090815260208201519101519092509050838383838383836000848484601b620001df620001d06001600160e01b03620002ad16565b6001600160e01b03620002b216565b620001f26001600160e01b03620002ad16565b600480546001600160a01b0319166001600160a01b0392831617908190556040519116906000907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908290a38251620002539060059060208601906200042e565b508151620002699060069060208501906200042e565b506007805460ff90921660ff19928316179055600b959095555050600c9190915543600d55600e80549115159190921617905550620004d098505050505050505050565b335b90565b620002cd8160036200030460201b6200148b1790919060201c565b6040516001600160a01b038216907f6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f690600090a250565b6200031982826001600160e01b03620003ab16565b156200038657604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601f60248201527f526f6c65733a206163636f756e7420616c72656164792068617320726f6c6500604482015290519081900360640190fd5b6001600160a01b0316600090815260209190915260409020805460ff19166001179055565b60006001600160a01b0382166200040e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602281526020018062001e6d6022913960400191505060405180910390fd5b506001600160a01b03166000908152602091909152604090205460ff1690565b828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f106200047157805160ff1916838001178555620004a1565b82800160010185558215620004a1579182015b82811115620004a157825182559160200191906001019062000484565b50620004af929150620004b3565b5090565b620002af91905b80821115620004af5760008155600101620004ba565b61198d80620004e06000396000f3fe608060405234801561001057600080fd5b50600436106101a95760003560e01c8063817e9d31116100f9578063a9059cbb11610097578063d4132ee211610071578063d4132ee2146104bf578063dd62ed3e146104c7578063f2fde38b146104f5578063f41e60c51461051b576101a9565b8063a9059cbb14610465578063aa271e1a14610491578063bef97c87146104b7576101a9565b806395d89b41116100d357806395d89b4114610403578063983b2d561461040b5780639865027514610431578063a457c2d714610439576101a9565b8063817e9d31146103ba5780638da5cb5b146103d75780638f32d59b146103fb576101a9565b806340c10f191161016657806370a082311161014057806370a0823114610358578063715018a61461037e57806379cc679014610386578063806b984f146103b2576101a9565b806340c10f191461030557806342966c681461033157806354f703f814610350576101a9565b806306fdde03146101ae578063095ea7b31461022b57806318160ddd1461026b57806323b872dd14610285578063313ce567146102bb57806339509351146102d9575b600080fd5b6101b661053a565b6040805160208082528351818301528351919283929083019185019080838360005b838110156101f05781810151838201526020016101d8565b50505050905090810190601f16801561021d5780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b6102576004803603604081101561024157600080fd5b506001600160a01b0381351690602001356105d0565b604080519115158252519081900360200190f35b6102736105ee565b60408051918252519081900360200190f35b6102576004803603606081101561029b57600080fd5b506001600160a01b03813581169160208101359091169060400135610600565b6102c36106f1565b6040805160ff9092168252519081900360200190f35b610257600480360360408110156102ef57600080fd5b506001600160a01b0381351690602001356106fa565b6102576004803603604081101561031b57600080fd5b506001600160a01b03813516906020013561074e565b61034e6004803603602081101561034757600080fd5b50356107a5565b005b6102736107b9565b6102736004803603602081101561036e57600080fd5b50356001600160a01b03166107bf565b61034e6107e9565b61034e6004803603604081101561039c57600080fd5b506001600160a01b03813516906020013561087a565b610273610888565b610257600480360360208110156103d057600080fd5b503561088e565b6103df610920565b604080516001600160a01b039092168252519081900360200190f35b61025761092f565b6101b6610955565b61034e6004803603602081101561042157600080fd5b50356001600160a01b03166109b6565b61034e610a05565b6102576004803603604081101561044f57600080fd5b506001600160a01b038135169060200135610a17565b6102576004803603604081101561047b57600080fd5b506001600160a01b038135169060200135610a85565b610257600480360360208110156104a757600080fd5b50356001600160a01b0316610afd565b610257610b10565b610273610b19565b610273600480360360408110156104dd57600080fd5b506001600160a01b0381358116916020013516610b1f565b61034e6004803603602081101561050b57600080fd5b50356001600160a01b0316610b4a565b61034e6004803603602081101561053157600080fd5b50351515610b9a565b60058054604080516020601f60026000196101006001881615020190951694909404938401819004810282018101909252828152606093909290918301828280156105c65780601f1061059b576101008083540402835291602001916105c6565b820191906000526020600020905b8154815290600101906020018083116105a957829003601f168201915b5050505050905090565b60006105e46105dd610bf4565b8484610bf8565b5060015b92915050565b60006105fb600a54610cec565b905090565b600061060a610920565b6001600160a01b0316336001600160a01b0316148061062b5750600e5460ff165b6106665760405162461bcd60e51b815260040180806020018281038252602a815260200180611864602a913960400191505060405180910390fd5b610671848484610d32565b6106e78461067d610bf4565b6106e2856040518060600160405280603781526020016118be603791396001600160a01b038a166000908152600960205260408120906106bb610bf4565b6001600160a01b03168152602081019190915260400160002054919063ffffffff610ea916565b610bf8565b5060019392505050565b60075460ff1690565b60006105e4610707610bf4565b846106e28560096000610718610bf4565b6001600160a01b03908116825260208083019390935260409182016000908120918c16815292529020549063ffffffff610f4016565b600061076061075b610bf4565b610afd565b61079b5760405162461bcd60e51b815260040180806020018281038252603081526020018061173c6030913960400191505060405180910390fd5b6105e48383610f9a565b6107b66107b0610bf4565b82611091565b50565b600b5490565b6001600160a01b0381166000908152600860205260408120546107e190610cec565b90505b919050565b6107f161092f565b610830576040805162461bcd60e51b815260206004820181905260248201526000805160206117bb833981519152604482015290519081900360640190fd5b6004546040516000916001600160a01b0316907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a3600480546001600160a01b0319169055565b6108848282611193565b5050565b600d5490565b600061089861092f565b6108d7576040805162461bcd60e51b815260206004820181905260248201526000805160206117bb833981519152604482015290519081900360640190fd5b600b805490839055604080518281526020810185905281517fafc9085bb15d79bc1e9d87807e2fc5f4c2b631088cb3e38c86cb627c12a0e430929181900390910190a150919050565b6004546001600160a01b031690565b6004546000906001600160a01b0316610946610bf4565b6001600160a01b031614905090565b60068054604080516020601f60026000196101006001881615020190951694909404938401819004810282018101909252828152606093909290918301828280156105c65780601f1061059b576101008083540402835291602001916105c6565b6109c161075b610bf4565b6109fc5760405162461bcd60e51b815260040180806020018281038252603081526020018061173c6030913960400191505060405180910390fd5b6107b6816111fb565b610a15610a10610bf4565b611243565b565b60006105e4610a24610bf4565b846106e2856040518060600160405280603481526020016116706034913960096000610a4e610bf4565b6001600160a01b03908116825260208083019390935260409182016000908120918d1681529252902054919063ffffffff610ea916565b6000610a8f610920565b6001600160a01b0316336001600160a01b03161480610ab05750600e5460ff165b610aeb5760405162461bcd60e51b815260040180806020018281038252602a815260200180611864602a913960400191505060405180910390fd5b6105e4610af6610bf4565b8484610d32565b60006107e160038363ffffffff61128b16565b600e5460ff1690565b600c5490565b6001600160a01b03918216600090815260096020908152604080832093909416825291909152205490565b610b5261092f565b610b91576040805162461bcd60e51b815260206004820181905260248201526000805160206117bb833981519152604482015290519081900360640190fd5b6107b6816112f2565b610ba261092f565b610be1576040805162461bcd60e51b815260206004820181905260248201526000805160206117bb833981519152604482015290519081900360640190fd5b600e805460ff1916911515919091179055565b3390565b610c00611393565b6001600160a01b038316610c455760405162461bcd60e51b81526004018080602001828103825260338152602001806116d86033913960400191505060405180910390fd5b6001600160a01b038216610c8a5760405162461bcd60e51b815260040180806020018281038252603181526020018061170b6031913960400191505060405180910390fd5b6001600160a01b03808416600081815260096020908152604080832094871680845294825291829020859055815185815291517f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9259281900390910190a3505050565b600081610cfb575060006107e4565b600d54430380610d1957610d1183600b546113e5565b9150506107e4565b610d2b83610d2683611426565b6113e5565b9392505050565b610d3a611393565b6001600160a01b038316610d7f5760405162461bcd60e51b81526004018080602001828103825260348152602001806116a46034913960400191505060405180910390fd5b6001600160a01b038216610dc45760405162461bcd60e51b81526004018080602001828103825260328152602001806117fd6032913960400191505060405180910390fd5b6000610dcf8261142d565b9050610e148160405180606001604052806035815260200161182f603591396001600160a01b038716600090815260086020526040902054919063ffffffff610ea916565b6001600160a01b038086166000908152600860205260408082209390935590851681522054610e49908263ffffffff610f4016565b6001600160a01b0380851660008181526008602052604090209290925585167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef610e928461143b565b60408051918252519081900360200190a350505050565b60008184841115610f385760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b83811015610efd578181015183820152602001610ee5565b50505050905090810190601f168015610f2a5780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b505050900390565b600082820183811015610d2b576040805162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604482015290519081900360640190fd5b610fa2611393565b6001600160a01b038216610fe75760405162461bcd60e51b815260040180806020018281038252602e81526020018061178d602e913960400191505060405180910390fd5b6000610ff28261142d565b600a54909150611008908263ffffffff610f4016565b600a556001600160a01b038316600090815260086020526040902054611034908263ffffffff610f4016565b6001600160a01b038416600081815260086020526040812092909255907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef61107b8461143b565b60408051918252519081900360200190a3505050565b611099611393565b6001600160a01b0382166110de5760405162461bcd60e51b815260040180806020018281038252603081526020018061188e6030913960400191505060405180910390fd5b60006110e98261142d565b905061112e816040518060600160405280603181526020016118f5603191396001600160a01b038616600090815260086020526040902054919063ffffffff610ea916565b6001600160a01b038416600090815260086020526040902055600a5461115a908263ffffffff61144916565b600a5560006001600160a01b0384167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef61107b8461143b565b61119b611393565b6111a58282611091565b6111ad61092f565b61088457610884826111bd610bf4565b6106e284604051806060016040528060338152602001611926603391396001600160a01b0388166000908152600960205260408120906106bb610bf4565b61120c60038263ffffffff61148b16565b6040516001600160a01b038216907f6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f690600090a250565b61125460038263ffffffff61150c16565b6040516001600160a01b038216907fe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb6669290600090a250565b60006001600160a01b0382166112d25760405162461bcd60e51b81526004018080602001828103825260228152602001806117db6022913960400191505060405180910390fd5b506001600160a01b03166000908152602091909152604090205460ff1690565b6001600160a01b0381166113375760405162461bcd60e51b815260040180806020018281038252602681526020018061164a6026913960400191505060405180910390fd5b6004546040516001600160a01b038084169216907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3600480546001600160a01b0319166001600160a01b0392909216919091179055565b600d54430380156107b6576113a781611426565b600b81905543600d5560408051918252517fe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb69181900360200190a150565b60006b033b2e3c9fd0803ce80000006114176114018585611573565b60026b033b2e3c9fd0803ce80000005b046115d6565b8161141e57fe5b049392505050565b50600b5490565b60006107e182600b54611625565b60006107e182600b546113e5565b6000610d2b83836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f770000815250610ea9565b611495828261128b565b156114e7576040805162461bcd60e51b815260206004820152601f60248201527f526f6c65733a206163636f756e7420616c72656164792068617320726f6c6500604482015290519081900360640190fd5b6001600160a01b0316600090815260209190915260409020805460ff19166001179055565b611516828261128b565b6115515760405162461bcd60e51b815260040180806020018281038252602181526020018061176c6021913960400191505060405180910390fd5b6001600160a01b0316600090815260209190915260409020805460ff19169055565b600081158061158e5750508082028282828161158b57fe5b04145b6105e8576040805162461bcd60e51b815260206004820152601460248201527364732d6d6174682d6d756c2d6f766572666c6f7760601b604482015290519081900360640190fd5b808201828110156105e8576040805162461bcd60e51b815260206004820152601460248201527364732d6d6174682d6164642d6f766572666c6f7760601b604482015290519081900360640190fd5b600081611417611641856b033b2e3c9fd0803ce8000000611573565b60028561141156fe4f776e61626c653a206e6577206f776e657220697320746865207a65726f20616464726573734175746f496e6372656d656e74436f696e6167653a2064656372656173656420616c6c6f77616e63652062656c6f77207a65726f4175746f496e6372656d656e74436f696e6167653a207472616e736665722066726f6d20746865207a65726f20616464726573734175746f496e6372656d656e74436f696e6167653a20617070726f76652066726f6d20746865207a65726f20616464726573734175746f496e6372656d656e74436f696e6167653a20617070726f766520746f20746865207a65726f20616464726573734d696e746572526f6c653a2063616c6c657220646f6573206e6f74206861766520746865204d696e74657220726f6c65526f6c65733a206163636f756e7420646f6573206e6f74206861766520726f6c654175746f496e6372656d656e74436f696e6167653a206d696e7420746f20746865207a65726f20616464726573734f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572526f6c65733a206163636f756e7420697320746865207a65726f20616464726573734175746f496e6372656d656e74436f696e6167653a207472616e7366657220746f20746865207a65726f20616464726573734175746f496e6372656d656e74436f696e6167653a207472616e7366657220616d6f756e7420657863656564732062616c616e63654175746f496e6372656d656e74436f696e6167653a207472616e73666572206e6f7420616c6c6f7765644175746f496e6372656d656e74436f696e6167653a206275726e2066726f6d20746865207a65726f20616464726573734175746f496e6372656d656e74436f696e6167653a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e63654175746f496e6372656d656e74436f696e6167653a206275726e20616d6f756e7420657863656564732062616c616e63654175746f496e6372656d656e74436f696e6167653a206275726e20616d6f756e74206578636565647320616c6c6f77616e6365a265627a7a72315820d5764adea31fbf3839fbc0cff7afda966ec63b8d0db737591e85afc150358bc364736f6c634300050c0032526f6c65733a206163636f756e7420697320746865207a65726f2061646472657373"

// DeployCustomIncrementCoinageMock deploys a new Ethereum contract, binding an instance of CustomIncrementCoinageMock to it.
func DeployCustomIncrementCoinageMock(auth *bind.TransactOpts, backend bind.ContractBackend, name string, symbol string, factor *big.Int, transfersEnabled bool) (common.Address, *types.Transaction, *CustomIncrementCoinageMock, error) {
	parsed, err := abi.JSON(strings.NewReader(CustomIncrementCoinageMockABI))
	if err != nil {
		return common.Address{}, nil, nil, err
	}

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(CustomIncrementCoinageMockBin), backend, name, symbol, factor, transfersEnabled)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &CustomIncrementCoinageMock{CustomIncrementCoinageMockCaller: CustomIncrementCoinageMockCaller{contract: contract}, CustomIncrementCoinageMockTransactor: CustomIncrementCoinageMockTransactor{contract: contract}, CustomIncrementCoinageMockFilterer: CustomIncrementCoinageMockFilterer{contract: contract}}, nil
}

// CustomIncrementCoinageMock is an auto generated Go binding around an Ethereum contract.
type CustomIncrementCoinageMock struct {
	CustomIncrementCoinageMockCaller     // Read-only binding to the contract
	CustomIncrementCoinageMockTransactor // Write-only binding to the contract
	CustomIncrementCoinageMockFilterer   // Log filterer for contract events
}

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

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

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

// CustomIncrementCoinageMockSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type CustomIncrementCoinageMockSession struct {
	Contract     *CustomIncrementCoinageMock // 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
}

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

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

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

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

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

// NewCustomIncrementCoinageMock creates a new instance of CustomIncrementCoinageMock, bound to a specific deployed contract.
func NewCustomIncrementCoinageMock(address common.Address, backend bind.ContractBackend) (*CustomIncrementCoinageMock, error) {
	contract, err := bindCustomIncrementCoinageMock(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &CustomIncrementCoinageMock{CustomIncrementCoinageMockCaller: CustomIncrementCoinageMockCaller{contract: contract}, CustomIncrementCoinageMockTransactor: CustomIncrementCoinageMockTransactor{contract: contract}, CustomIncrementCoinageMockFilterer: CustomIncrementCoinageMockFilterer{contract: contract}}, nil
}

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

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

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

// bindCustomIncrementCoinageMock binds a generic wrapper to an already deployed contract.
func bindCustomIncrementCoinageMock(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(CustomIncrementCoinageMockABI))
	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 (_CustomIncrementCoinageMock *CustomIncrementCoinageMockRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _CustomIncrementCoinageMock.Contract.CustomIncrementCoinageMockCaller.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 (_CustomIncrementCoinageMock *CustomIncrementCoinageMockRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.CustomIncrementCoinageMockTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.CustomIncrementCoinageMockTransactor.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 (_CustomIncrementCoinageMock *CustomIncrementCoinageMockCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _CustomIncrementCoinageMock.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 (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.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) constant returns(uint256)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _CustomIncrementCoinageMock.contract.Call(opts, out, "allowance", owner, spender)
	return *ret0, err
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _CustomIncrementCoinageMock.Contract.Allowance(&_CustomIncrementCoinageMock.CallOpts, owner, spender)
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _CustomIncrementCoinageMock.Contract.Allowance(&_CustomIncrementCoinageMock.CallOpts, owner, spender)
}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address account) constant returns(uint256)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _CustomIncrementCoinageMock.contract.Call(opts, out, "balanceOf", account)
	return *ret0, err
}

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

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

// Decimals is a free data retrieval call binding the contract method 0x313ce567.
//
// Solidity: function decimals() constant returns(uint8)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockCaller) Decimals(opts *bind.CallOpts) (uint8, error) {
	var (
		ret0 = new(uint8)
	)
	out := ret0
	err := _CustomIncrementCoinageMock.contract.Call(opts, out, "decimals")
	return *ret0, err
}

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

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

// Factor is a free data retrieval call binding the contract method 0x54f703f8.
//
// Solidity: function factor() constant returns(uint256)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockCaller) Factor(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _CustomIncrementCoinageMock.contract.Call(opts, out, "factor")
	return *ret0, err
}

// Factor is a free data retrieval call binding the contract method 0x54f703f8.
//
// Solidity: function factor() constant returns(uint256)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockSession) Factor() (*big.Int, error) {
	return _CustomIncrementCoinageMock.Contract.Factor(&_CustomIncrementCoinageMock.CallOpts)
}

// Factor is a free data retrieval call binding the contract method 0x54f703f8.
//
// Solidity: function factor() constant returns(uint256)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockCallerSession) Factor() (*big.Int, error) {
	return _CustomIncrementCoinageMock.Contract.Factor(&_CustomIncrementCoinageMock.CallOpts)
}

// FactorIncrement is a free data retrieval call binding the contract method 0xd4132ee2.
//
// Solidity: function factorIncrement() constant returns(uint256)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockCaller) FactorIncrement(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _CustomIncrementCoinageMock.contract.Call(opts, out, "factorIncrement")
	return *ret0, err
}

// FactorIncrement is a free data retrieval call binding the contract method 0xd4132ee2.
//
// Solidity: function factorIncrement() constant returns(uint256)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockSession) FactorIncrement() (*big.Int, error) {
	return _CustomIncrementCoinageMock.Contract.FactorIncrement(&_CustomIncrementCoinageMock.CallOpts)
}

// FactorIncrement is a free data retrieval call binding the contract method 0xd4132ee2.
//
// Solidity: function factorIncrement() constant returns(uint256)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockCallerSession) FactorIncrement() (*big.Int, error) {
	return _CustomIncrementCoinageMock.Contract.FactorIncrement(&_CustomIncrementCoinageMock.CallOpts)
}

// IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
//
// Solidity: function isMinter(address account) constant returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _CustomIncrementCoinageMock.contract.Call(opts, out, "isMinter", account)
	return *ret0, err
}

// IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
//
// Solidity: function isMinter(address account) constant returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockSession) IsMinter(account common.Address) (bool, error) {
	return _CustomIncrementCoinageMock.Contract.IsMinter(&_CustomIncrementCoinageMock.CallOpts, account)
}

// IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
//
// Solidity: function isMinter(address account) constant returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockCallerSession) IsMinter(account common.Address) (bool, error) {
	return _CustomIncrementCoinageMock.Contract.IsMinter(&_CustomIncrementCoinageMock.CallOpts, account)
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockCaller) IsOwner(opts *bind.CallOpts) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _CustomIncrementCoinageMock.contract.Call(opts, out, "isOwner")
	return *ret0, err
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockSession) IsOwner() (bool, error) {
	return _CustomIncrementCoinageMock.Contract.IsOwner(&_CustomIncrementCoinageMock.CallOpts)
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockCallerSession) IsOwner() (bool, error) {
	return _CustomIncrementCoinageMock.Contract.IsOwner(&_CustomIncrementCoinageMock.CallOpts)
}

// LastBlock is a free data retrieval call binding the contract method 0x806b984f.
//
// Solidity: function lastBlock() constant returns(uint256)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockCaller) LastBlock(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _CustomIncrementCoinageMock.contract.Call(opts, out, "lastBlock")
	return *ret0, err
}

// LastBlock is a free data retrieval call binding the contract method 0x806b984f.
//
// Solidity: function lastBlock() constant returns(uint256)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockSession) LastBlock() (*big.Int, error) {
	return _CustomIncrementCoinageMock.Contract.LastBlock(&_CustomIncrementCoinageMock.CallOpts)
}

// LastBlock is a free data retrieval call binding the contract method 0x806b984f.
//
// Solidity: function lastBlock() constant returns(uint256)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockCallerSession) LastBlock() (*big.Int, error) {
	return _CustomIncrementCoinageMock.Contract.LastBlock(&_CustomIncrementCoinageMock.CallOpts)
}

// Name is a free data retrieval call binding the contract method 0x06fdde03.
//
// Solidity: function name() constant returns(string)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockCaller) Name(opts *bind.CallOpts) (string, error) {
	var (
		ret0 = new(string)
	)
	out := ret0
	err := _CustomIncrementCoinageMock.contract.Call(opts, out, "name")
	return *ret0, err
}

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

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

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _CustomIncrementCoinageMock.contract.Call(opts, out, "owner")
	return *ret0, err
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockSession) Owner() (common.Address, error) {
	return _CustomIncrementCoinageMock.Contract.Owner(&_CustomIncrementCoinageMock.CallOpts)
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockCallerSession) Owner() (common.Address, error) {
	return _CustomIncrementCoinageMock.Contract.Owner(&_CustomIncrementCoinageMock.CallOpts)
}

// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
//
// Solidity: function symbol() constant returns(string)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockCaller) Symbol(opts *bind.CallOpts) (string, error) {
	var (
		ret0 = new(string)
	)
	out := ret0
	err := _CustomIncrementCoinageMock.contract.Call(opts, out, "symbol")
	return *ret0, err
}

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

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

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() constant returns(uint256)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _CustomIncrementCoinageMock.contract.Call(opts, out, "totalSupply")
	return *ret0, err
}

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

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

// TransfersEnabled is a free data retrieval call binding the contract method 0xbef97c87.
//
// Solidity: function transfersEnabled() constant returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockCaller) TransfersEnabled(opts *bind.CallOpts) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _CustomIncrementCoinageMock.contract.Call(opts, out, "transfersEnabled")
	return *ret0, err
}

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

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

// AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
//
// Solidity: function addMinter(address account) returns()
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.contract.Transact(opts, "addMinter", account)
}

// AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
//
// Solidity: function addMinter(address account) returns()
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockSession) AddMinter(account common.Address) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.AddMinter(&_CustomIncrementCoinageMock.TransactOpts, account)
}

// AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
//
// Solidity: function addMinter(address account) returns()
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactorSession) AddMinter(account common.Address) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.AddMinter(&_CustomIncrementCoinageMock.TransactOpts, account)
}

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address spender, uint256 amount) returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.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)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.Approve(&_CustomIncrementCoinageMock.TransactOpts, spender, amount)
}

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

// Burn is a paid mutator transaction binding the contract method 0x42966c68.
//
// Solidity: function burn(uint256 amount) returns()
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactor) Burn(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.contract.Transact(opts, "burn", amount)
}

// Burn is a paid mutator transaction binding the contract method 0x42966c68.
//
// Solidity: function burn(uint256 amount) returns()
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockSession) Burn(amount *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.Burn(&_CustomIncrementCoinageMock.TransactOpts, amount)
}

// Burn is a paid mutator transaction binding the contract method 0x42966c68.
//
// Solidity: function burn(uint256 amount) returns()
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactorSession) Burn(amount *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.Burn(&_CustomIncrementCoinageMock.TransactOpts, amount)
}

// BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790.
//
// Solidity: function burnFrom(address account, uint256 amount) returns()
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactor) BurnFrom(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.contract.Transact(opts, "burnFrom", account, amount)
}

// BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790.
//
// Solidity: function burnFrom(address account, uint256 amount) returns()
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.BurnFrom(&_CustomIncrementCoinageMock.TransactOpts, account, amount)
}

// BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790.
//
// Solidity: function burnFrom(address account, uint256 amount) returns()
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactorSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.BurnFrom(&_CustomIncrementCoinageMock.TransactOpts, account, amount)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.DecreaseAllowance(&_CustomIncrementCoinageMock.TransactOpts, spender, subtractedValue)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.DecreaseAllowance(&_CustomIncrementCoinageMock.TransactOpts, spender, subtractedValue)
}

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

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

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

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.contract.Transact(opts, "increaseAllowance", spender, addedValue)
}

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.IncreaseAllowance(&_CustomIncrementCoinageMock.TransactOpts, spender, addedValue)
}

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.IncreaseAllowance(&_CustomIncrementCoinageMock.TransactOpts, spender, addedValue)
}

// Mint is a paid mutator transaction binding the contract method 0x40c10f19.
//
// Solidity: function mint(address account, uint256 amount) returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactor) Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.contract.Transact(opts, "mint", account, amount)
}

// Mint is a paid mutator transaction binding the contract method 0x40c10f19.
//
// Solidity: function mint(address account, uint256 amount) returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.Mint(&_CustomIncrementCoinageMock.TransactOpts, account, amount)
}

// Mint is a paid mutator transaction binding the contract method 0x40c10f19.
//
// Solidity: function mint(address account, uint256 amount) returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactorSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.Mint(&_CustomIncrementCoinageMock.TransactOpts, account, amount)
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
//
// Solidity: function renounceMinter() returns()
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.contract.Transact(opts, "renounceMinter")
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
//
// Solidity: function renounceMinter() returns()
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockSession) RenounceMinter() (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.RenounceMinter(&_CustomIncrementCoinageMock.TransactOpts)
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
//
// Solidity: function renounceMinter() returns()
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactorSession) RenounceMinter() (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.RenounceMinter(&_CustomIncrementCoinageMock.TransactOpts)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.contract.Transact(opts, "renounceOwnership")
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockSession) RenounceOwnership() (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.RenounceOwnership(&_CustomIncrementCoinageMock.TransactOpts)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactorSession) RenounceOwnership() (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.RenounceOwnership(&_CustomIncrementCoinageMock.TransactOpts)
}

// SetFactor is a paid mutator transaction binding the contract method 0x817e9d31.
//
// Solidity: function setFactor(uint256 factor) returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactor) SetFactor(opts *bind.TransactOpts, factor *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.contract.Transact(opts, "setFactor", factor)
}

// SetFactor is a paid mutator transaction binding the contract method 0x817e9d31.
//
// Solidity: function setFactor(uint256 factor) returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockSession) SetFactor(factor *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.SetFactor(&_CustomIncrementCoinageMock.TransactOpts, factor)
}

// SetFactor is a paid mutator transaction binding the contract method 0x817e9d31.
//
// Solidity: function setFactor(uint256 factor) returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactorSession) SetFactor(factor *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.SetFactor(&_CustomIncrementCoinageMock.TransactOpts, factor)
}

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

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

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

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.contract.Transact(opts, "transferFrom", sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.TransferFrom(&_CustomIncrementCoinageMock.TransactOpts, sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.TransferFrom(&_CustomIncrementCoinageMock.TransactOpts, sender, recipient, amount)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.contract.Transact(opts, "transferOwnership", newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.TransferOwnership(&_CustomIncrementCoinageMock.TransactOpts, newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
	return _CustomIncrementCoinageMock.Contract.TransferOwnership(&_CustomIncrementCoinageMock.TransactOpts, newOwner)
}

// CustomIncrementCoinageMockApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the CustomIncrementCoinageMock contract.
type CustomIncrementCoinageMockApprovalIterator struct {
	Event *CustomIncrementCoinageMockApproval // 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 *CustomIncrementCoinageMockApprovalIterator) 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(CustomIncrementCoinageMockApproval)
			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(CustomIncrementCoinageMockApproval)
		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 *CustomIncrementCoinageMockApprovalIterator) Error() error {
	return it.fail
}

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

// CustomIncrementCoinageMockApproval represents a Approval event raised by the CustomIncrementCoinageMock contract.
type CustomIncrementCoinageMockApproval 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 (_CustomIncrementCoinageMock *CustomIncrementCoinageMockFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*CustomIncrementCoinageMockApprovalIterator, 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 := _CustomIncrementCoinageMock.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
	if err != nil {
		return nil, err
	}
	return &CustomIncrementCoinageMockApprovalIterator{contract: _CustomIncrementCoinageMock.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 (_CustomIncrementCoinageMock *CustomIncrementCoinageMockFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *CustomIncrementCoinageMockApproval, 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 := _CustomIncrementCoinageMock.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(CustomIncrementCoinageMockApproval)
				if err := _CustomIncrementCoinageMock.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 (_CustomIncrementCoinageMock *CustomIncrementCoinageMockFilterer) ParseApproval(log types.Log) (*CustomIncrementCoinageMockApproval, error) {
	event := new(CustomIncrementCoinageMockApproval)
	if err := _CustomIncrementCoinageMock.contract.UnpackLog(event, "Approval", log); err != nil {
		return nil, err
	}
	return event, nil
}

// CustomIncrementCoinageMockFactorIncreasedIterator is returned from FilterFactorIncreased and is used to iterate over the raw logs and unpacked data for FactorIncreased events raised by the CustomIncrementCoinageMock contract.
type CustomIncrementCoinageMockFactorIncreasedIterator struct {
	Event *CustomIncrementCoinageMockFactorIncreased // 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 *CustomIncrementCoinageMockFactorIncreasedIterator) 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(CustomIncrementCoinageMockFactorIncreased)
			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(CustomIncrementCoinageMockFactorIncreased)
		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 *CustomIncrementCoinageMockFactorIncreasedIterator) Error() error {
	return it.fail
}

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

// CustomIncrementCoinageMockFactorIncreased represents a FactorIncreased event raised by the CustomIncrementCoinageMock contract.
type CustomIncrementCoinageMockFactorIncreased struct {
	Factor *big.Int
	Raw    types.Log // Blockchain specific contextual infos
}

// FilterFactorIncreased is a free log retrieval operation binding the contract event 0xe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb6.
//
// Solidity: event FactorIncreased(uint256 factor)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockFilterer) FilterFactorIncreased(opts *bind.FilterOpts) (*CustomIncrementCoinageMockFactorIncreasedIterator, error) {

	logs, sub, err := _CustomIncrementCoinageMock.contract.FilterLogs(opts, "FactorIncreased")
	if err != nil {
		return nil, err
	}
	return &CustomIncrementCoinageMockFactorIncreasedIterator{contract: _CustomIncrementCoinageMock.contract, event: "FactorIncreased", logs: logs, sub: sub}, nil
}

// WatchFactorIncreased is a free log subscription operation binding the contract event 0xe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb6.
//
// Solidity: event FactorIncreased(uint256 factor)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockFilterer) WatchFactorIncreased(opts *bind.WatchOpts, sink chan<- *CustomIncrementCoinageMockFactorIncreased) (event.Subscription, error) {

	logs, sub, err := _CustomIncrementCoinageMock.contract.WatchLogs(opts, "FactorIncreased")
	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(CustomIncrementCoinageMockFactorIncreased)
				if err := _CustomIncrementCoinageMock.contract.UnpackLog(event, "FactorIncreased", 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
}

// ParseFactorIncreased is a log parse operation binding the contract event 0xe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb6.
//
// Solidity: event FactorIncreased(uint256 factor)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockFilterer) ParseFactorIncreased(log types.Log) (*CustomIncrementCoinageMockFactorIncreased, error) {
	event := new(CustomIncrementCoinageMockFactorIncreased)
	if err := _CustomIncrementCoinageMock.contract.UnpackLog(event, "FactorIncreased", log); err != nil {
		return nil, err
	}
	return event, nil
}

// CustomIncrementCoinageMockFactorSetIterator is returned from FilterFactorSet and is used to iterate over the raw logs and unpacked data for FactorSet events raised by the CustomIncrementCoinageMock contract.
type CustomIncrementCoinageMockFactorSetIterator struct {
	Event *CustomIncrementCoinageMockFactorSet // 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 *CustomIncrementCoinageMockFactorSetIterator) 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(CustomIncrementCoinageMockFactorSet)
			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(CustomIncrementCoinageMockFactorSet)
		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 *CustomIncrementCoinageMockFactorSetIterator) Error() error {
	return it.fail
}

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

// CustomIncrementCoinageMockFactorSet represents a FactorSet event raised by the CustomIncrementCoinageMock contract.
type CustomIncrementCoinageMockFactorSet struct {
	Previous *big.Int
	Current  *big.Int
	Raw      types.Log // Blockchain specific contextual infos
}

// FilterFactorSet is a free log retrieval operation binding the contract event 0xafc9085bb15d79bc1e9d87807e2fc5f4c2b631088cb3e38c86cb627c12a0e430.
//
// Solidity: event FactorSet(uint256 previous, uint256 current)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockFilterer) FilterFactorSet(opts *bind.FilterOpts) (*CustomIncrementCoinageMockFactorSetIterator, error) {

	logs, sub, err := _CustomIncrementCoinageMock.contract.FilterLogs(opts, "FactorSet")
	if err != nil {
		return nil, err
	}
	return &CustomIncrementCoinageMockFactorSetIterator{contract: _CustomIncrementCoinageMock.contract, event: "FactorSet", logs: logs, sub: sub}, nil
}

// WatchFactorSet is a free log subscription operation binding the contract event 0xafc9085bb15d79bc1e9d87807e2fc5f4c2b631088cb3e38c86cb627c12a0e430.
//
// Solidity: event FactorSet(uint256 previous, uint256 current)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockFilterer) WatchFactorSet(opts *bind.WatchOpts, sink chan<- *CustomIncrementCoinageMockFactorSet) (event.Subscription, error) {

	logs, sub, err := _CustomIncrementCoinageMock.contract.WatchLogs(opts, "FactorSet")
	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(CustomIncrementCoinageMockFactorSet)
				if err := _CustomIncrementCoinageMock.contract.UnpackLog(event, "FactorSet", 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
}

// ParseFactorSet is a log parse operation binding the contract event 0xafc9085bb15d79bc1e9d87807e2fc5f4c2b631088cb3e38c86cb627c12a0e430.
//
// Solidity: event FactorSet(uint256 previous, uint256 current)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockFilterer) ParseFactorSet(log types.Log) (*CustomIncrementCoinageMockFactorSet, error) {
	event := new(CustomIncrementCoinageMockFactorSet)
	if err := _CustomIncrementCoinageMock.contract.UnpackLog(event, "FactorSet", log); err != nil {
		return nil, err
	}
	return event, nil
}

// CustomIncrementCoinageMockMinterAddedIterator is returned from FilterMinterAdded and is used to iterate over the raw logs and unpacked data for MinterAdded events raised by the CustomIncrementCoinageMock contract.
type CustomIncrementCoinageMockMinterAddedIterator struct {
	Event *CustomIncrementCoinageMockMinterAdded // 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 *CustomIncrementCoinageMockMinterAddedIterator) 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(CustomIncrementCoinageMockMinterAdded)
			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(CustomIncrementCoinageMockMinterAdded)
		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 *CustomIncrementCoinageMockMinterAddedIterator) Error() error {
	return it.fail
}

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

// CustomIncrementCoinageMockMinterAdded represents a MinterAdded event raised by the CustomIncrementCoinageMock contract.
type CustomIncrementCoinageMockMinterAdded struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterMinterAdded is a free log retrieval operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
//
// Solidity: event MinterAdded(address indexed account)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*CustomIncrementCoinageMockMinterAddedIterator, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _CustomIncrementCoinageMock.contract.FilterLogs(opts, "MinterAdded", accountRule)
	if err != nil {
		return nil, err
	}
	return &CustomIncrementCoinageMockMinterAddedIterator{contract: _CustomIncrementCoinageMock.contract, event: "MinterAdded", logs: logs, sub: sub}, nil
}

// WatchMinterAdded is a free log subscription operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
//
// Solidity: event MinterAdded(address indexed account)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *CustomIncrementCoinageMockMinterAdded, account []common.Address) (event.Subscription, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _CustomIncrementCoinageMock.contract.WatchLogs(opts, "MinterAdded", accountRule)
	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(CustomIncrementCoinageMockMinterAdded)
				if err := _CustomIncrementCoinageMock.contract.UnpackLog(event, "MinterAdded", 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
}

// ParseMinterAdded is a log parse operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
//
// Solidity: event MinterAdded(address indexed account)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockFilterer) ParseMinterAdded(log types.Log) (*CustomIncrementCoinageMockMinterAdded, error) {
	event := new(CustomIncrementCoinageMockMinterAdded)
	if err := _CustomIncrementCoinageMock.contract.UnpackLog(event, "MinterAdded", log); err != nil {
		return nil, err
	}
	return event, nil
}

// CustomIncrementCoinageMockMinterRemovedIterator is returned from FilterMinterRemoved and is used to iterate over the raw logs and unpacked data for MinterRemoved events raised by the CustomIncrementCoinageMock contract.
type CustomIncrementCoinageMockMinterRemovedIterator struct {
	Event *CustomIncrementCoinageMockMinterRemoved // 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 *CustomIncrementCoinageMockMinterRemovedIterator) 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(CustomIncrementCoinageMockMinterRemoved)
			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(CustomIncrementCoinageMockMinterRemoved)
		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 *CustomIncrementCoinageMockMinterRemovedIterator) Error() error {
	return it.fail
}

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

// CustomIncrementCoinageMockMinterRemoved represents a MinterRemoved event raised by the CustomIncrementCoinageMock contract.
type CustomIncrementCoinageMockMinterRemoved struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterMinterRemoved is a free log retrieval operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
//
// Solidity: event MinterRemoved(address indexed account)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*CustomIncrementCoinageMockMinterRemovedIterator, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _CustomIncrementCoinageMock.contract.FilterLogs(opts, "MinterRemoved", accountRule)
	if err != nil {
		return nil, err
	}
	return &CustomIncrementCoinageMockMinterRemovedIterator{contract: _CustomIncrementCoinageMock.contract, event: "MinterRemoved", logs: logs, sub: sub}, nil
}

// WatchMinterRemoved is a free log subscription operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
//
// Solidity: event MinterRemoved(address indexed account)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *CustomIncrementCoinageMockMinterRemoved, account []common.Address) (event.Subscription, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _CustomIncrementCoinageMock.contract.WatchLogs(opts, "MinterRemoved", accountRule)
	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(CustomIncrementCoinageMockMinterRemoved)
				if err := _CustomIncrementCoinageMock.contract.UnpackLog(event, "MinterRemoved", 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
}

// ParseMinterRemoved is a log parse operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
//
// Solidity: event MinterRemoved(address indexed account)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockFilterer) ParseMinterRemoved(log types.Log) (*CustomIncrementCoinageMockMinterRemoved, error) {
	event := new(CustomIncrementCoinageMockMinterRemoved)
	if err := _CustomIncrementCoinageMock.contract.UnpackLog(event, "MinterRemoved", log); err != nil {
		return nil, err
	}
	return event, nil
}

// CustomIncrementCoinageMockOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the CustomIncrementCoinageMock contract.
type CustomIncrementCoinageMockOwnershipTransferredIterator struct {
	Event *CustomIncrementCoinageMockOwnershipTransferred // 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 *CustomIncrementCoinageMockOwnershipTransferredIterator) 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(CustomIncrementCoinageMockOwnershipTransferred)
			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(CustomIncrementCoinageMockOwnershipTransferred)
		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 *CustomIncrementCoinageMockOwnershipTransferredIterator) Error() error {
	return it.fail
}

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

// CustomIncrementCoinageMockOwnershipTransferred represents a OwnershipTransferred event raised by the CustomIncrementCoinageMock contract.
type CustomIncrementCoinageMockOwnershipTransferred struct {
	PreviousOwner common.Address
	NewOwner      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*CustomIncrementCoinageMockOwnershipTransferredIterator, error) {

	var previousOwnerRule []interface{}
	for _, previousOwnerItem := range previousOwner {
		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
	}
	var newOwnerRule []interface{}
	for _, newOwnerItem := range newOwner {
		newOwnerRule = append(newOwnerRule, newOwnerItem)
	}

	logs, sub, err := _CustomIncrementCoinageMock.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
	if err != nil {
		return nil, err
	}
	return &CustomIncrementCoinageMockOwnershipTransferredIterator{contract: _CustomIncrementCoinageMock.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
}

// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *CustomIncrementCoinageMockOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {

	var previousOwnerRule []interface{}
	for _, previousOwnerItem := range previousOwner {
		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
	}
	var newOwnerRule []interface{}
	for _, newOwnerItem := range newOwner {
		newOwnerRule = append(newOwnerRule, newOwnerItem)
	}

	logs, sub, err := _CustomIncrementCoinageMock.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
	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(CustomIncrementCoinageMockOwnershipTransferred)
				if err := _CustomIncrementCoinageMock.contract.UnpackLog(event, "OwnershipTransferred", 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
}

// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_CustomIncrementCoinageMock *CustomIncrementCoinageMockFilterer) ParseOwnershipTransferred(log types.Log) (*CustomIncrementCoinageMockOwnershipTransferred, error) {
	event := new(CustomIncrementCoinageMockOwnershipTransferred)
	if err := _CustomIncrementCoinageMock.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
		return nil, err
	}
	return event, nil
}

// CustomIncrementCoinageMockTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the CustomIncrementCoinageMock contract.
type CustomIncrementCoinageMockTransferIterator struct {
	Event *CustomIncrementCoinageMockTransfer // 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 *CustomIncrementCoinageMockTransferIterator) 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(CustomIncrementCoinageMockTransfer)
			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(CustomIncrementCoinageMockTransfer)
		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 *CustomIncrementCoinageMockTransferIterator) Error() error {
	return it.fail
}

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

// CustomIncrementCoinageMockTransfer represents a Transfer event raised by the CustomIncrementCoinageMock contract.
type CustomIncrementCoinageMockTransfer 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 (_CustomIncrementCoinageMock *CustomIncrementCoinageMockFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*CustomIncrementCoinageMockTransferIterator, 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 := _CustomIncrementCoinageMock.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
	if err != nil {
		return nil, err
	}
	return &CustomIncrementCoinageMockTransferIterator{contract: _CustomIncrementCoinageMock.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 (_CustomIncrementCoinageMock *CustomIncrementCoinageMockFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *CustomIncrementCoinageMockTransfer, 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 := _CustomIncrementCoinageMock.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(CustomIncrementCoinageMockTransfer)
				if err := _CustomIncrementCoinageMock.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 (_CustomIncrementCoinageMock *CustomIncrementCoinageMockFilterer) ParseTransfer(log types.Log) (*CustomIncrementCoinageMockTransfer, error) {
	event := new(CustomIncrementCoinageMockTransfer)
	if err := _CustomIncrementCoinageMock.contract.UnpackLog(event, "Transfer", log); err != nil {
		return nil, err
	}
	return event, nil
}

// DSMathABI is the input ABI used to generate the binding from.
const DSMathABI = "[]"

// DSMathBin is the compiled bytecode used for deploying new contracts.
var DSMathBin = "0x6080604052348015600f57600080fd5b50603e80601d6000396000f3fe6080604052600080fdfea265627a7a72315820835d0f37e1207da2fc2224004e6efa210c7e8e2162ae19b8c8b7d3972779837464736f6c634300050c0032"

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

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(DSMathBin), backend)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &DSMath{DSMathCaller: DSMathCaller{contract: contract}, DSMathTransactor: DSMathTransactor{contract: contract}, DSMathFilterer: DSMathFilterer{contract: contract}}, nil
}

// DSMath is an auto generated Go binding around an Ethereum contract.
type DSMath struct {
	DSMathCaller     // Read-only binding to the contract
	DSMathTransactor // Write-only binding to the contract
	DSMathFilterer   // Log filterer for contract events
}

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

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

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

// DSMathSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type DSMathSession struct {
	Contract     *DSMath           // 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
}

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

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

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

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

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

// NewDSMath creates a new instance of DSMath, bound to a specific deployed contract.
func NewDSMath(address common.Address, backend bind.ContractBackend) (*DSMath, error) {
	contract, err := bindDSMath(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &DSMath{DSMathCaller: DSMathCaller{contract: contract}, DSMathTransactor: DSMathTransactor{contract: contract}, DSMathFilterer: DSMathFilterer{contract: contract}}, nil
}

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

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

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

// bindDSMath binds a generic wrapper to an already deployed contract.
func bindDSMath(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(DSMathABI))
	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 (_DSMath *DSMathRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _DSMath.Contract.DSMathCaller.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 (_DSMath *DSMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _DSMath.Contract.DSMathTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_DSMath *DSMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _DSMath.Contract.DSMathTransactor.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 (_DSMath *DSMathCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _DSMath.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 (_DSMath *DSMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _DSMath.Contract.contract.Transfer(opts)
}

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

// DelegateProxyABI is the input ABI used to generate the binding from.
const DelegateProxyABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"implementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"codeAddr\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"proxyType\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"proxyTypeId\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"}]"

// DelegateProxyFuncSigs maps the 4-byte function signature to its string representation.
var DelegateProxyFuncSigs = map[string]string{
	"5c60da1b": "implementation()",
	"4555d5c9": "proxyType()",
}

// DelegateProxy is an auto generated Go binding around an Ethereum contract.
type DelegateProxy struct {
	DelegateProxyCaller     // Read-only binding to the contract
	DelegateProxyTransactor // Write-only binding to the contract
	DelegateProxyFilterer   // Log filterer for contract events
}

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

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

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

// DelegateProxySession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type DelegateProxySession struct {
	Contract     *DelegateProxy    // 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
}

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

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

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

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

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

// NewDelegateProxy creates a new instance of DelegateProxy, bound to a specific deployed contract.
func NewDelegateProxy(address common.Address, backend bind.ContractBackend) (*DelegateProxy, error) {
	contract, err := bindDelegateProxy(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &DelegateProxy{DelegateProxyCaller: DelegateProxyCaller{contract: contract}, DelegateProxyTransactor: DelegateProxyTransactor{contract: contract}, DelegateProxyFilterer: DelegateProxyFilterer{contract: contract}}, nil
}

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

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

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

// bindDelegateProxy binds a generic wrapper to an already deployed contract.
func bindDelegateProxy(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(DelegateProxyABI))
	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 (_DelegateProxy *DelegateProxyRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _DelegateProxy.Contract.DelegateProxyCaller.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 (_DelegateProxy *DelegateProxyRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _DelegateProxy.Contract.DelegateProxyTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_DelegateProxy *DelegateProxyRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _DelegateProxy.Contract.DelegateProxyTransactor.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 (_DelegateProxy *DelegateProxyCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _DelegateProxy.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 (_DelegateProxy *DelegateProxyTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _DelegateProxy.Contract.contract.Transfer(opts)
}

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

// Implementation is a free data retrieval call binding the contract method 0x5c60da1b.
//
// Solidity: function implementation() constant returns(address codeAddr)
func (_DelegateProxy *DelegateProxyCaller) Implementation(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _DelegateProxy.contract.Call(opts, out, "implementation")
	return *ret0, err
}

// Implementation is a free data retrieval call binding the contract method 0x5c60da1b.
//
// Solidity: function implementation() constant returns(address codeAddr)
func (_DelegateProxy *DelegateProxySession) Implementation() (common.Address, error) {
	return _DelegateProxy.Contract.Implementation(&_DelegateProxy.CallOpts)
}

// Implementation is a free data retrieval call binding the contract method 0x5c60da1b.
//
// Solidity: function implementation() constant returns(address codeAddr)
func (_DelegateProxy *DelegateProxyCallerSession) Implementation() (common.Address, error) {
	return _DelegateProxy.Contract.Implementation(&_DelegateProxy.CallOpts)
}

// ProxyType is a free data retrieval call binding the contract method 0x4555d5c9.
//
// Solidity: function proxyType() constant returns(uint256 proxyTypeId)
func (_DelegateProxy *DelegateProxyCaller) ProxyType(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _DelegateProxy.contract.Call(opts, out, "proxyType")
	return *ret0, err
}

// ProxyType is a free data retrieval call binding the contract method 0x4555d5c9.
//
// Solidity: function proxyType() constant returns(uint256 proxyTypeId)
func (_DelegateProxy *DelegateProxySession) ProxyType() (*big.Int, error) {
	return _DelegateProxy.Contract.ProxyType(&_DelegateProxy.CallOpts)
}

// ProxyType is a free data retrieval call binding the contract method 0x4555d5c9.
//
// Solidity: function proxyType() constant returns(uint256 proxyTypeId)
func (_DelegateProxy *DelegateProxyCallerSession) ProxyType() (*big.Int, error) {
	return _DelegateProxy.Contract.ProxyType(&_DelegateProxy.CallOpts)
}

// DepositManagerIABI is the input ABI used to generate the binding from.
const DepositManagerIABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"WITHDRAWAL_DELAY\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"accStaked\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"accStakedAccount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"accStakedRootChain\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"accUnstaked\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"accUnstakedAccount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"accUnstakedRootChain\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"numPendingRequests\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"numRequests\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"pendingUnstaked\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"pendingUnstakedAccount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"pendingUnstakedRootChain\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"processRequest\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"n\",\"type\":\"uint256\"}],\"name\":\"processRequests\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"registry\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"requestWithdrawal\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"requestWithdrawalAll\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"seigManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"seigManager\",\"type\":\"address\"}],\"name\":\"setSeigManager\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"withdrawalRequest\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"withdrawableBlockNumber\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"internalType\":\"bool\",\"name\":\"processed\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"withdrawalRequestIndex\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"wton\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"

// DepositManagerIFuncSigs maps the 4-byte function signature to its string representation.
var DepositManagerIFuncSigs = map[string]string{
	"0ebb172a": "WITHDRAWAL_DELAY()",
	"2d2fab94": "accStaked(address,address)",
	"0055f5c1": "accStakedAccount(address)",
	"e8035ec9": "accStakedRootChain(address)",
	"9d91b87b": "accUnstaked(address,address)",
	"a3543989": "accUnstakedAccount(address)",
	"03dc6510": "accUnstakedRootChain(address)",
	"47e7ef24": "deposit(address,uint256)",
	"5c0df46b": "numPendingRequests(address,address)",
	"f762eb57": "numRequests(address,address)",
	"8da5cb5b": "owner()",
	"2638fdf5": "pendingUnstaked(address,address)",
	"a0b2a913": "pendingUnstakedAccount(address)",
	"a8f3fb98": "pendingUnstakedRootChain(address)",
	"5d6f7cca": "processRequest(address)",
	"06260ceb": "processRequests(address,uint256)",
	"7b103999": "registry()",
	"da95ebf7": "requestWithdrawal(address,uint256)",
	"6b2160b7": "requestWithdrawalAll(address)",
	"6fb7f558": "seigManager()",
	"7657f20a": "setSeigManager(address)",
	"8fbef2d0": "withdrawalRequest(address,address,uint256)",
	"c647f26e": "withdrawalRequestIndex(address,address)",
	"8d62d949": "wton()",
}

// DepositManagerI is an auto generated Go binding around an Ethereum contract.
type DepositManagerI struct {
	DepositManagerICaller     // Read-only binding to the contract
	DepositManagerITransactor // Write-only binding to the contract
	DepositManagerIFilterer   // Log filterer for contract events
}

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

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

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

// DepositManagerISession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type DepositManagerISession struct {
	Contract     *DepositManagerI  // 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
}

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

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

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

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

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

// NewDepositManagerI creates a new instance of DepositManagerI, bound to a specific deployed contract.
func NewDepositManagerI(address common.Address, backend bind.ContractBackend) (*DepositManagerI, error) {
	contract, err := bindDepositManagerI(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &DepositManagerI{DepositManagerICaller: DepositManagerICaller{contract: contract}, DepositManagerITransactor: DepositManagerITransactor{contract: contract}, DepositManagerIFilterer: DepositManagerIFilterer{contract: contract}}, nil
}

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

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

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

// bindDepositManagerI binds a generic wrapper to an already deployed contract.
func bindDepositManagerI(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(DepositManagerIABI))
	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 (_DepositManagerI *DepositManagerIRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _DepositManagerI.Contract.DepositManagerICaller.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 (_DepositManagerI *DepositManagerIRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _DepositManagerI.Contract.DepositManagerITransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_DepositManagerI *DepositManagerIRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _DepositManagerI.Contract.DepositManagerITransactor.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 (_DepositManagerI *DepositManagerICallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _DepositManagerI.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 (_DepositManagerI *DepositManagerITransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _DepositManagerI.Contract.contract.Transfer(opts)
}

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

// WITHDRAWALDELAY is a free data retrieval call binding the contract method 0x0ebb172a.
//
// Solidity: function WITHDRAWAL_DELAY() constant returns(uint256)
func (_DepositManagerI *DepositManagerICaller) WITHDRAWALDELAY(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _DepositManagerI.contract.Call(opts, out, "WITHDRAWAL_DELAY")
	return *ret0, err
}

// WITHDRAWALDELAY is a free data retrieval call binding the contract method 0x0ebb172a.
//
// Solidity: function WITHDRAWAL_DELAY() constant returns(uint256)
func (_DepositManagerI *DepositManagerISession) WITHDRAWALDELAY() (*big.Int, error) {
	return _DepositManagerI.Contract.WITHDRAWALDELAY(&_DepositManagerI.CallOpts)
}

// WITHDRAWALDELAY is a free data retrieval call binding the contract method 0x0ebb172a.
//
// Solidity: function WITHDRAWAL_DELAY() constant returns(uint256)
func (_DepositManagerI *DepositManagerICallerSession) WITHDRAWALDELAY() (*big.Int, error) {
	return _DepositManagerI.Contract.WITHDRAWALDELAY(&_DepositManagerI.CallOpts)
}

// AccStaked is a free data retrieval call binding the contract method 0x2d2fab94.
//
// Solidity: function accStaked(address rootchain, address account) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerICaller) AccStaked(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _DepositManagerI.contract.Call(opts, out, "accStaked", rootchain, account)
	return *ret0, err
}

// AccStaked is a free data retrieval call binding the contract method 0x2d2fab94.
//
// Solidity: function accStaked(address rootchain, address account) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerISession) AccStaked(rootchain common.Address, account common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.AccStaked(&_DepositManagerI.CallOpts, rootchain, account)
}

// AccStaked is a free data retrieval call binding the contract method 0x2d2fab94.
//
// Solidity: function accStaked(address rootchain, address account) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerICallerSession) AccStaked(rootchain common.Address, account common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.AccStaked(&_DepositManagerI.CallOpts, rootchain, account)
}

// AccStakedAccount is a free data retrieval call binding the contract method 0x0055f5c1.
//
// Solidity: function accStakedAccount(address account) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerICaller) AccStakedAccount(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _DepositManagerI.contract.Call(opts, out, "accStakedAccount", account)
	return *ret0, err
}

// AccStakedAccount is a free data retrieval call binding the contract method 0x0055f5c1.
//
// Solidity: function accStakedAccount(address account) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerISession) AccStakedAccount(account common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.AccStakedAccount(&_DepositManagerI.CallOpts, account)
}

// AccStakedAccount is a free data retrieval call binding the contract method 0x0055f5c1.
//
// Solidity: function accStakedAccount(address account) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerICallerSession) AccStakedAccount(account common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.AccStakedAccount(&_DepositManagerI.CallOpts, account)
}

// AccStakedRootChain is a free data retrieval call binding the contract method 0xe8035ec9.
//
// Solidity: function accStakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerICaller) AccStakedRootChain(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _DepositManagerI.contract.Call(opts, out, "accStakedRootChain", rootchain)
	return *ret0, err
}

// AccStakedRootChain is a free data retrieval call binding the contract method 0xe8035ec9.
//
// Solidity: function accStakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerISession) AccStakedRootChain(rootchain common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.AccStakedRootChain(&_DepositManagerI.CallOpts, rootchain)
}

// AccStakedRootChain is a free data retrieval call binding the contract method 0xe8035ec9.
//
// Solidity: function accStakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerICallerSession) AccStakedRootChain(rootchain common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.AccStakedRootChain(&_DepositManagerI.CallOpts, rootchain)
}

// AccUnstaked is a free data retrieval call binding the contract method 0x9d91b87b.
//
// Solidity: function accUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerICaller) AccUnstaked(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _DepositManagerI.contract.Call(opts, out, "accUnstaked", rootchain, account)
	return *ret0, err
}

// AccUnstaked is a free data retrieval call binding the contract method 0x9d91b87b.
//
// Solidity: function accUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerISession) AccUnstaked(rootchain common.Address, account common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.AccUnstaked(&_DepositManagerI.CallOpts, rootchain, account)
}

// AccUnstaked is a free data retrieval call binding the contract method 0x9d91b87b.
//
// Solidity: function accUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerICallerSession) AccUnstaked(rootchain common.Address, account common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.AccUnstaked(&_DepositManagerI.CallOpts, rootchain, account)
}

// AccUnstakedAccount is a free data retrieval call binding the contract method 0xa3543989.
//
// Solidity: function accUnstakedAccount(address account) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerICaller) AccUnstakedAccount(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _DepositManagerI.contract.Call(opts, out, "accUnstakedAccount", account)
	return *ret0, err
}

// AccUnstakedAccount is a free data retrieval call binding the contract method 0xa3543989.
//
// Solidity: function accUnstakedAccount(address account) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerISession) AccUnstakedAccount(account common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.AccUnstakedAccount(&_DepositManagerI.CallOpts, account)
}

// AccUnstakedAccount is a free data retrieval call binding the contract method 0xa3543989.
//
// Solidity: function accUnstakedAccount(address account) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerICallerSession) AccUnstakedAccount(account common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.AccUnstakedAccount(&_DepositManagerI.CallOpts, account)
}

// AccUnstakedRootChain is a free data retrieval call binding the contract method 0x03dc6510.
//
// Solidity: function accUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerICaller) AccUnstakedRootChain(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _DepositManagerI.contract.Call(opts, out, "accUnstakedRootChain", rootchain)
	return *ret0, err
}

// AccUnstakedRootChain is a free data retrieval call binding the contract method 0x03dc6510.
//
// Solidity: function accUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerISession) AccUnstakedRootChain(rootchain common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.AccUnstakedRootChain(&_DepositManagerI.CallOpts, rootchain)
}

// AccUnstakedRootChain is a free data retrieval call binding the contract method 0x03dc6510.
//
// Solidity: function accUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerICallerSession) AccUnstakedRootChain(rootchain common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.AccUnstakedRootChain(&_DepositManagerI.CallOpts, rootchain)
}

// NumPendingRequests is a free data retrieval call binding the contract method 0x5c0df46b.
//
// Solidity: function numPendingRequests(address rootchain, address account) constant returns(uint256)
func (_DepositManagerI *DepositManagerICaller) NumPendingRequests(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _DepositManagerI.contract.Call(opts, out, "numPendingRequests", rootchain, account)
	return *ret0, err
}

// NumPendingRequests is a free data retrieval call binding the contract method 0x5c0df46b.
//
// Solidity: function numPendingRequests(address rootchain, address account) constant returns(uint256)
func (_DepositManagerI *DepositManagerISession) NumPendingRequests(rootchain common.Address, account common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.NumPendingRequests(&_DepositManagerI.CallOpts, rootchain, account)
}

// NumPendingRequests is a free data retrieval call binding the contract method 0x5c0df46b.
//
// Solidity: function numPendingRequests(address rootchain, address account) constant returns(uint256)
func (_DepositManagerI *DepositManagerICallerSession) NumPendingRequests(rootchain common.Address, account common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.NumPendingRequests(&_DepositManagerI.CallOpts, rootchain, account)
}

// NumRequests is a free data retrieval call binding the contract method 0xf762eb57.
//
// Solidity: function numRequests(address rootchain, address account) constant returns(uint256)
func (_DepositManagerI *DepositManagerICaller) NumRequests(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _DepositManagerI.contract.Call(opts, out, "numRequests", rootchain, account)
	return *ret0, err
}

// NumRequests is a free data retrieval call binding the contract method 0xf762eb57.
//
// Solidity: function numRequests(address rootchain, address account) constant returns(uint256)
func (_DepositManagerI *DepositManagerISession) NumRequests(rootchain common.Address, account common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.NumRequests(&_DepositManagerI.CallOpts, rootchain, account)
}

// NumRequests is a free data retrieval call binding the contract method 0xf762eb57.
//
// Solidity: function numRequests(address rootchain, address account) constant returns(uint256)
func (_DepositManagerI *DepositManagerICallerSession) NumRequests(rootchain common.Address, account common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.NumRequests(&_DepositManagerI.CallOpts, rootchain, account)
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_DepositManagerI *DepositManagerICaller) Owner(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _DepositManagerI.contract.Call(opts, out, "owner")
	return *ret0, err
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_DepositManagerI *DepositManagerISession) Owner() (common.Address, error) {
	return _DepositManagerI.Contract.Owner(&_DepositManagerI.CallOpts)
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_DepositManagerI *DepositManagerICallerSession) Owner() (common.Address, error) {
	return _DepositManagerI.Contract.Owner(&_DepositManagerI.CallOpts)
}

// PendingUnstaked is a free data retrieval call binding the contract method 0x2638fdf5.
//
// Solidity: function pendingUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerICaller) PendingUnstaked(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _DepositManagerI.contract.Call(opts, out, "pendingUnstaked", rootchain, account)
	return *ret0, err
}

// PendingUnstaked is a free data retrieval call binding the contract method 0x2638fdf5.
//
// Solidity: function pendingUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerISession) PendingUnstaked(rootchain common.Address, account common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.PendingUnstaked(&_DepositManagerI.CallOpts, rootchain, account)
}

// PendingUnstaked is a free data retrieval call binding the contract method 0x2638fdf5.
//
// Solidity: function pendingUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerICallerSession) PendingUnstaked(rootchain common.Address, account common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.PendingUnstaked(&_DepositManagerI.CallOpts, rootchain, account)
}

// PendingUnstakedAccount is a free data retrieval call binding the contract method 0xa0b2a913.
//
// Solidity: function pendingUnstakedAccount(address account) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerICaller) PendingUnstakedAccount(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _DepositManagerI.contract.Call(opts, out, "pendingUnstakedAccount", account)
	return *ret0, err
}

// PendingUnstakedAccount is a free data retrieval call binding the contract method 0xa0b2a913.
//
// Solidity: function pendingUnstakedAccount(address account) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerISession) PendingUnstakedAccount(account common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.PendingUnstakedAccount(&_DepositManagerI.CallOpts, account)
}

// PendingUnstakedAccount is a free data retrieval call binding the contract method 0xa0b2a913.
//
// Solidity: function pendingUnstakedAccount(address account) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerICallerSession) PendingUnstakedAccount(account common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.PendingUnstakedAccount(&_DepositManagerI.CallOpts, account)
}

// PendingUnstakedRootChain is a free data retrieval call binding the contract method 0xa8f3fb98.
//
// Solidity: function pendingUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerICaller) PendingUnstakedRootChain(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _DepositManagerI.contract.Call(opts, out, "pendingUnstakedRootChain", rootchain)
	return *ret0, err
}

// PendingUnstakedRootChain is a free data retrieval call binding the contract method 0xa8f3fb98.
//
// Solidity: function pendingUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerISession) PendingUnstakedRootChain(rootchain common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.PendingUnstakedRootChain(&_DepositManagerI.CallOpts, rootchain)
}

// PendingUnstakedRootChain is a free data retrieval call binding the contract method 0xa8f3fb98.
//
// Solidity: function pendingUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
func (_DepositManagerI *DepositManagerICallerSession) PendingUnstakedRootChain(rootchain common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.PendingUnstakedRootChain(&_DepositManagerI.CallOpts, rootchain)
}

// Registry is a free data retrieval call binding the contract method 0x7b103999.
//
// Solidity: function registry() constant returns(address)
func (_DepositManagerI *DepositManagerICaller) Registry(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _DepositManagerI.contract.Call(opts, out, "registry")
	return *ret0, err
}

// Registry is a free data retrieval call binding the contract method 0x7b103999.
//
// Solidity: function registry() constant returns(address)
func (_DepositManagerI *DepositManagerISession) Registry() (common.Address, error) {
	return _DepositManagerI.Contract.Registry(&_DepositManagerI.CallOpts)
}

// Registry is a free data retrieval call binding the contract method 0x7b103999.
//
// Solidity: function registry() constant returns(address)
func (_DepositManagerI *DepositManagerICallerSession) Registry() (common.Address, error) {
	return _DepositManagerI.Contract.Registry(&_DepositManagerI.CallOpts)
}

// SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
//
// Solidity: function seigManager() constant returns(address)
func (_DepositManagerI *DepositManagerICaller) SeigManager(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _DepositManagerI.contract.Call(opts, out, "seigManager")
	return *ret0, err
}

// SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
//
// Solidity: function seigManager() constant returns(address)
func (_DepositManagerI *DepositManagerISession) SeigManager() (common.Address, error) {
	return _DepositManagerI.Contract.SeigManager(&_DepositManagerI.CallOpts)
}

// SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
//
// Solidity: function seigManager() constant returns(address)
func (_DepositManagerI *DepositManagerICallerSession) SeigManager() (common.Address, error) {
	return _DepositManagerI.Contract.SeigManager(&_DepositManagerI.CallOpts)
}

// WithdrawalRequest is a free data retrieval call binding the contract method 0x8fbef2d0.
//
// Solidity: function withdrawalRequest(address rootchain, address account, uint256 index) constant returns(uint128 withdrawableBlockNumber, uint128 amount, bool processed)
func (_DepositManagerI *DepositManagerICaller) WithdrawalRequest(opts *bind.CallOpts, rootchain common.Address, account common.Address, index *big.Int) (struct {
	WithdrawableBlockNumber *big.Int
	Amount                  *big.Int
	Processed               bool
}, error) {
	ret := new(struct {
		WithdrawableBlockNumber *big.Int
		Amount                  *big.Int
		Processed               bool
	})
	out := ret
	err := _DepositManagerI.contract.Call(opts, out, "withdrawalRequest", rootchain, account, index)
	return *ret, err
}

// WithdrawalRequest is a free data retrieval call binding the contract method 0x8fbef2d0.
//
// Solidity: function withdrawalRequest(address rootchain, address account, uint256 index) constant returns(uint128 withdrawableBlockNumber, uint128 amount, bool processed)
func (_DepositManagerI *DepositManagerISession) WithdrawalRequest(rootchain common.Address, account common.Address, index *big.Int) (struct {
	WithdrawableBlockNumber *big.Int
	Amount                  *big.Int
	Processed               bool
}, error) {
	return _DepositManagerI.Contract.WithdrawalRequest(&_DepositManagerI.CallOpts, rootchain, account, index)
}

// WithdrawalRequest is a free data retrieval call binding the contract method 0x8fbef2d0.
//
// Solidity: function withdrawalRequest(address rootchain, address account, uint256 index) constant returns(uint128 withdrawableBlockNumber, uint128 amount, bool processed)
func (_DepositManagerI *DepositManagerICallerSession) WithdrawalRequest(rootchain common.Address, account common.Address, index *big.Int) (struct {
	WithdrawableBlockNumber *big.Int
	Amount                  *big.Int
	Processed               bool
}, error) {
	return _DepositManagerI.Contract.WithdrawalRequest(&_DepositManagerI.CallOpts, rootchain, account, index)
}

// WithdrawalRequestIndex is a free data retrieval call binding the contract method 0xc647f26e.
//
// Solidity: function withdrawalRequestIndex(address rootchain, address account) constant returns(uint256 index)
func (_DepositManagerI *DepositManagerICaller) WithdrawalRequestIndex(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _DepositManagerI.contract.Call(opts, out, "withdrawalRequestIndex", rootchain, account)
	return *ret0, err
}

// WithdrawalRequestIndex is a free data retrieval call binding the contract method 0xc647f26e.
//
// Solidity: function withdrawalRequestIndex(address rootchain, address account) constant returns(uint256 index)
func (_DepositManagerI *DepositManagerISession) WithdrawalRequestIndex(rootchain common.Address, account common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.WithdrawalRequestIndex(&_DepositManagerI.CallOpts, rootchain, account)
}

// WithdrawalRequestIndex is a free data retrieval call binding the contract method 0xc647f26e.
//
// Solidity: function withdrawalRequestIndex(address rootchain, address account) constant returns(uint256 index)
func (_DepositManagerI *DepositManagerICallerSession) WithdrawalRequestIndex(rootchain common.Address, account common.Address) (*big.Int, error) {
	return _DepositManagerI.Contract.WithdrawalRequestIndex(&_DepositManagerI.CallOpts, rootchain, account)
}

// Wton is a free data retrieval call binding the contract method 0x8d62d949.
//
// Solidity: function wton() constant returns(address)
func (_DepositManagerI *DepositManagerICaller) Wton(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _DepositManagerI.contract.Call(opts, out, "wton")
	return *ret0, err
}

// Wton is a free data retrieval call binding the contract method 0x8d62d949.
//
// Solidity: function wton() constant returns(address)
func (_DepositManagerI *DepositManagerISession) Wton() (common.Address, error) {
	return _DepositManagerI.Contract.Wton(&_DepositManagerI.CallOpts)
}

// Wton is a free data retrieval call binding the contract method 0x8d62d949.
//
// Solidity: function wton() constant returns(address)
func (_DepositManagerI *DepositManagerICallerSession) Wton() (common.Address, error) {
	return _DepositManagerI.Contract.Wton(&_DepositManagerI.CallOpts)
}

// Deposit is a paid mutator transaction binding the contract method 0x47e7ef24.
//
// Solidity: function deposit(address rootchain, uint256 amount) returns(bool)
func (_DepositManagerI *DepositManagerITransactor) Deposit(opts *bind.TransactOpts, rootchain common.Address, amount *big.Int) (*types.Transaction, error) {
	return _DepositManagerI.contract.Transact(opts, "deposit", rootchain, amount)
}

// Deposit is a paid mutator transaction binding the contract method 0x47e7ef24.
//
// Solidity: function deposit(address rootchain, uint256 amount) returns(bool)
func (_DepositManagerI *DepositManagerISession) Deposit(rootchain common.Address, amount *big.Int) (*types.Transaction, error) {
	return _DepositManagerI.Contract.Deposit(&_DepositManagerI.TransactOpts, rootchain, amount)
}

// Deposit is a paid mutator transaction binding the contract method 0x47e7ef24.
//
// Solidity: function deposit(address rootchain, uint256 amount) returns(bool)
func (_DepositManagerI *DepositManagerITransactorSession) Deposit(rootchain common.Address, amount *big.Int) (*types.Transaction, error) {
	return _DepositManagerI.Contract.Deposit(&_DepositManagerI.TransactOpts, rootchain, amount)
}

// ProcessRequest is a paid mutator transaction binding the contract method 0x5d6f7cca.
//
// Solidity: function processRequest(address rootchain) returns(bool)
func (_DepositManagerI *DepositManagerITransactor) ProcessRequest(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) {
	return _DepositManagerI.contract.Transact(opts, "processRequest", rootchain)
}

// ProcessRequest is a paid mutator transaction binding the contract method 0x5d6f7cca.
//
// Solidity: function processRequest(address rootchain) returns(bool)
func (_DepositManagerI *DepositManagerISession) ProcessRequest(rootchain common.Address) (*types.Transaction, error) {
	return _DepositManagerI.Contract.ProcessRequest(&_DepositManagerI.TransactOpts, rootchain)
}

// ProcessRequest is a paid mutator transaction binding the contract method 0x5d6f7cca.
//
// Solidity: function processRequest(address rootchain) returns(bool)
func (_DepositManagerI *DepositManagerITransactorSession) ProcessRequest(rootchain common.Address) (*types.Transaction, error) {
	return _DepositManagerI.Contract.ProcessRequest(&_DepositManagerI.TransactOpts, rootchain)
}

// ProcessRequests is a paid mutator transaction binding the contract method 0x06260ceb.
//
// Solidity: function processRequests(address rootchain, uint256 n) returns(bool)
func (_DepositManagerI *DepositManagerITransactor) ProcessRequests(opts *bind.TransactOpts, rootchain common.Address, n *big.Int) (*types.Transaction, error) {
	return _DepositManagerI.contract.Transact(opts, "processRequests", rootchain, n)
}

// ProcessRequests is a paid mutator transaction binding the contract method 0x06260ceb.
//
// Solidity: function processRequests(address rootchain, uint256 n) returns(bool)
func (_DepositManagerI *DepositManagerISession) ProcessRequests(rootchain common.Address, n *big.Int) (*types.Transaction, error) {
	return _DepositManagerI.Contract.ProcessRequests(&_DepositManagerI.TransactOpts, rootchain, n)
}

// ProcessRequests is a paid mutator transaction binding the contract method 0x06260ceb.
//
// Solidity: function processRequests(address rootchain, uint256 n) returns(bool)
func (_DepositManagerI *DepositManagerITransactorSession) ProcessRequests(rootchain common.Address, n *big.Int) (*types.Transaction, error) {
	return _DepositManagerI.Contract.ProcessRequests(&_DepositManagerI.TransactOpts, rootchain, n)
}

// RequestWithdrawal is a paid mutator transaction binding the contract method 0xda95ebf7.
//
// Solidity: function requestWithdrawal(address rootchain, uint256 amount) returns(bool)
func (_DepositManagerI *DepositManagerITransactor) RequestWithdrawal(opts *bind.TransactOpts, rootchain common.Address, amount *big.Int) (*types.Transaction, error) {
	return _DepositManagerI.contract.Transact(opts, "requestWithdrawal", rootchain, amount)
}

// RequestWithdrawal is a paid mutator transaction binding the contract method 0xda95ebf7.
//
// Solidity: function requestWithdrawal(address rootchain, uint256 amount) returns(bool)
func (_DepositManagerI *DepositManagerISession) RequestWithdrawal(rootchain common.Address, amount *big.Int) (*types.Transaction, error) {
	return _DepositManagerI.Contract.RequestWithdrawal(&_DepositManagerI.TransactOpts, rootchain, amount)
}

// RequestWithdrawal is a paid mutator transaction binding the contract method 0xda95ebf7.
//
// Solidity: function requestWithdrawal(address rootchain, uint256 amount) returns(bool)
func (_DepositManagerI *DepositManagerITransactorSession) RequestWithdrawal(rootchain common.Address, amount *big.Int) (*types.Transaction, error) {
	return _DepositManagerI.Contract.RequestWithdrawal(&_DepositManagerI.TransactOpts, rootchain, amount)
}

// RequestWithdrawalAll is a paid mutator transaction binding the contract method 0x6b2160b7.
//
// Solidity: function requestWithdrawalAll(address rootchain) returns(bool)
func (_DepositManagerI *DepositManagerITransactor) RequestWithdrawalAll(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) {
	return _DepositManagerI.contract.Transact(opts, "requestWithdrawalAll", rootchain)
}

// RequestWithdrawalAll is a paid mutator transaction binding the contract method 0x6b2160b7.
//
// Solidity: function requestWithdrawalAll(address rootchain) returns(bool)
func (_DepositManagerI *DepositManagerISession) RequestWithdrawalAll(rootchain common.Address) (*types.Transaction, error) {
	return _DepositManagerI.Contract.RequestWithdrawalAll(&_DepositManagerI.TransactOpts, rootchain)
}

// RequestWithdrawalAll is a paid mutator transaction binding the contract method 0x6b2160b7.
//
// Solidity: function requestWithdrawalAll(address rootchain) returns(bool)
func (_DepositManagerI *DepositManagerITransactorSession) RequestWithdrawalAll(rootchain common.Address) (*types.Transaction, error) {
	return _DepositManagerI.Contract.RequestWithdrawalAll(&_DepositManagerI.TransactOpts, rootchain)
}

// SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.
//
// Solidity: function setSeigManager(address seigManager) returns()
func (_DepositManagerI *DepositManagerITransactor) SetSeigManager(opts *bind.TransactOpts, seigManager common.Address) (*types.Transaction, error) {
	return _DepositManagerI.contract.Transact(opts, "setSeigManager", seigManager)
}

// SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.
//
// Solidity: function setSeigManager(address seigManager) returns()
func (_DepositManagerI *DepositManagerISession) SetSeigManager(seigManager common.Address) (*types.Transaction, error) {
	return _DepositManagerI.Contract.SetSeigManager(&_DepositManagerI.TransactOpts, seigManager)
}

// SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.
//
// Solidity: function setSeigManager(address seigManager) returns()
func (_DepositManagerI *DepositManagerITransactorSession) SetSeigManager(seigManager common.Address) (*types.Transaction, error) {
	return _DepositManagerI.Contract.SetSeigManager(&_DepositManagerI.TransactOpts, seigManager)
}

// ERC20ABI is the input ABI used to generate the binding from.
const ERC20ABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"

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

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

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

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ERC20Bin), backend)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &ERC20{ERC20Caller: ERC20Caller{contract: contract}, ERC20Transactor: ERC20Transactor{contract: contract}, ERC20Filterer: ERC20Filterer{contract: contract}}, nil
}

// ERC20 is an auto generated Go binding around an Ethereum contract.
type ERC20 struct {
	ERC20Caller     // Read-only binding to the contract
	ERC20Transactor // Write-only binding to the contract
	ERC20Filterer   // Log filterer for contract events
}

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

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

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

// ERC20Session is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type ERC20Session struct {
	Contract     *ERC20            // 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
}

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

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

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

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

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

// NewERC20 creates a new instance of ERC20, bound to a specific deployed contract.
func NewERC20(address common.Address, backend bind.ContractBackend) (*ERC20, error) {
	contract, err := bindERC20(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &ERC20{ERC20Caller: ERC20Caller{contract: contract}, ERC20Transactor: ERC20Transactor{contract: contract}, ERC20Filterer: ERC20Filterer{contract: contract}}, nil
}

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

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

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

// bindERC20 binds a generic wrapper to an already deployed contract.
func bindERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(ERC20ABI))
	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 (_ERC20 *ERC20Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _ERC20.Contract.ERC20Caller.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 (_ERC20 *ERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _ERC20.Contract.ERC20Transactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_ERC20 *ERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _ERC20.Contract.ERC20Transactor.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 (_ERC20 *ERC20CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _ERC20.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 (_ERC20 *ERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _ERC20.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_ERC20 *ERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _ERC20.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) constant returns(uint256)
func (_ERC20 *ERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _ERC20.contract.Call(opts, out, "allowance", owner, spender)
	return *ret0, err
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_ERC20 *ERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _ERC20.Contract.Allowance(&_ERC20.CallOpts, owner, spender)
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_ERC20 *ERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _ERC20.Contract.Allowance(&_ERC20.CallOpts, owner, spender)
}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address account) constant returns(uint256)
func (_ERC20 *ERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _ERC20.contract.Call(opts, out, "balanceOf", account)
	return *ret0, err
}

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

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

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() constant returns(uint256)
func (_ERC20 *ERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _ERC20.contract.Call(opts, out, "totalSupply")
	return *ret0, err
}

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

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

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address spender, uint256 amount) returns(bool)
func (_ERC20 *ERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20.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)
func (_ERC20 *ERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20.Contract.Approve(&_ERC20.TransactOpts, spender, amount)
}

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

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_ERC20 *ERC20Transactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _ERC20.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_ERC20 *ERC20Session) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _ERC20.Contract.DecreaseAllowance(&_ERC20.TransactOpts, spender, subtractedValue)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_ERC20 *ERC20TransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _ERC20.Contract.DecreaseAllowance(&_ERC20.TransactOpts, spender, subtractedValue)
}

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_ERC20 *ERC20Transactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _ERC20.contract.Transact(opts, "increaseAllowance", spender, addedValue)
}

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_ERC20 *ERC20Session) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _ERC20.Contract.IncreaseAllowance(&_ERC20.TransactOpts, spender, addedValue)
}

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_ERC20 *ERC20TransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _ERC20.Contract.IncreaseAllowance(&_ERC20.TransactOpts, spender, addedValue)
}

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

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

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

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_ERC20 *ERC20Transactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20.contract.Transact(opts, "transferFrom", sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_ERC20 *ERC20Session) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20.Contract.TransferFrom(&_ERC20.TransactOpts, sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_ERC20 *ERC20TransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20.Contract.TransferFrom(&_ERC20.TransactOpts, sender, recipient, amount)
}

// ERC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ERC20 contract.
type ERC20ApprovalIterator struct {
	Event *ERC20Approval // 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 *ERC20ApprovalIterator) 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(ERC20Approval)
			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(ERC20Approval)
		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 *ERC20ApprovalIterator) Error() error {
	return it.fail
}

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

// ERC20Approval represents a Approval event raised by the ERC20 contract.
type ERC20Approval 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 (_ERC20 *ERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20ApprovalIterator, 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 := _ERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
	if err != nil {
		return nil, err
	}
	return &ERC20ApprovalIterator{contract: _ERC20.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 (_ERC20 *ERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20Approval, 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 := _ERC20.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(ERC20Approval)
				if err := _ERC20.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 (_ERC20 *ERC20Filterer) ParseApproval(log types.Log) (*ERC20Approval, error) {
	event := new(ERC20Approval)
	if err := _ERC20.contract.UnpackLog(event, "Approval", log); err != nil {
		return nil, err
	}
	return event, nil
}

// ERC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC20 contract.
type ERC20TransferIterator struct {
	Event *ERC20Transfer // 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 *ERC20TransferIterator) 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(ERC20Transfer)
			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(ERC20Transfer)
		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 *ERC20TransferIterator) Error() error {
	return it.fail
}

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

// ERC20Transfer represents a Transfer event raised by the ERC20 contract.
type ERC20Transfer 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 (_ERC20 *ERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20TransferIterator, 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 := _ERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
	if err != nil {
		return nil, err
	}
	return &ERC20TransferIterator{contract: _ERC20.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 (_ERC20 *ERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20Transfer, 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 := _ERC20.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(ERC20Transfer)
				if err := _ERC20.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 (_ERC20 *ERC20Filterer) ParseTransfer(log types.Log) (*ERC20Transfer, error) {
	event := new(ERC20Transfer)
	if err := _ERC20.contract.UnpackLog(event, "Transfer", log); err != nil {
		return nil, err
	}
	return event, nil
}

// ERC20BurnableABI is the input ABI used to generate the binding from.
const ERC20BurnableABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burnFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"

// ERC20BurnableFuncSigs maps the 4-byte function signature to its string representation.
var ERC20BurnableFuncSigs = map[string]string{
	"dd62ed3e": "allowance(address,address)",
	"095ea7b3": "approve(address,uint256)",
	"70a08231": "balanceOf(address)",
	"42966c68": "burn(uint256)",
	"79cc6790": "burnFrom(address,uint256)",
	"a457c2d7": "decreaseAllowance(address,uint256)",
	"39509351": "increaseAllowance(address,uint256)",
	"18160ddd": "totalSupply()",
	"a9059cbb": "transfer(address,uint256)",
	"23b872dd": "transferFrom(address,address,uint256)",
}

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

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

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ERC20BurnableBin), backend)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &ERC20Burnable{ERC20BurnableCaller: ERC20BurnableCaller{contract: contract}, ERC20BurnableTransactor: ERC20BurnableTransactor{contract: contract}, ERC20BurnableFilterer: ERC20BurnableFilterer{contract: contract}}, nil
}

// ERC20Burnable is an auto generated Go binding around an Ethereum contract.
type ERC20Burnable struct {
	ERC20BurnableCaller     // Read-only binding to the contract
	ERC20BurnableTransactor // Write-only binding to the contract
	ERC20BurnableFilterer   // Log filterer for contract events
}

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

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

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

// ERC20BurnableSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type ERC20BurnableSession struct {
	Contract     *ERC20Burnable    // 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
}

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

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

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

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

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

// NewERC20Burnable creates a new instance of ERC20Burnable, bound to a specific deployed contract.
func NewERC20Burnable(address common.Address, backend bind.ContractBackend) (*ERC20Burnable, error) {
	contract, err := bindERC20Burnable(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &ERC20Burnable{ERC20BurnableCaller: ERC20BurnableCaller{contract: contract}, ERC20BurnableTransactor: ERC20BurnableTransactor{contract: contract}, ERC20BurnableFilterer: ERC20BurnableFilterer{contract: contract}}, nil
}

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

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

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

// bindERC20Burnable binds a generic wrapper to an already deployed contract.
func bindERC20Burnable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(ERC20BurnableABI))
	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 (_ERC20Burnable *ERC20BurnableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _ERC20Burnable.Contract.ERC20BurnableCaller.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 (_ERC20Burnable *ERC20BurnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _ERC20Burnable.Contract.ERC20BurnableTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_ERC20Burnable *ERC20BurnableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _ERC20Burnable.Contract.ERC20BurnableTransactor.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 (_ERC20Burnable *ERC20BurnableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _ERC20Burnable.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 (_ERC20Burnable *ERC20BurnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _ERC20Burnable.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_ERC20Burnable *ERC20BurnableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _ERC20Burnable.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) constant returns(uint256)
func (_ERC20Burnable *ERC20BurnableCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _ERC20Burnable.contract.Call(opts, out, "allowance", owner, spender)
	return *ret0, err
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_ERC20Burnable *ERC20BurnableSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _ERC20Burnable.Contract.Allowance(&_ERC20Burnable.CallOpts, owner, spender)
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_ERC20Burnable *ERC20BurnableCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _ERC20Burnable.Contract.Allowance(&_ERC20Burnable.CallOpts, owner, spender)
}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address account) constant returns(uint256)
func (_ERC20Burnable *ERC20BurnableCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _ERC20Burnable.contract.Call(opts, out, "balanceOf", account)
	return *ret0, err
}

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

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

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() constant returns(uint256)
func (_ERC20Burnable *ERC20BurnableCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _ERC20Burnable.contract.Call(opts, out, "totalSupply")
	return *ret0, err
}

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

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

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address spender, uint256 amount) returns(bool)
func (_ERC20Burnable *ERC20BurnableTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Burnable.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)
func (_ERC20Burnable *ERC20BurnableSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Burnable.Contract.Approve(&_ERC20Burnable.TransactOpts, spender, amount)
}

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

// Burn is a paid mutator transaction binding the contract method 0x42966c68.
//
// Solidity: function burn(uint256 amount) returns()
func (_ERC20Burnable *ERC20BurnableTransactor) Burn(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Burnable.contract.Transact(opts, "burn", amount)
}

// Burn is a paid mutator transaction binding the contract method 0x42966c68.
//
// Solidity: function burn(uint256 amount) returns()
func (_ERC20Burnable *ERC20BurnableSession) Burn(amount *big.Int) (*types.Transaction, error) {
	return _ERC20Burnable.Contract.Burn(&_ERC20Burnable.TransactOpts, amount)
}

// Burn is a paid mutator transaction binding the contract method 0x42966c68.
//
// Solidity: function burn(uint256 amount) returns()
func (_ERC20Burnable *ERC20BurnableTransactorSession) Burn(amount *big.Int) (*types.Transaction, error) {
	return _ERC20Burnable.Contract.Burn(&_ERC20Burnable.TransactOpts, amount)
}

// BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790.
//
// Solidity: function burnFrom(address account, uint256 amount) returns()
func (_ERC20Burnable *ERC20BurnableTransactor) BurnFrom(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Burnable.contract.Transact(opts, "burnFrom", account, amount)
}

// BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790.
//
// Solidity: function burnFrom(address account, uint256 amount) returns()
func (_ERC20Burnable *ERC20BurnableSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Burnable.Contract.BurnFrom(&_ERC20Burnable.TransactOpts, account, amount)
}

// BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790.
//
// Solidity: function burnFrom(address account, uint256 amount) returns()
func (_ERC20Burnable *ERC20BurnableTransactorSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Burnable.Contract.BurnFrom(&_ERC20Burnable.TransactOpts, account, amount)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_ERC20Burnable *ERC20BurnableTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _ERC20Burnable.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_ERC20Burnable *ERC20BurnableSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _ERC20Burnable.Contract.DecreaseAllowance(&_ERC20Burnable.TransactOpts, spender, subtractedValue)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_ERC20Burnable *ERC20BurnableTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _ERC20Burnable.Contract.DecreaseAllowance(&_ERC20Burnable.TransactOpts, spender, subtractedValue)
}

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_ERC20Burnable *ERC20BurnableTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _ERC20Burnable.contract.Transact(opts, "increaseAllowance", spender, addedValue)
}

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_ERC20Burnable *ERC20BurnableSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _ERC20Burnable.Contract.IncreaseAllowance(&_ERC20Burnable.TransactOpts, spender, addedValue)
}

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_ERC20Burnable *ERC20BurnableTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _ERC20Burnable.Contract.IncreaseAllowance(&_ERC20Burnable.TransactOpts, spender, addedValue)
}

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

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

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

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_ERC20Burnable *ERC20BurnableTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Burnable.contract.Transact(opts, "transferFrom", sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_ERC20Burnable *ERC20BurnableSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Burnable.Contract.TransferFrom(&_ERC20Burnable.TransactOpts, sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_ERC20Burnable *ERC20BurnableTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Burnable.Contract.TransferFrom(&_ERC20Burnable.TransactOpts, sender, recipient, amount)
}

// ERC20BurnableApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ERC20Burnable contract.
type ERC20BurnableApprovalIterator struct {
	Event *ERC20BurnableApproval // 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 *ERC20BurnableApprovalIterator) 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(ERC20BurnableApproval)
			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(ERC20BurnableApproval)
		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 *ERC20BurnableApprovalIterator) Error() error {
	return it.fail
}

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

// ERC20BurnableApproval represents a Approval event raised by the ERC20Burnable contract.
type ERC20BurnableApproval 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 (_ERC20Burnable *ERC20BurnableFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20BurnableApprovalIterator, 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 := _ERC20Burnable.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
	if err != nil {
		return nil, err
	}
	return &ERC20BurnableApprovalIterator{contract: _ERC20Burnable.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 (_ERC20Burnable *ERC20BurnableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20BurnableApproval, 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 := _ERC20Burnable.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(ERC20BurnableApproval)
				if err := _ERC20Burnable.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 (_ERC20Burnable *ERC20BurnableFilterer) ParseApproval(log types.Log) (*ERC20BurnableApproval, error) {
	event := new(ERC20BurnableApproval)
	if err := _ERC20Burnable.contract.UnpackLog(event, "Approval", log); err != nil {
		return nil, err
	}
	return event, nil
}

// ERC20BurnableTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC20Burnable contract.
type ERC20BurnableTransferIterator struct {
	Event *ERC20BurnableTransfer // 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 *ERC20BurnableTransferIterator) 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(ERC20BurnableTransfer)
			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(ERC20BurnableTransfer)
		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 *ERC20BurnableTransferIterator) Error() error {
	return it.fail
}

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

// ERC20BurnableTransfer represents a Transfer event raised by the ERC20Burnable contract.
type ERC20BurnableTransfer 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 (_ERC20Burnable *ERC20BurnableFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20BurnableTransferIterator, 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 := _ERC20Burnable.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
	if err != nil {
		return nil, err
	}
	return &ERC20BurnableTransferIterator{contract: _ERC20Burnable.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 (_ERC20Burnable *ERC20BurnableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20BurnableTransfer, 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 := _ERC20Burnable.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(ERC20BurnableTransfer)
				if err := _ERC20Burnable.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 (_ERC20Burnable *ERC20BurnableFilterer) ParseTransfer(log types.Log) (*ERC20BurnableTransfer, error) {
	event := new(ERC20BurnableTransfer)
	if err := _ERC20Burnable.contract.UnpackLog(event, "Transfer", log); err != nil {
		return nil, err
	}
	return event, nil
}

// ERC20DetailedABI is the input ABI used to generate the binding from.
const ERC20DetailedABI = "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol\",\"type\":\"string\"},{\"internalType\":\"uint8\",\"name\":\"decimals\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"

// ERC20DetailedFuncSigs maps the 4-byte function signature to its string representation.
var ERC20DetailedFuncSigs = map[string]string{
	"dd62ed3e": "allowance(address,address)",
	"095ea7b3": "approve(address,uint256)",
	"70a08231": "balanceOf(address)",
	"313ce567": "decimals()",
	"06fdde03": "name()",
	"95d89b41": "symbol()",
	"18160ddd": "totalSupply()",
	"a9059cbb": "transfer(address,uint256)",
	"23b872dd": "transferFrom(address,address,uint256)",
}

// ERC20Detailed is an auto generated Go binding around an Ethereum contract.
type ERC20Detailed struct {
	ERC20DetailedCaller     // Read-only binding to the contract
	ERC20DetailedTransactor // Write-only binding to the contract
	ERC20DetailedFilterer   // Log filterer for contract events
}

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

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

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

// ERC20DetailedSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type ERC20DetailedSession struct {
	Contract     *ERC20Detailed    // 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
}

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

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

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

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

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

// NewERC20Detailed creates a new instance of ERC20Detailed, bound to a specific deployed contract.
func NewERC20Detailed(address common.Address, backend bind.ContractBackend) (*ERC20Detailed, error) {
	contract, err := bindERC20Detailed(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &ERC20Detailed{ERC20DetailedCaller: ERC20DetailedCaller{contract: contract}, ERC20DetailedTransactor: ERC20DetailedTransactor{contract: contract}, ERC20DetailedFilterer: ERC20DetailedFilterer{contract: contract}}, nil
}

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

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

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

// bindERC20Detailed binds a generic wrapper to an already deployed contract.
func bindERC20Detailed(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(ERC20DetailedABI))
	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 (_ERC20Detailed *ERC20DetailedRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _ERC20Detailed.Contract.ERC20DetailedCaller.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 (_ERC20Detailed *ERC20DetailedRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _ERC20Detailed.Contract.ERC20DetailedTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_ERC20Detailed *ERC20DetailedRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _ERC20Detailed.Contract.ERC20DetailedTransactor.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 (_ERC20Detailed *ERC20DetailedCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _ERC20Detailed.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 (_ERC20Detailed *ERC20DetailedTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _ERC20Detailed.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_ERC20Detailed *ERC20DetailedTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _ERC20Detailed.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) constant returns(uint256)
func (_ERC20Detailed *ERC20DetailedCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _ERC20Detailed.contract.Call(opts, out, "allowance", owner, spender)
	return *ret0, err
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_ERC20Detailed *ERC20DetailedSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _ERC20Detailed.Contract.Allowance(&_ERC20Detailed.CallOpts, owner, spender)
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_ERC20Detailed *ERC20DetailedCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _ERC20Detailed.Contract.Allowance(&_ERC20Detailed.CallOpts, owner, spender)
}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address account) constant returns(uint256)
func (_ERC20Detailed *ERC20DetailedCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _ERC20Detailed.contract.Call(opts, out, "balanceOf", account)
	return *ret0, err
}

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

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

// Decimals is a free data retrieval call binding the contract method 0x313ce567.
//
// Solidity: function decimals() constant returns(uint8)
func (_ERC20Detailed *ERC20DetailedCaller) Decimals(opts *bind.CallOpts) (uint8, error) {
	var (
		ret0 = new(uint8)
	)
	out := ret0
	err := _ERC20Detailed.contract.Call(opts, out, "decimals")
	return *ret0, err
}

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

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

// Name is a free data retrieval call binding the contract method 0x06fdde03.
//
// Solidity: function name() constant returns(string)
func (_ERC20Detailed *ERC20DetailedCaller) Name(opts *bind.CallOpts) (string, error) {
	var (
		ret0 = new(string)
	)
	out := ret0
	err := _ERC20Detailed.contract.Call(opts, out, "name")
	return *ret0, err
}

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

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

// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
//
// Solidity: function symbol() constant returns(string)
func (_ERC20Detailed *ERC20DetailedCaller) Symbol(opts *bind.CallOpts) (string, error) {
	var (
		ret0 = new(string)
	)
	out := ret0
	err := _ERC20Detailed.contract.Call(opts, out, "symbol")
	return *ret0, err
}

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

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

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() constant returns(uint256)
func (_ERC20Detailed *ERC20DetailedCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _ERC20Detailed.contract.Call(opts, out, "totalSupply")
	return *ret0, err
}

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

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

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address spender, uint256 amount) returns(bool)
func (_ERC20Detailed *ERC20DetailedTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Detailed.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)
func (_ERC20Detailed *ERC20DetailedSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Detailed.Contract.Approve(&_ERC20Detailed.TransactOpts, spender, amount)
}

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

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

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

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

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_ERC20Detailed *ERC20DetailedTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Detailed.contract.Transact(opts, "transferFrom", sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_ERC20Detailed *ERC20DetailedSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Detailed.Contract.TransferFrom(&_ERC20Detailed.TransactOpts, sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_ERC20Detailed *ERC20DetailedTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Detailed.Contract.TransferFrom(&_ERC20Detailed.TransactOpts, sender, recipient, amount)
}

// ERC20DetailedApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ERC20Detailed contract.
type ERC20DetailedApprovalIterator struct {
	Event *ERC20DetailedApproval // 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 *ERC20DetailedApprovalIterator) 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(ERC20DetailedApproval)
			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(ERC20DetailedApproval)
		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 *ERC20DetailedApprovalIterator) Error() error {
	return it.fail
}

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

// ERC20DetailedApproval represents a Approval event raised by the ERC20Detailed contract.
type ERC20DetailedApproval 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 (_ERC20Detailed *ERC20DetailedFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20DetailedApprovalIterator, 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 := _ERC20Detailed.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
	if err != nil {
		return nil, err
	}
	return &ERC20DetailedApprovalIterator{contract: _ERC20Detailed.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 (_ERC20Detailed *ERC20DetailedFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20DetailedApproval, 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 := _ERC20Detailed.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(ERC20DetailedApproval)
				if err := _ERC20Detailed.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 (_ERC20Detailed *ERC20DetailedFilterer) ParseApproval(log types.Log) (*ERC20DetailedApproval, error) {
	event := new(ERC20DetailedApproval)
	if err := _ERC20Detailed.contract.UnpackLog(event, "Approval", log); err != nil {
		return nil, err
	}
	return event, nil
}

// ERC20DetailedTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC20Detailed contract.
type ERC20DetailedTransferIterator struct {
	Event *ERC20DetailedTransfer // 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 *ERC20DetailedTransferIterator) 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(ERC20DetailedTransfer)
			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(ERC20DetailedTransfer)
		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 *ERC20DetailedTransferIterator) Error() error {
	return it.fail
}

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

// ERC20DetailedTransfer represents a Transfer event raised by the ERC20Detailed contract.
type ERC20DetailedTransfer 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 (_ERC20Detailed *ERC20DetailedFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20DetailedTransferIterator, 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 := _ERC20Detailed.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
	if err != nil {
		return nil, err
	}
	return &ERC20DetailedTransferIterator{contract: _ERC20Detailed.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 (_ERC20Detailed *ERC20DetailedFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20DetailedTransfer, 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 := _ERC20Detailed.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(ERC20DetailedTransfer)
				if err := _ERC20Detailed.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 (_ERC20Detailed *ERC20DetailedFilterer) ParseTransfer(log types.Log) (*ERC20DetailedTransfer, error) {
	event := new(ERC20DetailedTransfer)
	if err := _ERC20Detailed.contract.UnpackLog(event, "Transfer", log); err != nil {
		return nil, err
	}
	return event, nil
}

// ERC20MintableABI is the input ABI used to generate the binding from.
const ERC20MintableABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterRemoved\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"addMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isMinter\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"

// ERC20MintableFuncSigs maps the 4-byte function signature to its string representation.
var ERC20MintableFuncSigs = map[string]string{
	"983b2d56": "addMinter(address)",
	"dd62ed3e": "allowance(address,address)",
	"095ea7b3": "approve(address,uint256)",
	"70a08231": "balanceOf(address)",
	"a457c2d7": "decreaseAllowance(address,uint256)",
	"39509351": "increaseAllowance(address,uint256)",
	"aa271e1a": "isMinter(address)",
	"40c10f19": "mint(address,uint256)",
	"98650275": "renounceMinter()",
	"18160ddd": "totalSupply()",
	"a9059cbb": "transfer(address,uint256)",
	"23b872dd": "transferFrom(address,address,uint256)",
}

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

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

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ERC20MintableBin), backend)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &ERC20Mintable{ERC20MintableCaller: ERC20MintableCaller{contract: contract}, ERC20MintableTransactor: ERC20MintableTransactor{contract: contract}, ERC20MintableFilterer: ERC20MintableFilterer{contract: contract}}, nil
}

// ERC20Mintable is an auto generated Go binding around an Ethereum contract.
type ERC20Mintable struct {
	ERC20MintableCaller     // Read-only binding to the contract
	ERC20MintableTransactor // Write-only binding to the contract
	ERC20MintableFilterer   // Log filterer for contract events
}

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

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

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

// ERC20MintableSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type ERC20MintableSession struct {
	Contract     *ERC20Mintable    // 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
}

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

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

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

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

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

// NewERC20Mintable creates a new instance of ERC20Mintable, bound to a specific deployed contract.
func NewERC20Mintable(address common.Address, backend bind.ContractBackend) (*ERC20Mintable, error) {
	contract, err := bindERC20Mintable(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &ERC20Mintable{ERC20MintableCaller: ERC20MintableCaller{contract: contract}, ERC20MintableTransactor: ERC20MintableTransactor{contract: contract}, ERC20MintableFilterer: ERC20MintableFilterer{contract: contract}}, nil
}

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

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

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

// bindERC20Mintable binds a generic wrapper to an already deployed contract.
func bindERC20Mintable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(ERC20MintableABI))
	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 (_ERC20Mintable *ERC20MintableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _ERC20Mintable.Contract.ERC20MintableCaller.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 (_ERC20Mintable *ERC20MintableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _ERC20Mintable.Contract.ERC20MintableTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_ERC20Mintable *ERC20MintableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _ERC20Mintable.Contract.ERC20MintableTransactor.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 (_ERC20Mintable *ERC20MintableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _ERC20Mintable.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 (_ERC20Mintable *ERC20MintableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _ERC20Mintable.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_ERC20Mintable *ERC20MintableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _ERC20Mintable.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) constant returns(uint256)
func (_ERC20Mintable *ERC20MintableCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _ERC20Mintable.contract.Call(opts, out, "allowance", owner, spender)
	return *ret0, err
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_ERC20Mintable *ERC20MintableSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _ERC20Mintable.Contract.Allowance(&_ERC20Mintable.CallOpts, owner, spender)
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_ERC20Mintable *ERC20MintableCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _ERC20Mintable.Contract.Allowance(&_ERC20Mintable.CallOpts, owner, spender)
}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address account) constant returns(uint256)
func (_ERC20Mintable *ERC20MintableCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _ERC20Mintable.contract.Call(opts, out, "balanceOf", account)
	return *ret0, err
}

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

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

// IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
//
// Solidity: function isMinter(address account) constant returns(bool)
func (_ERC20Mintable *ERC20MintableCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _ERC20Mintable.contract.Call(opts, out, "isMinter", account)
	return *ret0, err
}

// IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
//
// Solidity: function isMinter(address account) constant returns(bool)
func (_ERC20Mintable *ERC20MintableSession) IsMinter(account common.Address) (bool, error) {
	return _ERC20Mintable.Contract.IsMinter(&_ERC20Mintable.CallOpts, account)
}

// IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
//
// Solidity: function isMinter(address account) constant returns(bool)
func (_ERC20Mintable *ERC20MintableCallerSession) IsMinter(account common.Address) (bool, error) {
	return _ERC20Mintable.Contract.IsMinter(&_ERC20Mintable.CallOpts, account)
}

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() constant returns(uint256)
func (_ERC20Mintable *ERC20MintableCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _ERC20Mintable.contract.Call(opts, out, "totalSupply")
	return *ret0, err
}

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

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

// AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
//
// Solidity: function addMinter(address account) returns()
func (_ERC20Mintable *ERC20MintableTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) {
	return _ERC20Mintable.contract.Transact(opts, "addMinter", account)
}

// AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
//
// Solidity: function addMinter(address account) returns()
func (_ERC20Mintable *ERC20MintableSession) AddMinter(account common.Address) (*types.Transaction, error) {
	return _ERC20Mintable.Contract.AddMinter(&_ERC20Mintable.TransactOpts, account)
}

// AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
//
// Solidity: function addMinter(address account) returns()
func (_ERC20Mintable *ERC20MintableTransactorSession) AddMinter(account common.Address) (*types.Transaction, error) {
	return _ERC20Mintable.Contract.AddMinter(&_ERC20Mintable.TransactOpts, account)
}

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address spender, uint256 amount) returns(bool)
func (_ERC20Mintable *ERC20MintableTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Mintable.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)
func (_ERC20Mintable *ERC20MintableSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Mintable.Contract.Approve(&_ERC20Mintable.TransactOpts, spender, amount)
}

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

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_ERC20Mintable *ERC20MintableTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _ERC20Mintable.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_ERC20Mintable *ERC20MintableSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _ERC20Mintable.Contract.DecreaseAllowance(&_ERC20Mintable.TransactOpts, spender, subtractedValue)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_ERC20Mintable *ERC20MintableTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _ERC20Mintable.Contract.DecreaseAllowance(&_ERC20Mintable.TransactOpts, spender, subtractedValue)
}

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_ERC20Mintable *ERC20MintableTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _ERC20Mintable.contract.Transact(opts, "increaseAllowance", spender, addedValue)
}

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_ERC20Mintable *ERC20MintableSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _ERC20Mintable.Contract.IncreaseAllowance(&_ERC20Mintable.TransactOpts, spender, addedValue)
}

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_ERC20Mintable *ERC20MintableTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _ERC20Mintable.Contract.IncreaseAllowance(&_ERC20Mintable.TransactOpts, spender, addedValue)
}

// Mint is a paid mutator transaction binding the contract method 0x40c10f19.
//
// Solidity: function mint(address account, uint256 amount) returns(bool)
func (_ERC20Mintable *ERC20MintableTransactor) Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Mintable.contract.Transact(opts, "mint", account, amount)
}

// Mint is a paid mutator transaction binding the contract method 0x40c10f19.
//
// Solidity: function mint(address account, uint256 amount) returns(bool)
func (_ERC20Mintable *ERC20MintableSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Mintable.Contract.Mint(&_ERC20Mintable.TransactOpts, account, amount)
}

// Mint is a paid mutator transaction binding the contract method 0x40c10f19.
//
// Solidity: function mint(address account, uint256 amount) returns(bool)
func (_ERC20Mintable *ERC20MintableTransactorSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Mintable.Contract.Mint(&_ERC20Mintable.TransactOpts, account, amount)
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
//
// Solidity: function renounceMinter() returns()
func (_ERC20Mintable *ERC20MintableTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _ERC20Mintable.contract.Transact(opts, "renounceMinter")
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
//
// Solidity: function renounceMinter() returns()
func (_ERC20Mintable *ERC20MintableSession) RenounceMinter() (*types.Transaction, error) {
	return _ERC20Mintable.Contract.RenounceMinter(&_ERC20Mintable.TransactOpts)
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
//
// Solidity: function renounceMinter() returns()
func (_ERC20Mintable *ERC20MintableTransactorSession) RenounceMinter() (*types.Transaction, error) {
	return _ERC20Mintable.Contract.RenounceMinter(&_ERC20Mintable.TransactOpts)
}

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

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

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

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_ERC20Mintable *ERC20MintableTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Mintable.contract.Transact(opts, "transferFrom", sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_ERC20Mintable *ERC20MintableSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Mintable.Contract.TransferFrom(&_ERC20Mintable.TransactOpts, sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_ERC20Mintable *ERC20MintableTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _ERC20Mintable.Contract.TransferFrom(&_ERC20Mintable.TransactOpts, sender, recipient, amount)
}

// ERC20MintableApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ERC20Mintable contract.
type ERC20MintableApprovalIterator struct {
	Event *ERC20MintableApproval // 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 *ERC20MintableApprovalIterator) 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(ERC20MintableApproval)
			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(ERC20MintableApproval)
		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 *ERC20MintableApprovalIterator) Error() error {
	return it.fail
}

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

// ERC20MintableApproval represents a Approval event raised by the ERC20Mintable contract.
type ERC20MintableApproval 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 (_ERC20Mintable *ERC20MintableFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20MintableApprovalIterator, 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 := _ERC20Mintable.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
	if err != nil {
		return nil, err
	}
	return &ERC20MintableApprovalIterator{contract: _ERC20Mintable.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 (_ERC20Mintable *ERC20MintableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20MintableApproval, 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 := _ERC20Mintable.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(ERC20MintableApproval)
				if err := _ERC20Mintable.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 (_ERC20Mintable *ERC20MintableFilterer) ParseApproval(log types.Log) (*ERC20MintableApproval, error) {
	event := new(ERC20MintableApproval)
	if err := _ERC20Mintable.contract.UnpackLog(event, "Approval", log); err != nil {
		return nil, err
	}
	return event, nil
}

// ERC20MintableMinterAddedIterator is returned from FilterMinterAdded and is used to iterate over the raw logs and unpacked data for MinterAdded events raised by the ERC20Mintable contract.
type ERC20MintableMinterAddedIterator struct {
	Event *ERC20MintableMinterAdded // 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 *ERC20MintableMinterAddedIterator) 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(ERC20MintableMinterAdded)
			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(ERC20MintableMinterAdded)
		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 *ERC20MintableMinterAddedIterator) Error() error {
	return it.fail
}

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

// ERC20MintableMinterAdded represents a MinterAdded event raised by the ERC20Mintable contract.
type ERC20MintableMinterAdded struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterMinterAdded is a free log retrieval operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
//
// Solidity: event MinterAdded(address indexed account)
func (_ERC20Mintable *ERC20MintableFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*ERC20MintableMinterAddedIterator, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _ERC20Mintable.contract.FilterLogs(opts, "MinterAdded", accountRule)
	if err != nil {
		return nil, err
	}
	return &ERC20MintableMinterAddedIterator{contract: _ERC20Mintable.contract, event: "MinterAdded", logs: logs, sub: sub}, nil
}

// WatchMinterAdded is a free log subscription operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
//
// Solidity: event MinterAdded(address indexed account)
func (_ERC20Mintable *ERC20MintableFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *ERC20MintableMinterAdded, account []common.Address) (event.Subscription, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _ERC20Mintable.contract.WatchLogs(opts, "MinterAdded", accountRule)
	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(ERC20MintableMinterAdded)
				if err := _ERC20Mintable.contract.UnpackLog(event, "MinterAdded", 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
}

// ParseMinterAdded is a log parse operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
//
// Solidity: event MinterAdded(address indexed account)
func (_ERC20Mintable *ERC20MintableFilterer) ParseMinterAdded(log types.Log) (*ERC20MintableMinterAdded, error) {
	event := new(ERC20MintableMinterAdded)
	if err := _ERC20Mintable.contract.UnpackLog(event, "MinterAdded", log); err != nil {
		return nil, err
	}
	return event, nil
}

// ERC20MintableMinterRemovedIterator is returned from FilterMinterRemoved and is used to iterate over the raw logs and unpacked data for MinterRemoved events raised by the ERC20Mintable contract.
type ERC20MintableMinterRemovedIterator struct {
	Event *ERC20MintableMinterRemoved // 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 *ERC20MintableMinterRemovedIterator) 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(ERC20MintableMinterRemoved)
			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(ERC20MintableMinterRemoved)
		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 *ERC20MintableMinterRemovedIterator) Error() error {
	return it.fail
}

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

// ERC20MintableMinterRemoved represents a MinterRemoved event raised by the ERC20Mintable contract.
type ERC20MintableMinterRemoved struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterMinterRemoved is a free log retrieval operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
//
// Solidity: event MinterRemoved(address indexed account)
func (_ERC20Mintable *ERC20MintableFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*ERC20MintableMinterRemovedIterator, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _ERC20Mintable.contract.FilterLogs(opts, "MinterRemoved", accountRule)
	if err != nil {
		return nil, err
	}
	return &ERC20MintableMinterRemovedIterator{contract: _ERC20Mintable.contract, event: "MinterRemoved", logs: logs, sub: sub}, nil
}

// WatchMinterRemoved is a free log subscription operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
//
// Solidity: event MinterRemoved(address indexed account)
func (_ERC20Mintable *ERC20MintableFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *ERC20MintableMinterRemoved, account []common.Address) (event.Subscription, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _ERC20Mintable.contract.WatchLogs(opts, "MinterRemoved", accountRule)
	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(ERC20MintableMinterRemoved)
				if err := _ERC20Mintable.contract.UnpackLog(event, "MinterRemoved", 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
}

// ParseMinterRemoved is a log parse operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
//
// Solidity: event MinterRemoved(address indexed account)
func (_ERC20Mintable *ERC20MintableFilterer) ParseMinterRemoved(log types.Log) (*ERC20MintableMinterRemoved, error) {
	event := new(ERC20MintableMinterRemoved)
	if err := _ERC20Mintable.contract.UnpackLog(event, "MinterRemoved", log); err != nil {
		return nil, err
	}
	return event, nil
}

// ERC20MintableTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC20Mintable contract.
type ERC20MintableTransferIterator struct {
	Event *ERC20MintableTransfer // 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 *ERC20MintableTransferIterator) 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(ERC20MintableTransfer)
			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(ERC20MintableTransfer)
		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 *ERC20MintableTransferIterator) Error() error {
	return it.fail
}

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

// ERC20MintableTransfer represents a Transfer event raised by the ERC20Mintable contract.
type ERC20MintableTransfer 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 (_ERC20Mintable *ERC20MintableFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20MintableTransferIterator, 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 := _ERC20Mintable.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
	if err != nil {
		return nil, err
	}
	return &ERC20MintableTransferIterator{contract: _ERC20Mintable.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 (_ERC20Mintable *ERC20MintableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20MintableTransfer, 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 := _ERC20Mintable.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(ERC20MintableTransfer)
				if err := _ERC20Mintable.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 (_ERC20Mintable *ERC20MintableFilterer) ParseTransfer(log types.Log) (*ERC20MintableTransfer, error) {
	event := new(ERC20MintableTransfer)
	if err := _ERC20Mintable.contract.UnpackLog(event, "Transfer", log); err != nil {
		return nil, err
	}
	return event, nil
}

// ERCProxyABI is the input ABI used to generate the binding from.
const ERCProxyABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"implementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"codeAddr\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"proxyType\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"proxyTypeId\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"}]"

// ERCProxyFuncSigs maps the 4-byte function signature to its string representation.
var ERCProxyFuncSigs = map[string]string{
	"5c60da1b": "implementation()",
	"4555d5c9": "proxyType()",
}

// ERCProxy is an auto generated Go binding around an Ethereum contract.
type ERCProxy struct {
	ERCProxyCaller     // Read-only binding to the contract
	ERCProxyTransactor // Write-only binding to the contract
	ERCProxyFilterer   // Log filterer for contract events
}

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

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

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

// ERCProxySession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type ERCProxySession struct {
	Contract     *ERCProxy         // 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
}

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

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

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

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

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

// NewERCProxy creates a new instance of ERCProxy, bound to a specific deployed contract.
func NewERCProxy(address common.Address, backend bind.ContractBackend) (*ERCProxy, error) {
	contract, err := bindERCProxy(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &ERCProxy{ERCProxyCaller: ERCProxyCaller{contract: contract}, ERCProxyTransactor: ERCProxyTransactor{contract: contract}, ERCProxyFilterer: ERCProxyFilterer{contract: contract}}, nil
}

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

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

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

// bindERCProxy binds a generic wrapper to an already deployed contract.
func bindERCProxy(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(ERCProxyABI))
	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 (_ERCProxy *ERCProxyRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _ERCProxy.Contract.ERCProxyCaller.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 (_ERCProxy *ERCProxyRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _ERCProxy.Contract.ERCProxyTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_ERCProxy *ERCProxyRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _ERCProxy.Contract.ERCProxyTransactor.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 (_ERCProxy *ERCProxyCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _ERCProxy.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 (_ERCProxy *ERCProxyTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _ERCProxy.Contract.contract.Transfer(opts)
}

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

// Implementation is a free data retrieval call binding the contract method 0x5c60da1b.
//
// Solidity: function implementation() constant returns(address codeAddr)
func (_ERCProxy *ERCProxyCaller) Implementation(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _ERCProxy.contract.Call(opts, out, "implementation")
	return *ret0, err
}

// Implementation is a free data retrieval call binding the contract method 0x5c60da1b.
//
// Solidity: function implementation() constant returns(address codeAddr)
func (_ERCProxy *ERCProxySession) Implementation() (common.Address, error) {
	return _ERCProxy.Contract.Implementation(&_ERCProxy.CallOpts)
}

// Implementation is a free data retrieval call binding the contract method 0x5c60da1b.
//
// Solidity: function implementation() constant returns(address codeAddr)
func (_ERCProxy *ERCProxyCallerSession) Implementation() (common.Address, error) {
	return _ERCProxy.Contract.Implementation(&_ERCProxy.CallOpts)
}

// ProxyType is a free data retrieval call binding the contract method 0x4555d5c9.
//
// Solidity: function proxyType() constant returns(uint256 proxyTypeId)
func (_ERCProxy *ERCProxyCaller) ProxyType(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _ERCProxy.contract.Call(opts, out, "proxyType")
	return *ret0, err
}

// ProxyType is a free data retrieval call binding the contract method 0x4555d5c9.
//
// Solidity: function proxyType() constant returns(uint256 proxyTypeId)
func (_ERCProxy *ERCProxySession) ProxyType() (*big.Int, error) {
	return _ERCProxy.Contract.ProxyType(&_ERCProxy.CallOpts)
}

// ProxyType is a free data retrieval call binding the contract method 0x4555d5c9.
//
// Solidity: function proxyType() constant returns(uint256 proxyTypeId)
func (_ERCProxy *ERCProxyCallerSession) ProxyType() (*big.Int, error) {
	return _ERCProxy.Contract.ProxyType(&_ERCProxy.CallOpts)
}

// FixedIncrementCoinageABI is the input ABI used to generate the binding from.
const FixedIncrementCoinageABI = "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"factor\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"seigPerBlock\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"transfersEnabled\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"factor\",\"type\":\"uint256\"}],\"name\":\"FactorIncreased\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"bool\",\"name\":\"v\",\"type\":\"bool\"}],\"name\":\"enableTransfers\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"factor\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"factorIncrement\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"isOwner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"lastBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"seigPerBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"transfersEnabled\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"

// FixedIncrementCoinageFuncSigs maps the 4-byte function signature to its string representation.
var FixedIncrementCoinageFuncSigs = map[string]string{
	"dd62ed3e": "allowance(address,address)",
	"095ea7b3": "approve(address,uint256)",
	"70a08231": "balanceOf(address)",
	"313ce567": "decimals()",
	"a457c2d7": "decreaseAllowance(address,uint256)",
	"f41e60c5": "enableTransfers(bool)",
	"54f703f8": "factor()",
	"d4132ee2": "factorIncrement()",
	"39509351": "increaseAllowance(address,uint256)",
	"8f32d59b": "isOwner()",
	"806b984f": "lastBlock()",
	"06fdde03": "name()",
	"8da5cb5b": "owner()",
	"715018a6": "renounceOwnership()",
	"5f40a349": "seigPerBlock()",
	"95d89b41": "symbol()",
	"18160ddd": "totalSupply()",
	"a9059cbb": "transfer(address,uint256)",
	"23b872dd": "transferFrom(address,address,uint256)",
	"f2fde38b": "transferOwnership(address)",
	"bef97c87": "transfersEnabled()",
}

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

// DeployFixedIncrementCoinage deploys a new Ethereum contract, binding an instance of FixedIncrementCoinage to it.
func DeployFixedIncrementCoinage(auth *bind.TransactOpts, backend bind.ContractBackend, name string, symbol string, factor *big.Int, seigPerBlock *big.Int, transfersEnabled bool) (common.Address, *types.Transaction, *FixedIncrementCoinage, error) {
	parsed, err := abi.JSON(strings.NewReader(FixedIncrementCoinageABI))
	if err != nil {
		return common.Address{}, nil, nil, err
	}

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(FixedIncrementCoinageBin), backend, name, symbol, factor, seigPerBlock, transfersEnabled)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &FixedIncrementCoinage{FixedIncrementCoinageCaller: FixedIncrementCoinageCaller{contract: contract}, FixedIncrementCoinageTransactor: FixedIncrementCoinageTransactor{contract: contract}, FixedIncrementCoinageFilterer: FixedIncrementCoinageFilterer{contract: contract}}, nil
}

// FixedIncrementCoinage is an auto generated Go binding around an Ethereum contract.
type FixedIncrementCoinage struct {
	FixedIncrementCoinageCaller     // Read-only binding to the contract
	FixedIncrementCoinageTransactor // Write-only binding to the contract
	FixedIncrementCoinageFilterer   // Log filterer for contract events
}

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

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

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

// FixedIncrementCoinageSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type FixedIncrementCoinageSession struct {
	Contract     *FixedIncrementCoinage // 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
}

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

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

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

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

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

// NewFixedIncrementCoinage creates a new instance of FixedIncrementCoinage, bound to a specific deployed contract.
func NewFixedIncrementCoinage(address common.Address, backend bind.ContractBackend) (*FixedIncrementCoinage, error) {
	contract, err := bindFixedIncrementCoinage(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &FixedIncrementCoinage{FixedIncrementCoinageCaller: FixedIncrementCoinageCaller{contract: contract}, FixedIncrementCoinageTransactor: FixedIncrementCoinageTransactor{contract: contract}, FixedIncrementCoinageFilterer: FixedIncrementCoinageFilterer{contract: contract}}, nil
}

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

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

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

// bindFixedIncrementCoinage binds a generic wrapper to an already deployed contract.
func bindFixedIncrementCoinage(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(FixedIncrementCoinageABI))
	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 (_FixedIncrementCoinage *FixedIncrementCoinageRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _FixedIncrementCoinage.Contract.FixedIncrementCoinageCaller.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 (_FixedIncrementCoinage *FixedIncrementCoinageRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _FixedIncrementCoinage.Contract.FixedIncrementCoinageTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_FixedIncrementCoinage *FixedIncrementCoinageRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _FixedIncrementCoinage.Contract.FixedIncrementCoinageTransactor.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 (_FixedIncrementCoinage *FixedIncrementCoinageCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _FixedIncrementCoinage.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 (_FixedIncrementCoinage *FixedIncrementCoinageTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _FixedIncrementCoinage.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_FixedIncrementCoinage *FixedIncrementCoinageTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _FixedIncrementCoinage.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) constant returns(uint256)
func (_FixedIncrementCoinage *FixedIncrementCoinageCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _FixedIncrementCoinage.contract.Call(opts, out, "allowance", owner, spender)
	return *ret0, err
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_FixedIncrementCoinage *FixedIncrementCoinageSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _FixedIncrementCoinage.Contract.Allowance(&_FixedIncrementCoinage.CallOpts, owner, spender)
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_FixedIncrementCoinage *FixedIncrementCoinageCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _FixedIncrementCoinage.Contract.Allowance(&_FixedIncrementCoinage.CallOpts, owner, spender)
}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address account) constant returns(uint256)
func (_FixedIncrementCoinage *FixedIncrementCoinageCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _FixedIncrementCoinage.contract.Call(opts, out, "balanceOf", account)
	return *ret0, err
}

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

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

// Decimals is a free data retrieval call binding the contract method 0x313ce567.
//
// Solidity: function decimals() constant returns(uint8)
func (_FixedIncrementCoinage *FixedIncrementCoinageCaller) Decimals(opts *bind.CallOpts) (uint8, error) {
	var (
		ret0 = new(uint8)
	)
	out := ret0
	err := _FixedIncrementCoinage.contract.Call(opts, out, "decimals")
	return *ret0, err
}

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

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

// Factor is a free data retrieval call binding the contract method 0x54f703f8.
//
// Solidity: function factor() constant returns(uint256)
func (_FixedIncrementCoinage *FixedIncrementCoinageCaller) Factor(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _FixedIncrementCoinage.contract.Call(opts, out, "factor")
	return *ret0, err
}

// Factor is a free data retrieval call binding the contract method 0x54f703f8.
//
// Solidity: function factor() constant returns(uint256)
func (_FixedIncrementCoinage *FixedIncrementCoinageSession) Factor() (*big.Int, error) {
	return _FixedIncrementCoinage.Contract.Factor(&_FixedIncrementCoinage.CallOpts)
}

// Factor is a free data retrieval call binding the contract method 0x54f703f8.
//
// Solidity: function factor() constant returns(uint256)
func (_FixedIncrementCoinage *FixedIncrementCoinageCallerSession) Factor() (*big.Int, error) {
	return _FixedIncrementCoinage.Contract.Factor(&_FixedIncrementCoinage.CallOpts)
}

// FactorIncrement is a free data retrieval call binding the contract method 0xd4132ee2.
//
// Solidity: function factorIncrement() constant returns(uint256)
func (_FixedIncrementCoinage *FixedIncrementCoinageCaller) FactorIncrement(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _FixedIncrementCoinage.contract.Call(opts, out, "factorIncrement")
	return *ret0, err
}

// FactorIncrement is a free data retrieval call binding the contract method 0xd4132ee2.
//
// Solidity: function factorIncrement() constant returns(uint256)
func (_FixedIncrementCoinage *FixedIncrementCoinageSession) FactorIncrement() (*big.Int, error) {
	return _FixedIncrementCoinage.Contract.FactorIncrement(&_FixedIncrementCoinage.CallOpts)
}

// FactorIncrement is a free data retrieval call binding the contract method 0xd4132ee2.
//
// Solidity: function factorIncrement() constant returns(uint256)
func (_FixedIncrementCoinage *FixedIncrementCoinageCallerSession) FactorIncrement() (*big.Int, error) {
	return _FixedIncrementCoinage.Contract.FactorIncrement(&_FixedIncrementCoinage.CallOpts)
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_FixedIncrementCoinage *FixedIncrementCoinageCaller) IsOwner(opts *bind.CallOpts) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _FixedIncrementCoinage.contract.Call(opts, out, "isOwner")
	return *ret0, err
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_FixedIncrementCoinage *FixedIncrementCoinageSession) IsOwner() (bool, error) {
	return _FixedIncrementCoinage.Contract.IsOwner(&_FixedIncrementCoinage.CallOpts)
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_FixedIncrementCoinage *FixedIncrementCoinageCallerSession) IsOwner() (bool, error) {
	return _FixedIncrementCoinage.Contract.IsOwner(&_FixedIncrementCoinage.CallOpts)
}

// LastBlock is a free data retrieval call binding the contract method 0x806b984f.
//
// Solidity: function lastBlock() constant returns(uint256)
func (_FixedIncrementCoinage *FixedIncrementCoinageCaller) LastBlock(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _FixedIncrementCoinage.contract.Call(opts, out, "lastBlock")
	return *ret0, err
}

// LastBlock is a free data retrieval call binding the contract method 0x806b984f.
//
// Solidity: function lastBlock() constant returns(uint256)
func (_FixedIncrementCoinage *FixedIncrementCoinageSession) LastBlock() (*big.Int, error) {
	return _FixedIncrementCoinage.Contract.LastBlock(&_FixedIncrementCoinage.CallOpts)
}

// LastBlock is a free data retrieval call binding the contract method 0x806b984f.
//
// Solidity: function lastBlock() constant returns(uint256)
func (_FixedIncrementCoinage *FixedIncrementCoinageCallerSession) LastBlock() (*big.Int, error) {
	return _FixedIncrementCoinage.Contract.LastBlock(&_FixedIncrementCoinage.CallOpts)
}

// Name is a free data retrieval call binding the contract method 0x06fdde03.
//
// Solidity: function name() constant returns(string)
func (_FixedIncrementCoinage *FixedIncrementCoinageCaller) Name(opts *bind.CallOpts) (string, error) {
	var (
		ret0 = new(string)
	)
	out := ret0
	err := _FixedIncrementCoinage.contract.Call(opts, out, "name")
	return *ret0, err
}

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

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

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_FixedIncrementCoinage *FixedIncrementCoinageCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _FixedIncrementCoinage.contract.Call(opts, out, "owner")
	return *ret0, err
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_FixedIncrementCoinage *FixedIncrementCoinageSession) Owner() (common.Address, error) {
	return _FixedIncrementCoinage.Contract.Owner(&_FixedIncrementCoinage.CallOpts)
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_FixedIncrementCoinage *FixedIncrementCoinageCallerSession) Owner() (common.Address, error) {
	return _FixedIncrementCoinage.Contract.Owner(&_FixedIncrementCoinage.CallOpts)
}

// SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349.
//
// Solidity: function seigPerBlock() constant returns(uint256)
func (_FixedIncrementCoinage *FixedIncrementCoinageCaller) SeigPerBlock(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _FixedIncrementCoinage.contract.Call(opts, out, "seigPerBlock")
	return *ret0, err
}

// SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349.
//
// Solidity: function seigPerBlock() constant returns(uint256)
func (_FixedIncrementCoinage *FixedIncrementCoinageSession) SeigPerBlock() (*big.Int, error) {
	return _FixedIncrementCoinage.Contract.SeigPerBlock(&_FixedIncrementCoinage.CallOpts)
}

// SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349.
//
// Solidity: function seigPerBlock() constant returns(uint256)
func (_FixedIncrementCoinage *FixedIncrementCoinageCallerSession) SeigPerBlock() (*big.Int, error) {
	return _FixedIncrementCoinage.Contract.SeigPerBlock(&_FixedIncrementCoinage.CallOpts)
}

// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
//
// Solidity: function symbol() constant returns(string)
func (_FixedIncrementCoinage *FixedIncrementCoinageCaller) Symbol(opts *bind.CallOpts) (string, error) {
	var (
		ret0 = new(string)
	)
	out := ret0
	err := _FixedIncrementCoinage.contract.Call(opts, out, "symbol")
	return *ret0, err
}

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

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

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() constant returns(uint256)
func (_FixedIncrementCoinage *FixedIncrementCoinageCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _FixedIncrementCoinage.contract.Call(opts, out, "totalSupply")
	return *ret0, err
}

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

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

// TransfersEnabled is a free data retrieval call binding the contract method 0xbef97c87.
//
// Solidity: function transfersEnabled() constant returns(bool)
func (_FixedIncrementCoinage *FixedIncrementCoinageCaller) TransfersEnabled(opts *bind.CallOpts) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _FixedIncrementCoinage.contract.Call(opts, out, "transfersEnabled")
	return *ret0, err
}

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

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

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address spender, uint256 amount) returns(bool)
func (_FixedIncrementCoinage *FixedIncrementCoinageTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinage.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)
func (_FixedIncrementCoinage *FixedIncrementCoinageSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinage.Contract.Approve(&_FixedIncrementCoinage.TransactOpts, spender, amount)
}

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

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_FixedIncrementCoinage *FixedIncrementCoinageTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinage.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_FixedIncrementCoinage *FixedIncrementCoinageSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinage.Contract.DecreaseAllowance(&_FixedIncrementCoinage.TransactOpts, spender, subtractedValue)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_FixedIncrementCoinage *FixedIncrementCoinageTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinage.Contract.DecreaseAllowance(&_FixedIncrementCoinage.TransactOpts, spender, subtractedValue)
}

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

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

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

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_FixedIncrementCoinage *FixedIncrementCoinageTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinage.contract.Transact(opts, "increaseAllowance", spender, addedValue)
}

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_FixedIncrementCoinage *FixedIncrementCoinageSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinage.Contract.IncreaseAllowance(&_FixedIncrementCoinage.TransactOpts, spender, addedValue)
}

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_FixedIncrementCoinage *FixedIncrementCoinageTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinage.Contract.IncreaseAllowance(&_FixedIncrementCoinage.TransactOpts, spender, addedValue)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_FixedIncrementCoinage *FixedIncrementCoinageTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _FixedIncrementCoinage.contract.Transact(opts, "renounceOwnership")
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_FixedIncrementCoinage *FixedIncrementCoinageSession) RenounceOwnership() (*types.Transaction, error) {
	return _FixedIncrementCoinage.Contract.RenounceOwnership(&_FixedIncrementCoinage.TransactOpts)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_FixedIncrementCoinage *FixedIncrementCoinageTransactorSession) RenounceOwnership() (*types.Transaction, error) {
	return _FixedIncrementCoinage.Contract.RenounceOwnership(&_FixedIncrementCoinage.TransactOpts)
}

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

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

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

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_FixedIncrementCoinage *FixedIncrementCoinageTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinage.contract.Transact(opts, "transferFrom", sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_FixedIncrementCoinage *FixedIncrementCoinageSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinage.Contract.TransferFrom(&_FixedIncrementCoinage.TransactOpts, sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_FixedIncrementCoinage *FixedIncrementCoinageTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinage.Contract.TransferFrom(&_FixedIncrementCoinage.TransactOpts, sender, recipient, amount)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_FixedIncrementCoinage *FixedIncrementCoinageTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
	return _FixedIncrementCoinage.contract.Transact(opts, "transferOwnership", newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_FixedIncrementCoinage *FixedIncrementCoinageSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
	return _FixedIncrementCoinage.Contract.TransferOwnership(&_FixedIncrementCoinage.TransactOpts, newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_FixedIncrementCoinage *FixedIncrementCoinageTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
	return _FixedIncrementCoinage.Contract.TransferOwnership(&_FixedIncrementCoinage.TransactOpts, newOwner)
}

// FixedIncrementCoinageApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the FixedIncrementCoinage contract.
type FixedIncrementCoinageApprovalIterator struct {
	Event *FixedIncrementCoinageApproval // 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 *FixedIncrementCoinageApprovalIterator) 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(FixedIncrementCoinageApproval)
			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(FixedIncrementCoinageApproval)
		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 *FixedIncrementCoinageApprovalIterator) Error() error {
	return it.fail
}

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

// FixedIncrementCoinageApproval represents a Approval event raised by the FixedIncrementCoinage contract.
type FixedIncrementCoinageApproval 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 (_FixedIncrementCoinage *FixedIncrementCoinageFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*FixedIncrementCoinageApprovalIterator, 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 := _FixedIncrementCoinage.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
	if err != nil {
		return nil, err
	}
	return &FixedIncrementCoinageApprovalIterator{contract: _FixedIncrementCoinage.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 (_FixedIncrementCoinage *FixedIncrementCoinageFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *FixedIncrementCoinageApproval, 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 := _FixedIncrementCoinage.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(FixedIncrementCoinageApproval)
				if err := _FixedIncrementCoinage.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 (_FixedIncrementCoinage *FixedIncrementCoinageFilterer) ParseApproval(log types.Log) (*FixedIncrementCoinageApproval, error) {
	event := new(FixedIncrementCoinageApproval)
	if err := _FixedIncrementCoinage.contract.UnpackLog(event, "Approval", log); err != nil {
		return nil, err
	}
	return event, nil
}

// FixedIncrementCoinageFactorIncreasedIterator is returned from FilterFactorIncreased and is used to iterate over the raw logs and unpacked data for FactorIncreased events raised by the FixedIncrementCoinage contract.
type FixedIncrementCoinageFactorIncreasedIterator struct {
	Event *FixedIncrementCoinageFactorIncreased // 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 *FixedIncrementCoinageFactorIncreasedIterator) 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(FixedIncrementCoinageFactorIncreased)
			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(FixedIncrementCoinageFactorIncreased)
		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 *FixedIncrementCoinageFactorIncreasedIterator) Error() error {
	return it.fail
}

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

// FixedIncrementCoinageFactorIncreased represents a FactorIncreased event raised by the FixedIncrementCoinage contract.
type FixedIncrementCoinageFactorIncreased struct {
	Factor *big.Int
	Raw    types.Log // Blockchain specific contextual infos
}

// FilterFactorIncreased is a free log retrieval operation binding the contract event 0xe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb6.
//
// Solidity: event FactorIncreased(uint256 factor)
func (_FixedIncrementCoinage *FixedIncrementCoinageFilterer) FilterFactorIncreased(opts *bind.FilterOpts) (*FixedIncrementCoinageFactorIncreasedIterator, error) {

	logs, sub, err := _FixedIncrementCoinage.contract.FilterLogs(opts, "FactorIncreased")
	if err != nil {
		return nil, err
	}
	return &FixedIncrementCoinageFactorIncreasedIterator{contract: _FixedIncrementCoinage.contract, event: "FactorIncreased", logs: logs, sub: sub}, nil
}

// WatchFactorIncreased is a free log subscription operation binding the contract event 0xe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb6.
//
// Solidity: event FactorIncreased(uint256 factor)
func (_FixedIncrementCoinage *FixedIncrementCoinageFilterer) WatchFactorIncreased(opts *bind.WatchOpts, sink chan<- *FixedIncrementCoinageFactorIncreased) (event.Subscription, error) {

	logs, sub, err := _FixedIncrementCoinage.contract.WatchLogs(opts, "FactorIncreased")
	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(FixedIncrementCoinageFactorIncreased)
				if err := _FixedIncrementCoinage.contract.UnpackLog(event, "FactorIncreased", 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
}

// ParseFactorIncreased is a log parse operation binding the contract event 0xe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb6.
//
// Solidity: event FactorIncreased(uint256 factor)
func (_FixedIncrementCoinage *FixedIncrementCoinageFilterer) ParseFactorIncreased(log types.Log) (*FixedIncrementCoinageFactorIncreased, error) {
	event := new(FixedIncrementCoinageFactorIncreased)
	if err := _FixedIncrementCoinage.contract.UnpackLog(event, "FactorIncreased", log); err != nil {
		return nil, err
	}
	return event, nil
}

// FixedIncrementCoinageOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the FixedIncrementCoinage contract.
type FixedIncrementCoinageOwnershipTransferredIterator struct {
	Event *FixedIncrementCoinageOwnershipTransferred // 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 *FixedIncrementCoinageOwnershipTransferredIterator) 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(FixedIncrementCoinageOwnershipTransferred)
			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(FixedIncrementCoinageOwnershipTransferred)
		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 *FixedIncrementCoinageOwnershipTransferredIterator) Error() error {
	return it.fail
}

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

// FixedIncrementCoinageOwnershipTransferred represents a OwnershipTransferred event raised by the FixedIncrementCoinage contract.
type FixedIncrementCoinageOwnershipTransferred struct {
	PreviousOwner common.Address
	NewOwner      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_FixedIncrementCoinage *FixedIncrementCoinageFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*FixedIncrementCoinageOwnershipTransferredIterator, error) {

	var previousOwnerRule []interface{}
	for _, previousOwnerItem := range previousOwner {
		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
	}
	var newOwnerRule []interface{}
	for _, newOwnerItem := range newOwner {
		newOwnerRule = append(newOwnerRule, newOwnerItem)
	}

	logs, sub, err := _FixedIncrementCoinage.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
	if err != nil {
		return nil, err
	}
	return &FixedIncrementCoinageOwnershipTransferredIterator{contract: _FixedIncrementCoinage.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
}

// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_FixedIncrementCoinage *FixedIncrementCoinageFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *FixedIncrementCoinageOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {

	var previousOwnerRule []interface{}
	for _, previousOwnerItem := range previousOwner {
		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
	}
	var newOwnerRule []interface{}
	for _, newOwnerItem := range newOwner {
		newOwnerRule = append(newOwnerRule, newOwnerItem)
	}

	logs, sub, err := _FixedIncrementCoinage.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
	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(FixedIncrementCoinageOwnershipTransferred)
				if err := _FixedIncrementCoinage.contract.UnpackLog(event, "OwnershipTransferred", 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
}

// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_FixedIncrementCoinage *FixedIncrementCoinageFilterer) ParseOwnershipTransferred(log types.Log) (*FixedIncrementCoinageOwnershipTransferred, error) {
	event := new(FixedIncrementCoinageOwnershipTransferred)
	if err := _FixedIncrementCoinage.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
		return nil, err
	}
	return event, nil
}

// FixedIncrementCoinageTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the FixedIncrementCoinage contract.
type FixedIncrementCoinageTransferIterator struct {
	Event *FixedIncrementCoinageTransfer // 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 *FixedIncrementCoinageTransferIterator) 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(FixedIncrementCoinageTransfer)
			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(FixedIncrementCoinageTransfer)
		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 *FixedIncrementCoinageTransferIterator) Error() error {
	return it.fail
}

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

// FixedIncrementCoinageTransfer represents a Transfer event raised by the FixedIncrementCoinage contract.
type FixedIncrementCoinageTransfer 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 (_FixedIncrementCoinage *FixedIncrementCoinageFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*FixedIncrementCoinageTransferIterator, 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 := _FixedIncrementCoinage.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
	if err != nil {
		return nil, err
	}
	return &FixedIncrementCoinageTransferIterator{contract: _FixedIncrementCoinage.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 (_FixedIncrementCoinage *FixedIncrementCoinageFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *FixedIncrementCoinageTransfer, 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 := _FixedIncrementCoinage.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(FixedIncrementCoinageTransfer)
				if err := _FixedIncrementCoinage.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 (_FixedIncrementCoinage *FixedIncrementCoinageFilterer) ParseTransfer(log types.Log) (*FixedIncrementCoinageTransfer, error) {
	event := new(FixedIncrementCoinageTransfer)
	if err := _FixedIncrementCoinage.contract.UnpackLog(event, "Transfer", log); err != nil {
		return nil, err
	}
	return event, nil
}

// FixedIncrementCoinageMockABI is the input ABI used to generate the binding from.
const FixedIncrementCoinageMockABI = "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"factor\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"seigPerBlock\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"transfersEnabled\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"factor\",\"type\":\"uint256\"}],\"name\":\"FactorIncreased\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterRemoved\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"addMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burnFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"bool\",\"name\":\"v\",\"type\":\"bool\"}],\"name\":\"enableTransfers\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"factor\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"factorIncrement\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isMinter\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"isOwner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"lastBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"seigPerBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"transfersEnabled\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"

// FixedIncrementCoinageMockFuncSigs maps the 4-byte function signature to its string representation.
var FixedIncrementCoinageMockFuncSigs = map[string]string{
	"983b2d56": "addMinter(address)",
	"dd62ed3e": "allowance(address,address)",
	"095ea7b3": "approve(address,uint256)",
	"70a08231": "balanceOf(address)",
	"42966c68": "burn(uint256)",
	"79cc6790": "burnFrom(address,uint256)",
	"313ce567": "decimals()",
	"a457c2d7": "decreaseAllowance(address,uint256)",
	"f41e60c5": "enableTransfers(bool)",
	"54f703f8": "factor()",
	"d4132ee2": "factorIncrement()",
	"39509351": "increaseAllowance(address,uint256)",
	"aa271e1a": "isMinter(address)",
	"8f32d59b": "isOwner()",
	"806b984f": "lastBlock()",
	"40c10f19": "mint(address,uint256)",
	"06fdde03": "name()",
	"8da5cb5b": "owner()",
	"98650275": "renounceMinter()",
	"715018a6": "renounceOwnership()",
	"5f40a349": "seigPerBlock()",
	"95d89b41": "symbol()",
	"18160ddd": "totalSupply()",
	"a9059cbb": "transfer(address,uint256)",
	"23b872dd": "transferFrom(address,address,uint256)",
	"f2fde38b": "transferOwnership(address)",
	"bef97c87": "transfersEnabled()",
}

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

// DeployFixedIncrementCoinageMock deploys a new Ethereum contract, binding an instance of FixedIncrementCoinageMock to it.
func DeployFixedIncrementCoinageMock(auth *bind.TransactOpts, backend bind.ContractBackend, name string, symbol string, factor *big.Int, seigPerBlock *big.Int, transfersEnabled bool) (common.Address, *types.Transaction, *FixedIncrementCoinageMock, error) {
	parsed, err := abi.JSON(strings.NewReader(FixedIncrementCoinageMockABI))
	if err != nil {
		return common.Address{}, nil, nil, err
	}

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(FixedIncrementCoinageMockBin), backend, name, symbol, factor, seigPerBlock, transfersEnabled)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &FixedIncrementCoinageMock{FixedIncrementCoinageMockCaller: FixedIncrementCoinageMockCaller{contract: contract}, FixedIncrementCoinageMockTransactor: FixedIncrementCoinageMockTransactor{contract: contract}, FixedIncrementCoinageMockFilterer: FixedIncrementCoinageMockFilterer{contract: contract}}, nil
}

// FixedIncrementCoinageMock is an auto generated Go binding around an Ethereum contract.
type FixedIncrementCoinageMock struct {
	FixedIncrementCoinageMockCaller     // Read-only binding to the contract
	FixedIncrementCoinageMockTransactor // Write-only binding to the contract
	FixedIncrementCoinageMockFilterer   // Log filterer for contract events
}

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

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

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

// FixedIncrementCoinageMockSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type FixedIncrementCoinageMockSession struct {
	Contract     *FixedIncrementCoinageMock // 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
}

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

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

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

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

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

// NewFixedIncrementCoinageMock creates a new instance of FixedIncrementCoinageMock, bound to a specific deployed contract.
func NewFixedIncrementCoinageMock(address common.Address, backend bind.ContractBackend) (*FixedIncrementCoinageMock, error) {
	contract, err := bindFixedIncrementCoinageMock(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &FixedIncrementCoinageMock{FixedIncrementCoinageMockCaller: FixedIncrementCoinageMockCaller{contract: contract}, FixedIncrementCoinageMockTransactor: FixedIncrementCoinageMockTransactor{contract: contract}, FixedIncrementCoinageMockFilterer: FixedIncrementCoinageMockFilterer{contract: contract}}, nil
}

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

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

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

// bindFixedIncrementCoinageMock binds a generic wrapper to an already deployed contract.
func bindFixedIncrementCoinageMock(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(FixedIncrementCoinageMockABI))
	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 (_FixedIncrementCoinageMock *FixedIncrementCoinageMockRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _FixedIncrementCoinageMock.Contract.FixedIncrementCoinageMockCaller.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 (_FixedIncrementCoinageMock *FixedIncrementCoinageMockRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.FixedIncrementCoinageMockTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.FixedIncrementCoinageMockTransactor.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 (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _FixedIncrementCoinageMock.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 (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.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) constant returns(uint256)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _FixedIncrementCoinageMock.contract.Call(opts, out, "allowance", owner, spender)
	return *ret0, err
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _FixedIncrementCoinageMock.Contract.Allowance(&_FixedIncrementCoinageMock.CallOpts, owner, spender)
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _FixedIncrementCoinageMock.Contract.Allowance(&_FixedIncrementCoinageMock.CallOpts, owner, spender)
}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address account) constant returns(uint256)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _FixedIncrementCoinageMock.contract.Call(opts, out, "balanceOf", account)
	return *ret0, err
}

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

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

// Decimals is a free data retrieval call binding the contract method 0x313ce567.
//
// Solidity: function decimals() constant returns(uint8)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCaller) Decimals(opts *bind.CallOpts) (uint8, error) {
	var (
		ret0 = new(uint8)
	)
	out := ret0
	err := _FixedIncrementCoinageMock.contract.Call(opts, out, "decimals")
	return *ret0, err
}

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

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

// Factor is a free data retrieval call binding the contract method 0x54f703f8.
//
// Solidity: function factor() constant returns(uint256)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCaller) Factor(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _FixedIncrementCoinageMock.contract.Call(opts, out, "factor")
	return *ret0, err
}

// Factor is a free data retrieval call binding the contract method 0x54f703f8.
//
// Solidity: function factor() constant returns(uint256)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockSession) Factor() (*big.Int, error) {
	return _FixedIncrementCoinageMock.Contract.Factor(&_FixedIncrementCoinageMock.CallOpts)
}

// Factor is a free data retrieval call binding the contract method 0x54f703f8.
//
// Solidity: function factor() constant returns(uint256)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCallerSession) Factor() (*big.Int, error) {
	return _FixedIncrementCoinageMock.Contract.Factor(&_FixedIncrementCoinageMock.CallOpts)
}

// FactorIncrement is a free data retrieval call binding the contract method 0xd4132ee2.
//
// Solidity: function factorIncrement() constant returns(uint256)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCaller) FactorIncrement(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _FixedIncrementCoinageMock.contract.Call(opts, out, "factorIncrement")
	return *ret0, err
}

// FactorIncrement is a free data retrieval call binding the contract method 0xd4132ee2.
//
// Solidity: function factorIncrement() constant returns(uint256)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockSession) FactorIncrement() (*big.Int, error) {
	return _FixedIncrementCoinageMock.Contract.FactorIncrement(&_FixedIncrementCoinageMock.CallOpts)
}

// FactorIncrement is a free data retrieval call binding the contract method 0xd4132ee2.
//
// Solidity: function factorIncrement() constant returns(uint256)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCallerSession) FactorIncrement() (*big.Int, error) {
	return _FixedIncrementCoinageMock.Contract.FactorIncrement(&_FixedIncrementCoinageMock.CallOpts)
}

// IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
//
// Solidity: function isMinter(address account) constant returns(bool)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _FixedIncrementCoinageMock.contract.Call(opts, out, "isMinter", account)
	return *ret0, err
}

// IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
//
// Solidity: function isMinter(address account) constant returns(bool)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockSession) IsMinter(account common.Address) (bool, error) {
	return _FixedIncrementCoinageMock.Contract.IsMinter(&_FixedIncrementCoinageMock.CallOpts, account)
}

// IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
//
// Solidity: function isMinter(address account) constant returns(bool)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCallerSession) IsMinter(account common.Address) (bool, error) {
	return _FixedIncrementCoinageMock.Contract.IsMinter(&_FixedIncrementCoinageMock.CallOpts, account)
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCaller) IsOwner(opts *bind.CallOpts) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _FixedIncrementCoinageMock.contract.Call(opts, out, "isOwner")
	return *ret0, err
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockSession) IsOwner() (bool, error) {
	return _FixedIncrementCoinageMock.Contract.IsOwner(&_FixedIncrementCoinageMock.CallOpts)
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCallerSession) IsOwner() (bool, error) {
	return _FixedIncrementCoinageMock.Contract.IsOwner(&_FixedIncrementCoinageMock.CallOpts)
}

// LastBlock is a free data retrieval call binding the contract method 0x806b984f.
//
// Solidity: function lastBlock() constant returns(uint256)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCaller) LastBlock(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _FixedIncrementCoinageMock.contract.Call(opts, out, "lastBlock")
	return *ret0, err
}

// LastBlock is a free data retrieval call binding the contract method 0x806b984f.
//
// Solidity: function lastBlock() constant returns(uint256)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockSession) LastBlock() (*big.Int, error) {
	return _FixedIncrementCoinageMock.Contract.LastBlock(&_FixedIncrementCoinageMock.CallOpts)
}

// LastBlock is a free data retrieval call binding the contract method 0x806b984f.
//
// Solidity: function lastBlock() constant returns(uint256)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCallerSession) LastBlock() (*big.Int, error) {
	return _FixedIncrementCoinageMock.Contract.LastBlock(&_FixedIncrementCoinageMock.CallOpts)
}

// Name is a free data retrieval call binding the contract method 0x06fdde03.
//
// Solidity: function name() constant returns(string)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCaller) Name(opts *bind.CallOpts) (string, error) {
	var (
		ret0 = new(string)
	)
	out := ret0
	err := _FixedIncrementCoinageMock.contract.Call(opts, out, "name")
	return *ret0, err
}

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

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

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _FixedIncrementCoinageMock.contract.Call(opts, out, "owner")
	return *ret0, err
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockSession) Owner() (common.Address, error) {
	return _FixedIncrementCoinageMock.Contract.Owner(&_FixedIncrementCoinageMock.CallOpts)
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCallerSession) Owner() (common.Address, error) {
	return _FixedIncrementCoinageMock.Contract.Owner(&_FixedIncrementCoinageMock.CallOpts)
}

// SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349.
//
// Solidity: function seigPerBlock() constant returns(uint256)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCaller) SeigPerBlock(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _FixedIncrementCoinageMock.contract.Call(opts, out, "seigPerBlock")
	return *ret0, err
}

// SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349.
//
// Solidity: function seigPerBlock() constant returns(uint256)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockSession) SeigPerBlock() (*big.Int, error) {
	return _FixedIncrementCoinageMock.Contract.SeigPerBlock(&_FixedIncrementCoinageMock.CallOpts)
}

// SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349.
//
// Solidity: function seigPerBlock() constant returns(uint256)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCallerSession) SeigPerBlock() (*big.Int, error) {
	return _FixedIncrementCoinageMock.Contract.SeigPerBlock(&_FixedIncrementCoinageMock.CallOpts)
}

// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
//
// Solidity: function symbol() constant returns(string)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCaller) Symbol(opts *bind.CallOpts) (string, error) {
	var (
		ret0 = new(string)
	)
	out := ret0
	err := _FixedIncrementCoinageMock.contract.Call(opts, out, "symbol")
	return *ret0, err
}

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

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

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() constant returns(uint256)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _FixedIncrementCoinageMock.contract.Call(opts, out, "totalSupply")
	return *ret0, err
}

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

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

// TransfersEnabled is a free data retrieval call binding the contract method 0xbef97c87.
//
// Solidity: function transfersEnabled() constant returns(bool)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockCaller) TransfersEnabled(opts *bind.CallOpts) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _FixedIncrementCoinageMock.contract.Call(opts, out, "transfersEnabled")
	return *ret0, err
}

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

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

// AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
//
// Solidity: function addMinter(address account) returns()
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.contract.Transact(opts, "addMinter", account)
}

// AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
//
// Solidity: function addMinter(address account) returns()
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockSession) AddMinter(account common.Address) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.AddMinter(&_FixedIncrementCoinageMock.TransactOpts, account)
}

// AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
//
// Solidity: function addMinter(address account) returns()
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactorSession) AddMinter(account common.Address) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.AddMinter(&_FixedIncrementCoinageMock.TransactOpts, account)
}

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address spender, uint256 amount) returns(bool)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.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)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.Approve(&_FixedIncrementCoinageMock.TransactOpts, spender, amount)
}

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

// Burn is a paid mutator transaction binding the contract method 0x42966c68.
//
// Solidity: function burn(uint256 amount) returns()
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactor) Burn(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.contract.Transact(opts, "burn", amount)
}

// Burn is a paid mutator transaction binding the contract method 0x42966c68.
//
// Solidity: function burn(uint256 amount) returns()
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockSession) Burn(amount *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.Burn(&_FixedIncrementCoinageMock.TransactOpts, amount)
}

// Burn is a paid mutator transaction binding the contract method 0x42966c68.
//
// Solidity: function burn(uint256 amount) returns()
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactorSession) Burn(amount *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.Burn(&_FixedIncrementCoinageMock.TransactOpts, amount)
}

// BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790.
//
// Solidity: function burnFrom(address account, uint256 amount) returns()
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactor) BurnFrom(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.contract.Transact(opts, "burnFrom", account, amount)
}

// BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790.
//
// Solidity: function burnFrom(address account, uint256 amount) returns()
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.BurnFrom(&_FixedIncrementCoinageMock.TransactOpts, account, amount)
}

// BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790.
//
// Solidity: function burnFrom(address account, uint256 amount) returns()
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactorSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.BurnFrom(&_FixedIncrementCoinageMock.TransactOpts, account, amount)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.DecreaseAllowance(&_FixedIncrementCoinageMock.TransactOpts, spender, subtractedValue)
}

// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
//
// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.DecreaseAllowance(&_FixedIncrementCoinageMock.TransactOpts, spender, subtractedValue)
}

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

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

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

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.contract.Transact(opts, "increaseAllowance", spender, addedValue)
}

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.IncreaseAllowance(&_FixedIncrementCoinageMock.TransactOpts, spender, addedValue)
}

// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
//
// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.IncreaseAllowance(&_FixedIncrementCoinageMock.TransactOpts, spender, addedValue)
}

// Mint is a paid mutator transaction binding the contract method 0x40c10f19.
//
// Solidity: function mint(address account, uint256 amount) returns(bool)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactor) Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.contract.Transact(opts, "mint", account, amount)
}

// Mint is a paid mutator transaction binding the contract method 0x40c10f19.
//
// Solidity: function mint(address account, uint256 amount) returns(bool)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.Mint(&_FixedIncrementCoinageMock.TransactOpts, account, amount)
}

// Mint is a paid mutator transaction binding the contract method 0x40c10f19.
//
// Solidity: function mint(address account, uint256 amount) returns(bool)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactorSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.Mint(&_FixedIncrementCoinageMock.TransactOpts, account, amount)
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
//
// Solidity: function renounceMinter() returns()
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.contract.Transact(opts, "renounceMinter")
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
//
// Solidity: function renounceMinter() returns()
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockSession) RenounceMinter() (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.RenounceMinter(&_FixedIncrementCoinageMock.TransactOpts)
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
//
// Solidity: function renounceMinter() returns()
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactorSession) RenounceMinter() (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.RenounceMinter(&_FixedIncrementCoinageMock.TransactOpts)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.contract.Transact(opts, "renounceOwnership")
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockSession) RenounceOwnership() (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.RenounceOwnership(&_FixedIncrementCoinageMock.TransactOpts)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactorSession) RenounceOwnership() (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.RenounceOwnership(&_FixedIncrementCoinageMock.TransactOpts)
}

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

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

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

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.contract.Transact(opts, "transferFrom", sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.TransferFrom(&_FixedIncrementCoinageMock.TransactOpts, sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.TransferFrom(&_FixedIncrementCoinageMock.TransactOpts, sender, recipient, amount)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.contract.Transact(opts, "transferOwnership", newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.TransferOwnership(&_FixedIncrementCoinageMock.TransactOpts, newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
	return _FixedIncrementCoinageMock.Contract.TransferOwnership(&_FixedIncrementCoinageMock.TransactOpts, newOwner)
}

// FixedIncrementCoinageMockApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the FixedIncrementCoinageMock contract.
type FixedIncrementCoinageMockApprovalIterator struct {
	Event *FixedIncrementCoinageMockApproval // 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 *FixedIncrementCoinageMockApprovalIterator) 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(FixedIncrementCoinageMockApproval)
			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(FixedIncrementCoinageMockApproval)
		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 *FixedIncrementCoinageMockApprovalIterator) Error() error {
	return it.fail
}

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

// FixedIncrementCoinageMockApproval represents a Approval event raised by the FixedIncrementCoinageMock contract.
type FixedIncrementCoinageMockApproval 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 (_FixedIncrementCoinageMock *FixedIncrementCoinageMockFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*FixedIncrementCoinageMockApprovalIterator, 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 := _FixedIncrementCoinageMock.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
	if err != nil {
		return nil, err
	}
	return &FixedIncrementCoinageMockApprovalIterator{contract: _FixedIncrementCoinageMock.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 (_FixedIncrementCoinageMock *FixedIncrementCoinageMockFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *FixedIncrementCoinageMockApproval, 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 := _FixedIncrementCoinageMock.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(FixedIncrementCoinageMockApproval)
				if err := _FixedIncrementCoinageMock.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 (_FixedIncrementCoinageMock *FixedIncrementCoinageMockFilterer) ParseApproval(log types.Log) (*FixedIncrementCoinageMockApproval, error) {
	event := new(FixedIncrementCoinageMockApproval)
	if err := _FixedIncrementCoinageMock.contract.UnpackLog(event, "Approval", log); err != nil {
		return nil, err
	}
	return event, nil
}

// FixedIncrementCoinageMockFactorIncreasedIterator is returned from FilterFactorIncreased and is used to iterate over the raw logs and unpacked data for FactorIncreased events raised by the FixedIncrementCoinageMock contract.
type FixedIncrementCoinageMockFactorIncreasedIterator struct {
	Event *FixedIncrementCoinageMockFactorIncreased // 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 *FixedIncrementCoinageMockFactorIncreasedIterator) 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(FixedIncrementCoinageMockFactorIncreased)
			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(FixedIncrementCoinageMockFactorIncreased)
		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 *FixedIncrementCoinageMockFactorIncreasedIterator) Error() error {
	return it.fail
}

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

// FixedIncrementCoinageMockFactorIncreased represents a FactorIncreased event raised by the FixedIncrementCoinageMock contract.
type FixedIncrementCoinageMockFactorIncreased struct {
	Factor *big.Int
	Raw    types.Log // Blockchain specific contextual infos
}

// FilterFactorIncreased is a free log retrieval operation binding the contract event 0xe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb6.
//
// Solidity: event FactorIncreased(uint256 factor)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockFilterer) FilterFactorIncreased(opts *bind.FilterOpts) (*FixedIncrementCoinageMockFactorIncreasedIterator, error) {

	logs, sub, err := _FixedIncrementCoinageMock.contract.FilterLogs(opts, "FactorIncreased")
	if err != nil {
		return nil, err
	}
	return &FixedIncrementCoinageMockFactorIncreasedIterator{contract: _FixedIncrementCoinageMock.contract, event: "FactorIncreased", logs: logs, sub: sub}, nil
}

// WatchFactorIncreased is a free log subscription operation binding the contract event 0xe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb6.
//
// Solidity: event FactorIncreased(uint256 factor)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockFilterer) WatchFactorIncreased(opts *bind.WatchOpts, sink chan<- *FixedIncrementCoinageMockFactorIncreased) (event.Subscription, error) {

	logs, sub, err := _FixedIncrementCoinageMock.contract.WatchLogs(opts, "FactorIncreased")
	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(FixedIncrementCoinageMockFactorIncreased)
				if err := _FixedIncrementCoinageMock.contract.UnpackLog(event, "FactorIncreased", 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
}

// ParseFactorIncreased is a log parse operation binding the contract event 0xe26ee4870433319e6f01f123f37f6f6823ff4084f5651912025d24930b01bcb6.
//
// Solidity: event FactorIncreased(uint256 factor)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockFilterer) ParseFactorIncreased(log types.Log) (*FixedIncrementCoinageMockFactorIncreased, error) {
	event := new(FixedIncrementCoinageMockFactorIncreased)
	if err := _FixedIncrementCoinageMock.contract.UnpackLog(event, "FactorIncreased", log); err != nil {
		return nil, err
	}
	return event, nil
}

// FixedIncrementCoinageMockMinterAddedIterator is returned from FilterMinterAdded and is used to iterate over the raw logs and unpacked data for MinterAdded events raised by the FixedIncrementCoinageMock contract.
type FixedIncrementCoinageMockMinterAddedIterator struct {
	Event *FixedIncrementCoinageMockMinterAdded // 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 *FixedIncrementCoinageMockMinterAddedIterator) 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(FixedIncrementCoinageMockMinterAdded)
			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(FixedIncrementCoinageMockMinterAdded)
		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 *FixedIncrementCoinageMockMinterAddedIterator) Error() error {
	return it.fail
}

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

// FixedIncrementCoinageMockMinterAdded represents a MinterAdded event raised by the FixedIncrementCoinageMock contract.
type FixedIncrementCoinageMockMinterAdded struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterMinterAdded is a free log retrieval operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
//
// Solidity: event MinterAdded(address indexed account)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*FixedIncrementCoinageMockMinterAddedIterator, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _FixedIncrementCoinageMock.contract.FilterLogs(opts, "MinterAdded", accountRule)
	if err != nil {
		return nil, err
	}
	return &FixedIncrementCoinageMockMinterAddedIterator{contract: _FixedIncrementCoinageMock.contract, event: "MinterAdded", logs: logs, sub: sub}, nil
}

// WatchMinterAdded is a free log subscription operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
//
// Solidity: event MinterAdded(address indexed account)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *FixedIncrementCoinageMockMinterAdded, account []common.Address) (event.Subscription, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _FixedIncrementCoinageMock.contract.WatchLogs(opts, "MinterAdded", accountRule)
	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(FixedIncrementCoinageMockMinterAdded)
				if err := _FixedIncrementCoinageMock.contract.UnpackLog(event, "MinterAdded", 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
}

// ParseMinterAdded is a log parse operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
//
// Solidity: event MinterAdded(address indexed account)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockFilterer) ParseMinterAdded(log types.Log) (*FixedIncrementCoinageMockMinterAdded, error) {
	event := new(FixedIncrementCoinageMockMinterAdded)
	if err := _FixedIncrementCoinageMock.contract.UnpackLog(event, "MinterAdded", log); err != nil {
		return nil, err
	}
	return event, nil
}

// FixedIncrementCoinageMockMinterRemovedIterator is returned from FilterMinterRemoved and is used to iterate over the raw logs and unpacked data for MinterRemoved events raised by the FixedIncrementCoinageMock contract.
type FixedIncrementCoinageMockMinterRemovedIterator struct {
	Event *FixedIncrementCoinageMockMinterRemoved // 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 *FixedIncrementCoinageMockMinterRemovedIterator) 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(FixedIncrementCoinageMockMinterRemoved)
			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(FixedIncrementCoinageMockMinterRemoved)
		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 *FixedIncrementCoinageMockMinterRemovedIterator) Error() error {
	return it.fail
}

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

// FixedIncrementCoinageMockMinterRemoved represents a MinterRemoved event raised by the FixedIncrementCoinageMock contract.
type FixedIncrementCoinageMockMinterRemoved struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterMinterRemoved is a free log retrieval operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
//
// Solidity: event MinterRemoved(address indexed account)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*FixedIncrementCoinageMockMinterRemovedIterator, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _FixedIncrementCoinageMock.contract.FilterLogs(opts, "MinterRemoved", accountRule)
	if err != nil {
		return nil, err
	}
	return &FixedIncrementCoinageMockMinterRemovedIterator{contract: _FixedIncrementCoinageMock.contract, event: "MinterRemoved", logs: logs, sub: sub}, nil
}

// WatchMinterRemoved is a free log subscription operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
//
// Solidity: event MinterRemoved(address indexed account)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *FixedIncrementCoinageMockMinterRemoved, account []common.Address) (event.Subscription, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _FixedIncrementCoinageMock.contract.WatchLogs(opts, "MinterRemoved", accountRule)
	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(FixedIncrementCoinageMockMinterRemoved)
				if err := _FixedIncrementCoinageMock.contract.UnpackLog(event, "MinterRemoved", 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
}

// ParseMinterRemoved is a log parse operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
//
// Solidity: event MinterRemoved(address indexed account)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockFilterer) ParseMinterRemoved(log types.Log) (*FixedIncrementCoinageMockMinterRemoved, error) {
	event := new(FixedIncrementCoinageMockMinterRemoved)
	if err := _FixedIncrementCoinageMock.contract.UnpackLog(event, "MinterRemoved", log); err != nil {
		return nil, err
	}
	return event, nil
}

// FixedIncrementCoinageMockOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the FixedIncrementCoinageMock contract.
type FixedIncrementCoinageMockOwnershipTransferredIterator struct {
	Event *FixedIncrementCoinageMockOwnershipTransferred // 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 *FixedIncrementCoinageMockOwnershipTransferredIterator) 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(FixedIncrementCoinageMockOwnershipTransferred)
			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(FixedIncrementCoinageMockOwnershipTransferred)
		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 *FixedIncrementCoinageMockOwnershipTransferredIterator) Error() error {
	return it.fail
}

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

// FixedIncrementCoinageMockOwnershipTransferred represents a OwnershipTransferred event raised by the FixedIncrementCoinageMock contract.
type FixedIncrementCoinageMockOwnershipTransferred struct {
	PreviousOwner common.Address
	NewOwner      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*FixedIncrementCoinageMockOwnershipTransferredIterator, error) {

	var previousOwnerRule []interface{}
	for _, previousOwnerItem := range previousOwner {
		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
	}
	var newOwnerRule []interface{}
	for _, newOwnerItem := range newOwner {
		newOwnerRule = append(newOwnerRule, newOwnerItem)
	}

	logs, sub, err := _FixedIncrementCoinageMock.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
	if err != nil {
		return nil, err
	}
	return &FixedIncrementCoinageMockOwnershipTransferredIterator{contract: _FixedIncrementCoinageMock.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
}

// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *FixedIncrementCoinageMockOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {

	var previousOwnerRule []interface{}
	for _, previousOwnerItem := range previousOwner {
		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
	}
	var newOwnerRule []interface{}
	for _, newOwnerItem := range newOwner {
		newOwnerRule = append(newOwnerRule, newOwnerItem)
	}

	logs, sub, err := _FixedIncrementCoinageMock.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
	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(FixedIncrementCoinageMockOwnershipTransferred)
				if err := _FixedIncrementCoinageMock.contract.UnpackLog(event, "OwnershipTransferred", 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
}

// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_FixedIncrementCoinageMock *FixedIncrementCoinageMockFilterer) ParseOwnershipTransferred(log types.Log) (*FixedIncrementCoinageMockOwnershipTransferred, error) {
	event := new(FixedIncrementCoinageMockOwnershipTransferred)
	if err := _FixedIncrementCoinageMock.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
		return nil, err
	}
	return event, nil
}

// FixedIncrementCoinageMockTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the FixedIncrementCoinageMock contract.
type FixedIncrementCoinageMockTransferIterator struct {
	Event *FixedIncrementCoinageMockTransfer // 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 *FixedIncrementCoinageMockTransferIterator) 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(FixedIncrementCoinageMockTransfer)
			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(FixedIncrementCoinageMockTransfer)
		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 *FixedIncrementCoinageMockTransferIterator) Error() error {
	return it.fail
}

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

// FixedIncrementCoinageMockTransfer represents a Transfer event raised by the FixedIncrementCoinageMock contract.
type FixedIncrementCoinageMockTransfer 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 (_FixedIncrementCoinageMock *FixedIncrementCoinageMockFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*FixedIncrementCoinageMockTransferIterator, 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 := _FixedIncrementCoinageMock.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
	if err != nil {
		return nil, err
	}
	return &FixedIncrementCoinageMockTransferIterator{contract: _FixedIncrementCoinageMock.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 (_FixedIncrementCoinageMock *FixedIncrementCoinageMockFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *FixedIncrementCoinageMockTransfer, 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 := _FixedIncrementCoinageMock.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(FixedIncrementCoinageMockTransfer)
				if err := _FixedIncrementCoinageMock.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 (_FixedIncrementCoinageMock *FixedIncrementCoinageMockFilterer) ParseTransfer(log types.Log) (*FixedIncrementCoinageMockTransfer, error) {
	event := new(FixedIncrementCoinageMockTransfer)
	if err := _FixedIncrementCoinageMock.contract.UnpackLog(event, "Transfer", log); err != nil {
		return nil, err
	}
	return event, nil
}

// IERC20ABI is the input ABI used to generate the binding from.
const IERC20ABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"

// IERC20FuncSigs maps the 4-byte function signature to its string representation.
var IERC20FuncSigs = 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)",
}

// IERC20 is an auto generated Go binding around an Ethereum contract.
type IERC20 struct {
	IERC20Caller     // Read-only binding to the contract
	IERC20Transactor // Write-only binding to the contract
	IERC20Filterer   // Log filterer for contract events
}

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

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

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

// IERC20Session is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type IERC20Session struct {
	Contract     *IERC20           // 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
}

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

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

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

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

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

// NewIERC20 creates a new instance of IERC20, bound to a specific deployed contract.
func NewIERC20(address common.Address, backend bind.ContractBackend) (*IERC20, error) {
	contract, err := bindIERC20(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &IERC20{IERC20Caller: IERC20Caller{contract: contract}, IERC20Transactor: IERC20Transactor{contract: contract}, IERC20Filterer: IERC20Filterer{contract: contract}}, nil
}

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

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

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

// bindIERC20 binds a generic wrapper to an already deployed contract.
func bindIERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(IERC20ABI))
	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 (_IERC20 *IERC20Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _IERC20.Contract.IERC20Caller.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 (_IERC20 *IERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _IERC20.Contract.IERC20Transactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_IERC20 *IERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _IERC20.Contract.IERC20Transactor.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 (_IERC20 *IERC20CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _IERC20.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 (_IERC20 *IERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _IERC20.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_IERC20 *IERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _IERC20.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) constant returns(uint256)
func (_IERC20 *IERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _IERC20.contract.Call(opts, out, "allowance", owner, spender)
	return *ret0, err
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_IERC20 *IERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _IERC20.Contract.Allowance(&_IERC20.CallOpts, owner, spender)
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address owner, address spender) constant returns(uint256)
func (_IERC20 *IERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
	return _IERC20.Contract.Allowance(&_IERC20.CallOpts, owner, spender)
}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address account) constant returns(uint256)
func (_IERC20 *IERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _IERC20.contract.Call(opts, out, "balanceOf", account)
	return *ret0, err
}

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

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

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() constant returns(uint256)
func (_IERC20 *IERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _IERC20.contract.Call(opts, out, "totalSupply")
	return *ret0, err
}

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

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

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address spender, uint256 amount) returns(bool)
func (_IERC20 *IERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _IERC20.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)
func (_IERC20 *IERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
	return _IERC20.Contract.Approve(&_IERC20.TransactOpts, spender, amount)
}

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

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

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

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

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_IERC20 *IERC20Transactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _IERC20.contract.Transact(opts, "transferFrom", sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_IERC20 *IERC20Session) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _IERC20.Contract.TransferFrom(&_IERC20.TransactOpts, sender, recipient, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
func (_IERC20 *IERC20TransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
	return _IERC20.Contract.TransferFrom(&_IERC20.TransactOpts, sender, recipient, amount)
}

// IERC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IERC20 contract.
type IERC20ApprovalIterator struct {
	Event *IERC20Approval // 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 *IERC20ApprovalIterator) 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(IERC20Approval)
			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(IERC20Approval)
		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 *IERC20ApprovalIterator) Error() error {
	return it.fail
}

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

// IERC20Approval represents a Approval event raised by the IERC20 contract.
type IERC20Approval 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 (_IERC20 *IERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*IERC20ApprovalIterator, 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 := _IERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
	if err != nil {
		return nil, err
	}
	return &IERC20ApprovalIterator{contract: _IERC20.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 (_IERC20 *IERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC20Approval, 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 := _IERC20.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(IERC20Approval)
				if err := _IERC20.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 (_IERC20 *IERC20Filterer) ParseApproval(log types.Log) (*IERC20Approval, error) {
	event := new(IERC20Approval)
	if err := _IERC20.contract.UnpackLog(event, "Approval", log); err != nil {
		return nil, err
	}
	return event, nil
}

// IERC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IERC20 contract.
type IERC20TransferIterator struct {
	Event *IERC20Transfer // 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 *IERC20TransferIterator) 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(IERC20Transfer)
			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(IERC20Transfer)
		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 *IERC20TransferIterator) Error() error {
	return it.fail
}

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

// IERC20Transfer represents a Transfer event raised by the IERC20 contract.
type IERC20Transfer 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 (_IERC20 *IERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*IERC20TransferIterator, 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 := _IERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
	if err != nil {
		return nil, err
	}
	return &IERC20TransferIterator{contract: _IERC20.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 (_IERC20 *IERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC20Transfer, 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 := _IERC20.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(IERC20Transfer)
				if err := _IERC20.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 (_IERC20 *IERC20Filterer) ParseTransfer(log types.Log) (*IERC20Transfer, error) {
	event := new(IERC20Transfer)
	if err := _IERC20.contract.UnpackLog(event, "Transfer", log); err != nil {
		return nil, err
	}
	return event, nil
}

// IsContractABI is the input ABI used to generate the binding from.
const IsContractABI = "[]"

// IsContractBin is the compiled bytecode used for deploying new contracts.
var IsContractBin = "0x6080604052348015600f57600080fd5b50603e80601d6000396000f3fe6080604052600080fdfea265627a7a7231582067cb16b73c67642688900f54175de899738878e910b642bca8dd45813302830f64736f6c634300050c0032"

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

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(IsContractBin), backend)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &IsContract{IsContractCaller: IsContractCaller{contract: contract}, IsContractTransactor: IsContractTransactor{contract: contract}, IsContractFilterer: IsContractFilterer{contract: contract}}, nil
}

// IsContract is an auto generated Go binding around an Ethereum contract.
type IsContract struct {
	IsContractCaller     // Read-only binding to the contract
	IsContractTransactor // Write-only binding to the contract
	IsContractFilterer   // Log filterer for contract events
}

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

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

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

// IsContractSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type IsContractSession struct {
	Contract     *IsContract       // 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
}

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

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

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

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

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

// NewIsContract creates a new instance of IsContract, bound to a specific deployed contract.
func NewIsContract(address common.Address, backend bind.ContractBackend) (*IsContract, error) {
	contract, err := bindIsContract(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &IsContract{IsContractCaller: IsContractCaller{contract: contract}, IsContractTransactor: IsContractTransactor{contract: contract}, IsContractFilterer: IsContractFilterer{contract: contract}}, nil
}

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

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

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

// bindIsContract binds a generic wrapper to an already deployed contract.
func bindIsContract(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(IsContractABI))
	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 (_IsContract *IsContractRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _IsContract.Contract.IsContractCaller.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 (_IsContract *IsContractRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _IsContract.Contract.IsContractTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_IsContract *IsContractRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _IsContract.Contract.IsContractTransactor.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 (_IsContract *IsContractCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _IsContract.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 (_IsContract *IsContractTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _IsContract.Contract.contract.Transfer(opts)
}

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

// MigrationsABI is the input ABI used to generate the binding from.
const MigrationsABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"constant\":true,\"inputs\":[],\"name\":\"last_completed_migration\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"completed\",\"type\":\"uint256\"}],\"name\":\"setCompleted\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"new_address\",\"type\":\"address\"}],\"name\":\"upgrade\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"

// MigrationsFuncSigs maps the 4-byte function signature to its string representation.
var MigrationsFuncSigs = map[string]string{
	"445df0ac": "last_completed_migration()",
	"8da5cb5b": "owner()",
	"fdacd576": "setCompleted(uint256)",
	"0900f010": "upgrade(address)",
}

// MigrationsBin is the compiled bytecode used for deploying new contracts.
var MigrationsBin = "0x608060405234801561001057600080fd5b50600080546001600160a01b031916331790556101b3806100326000396000f3fe608060405234801561001057600080fd5b506004361061004c5760003560e01c80630900f01014610051578063445df0ac146100795780638da5cb5b14610093578063fdacd576146100b7575b600080fd5b6100776004803603602081101561006757600080fd5b50356001600160a01b03166100d4565b005b610081610151565b60408051918252519081900360200190f35b61009b610157565b604080516001600160a01b039092168252519081900360200190f35b610077600480360360208110156100cd57600080fd5b5035610166565b6000546001600160a01b031633141561014e576000819050806001600160a01b031663fdacd5766001546040518263ffffffff1660e01b815260040180828152602001915050600060405180830381600087803b15801561013457600080fd5b505af1158015610148573d6000803e3d6000fd5b50505050505b50565b60015481565b6000546001600160a01b031681565b6000546001600160a01b031633141561014e5760015556fea265627a7a723158205289ded263102a97835af8cb578c71b8a327c813af682129fe78357a8197a5c064736f6c634300050c0032"

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

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(MigrationsBin), backend)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &Migrations{MigrationsCaller: MigrationsCaller{contract: contract}, MigrationsTransactor: MigrationsTransactor{contract: contract}, MigrationsFilterer: MigrationsFilterer{contract: contract}}, nil
}

// Migrations is an auto generated Go binding around an Ethereum contract.
type Migrations struct {
	MigrationsCaller     // Read-only binding to the contract
	MigrationsTransactor // Write-only binding to the contract
	MigrationsFilterer   // Log filterer for contract events
}

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

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

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

// MigrationsSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type MigrationsSession struct {
	Contract     *Migrations       // 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
}

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

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

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

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

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

// NewMigrations creates a new instance of Migrations, bound to a specific deployed contract.
func NewMigrations(address common.Address, backend bind.ContractBackend) (*Migrations, error) {
	contract, err := bindMigrations(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &Migrations{MigrationsCaller: MigrationsCaller{contract: contract}, MigrationsTransactor: MigrationsTransactor{contract: contract}, MigrationsFilterer: MigrationsFilterer{contract: contract}}, nil
}

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

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

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

// bindMigrations binds a generic wrapper to an already deployed contract.
func bindMigrations(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(MigrationsABI))
	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 (_Migrations *MigrationsRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _Migrations.Contract.MigrationsCaller.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 (_Migrations *MigrationsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _Migrations.Contract.MigrationsTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_Migrations *MigrationsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _Migrations.Contract.MigrationsTransactor.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 (_Migrations *MigrationsCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _Migrations.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 (_Migrations *MigrationsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _Migrations.Contract.contract.Transfer(opts)
}

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

// LastCompletedMigration is a free data retrieval call binding the contract method 0x445df0ac.
//
// Solidity: function last_completed_migration() constant returns(uint256)
func (_Migrations *MigrationsCaller) LastCompletedMigration(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _Migrations.contract.Call(opts, out, "last_completed_migration")
	return *ret0, err
}

// LastCompletedMigration is a free data retrieval call binding the contract method 0x445df0ac.
//
// Solidity: function last_completed_migration() constant returns(uint256)
func (_Migrations *MigrationsSession) LastCompletedMigration() (*big.Int, error) {
	return _Migrations.Contract.LastCompletedMigration(&_Migrations.CallOpts)
}

// LastCompletedMigration is a free data retrieval call binding the contract method 0x445df0ac.
//
// Solidity: function last_completed_migration() constant returns(uint256)
func (_Migrations *MigrationsCallerSession) LastCompletedMigration() (*big.Int, error) {
	return _Migrations.Contract.LastCompletedMigration(&_Migrations.CallOpts)
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_Migrations *MigrationsCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _Migrations.contract.Call(opts, out, "owner")
	return *ret0, err
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_Migrations *MigrationsSession) Owner() (common.Address, error) {
	return _Migrations.Contract.Owner(&_Migrations.CallOpts)
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_Migrations *MigrationsCallerSession) Owner() (common.Address, error) {
	return _Migrations.Contract.Owner(&_Migrations.CallOpts)
}

// SetCompleted is a paid mutator transaction binding the contract method 0xfdacd576.
//
// Solidity: function setCompleted(uint256 completed) returns()
func (_Migrations *MigrationsTransactor) SetCompleted(opts *bind.TransactOpts, completed *big.Int) (*types.Transaction, error) {
	return _Migrations.contract.Transact(opts, "setCompleted", completed)
}

// SetCompleted is a paid mutator transaction binding the contract method 0xfdacd576.
//
// Solidity: function setCompleted(uint256 completed) returns()
func (_Migrations *MigrationsSession) SetCompleted(completed *big.Int) (*types.Transaction, error) {
	return _Migrations.Contract.SetCompleted(&_Migrations.TransactOpts, completed)
}

// SetCompleted is a paid mutator transaction binding the contract method 0xfdacd576.
//
// Solidity: function setCompleted(uint256 completed) returns()
func (_Migrations *MigrationsTransactorSession) SetCompleted(completed *big.Int) (*types.Transaction, error) {
	return _Migrations.Contract.SetCompleted(&_Migrations.TransactOpts, completed)
}

// Upgrade is a paid mutator transaction binding the contract method 0x0900f010.
//
// Solidity: function upgrade(address new_address) returns()
func (_Migrations *MigrationsTransactor) Upgrade(opts *bind.TransactOpts, new_address common.Address) (*types.Transaction, error) {
	return _Migrations.contract.Transact(opts, "upgrade", new_address)
}

// Upgrade is a paid mutator transaction binding the contract method 0x0900f010.
//
// Solidity: function upgrade(address new_address) returns()
func (_Migrations *MigrationsSession) Upgrade(new_address common.Address) (*types.Transaction, error) {
	return _Migrations.Contract.Upgrade(&_Migrations.TransactOpts, new_address)
}

// Upgrade is a paid mutator transaction binding the contract method 0x0900f010.
//
// Solidity: function upgrade(address new_address) returns()
func (_Migrations *MigrationsTransactorSession) Upgrade(new_address common.Address) (*types.Transaction, error) {
	return _Migrations.Contract.Upgrade(&_Migrations.TransactOpts, new_address)
}

// MiniMeTokenABI is the input ABI used to generate the binding from.
const MiniMeTokenABI = "[{\"inputs\":[{\"internalType\":\"addresspayable\",\"name\":\"_tokenFactory\",\"type\":\"address\"},{\"internalType\":\"addresspayable\",\"name\":\"_parentToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_parentSnapShotBlock\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"_tokenName\",\"type\":\"string\"},{\"internalType\":\"uint8\",\"name\":\"_decimalUnits\",\"type\":\"uint8\"},{\"internalType\":\"string\",\"name\":\"_tokenSymbol\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"_transfersEnabled\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_controller\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"ClaimedTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_cloneToken\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_snapshotBlock\",\"type\":\"uint256\"}],\"name\":\"NewCloneToken\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"payable\":true,\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"remaining\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"_extraData\",\"type\":\"bytes\"}],\"name\":\"approveAndCall\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"balance\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_blockNumber\",\"type\":\"uint256\"}],\"name\":\"balanceOfAt\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"addresspayable\",\"name\":\"_newController\",\"type\":\"address\"}],\"name\":\"changeController\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"addresspayable\",\"name\":\"_token\",\"type\":\"address\"}],\"name\":\"claimTokens\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"controller\",\"outputs\":[{\"internalType\":\"addresspayable\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"string\",\"name\":\"_cloneTokenName\",\"type\":\"string\"},{\"internalType\":\"uint8\",\"name\":\"_cloneDecimalUnits\",\"type\":\"uint8\"},{\"internalType\":\"string\",\"name\":\"_cloneTokenSymbol\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"_snapshotBlock\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"_transfersEnabled\",\"type\":\"bool\"}],\"name\":\"createCloneToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"creationBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"destroyTokens\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"bool\",\"name\":\"_transfersEnabled\",\"type\":\"bool\"}],\"name\":\"enableTransfers\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"generateTokens\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"parentSnapShotBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"parentToken\",\"outputs\":[{\"internalType\":\"contractMiniMeToken\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"tokenFactory\",\"outputs\":[{\"internalType\":\"contractMiniMeTokenFactory\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_blockNumber\",\"type\":\"uint256\"}],\"name\":\"totalSupplyAt\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"transfersEnabled\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"version\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"

// 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) constant returns(uint256 remaining)
func (_MiniMeToken *MiniMeTokenCaller) Allowance(opts *bind.CallOpts, _owner common.Address, _spender common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _MiniMeToken.contract.Call(opts, out, "allowance", _owner, _spender)
	return *ret0, err
}

// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
//
// Solidity: function allowance(address _owner, address _spender) constant 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) constant 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) constant returns(uint256 balance)
func (_MiniMeToken *MiniMeTokenCaller) BalanceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _MiniMeToken.contract.Call(opts, out, "balanceOf", _owner)
	return *ret0, err
}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address _owner) constant 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) constant 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) constant returns(uint256)
func (_MiniMeToken *MiniMeTokenCaller) BalanceOfAt(opts *bind.CallOpts, _owner common.Address, _blockNumber *big.Int) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _MiniMeToken.contract.Call(opts, out, "balanceOfAt", _owner, _blockNumber)
	return *ret0, err
}

// BalanceOfAt is a free data retrieval call binding the contract method 0x4ee2cd7e.
//
// Solidity: function balanceOfAt(address _owner, uint256 _blockNumber) constant 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) constant 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() constant returns(address)
func (_MiniMeToken *MiniMeTokenCaller) Controller(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _MiniMeToken.contract.Call(opts, out, "controller")
	return *ret0, err
}

// Controller is a free data retrieval call binding the contract method 0xf77c4791.
//
// Solidity: function controller() constant 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() constant 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() constant returns(uint256)
func (_MiniMeToken *MiniMeTokenCaller) CreationBlock(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _MiniMeToken.contract.Call(opts, out, "creationBlock")
	return *ret0, err
}

// CreationBlock is a free data retrieval call binding the contract method 0x17634514.
//
// Solidity: function creationBlock() constant 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() constant 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() constant returns(uint8)
func (_MiniMeToken *MiniMeTokenCaller) Decimals(opts *bind.CallOpts) (uint8, error) {
	var (
		ret0 = new(uint8)
	)
	out := ret0
	err := _MiniMeToken.contract.Call(opts, out, "decimals")
	return *ret0, err
}

// Decimals is a free data retrieval call binding the contract method 0x313ce567.
//
// Solidity: function decimals() constant 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() constant 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() constant returns(string)
func (_MiniMeToken *MiniMeTokenCaller) Name(opts *bind.CallOpts) (string, error) {
	var (
		ret0 = new(string)
	)
	out := ret0
	err := _MiniMeToken.contract.Call(opts, out, "name")
	return *ret0, err
}

// Name is a free data retrieval call binding the contract method 0x06fdde03.
//
// Solidity: function name() constant 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() constant 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() constant returns(uint256)
func (_MiniMeToken *MiniMeTokenCaller) ParentSnapShotBlock(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _MiniMeToken.contract.Call(opts, out, "parentSnapShotBlock")
	return *ret0, err
}

// ParentSnapShotBlock is a free data retrieval call binding the contract method 0xc5bcc4f1.
//
// Solidity: function parentSnapShotBlock() constant 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() constant 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() constant returns(address)
func (_MiniMeToken *MiniMeTokenCaller) ParentToken(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _MiniMeToken.contract.Call(opts, out, "parentToken")
	return *ret0, err
}

// ParentToken is a free data retrieval call binding the contract method 0x80a54001.
//
// Solidity: function parentToken() constant 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() constant 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() constant returns(string)
func (_MiniMeToken *MiniMeTokenCaller) Symbol(opts *bind.CallOpts) (string, error) {
	var (
		ret0 = new(string)
	)
	out := ret0
	err := _MiniMeToken.contract.Call(opts, out, "symbol")
	return *ret0, err
}

// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
//
// Solidity: function symbol() constant 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() constant 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() constant returns(address)
func (_MiniMeToken *MiniMeTokenCaller) TokenFactory(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _MiniMeToken.contract.Call(opts, out, "tokenFactory")
	return *ret0, err
}

// TokenFactory is a free data retrieval call binding the contract method 0xe77772fe.
//
// Solidity: function tokenFactory() constant 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() constant 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() constant returns(uint256)
func (_MiniMeToken *MiniMeTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _MiniMeToken.contract.Call(opts, out, "totalSupply")
	return *ret0, err
}

// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
//
// Solidity: function totalSupply() constant 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() constant 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) constant returns(uint256)
func (_MiniMeToken *MiniMeTokenCaller) TotalSupplyAt(opts *bind.CallOpts, _blockNumber *big.Int) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _MiniMeToken.contract.Call(opts, out, "totalSupplyAt", _blockNumber)
	return *ret0, err
}

// TotalSupplyAt is a free data retrieval call binding the contract method 0x981b24d0.
//
// Solidity: function totalSupplyAt(uint256 _blockNumber) constant 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) constant 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() constant returns(bool)
func (_MiniMeToken *MiniMeTokenCaller) TransfersEnabled(opts *bind.CallOpts) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _MiniMeToken.contract.Call(opts, out, "transfersEnabled")
	return *ret0, err
}

// TransfersEnabled is a free data retrieval call binding the contract method 0xbef97c87.
//
// Solidity: function transfersEnabled() constant 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() constant 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() constant returns(string)
func (_MiniMeToken *MiniMeTokenCaller) Version(opts *bind.CallOpts) (string, error) {
	var (
		ret0 = new(string)
	)
	out := ret0
	err := _MiniMeToken.contract.Call(opts, out, "version")
	return *ret0, err
}

// Version is a free data retrieval call binding the contract method 0x54fd4d50.
//
// Solidity: function version() constant 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() constant 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)
}

// 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
	}
	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
	}
	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
	}
	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
	}
	return event, nil
}

// MiniMeTokenFactoryABI is the input ABI used to generate the binding from.
const MiniMeTokenFactoryABI = "[{\"constant\":false,\"inputs\":[{\"internalType\":\"addresspayable\",\"name\":\"_parentToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_snapshotBlock\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"_tokenName\",\"type\":\"string\"},{\"internalType\":\"uint8\",\"name\":\"_decimalUnits\",\"type\":\"uint8\"},{\"internalType\":\"string\",\"name\":\"_tokenSymbol\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"_transfersEnabled\",\"type\":\"bool\"}],\"name\":\"createCloneToken\",\"outputs\":[{\"internalType\":\"contractMiniMeToken\",\"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)",
}

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

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

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(MiniMeTokenFactoryBin), backend)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &MiniMeTokenFactory{MiniMeTokenFactoryCaller: MiniMeTokenFactoryCaller{contract: contract}, MiniMeTokenFactoryTransactor: MiniMeTokenFactoryTransactor{contract: contract}, MiniMeTokenFactoryFilterer: MiniMeTokenFactoryFilterer{contract: contract}}, nil
}

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

// MinterRoleABI is the input ABI used to generate the binding from.
const MinterRoleABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterRemoved\",\"type\":\"event\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"addMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isMinter\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"

// MinterRoleFuncSigs maps the 4-byte function signature to its string representation.
var MinterRoleFuncSigs = map[string]string{
	"983b2d56": "addMinter(address)",
	"aa271e1a": "isMinter(address)",
	"98650275": "renounceMinter()",
}

// MinterRole is an auto generated Go binding around an Ethereum contract.
type MinterRole struct {
	MinterRoleCaller     // Read-only binding to the contract
	MinterRoleTransactor // Write-only binding to the contract
	MinterRoleFilterer   // Log filterer for contract events
}

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

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

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

// MinterRoleSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type MinterRoleSession struct {
	Contract     *MinterRole       // 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
}

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

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

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

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

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

// NewMinterRole creates a new instance of MinterRole, bound to a specific deployed contract.
func NewMinterRole(address common.Address, backend bind.ContractBackend) (*MinterRole, error) {
	contract, err := bindMinterRole(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &MinterRole{MinterRoleCaller: MinterRoleCaller{contract: contract}, MinterRoleTransactor: MinterRoleTransactor{contract: contract}, MinterRoleFilterer: MinterRoleFilterer{contract: contract}}, nil
}

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

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

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

// bindMinterRole binds a generic wrapper to an already deployed contract.
func bindMinterRole(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(MinterRoleABI))
	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 (_MinterRole *MinterRoleRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _MinterRole.Contract.MinterRoleCaller.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 (_MinterRole *MinterRoleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _MinterRole.Contract.MinterRoleTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_MinterRole *MinterRoleRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _MinterRole.Contract.MinterRoleTransactor.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 (_MinterRole *MinterRoleCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _MinterRole.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 (_MinterRole *MinterRoleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _MinterRole.Contract.contract.Transfer(opts)
}

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

// IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
//
// Solidity: function isMinter(address account) constant returns(bool)
func (_MinterRole *MinterRoleCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _MinterRole.contract.Call(opts, out, "isMinter", account)
	return *ret0, err
}

// IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
//
// Solidity: function isMinter(address account) constant returns(bool)
func (_MinterRole *MinterRoleSession) IsMinter(account common.Address) (bool, error) {
	return _MinterRole.Contract.IsMinter(&_MinterRole.CallOpts, account)
}

// IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
//
// Solidity: function isMinter(address account) constant returns(bool)
func (_MinterRole *MinterRoleCallerSession) IsMinter(account common.Address) (bool, error) {
	return _MinterRole.Contract.IsMinter(&_MinterRole.CallOpts, account)
}

// AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
//
// Solidity: function addMinter(address account) returns()
func (_MinterRole *MinterRoleTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) {
	return _MinterRole.contract.Transact(opts, "addMinter", account)
}

// AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
//
// Solidity: function addMinter(address account) returns()
func (_MinterRole *MinterRoleSession) AddMinter(account common.Address) (*types.Transaction, error) {
	return _MinterRole.Contract.AddMinter(&_MinterRole.TransactOpts, account)
}

// AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
//
// Solidity: function addMinter(address account) returns()
func (_MinterRole *MinterRoleTransactorSession) AddMinter(account common.Address) (*types.Transaction, error) {
	return _MinterRole.Contract.AddMinter(&_MinterRole.TransactOpts, account)
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
//
// Solidity: function renounceMinter() returns()
func (_MinterRole *MinterRoleTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _MinterRole.contract.Transact(opts, "renounceMinter")
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
//
// Solidity: function renounceMinter() returns()
func (_MinterRole *MinterRoleSession) RenounceMinter() (*types.Transaction, error) {
	return _MinterRole.Contract.RenounceMinter(&_MinterRole.TransactOpts)
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
//
// Solidity: function renounceMinter() returns()
func (_MinterRole *MinterRoleTransactorSession) RenounceMinter() (*types.Transaction, error) {
	return _MinterRole.Contract.RenounceMinter(&_MinterRole.TransactOpts)
}

// MinterRoleMinterAddedIterator is returned from FilterMinterAdded and is used to iterate over the raw logs and unpacked data for MinterAdded events raised by the MinterRole contract.
type MinterRoleMinterAddedIterator struct {
	Event *MinterRoleMinterAdded // 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 *MinterRoleMinterAddedIterator) 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(MinterRoleMinterAdded)
			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(MinterRoleMinterAdded)
		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 *MinterRoleMinterAddedIterator) Error() error {
	return it.fail
}

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

// MinterRoleMinterAdded represents a MinterAdded event raised by the MinterRole contract.
type MinterRoleMinterAdded struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterMinterAdded is a free log retrieval operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
//
// Solidity: event MinterAdded(address indexed account)
func (_MinterRole *MinterRoleFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*MinterRoleMinterAddedIterator, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _MinterRole.contract.FilterLogs(opts, "MinterAdded", accountRule)
	if err != nil {
		return nil, err
	}
	return &MinterRoleMinterAddedIterator{contract: _MinterRole.contract, event: "MinterAdded", logs: logs, sub: sub}, nil
}

// WatchMinterAdded is a free log subscription operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
//
// Solidity: event MinterAdded(address indexed account)
func (_MinterRole *MinterRoleFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *MinterRoleMinterAdded, account []common.Address) (event.Subscription, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _MinterRole.contract.WatchLogs(opts, "MinterAdded", accountRule)
	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(MinterRoleMinterAdded)
				if err := _MinterRole.contract.UnpackLog(event, "MinterAdded", 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
}

// ParseMinterAdded is a log parse operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
//
// Solidity: event MinterAdded(address indexed account)
func (_MinterRole *MinterRoleFilterer) ParseMinterAdded(log types.Log) (*MinterRoleMinterAdded, error) {
	event := new(MinterRoleMinterAdded)
	if err := _MinterRole.contract.UnpackLog(event, "MinterAdded", log); err != nil {
		return nil, err
	}
	return event, nil
}

// MinterRoleMinterRemovedIterator is returned from FilterMinterRemoved and is used to iterate over the raw logs and unpacked data for MinterRemoved events raised by the MinterRole contract.
type MinterRoleMinterRemovedIterator struct {
	Event *MinterRoleMinterRemoved // 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 *MinterRoleMinterRemovedIterator) 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(MinterRoleMinterRemoved)
			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(MinterRoleMinterRemoved)
		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 *MinterRoleMinterRemovedIterator) Error() error {
	return it.fail
}

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

// MinterRoleMinterRemoved represents a MinterRemoved event raised by the MinterRole contract.
type MinterRoleMinterRemoved struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterMinterRemoved is a free log retrieval operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
//
// Solidity: event MinterRemoved(address indexed account)
func (_MinterRole *MinterRoleFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*MinterRoleMinterRemovedIterator, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _MinterRole.contract.FilterLogs(opts, "MinterRemoved", accountRule)
	if err != nil {
		return nil, err
	}
	return &MinterRoleMinterRemovedIterator{contract: _MinterRole.contract, event: "MinterRemoved", logs: logs, sub: sub}, nil
}

// WatchMinterRemoved is a free log subscription operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
//
// Solidity: event MinterRemoved(address indexed account)
func (_MinterRole *MinterRoleFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *MinterRoleMinterRemoved, account []common.Address) (event.Subscription, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _MinterRole.contract.WatchLogs(opts, "MinterRemoved", accountRule)
	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(MinterRoleMinterRemoved)
				if err := _MinterRole.contract.UnpackLog(event, "MinterRemoved", 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
}

// ParseMinterRemoved is a log parse operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
//
// Solidity: event MinterRemoved(address indexed account)
func (_MinterRole *MinterRoleFilterer) ParseMinterRemoved(log types.Log) (*MinterRoleMinterRemoved, error) {
	event := new(MinterRoleMinterRemoved)
	if err := _MinterRole.contract.UnpackLog(event, "MinterRemoved", log); err != nil {
		return nil, err
	}
	return event, nil
}

// MinterRoleRenounceTargetABI is the input ABI used to generate the binding from.
const MinterRoleRenounceTargetABI = "[{\"constant\":false,\"inputs\":[],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"

// MinterRoleRenounceTargetFuncSigs maps the 4-byte function signature to its string representation.
var MinterRoleRenounceTargetFuncSigs = map[string]string{
	"98650275": "renounceMinter()",
}

// MinterRoleRenounceTarget is an auto generated Go binding around an Ethereum contract.
type MinterRoleRenounceTarget struct {
	MinterRoleRenounceTargetCaller     // Read-only binding to the contract
	MinterRoleRenounceTargetTransactor // Write-only binding to the contract
	MinterRoleRenounceTargetFilterer   // Log filterer for contract events
}

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

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

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

// MinterRoleRenounceTargetSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type MinterRoleRenounceTargetSession struct {
	Contract     *MinterRoleRenounceTarget // 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
}

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

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

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

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

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

// NewMinterRoleRenounceTarget creates a new instance of MinterRoleRenounceTarget, bound to a specific deployed contract.
func NewMinterRoleRenounceTarget(address common.Address, backend bind.ContractBackend) (*MinterRoleRenounceTarget, error) {
	contract, err := bindMinterRoleRenounceTarget(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &MinterRoleRenounceTarget{MinterRoleRenounceTargetCaller: MinterRoleRenounceTargetCaller{contract: contract}, MinterRoleRenounceTargetTransactor: MinterRoleRenounceTargetTransactor{contract: contract}, MinterRoleRenounceTargetFilterer: MinterRoleRenounceTargetFilterer{contract: contract}}, nil
}

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

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

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

// bindMinterRoleRenounceTarget binds a generic wrapper to an already deployed contract.
func bindMinterRoleRenounceTarget(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(MinterRoleRenounceTargetABI))
	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 (_MinterRoleRenounceTarget *MinterRoleRenounceTargetRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _MinterRoleRenounceTarget.Contract.MinterRoleRenounceTargetCaller.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 (_MinterRoleRenounceTarget *MinterRoleRenounceTargetRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _MinterRoleRenounceTarget.Contract.MinterRoleRenounceTargetTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _MinterRoleRenounceTarget.Contract.MinterRoleRenounceTargetTransactor.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 (_MinterRoleRenounceTarget *MinterRoleRenounceTargetCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _MinterRoleRenounceTarget.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 (_MinterRoleRenounceTarget *MinterRoleRenounceTargetTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _MinterRoleRenounceTarget.Contract.contract.Transfer(opts)
}

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

// RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
//
// Solidity: function renounceMinter() returns()
func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _MinterRoleRenounceTarget.contract.Transact(opts, "renounceMinter")
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
//
// Solidity: function renounceMinter() returns()
func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetSession) RenounceMinter() (*types.Transaction, error) {
	return _MinterRoleRenounceTarget.Contract.RenounceMinter(&_MinterRoleRenounceTarget.TransactOpts)
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
//
// Solidity: function renounceMinter() returns()
func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetTransactorSession) RenounceMinter() (*types.Transaction, error) {
	return _MinterRoleRenounceTarget.Contract.RenounceMinter(&_MinterRoleRenounceTarget.TransactOpts)
}

// OwnableABI is the input ABI used to generate the binding from.
const OwnableABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[],\"name\":\"isOwner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"

// OwnableFuncSigs maps the 4-byte function signature to its string representation.
var OwnableFuncSigs = map[string]string{
	"8f32d59b": "isOwner()",
	"8da5cb5b": "owner()",
	"715018a6": "renounceOwnership()",
	"f2fde38b": "transferOwnership(address)",
}

// Ownable is an auto generated Go binding around an Ethereum contract.
type Ownable struct {
	OwnableCaller     // Read-only binding to the contract
	OwnableTransactor // Write-only binding to the contract
	OwnableFilterer   // Log filterer for contract events
}

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

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

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

// OwnableSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type OwnableSession struct {
	Contract     *Ownable          // 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
}

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

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

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

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

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

// NewOwnable creates a new instance of Ownable, bound to a specific deployed contract.
func NewOwnable(address common.Address, backend bind.ContractBackend) (*Ownable, error) {
	contract, err := bindOwnable(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &Ownable{OwnableCaller: OwnableCaller{contract: contract}, OwnableTransactor: OwnableTransactor{contract: contract}, OwnableFilterer: OwnableFilterer{contract: contract}}, nil
}

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

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

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

// bindOwnable binds a generic wrapper to an already deployed contract.
func bindOwnable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(OwnableABI))
	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 (_Ownable *OwnableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _Ownable.Contract.OwnableCaller.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 (_Ownable *OwnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _Ownable.Contract.OwnableTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_Ownable *OwnableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _Ownable.Contract.OwnableTransactor.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 (_Ownable *OwnableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _Ownable.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 (_Ownable *OwnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _Ownable.Contract.contract.Transfer(opts)
}

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

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_Ownable *OwnableCaller) IsOwner(opts *bind.CallOpts) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _Ownable.contract.Call(opts, out, "isOwner")
	return *ret0, err
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_Ownable *OwnableSession) IsOwner() (bool, error) {
	return _Ownable.Contract.IsOwner(&_Ownable.CallOpts)
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_Ownable *OwnableCallerSession) IsOwner() (bool, error) {
	return _Ownable.Contract.IsOwner(&_Ownable.CallOpts)
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_Ownable *OwnableCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _Ownable.contract.Call(opts, out, "owner")
	return *ret0, err
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_Ownable *OwnableSession) Owner() (common.Address, error) {
	return _Ownable.Contract.Owner(&_Ownable.CallOpts)
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_Ownable *OwnableCallerSession) Owner() (common.Address, error) {
	return _Ownable.Contract.Owner(&_Ownable.CallOpts)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_Ownable *OwnableTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _Ownable.contract.Transact(opts, "renounceOwnership")
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_Ownable *OwnableSession) RenounceOwnership() (*types.Transaction, error) {
	return _Ownable.Contract.RenounceOwnership(&_Ownable.TransactOpts)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_Ownable *OwnableTransactorSession) RenounceOwnership() (*types.Transaction, error) {
	return _Ownable.Contract.RenounceOwnership(&_Ownable.TransactOpts)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_Ownable *OwnableTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
	return _Ownable.contract.Transact(opts, "transferOwnership", newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_Ownable *OwnableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
	return _Ownable.Contract.TransferOwnership(&_Ownable.TransactOpts, newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_Ownable *OwnableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
	return _Ownable.Contract.TransferOwnership(&_Ownable.TransactOpts, newOwner)
}

// OwnableOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Ownable contract.
type OwnableOwnershipTransferredIterator struct {
	Event *OwnableOwnershipTransferred // 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 *OwnableOwnershipTransferredIterator) 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(OwnableOwnershipTransferred)
			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(OwnableOwnershipTransferred)
		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 *OwnableOwnershipTransferredIterator) Error() error {
	return it.fail
}

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

// OwnableOwnershipTransferred represents a OwnershipTransferred event raised by the Ownable contract.
type OwnableOwnershipTransferred struct {
	PreviousOwner common.Address
	NewOwner      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_Ownable *OwnableFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*OwnableOwnershipTransferredIterator, error) {

	var previousOwnerRule []interface{}
	for _, previousOwnerItem := range previousOwner {
		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
	}
	var newOwnerRule []interface{}
	for _, newOwnerItem := range newOwner {
		newOwnerRule = append(newOwnerRule, newOwnerItem)
	}

	logs, sub, err := _Ownable.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
	if err != nil {
		return nil, err
	}
	return &OwnableOwnershipTransferredIterator{contract: _Ownable.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
}

// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_Ownable *OwnableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OwnableOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {

	var previousOwnerRule []interface{}
	for _, previousOwnerItem := range previousOwner {
		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
	}
	var newOwnerRule []interface{}
	for _, newOwnerItem := range newOwner {
		newOwnerRule = append(newOwnerRule, newOwnerItem)
	}

	logs, sub, err := _Ownable.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
	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(OwnableOwnershipTransferred)
				if err := _Ownable.contract.UnpackLog(event, "OwnershipTransferred", 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
}

// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_Ownable *OwnableFilterer) ParseOwnershipTransferred(log types.Log) (*OwnableOwnershipTransferred, error) {
	event := new(OwnableOwnershipTransferred)
	if err := _Ownable.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
		return nil, err
	}
	return event, nil
}

// OwnableTargetABI is the input ABI used to generate the binding from.
const OwnableTargetABI = "[{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"

// OwnableTargetFuncSigs maps the 4-byte function signature to its string representation.
var OwnableTargetFuncSigs = map[string]string{
	"715018a6": "renounceOwnership()",
	"f2fde38b": "transferOwnership(address)",
}

// OwnableTarget is an auto generated Go binding around an Ethereum contract.
type OwnableTarget struct {
	OwnableTargetCaller     // Read-only binding to the contract
	OwnableTargetTransactor // Write-only binding to the contract
	OwnableTargetFilterer   // Log filterer for contract events
}

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

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

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

// OwnableTargetSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type OwnableTargetSession struct {
	Contract     *OwnableTarget    // 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
}

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

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

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

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

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

// NewOwnableTarget creates a new instance of OwnableTarget, bound to a specific deployed contract.
func NewOwnableTarget(address common.Address, backend bind.ContractBackend) (*OwnableTarget, error) {
	contract, err := bindOwnableTarget(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &OwnableTarget{OwnableTargetCaller: OwnableTargetCaller{contract: contract}, OwnableTargetTransactor: OwnableTargetTransactor{contract: contract}, OwnableTargetFilterer: OwnableTargetFilterer{contract: contract}}, nil
}

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

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

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

// bindOwnableTarget binds a generic wrapper to an already deployed contract.
func bindOwnableTarget(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(OwnableTargetABI))
	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 (_OwnableTarget *OwnableTargetRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _OwnableTarget.Contract.OwnableTargetCaller.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 (_OwnableTarget *OwnableTargetRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _OwnableTarget.Contract.OwnableTargetTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_OwnableTarget *OwnableTargetRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _OwnableTarget.Contract.OwnableTargetTransactor.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 (_OwnableTarget *OwnableTargetCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _OwnableTarget.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 (_OwnableTarget *OwnableTargetTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _OwnableTarget.Contract.contract.Transfer(opts)
}

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

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_OwnableTarget *OwnableTargetTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _OwnableTarget.contract.Transact(opts, "renounceOwnership")
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_OwnableTarget *OwnableTargetSession) RenounceOwnership() (*types.Transaction, error) {
	return _OwnableTarget.Contract.RenounceOwnership(&_OwnableTarget.TransactOpts)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_OwnableTarget *OwnableTargetTransactorSession) RenounceOwnership() (*types.Transaction, error) {
	return _OwnableTarget.Contract.RenounceOwnership(&_OwnableTarget.TransactOpts)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_OwnableTarget *OwnableTargetTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
	return _OwnableTarget.contract.Transact(opts, "transferOwnership", newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_OwnableTarget *OwnableTargetSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
	return _OwnableTarget.Contract.TransferOwnership(&_OwnableTarget.TransactOpts, newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_OwnableTarget *OwnableTargetTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
	return _OwnableTarget.Contract.TransferOwnership(&_OwnableTarget.TransactOpts, newOwner)
}

// PausableABI is the input ABI used to generate the binding from.
const PausableABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"Paused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"PauserAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"PauserRemoved\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"Unpaused\",\"type\":\"event\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"addPauser\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isPauser\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"pause\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"paused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renouncePauser\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"unpause\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"

// PausableFuncSigs maps the 4-byte function signature to its string representation.
var PausableFuncSigs = map[string]string{
	"82dc1ec4": "addPauser(address)",
	"46fbf68e": "isPauser(address)",
	"8456cb59": "pause()",
	"5c975abb": "paused()",
	"6ef8d66d": "renouncePauser()",
	"3f4ba83a": "unpause()",
}

// Pausable is an auto generated Go binding around an Ethereum contract.
type Pausable struct {
	PausableCaller     // Read-only binding to the contract
	PausableTransactor // Write-only binding to the contract
	PausableFilterer   // Log filterer for contract events
}

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

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

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

// PausableSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type PausableSession struct {
	Contract     *Pausable         // 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
}

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

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

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

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

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

// NewPausable creates a new instance of Pausable, bound to a specific deployed contract.
func NewPausable(address common.Address, backend bind.ContractBackend) (*Pausable, error) {
	contract, err := bindPausable(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &Pausable{PausableCaller: PausableCaller{contract: contract}, PausableTransactor: PausableTransactor{contract: contract}, PausableFilterer: PausableFilterer{contract: contract}}, nil
}

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

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

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

// bindPausable binds a generic wrapper to an already deployed contract.
func bindPausable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(PausableABI))
	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 (_Pausable *PausableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _Pausable.Contract.PausableCaller.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 (_Pausable *PausableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _Pausable.Contract.PausableTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_Pausable *PausableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _Pausable.Contract.PausableTransactor.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 (_Pausable *PausableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _Pausable.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 (_Pausable *PausableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _Pausable.Contract.contract.Transfer(opts)
}

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

// IsPauser is a free data retrieval call binding the contract method 0x46fbf68e.
//
// Solidity: function isPauser(address account) constant returns(bool)
func (_Pausable *PausableCaller) IsPauser(opts *bind.CallOpts, account common.Address) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _Pausable.contract.Call(opts, out, "isPauser", account)
	return *ret0, err
}

// IsPauser is a free data retrieval call binding the contract method 0x46fbf68e.
//
// Solidity: function isPauser(address account) constant returns(bool)
func (_Pausable *PausableSession) IsPauser(account common.Address) (bool, error) {
	return _Pausable.Contract.IsPauser(&_Pausable.CallOpts, account)
}

// IsPauser is a free data retrieval call binding the contract method 0x46fbf68e.
//
// Solidity: function isPauser(address account) constant returns(bool)
func (_Pausable *PausableCallerSession) IsPauser(account common.Address) (bool, error) {
	return _Pausable.Contract.IsPauser(&_Pausable.CallOpts, account)
}

// Paused is a free data retrieval call binding the contract method 0x5c975abb.
//
// Solidity: function paused() constant returns(bool)
func (_Pausable *PausableCaller) Paused(opts *bind.CallOpts) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _Pausable.contract.Call(opts, out, "paused")
	return *ret0, err
}

// Paused is a free data retrieval call binding the contract method 0x5c975abb.
//
// Solidity: function paused() constant returns(bool)
func (_Pausable *PausableSession) Paused() (bool, error) {
	return _Pausable.Contract.Paused(&_Pausable.CallOpts)
}

// Paused is a free data retrieval call binding the contract method 0x5c975abb.
//
// Solidity: function paused() constant returns(bool)
func (_Pausable *PausableCallerSession) Paused() (bool, error) {
	return _Pausable.Contract.Paused(&_Pausable.CallOpts)
}

// AddPauser is a paid mutator transaction binding the contract method 0x82dc1ec4.
//
// Solidity: function addPauser(address account) returns()
func (_Pausable *PausableTransactor) AddPauser(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) {
	return _Pausable.contract.Transact(opts, "addPauser", account)
}

// AddPauser is a paid mutator transaction binding the contract method 0x82dc1ec4.
//
// Solidity: function addPauser(address account) returns()
func (_Pausable *PausableSession) AddPauser(account common.Address) (*types.Transaction, error) {
	return _Pausable.Contract.AddPauser(&_Pausable.TransactOpts, account)
}

// AddPauser is a paid mutator transaction binding the contract method 0x82dc1ec4.
//
// Solidity: function addPauser(address account) returns()
func (_Pausable *PausableTransactorSession) AddPauser(account common.Address) (*types.Transaction, error) {
	return _Pausable.Contract.AddPauser(&_Pausable.TransactOpts, account)
}

// Pause is a paid mutator transaction binding the contract method 0x8456cb59.
//
// Solidity: function pause() returns()
func (_Pausable *PausableTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _Pausable.contract.Transact(opts, "pause")
}

// Pause is a paid mutator transaction binding the contract method 0x8456cb59.
//
// Solidity: function pause() returns()
func (_Pausable *PausableSession) Pause() (*types.Transaction, error) {
	return _Pausable.Contract.Pause(&_Pausable.TransactOpts)
}

// Pause is a paid mutator transaction binding the contract method 0x8456cb59.
//
// Solidity: function pause() returns()
func (_Pausable *PausableTransactorSession) Pause() (*types.Transaction, error) {
	return _Pausable.Contract.Pause(&_Pausable.TransactOpts)
}

// RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d.
//
// Solidity: function renouncePauser() returns()
func (_Pausable *PausableTransactor) RenouncePauser(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _Pausable.contract.Transact(opts, "renouncePauser")
}

// RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d.
//
// Solidity: function renouncePauser() returns()
func (_Pausable *PausableSession) RenouncePauser() (*types.Transaction, error) {
	return _Pausable.Contract.RenouncePauser(&_Pausable.TransactOpts)
}

// RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d.
//
// Solidity: function renouncePauser() returns()
func (_Pausable *PausableTransactorSession) RenouncePauser() (*types.Transaction, error) {
	return _Pausable.Contract.RenouncePauser(&_Pausable.TransactOpts)
}

// Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a.
//
// Solidity: function unpause() returns()
func (_Pausable *PausableTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _Pausable.contract.Transact(opts, "unpause")
}

// Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a.
//
// Solidity: function unpause() returns()
func (_Pausable *PausableSession) Unpause() (*types.Transaction, error) {
	return _Pausable.Contract.Unpause(&_Pausable.TransactOpts)
}

// Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a.
//
// Solidity: function unpause() returns()
func (_Pausable *PausableTransactorSession) Unpause() (*types.Transaction, error) {
	return _Pausable.Contract.Unpause(&_Pausable.TransactOpts)
}

// PausablePausedIterator is returned from FilterPaused and is used to iterate over the raw logs and unpacked data for Paused events raised by the Pausable contract.
type PausablePausedIterator struct {
	Event *PausablePaused // 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 *PausablePausedIterator) 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(PausablePaused)
			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(PausablePaused)
		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 *PausablePausedIterator) Error() error {
	return it.fail
}

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

// PausablePaused represents a Paused event raised by the Pausable contract.
type PausablePaused struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterPaused is a free log retrieval operation binding the contract event 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258.
//
// Solidity: event Paused(address account)
func (_Pausable *PausableFilterer) FilterPaused(opts *bind.FilterOpts) (*PausablePausedIterator, error) {

	logs, sub, err := _Pausable.contract.FilterLogs(opts, "Paused")
	if err != nil {
		return nil, err
	}
	return &PausablePausedIterator{contract: _Pausable.contract, event: "Paused", logs: logs, sub: sub}, nil
}

// WatchPaused is a free log subscription operation binding the contract event 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258.
//
// Solidity: event Paused(address account)
func (_Pausable *PausableFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *PausablePaused) (event.Subscription, error) {

	logs, sub, err := _Pausable.contract.WatchLogs(opts, "Paused")
	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(PausablePaused)
				if err := _Pausable.contract.UnpackLog(event, "Paused", 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
}

// ParsePaused is a log parse operation binding the contract event 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258.
//
// Solidity: event Paused(address account)
func (_Pausable *PausableFilterer) ParsePaused(log types.Log) (*PausablePaused, error) {
	event := new(PausablePaused)
	if err := _Pausable.contract.UnpackLog(event, "Paused", log); err != nil {
		return nil, err
	}
	return event, nil
}

// PausablePauserAddedIterator is returned from FilterPauserAdded and is used to iterate over the raw logs and unpacked data for PauserAdded events raised by the Pausable contract.
type PausablePauserAddedIterator struct {
	Event *PausablePauserAdded // 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 *PausablePauserAddedIterator) 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(PausablePauserAdded)
			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(PausablePauserAdded)
		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 *PausablePauserAddedIterator) Error() error {
	return it.fail
}

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

// PausablePauserAdded represents a PauserAdded event raised by the Pausable contract.
type PausablePauserAdded struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterPauserAdded is a free log retrieval operation binding the contract event 0x6719d08c1888103bea251a4ed56406bd0c3e69723c8a1686e017e7bbe159b6f8.
//
// Solidity: event PauserAdded(address indexed account)
func (_Pausable *PausableFilterer) FilterPauserAdded(opts *bind.FilterOpts, account []common.Address) (*PausablePauserAddedIterator, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _Pausable.contract.FilterLogs(opts, "PauserAdded", accountRule)
	if err != nil {
		return nil, err
	}
	return &PausablePauserAddedIterator{contract: _Pausable.contract, event: "PauserAdded", logs: logs, sub: sub}, nil
}

// WatchPauserAdded is a free log subscription operation binding the contract event 0x6719d08c1888103bea251a4ed56406bd0c3e69723c8a1686e017e7bbe159b6f8.
//
// Solidity: event PauserAdded(address indexed account)
func (_Pausable *PausableFilterer) WatchPauserAdded(opts *bind.WatchOpts, sink chan<- *PausablePauserAdded, account []common.Address) (event.Subscription, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _Pausable.contract.WatchLogs(opts, "PauserAdded", accountRule)
	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(PausablePauserAdded)
				if err := _Pausable.contract.UnpackLog(event, "PauserAdded", 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
}

// ParsePauserAdded is a log parse operation binding the contract event 0x6719d08c1888103bea251a4ed56406bd0c3e69723c8a1686e017e7bbe159b6f8.
//
// Solidity: event PauserAdded(address indexed account)
func (_Pausable *PausableFilterer) ParsePauserAdded(log types.Log) (*PausablePauserAdded, error) {
	event := new(PausablePauserAdded)
	if err := _Pausable.contract.UnpackLog(event, "PauserAdded", log); err != nil {
		return nil, err
	}
	return event, nil
}

// PausablePauserRemovedIterator is returned from FilterPauserRemoved and is used to iterate over the raw logs and unpacked data for PauserRemoved events raised by the Pausable contract.
type PausablePauserRemovedIterator struct {
	Event *PausablePauserRemoved // 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 *PausablePauserRemovedIterator) 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(PausablePauserRemoved)
			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(PausablePauserRemoved)
		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 *PausablePauserRemovedIterator) Error() error {
	return it.fail
}

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

// PausablePauserRemoved represents a PauserRemoved event raised by the Pausable contract.
type PausablePauserRemoved struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterPauserRemoved is a free log retrieval operation binding the contract event 0xcd265ebaf09df2871cc7bd4133404a235ba12eff2041bb89d9c714a2621c7c7e.
//
// Solidity: event PauserRemoved(address indexed account)
func (_Pausable *PausableFilterer) FilterPauserRemoved(opts *bind.FilterOpts, account []common.Address) (*PausablePauserRemovedIterator, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _Pausable.contract.FilterLogs(opts, "PauserRemoved", accountRule)
	if err != nil {
		return nil, err
	}
	return &PausablePauserRemovedIterator{contract: _Pausable.contract, event: "PauserRemoved", logs: logs, sub: sub}, nil
}

// WatchPauserRemoved is a free log subscription operation binding the contract event 0xcd265ebaf09df2871cc7bd4133404a235ba12eff2041bb89d9c714a2621c7c7e.
//
// Solidity: event PauserRemoved(address indexed account)
func (_Pausable *PausableFilterer) WatchPauserRemoved(opts *bind.WatchOpts, sink chan<- *PausablePauserRemoved, account []common.Address) (event.Subscription, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _Pausable.contract.WatchLogs(opts, "PauserRemoved", accountRule)
	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(PausablePauserRemoved)
				if err := _Pausable.contract.UnpackLog(event, "PauserRemoved", 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
}

// ParsePauserRemoved is a log parse operation binding the contract event 0xcd265ebaf09df2871cc7bd4133404a235ba12eff2041bb89d9c714a2621c7c7e.
//
// Solidity: event PauserRemoved(address indexed account)
func (_Pausable *PausableFilterer) ParsePauserRemoved(log types.Log) (*PausablePauserRemoved, error) {
	event := new(PausablePauserRemoved)
	if err := _Pausable.contract.UnpackLog(event, "PauserRemoved", log); err != nil {
		return nil, err
	}
	return event, nil
}

// PausableUnpausedIterator is returned from FilterUnpaused and is used to iterate over the raw logs and unpacked data for Unpaused events raised by the Pausable contract.
type PausableUnpausedIterator struct {
	Event *PausableUnpaused // 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 *PausableUnpausedIterator) 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(PausableUnpaused)
			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(PausableUnpaused)
		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 *PausableUnpausedIterator) Error() error {
	return it.fail
}

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

// PausableUnpaused represents a Unpaused event raised by the Pausable contract.
type PausableUnpaused struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterUnpaused is a free log retrieval operation binding the contract event 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa.
//
// Solidity: event Unpaused(address account)
func (_Pausable *PausableFilterer) FilterUnpaused(opts *bind.FilterOpts) (*PausableUnpausedIterator, error) {

	logs, sub, err := _Pausable.contract.FilterLogs(opts, "Unpaused")
	if err != nil {
		return nil, err
	}
	return &PausableUnpausedIterator{contract: _Pausable.contract, event: "Unpaused", logs: logs, sub: sub}, nil
}

// WatchUnpaused is a free log subscription operation binding the contract event 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa.
//
// Solidity: event Unpaused(address account)
func (_Pausable *PausableFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *PausableUnpaused) (event.Subscription, error) {

	logs, sub, err := _Pausable.contract.WatchLogs(opts, "Unpaused")
	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(PausableUnpaused)
				if err := _Pausable.contract.UnpackLog(event, "Unpaused", 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
}

// ParseUnpaused is a log parse operation binding the contract event 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa.
//
// Solidity: event Unpaused(address account)
func (_Pausable *PausableFilterer) ParseUnpaused(log types.Log) (*PausableUnpaused, error) {
	event := new(PausableUnpaused)
	if err := _Pausable.contract.UnpackLog(event, "Unpaused", log); err != nil {
		return nil, err
	}
	return event, nil
}

// PauserRoleABI is the input ABI used to generate the binding from.
const PauserRoleABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"PauserAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"PauserRemoved\",\"type\":\"event\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"addPauser\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isPauser\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renouncePauser\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"

// PauserRoleFuncSigs maps the 4-byte function signature to its string representation.
var PauserRoleFuncSigs = map[string]string{
	"82dc1ec4": "addPauser(address)",
	"46fbf68e": "isPauser(address)",
	"6ef8d66d": "renouncePauser()",
}

// PauserRole is an auto generated Go binding around an Ethereum contract.
type PauserRole struct {
	PauserRoleCaller     // Read-only binding to the contract
	PauserRoleTransactor // Write-only binding to the contract
	PauserRoleFilterer   // Log filterer for contract events
}

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

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

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

// PauserRoleSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type PauserRoleSession struct {
	Contract     *PauserRole       // 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
}

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

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

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

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

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

// NewPauserRole creates a new instance of PauserRole, bound to a specific deployed contract.
func NewPauserRole(address common.Address, backend bind.ContractBackend) (*PauserRole, error) {
	contract, err := bindPauserRole(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &PauserRole{PauserRoleCaller: PauserRoleCaller{contract: contract}, PauserRoleTransactor: PauserRoleTransactor{contract: contract}, PauserRoleFilterer: PauserRoleFilterer{contract: contract}}, nil
}

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

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

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

// bindPauserRole binds a generic wrapper to an already deployed contract.
func bindPauserRole(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(PauserRoleABI))
	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 (_PauserRole *PauserRoleRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _PauserRole.Contract.PauserRoleCaller.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 (_PauserRole *PauserRoleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _PauserRole.Contract.PauserRoleTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_PauserRole *PauserRoleRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _PauserRole.Contract.PauserRoleTransactor.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 (_PauserRole *PauserRoleCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _PauserRole.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 (_PauserRole *PauserRoleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _PauserRole.Contract.contract.Transfer(opts)
}

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

// IsPauser is a free data retrieval call binding the contract method 0x46fbf68e.
//
// Solidity: function isPauser(address account) constant returns(bool)
func (_PauserRole *PauserRoleCaller) IsPauser(opts *bind.CallOpts, account common.Address) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _PauserRole.contract.Call(opts, out, "isPauser", account)
	return *ret0, err
}

// IsPauser is a free data retrieval call binding the contract method 0x46fbf68e.
//
// Solidity: function isPauser(address account) constant returns(bool)
func (_PauserRole *PauserRoleSession) IsPauser(account common.Address) (bool, error) {
	return _PauserRole.Contract.IsPauser(&_PauserRole.CallOpts, account)
}

// IsPauser is a free data retrieval call binding the contract method 0x46fbf68e.
//
// Solidity: function isPauser(address account) constant returns(bool)
func (_PauserRole *PauserRoleCallerSession) IsPauser(account common.Address) (bool, error) {
	return _PauserRole.Contract.IsPauser(&_PauserRole.CallOpts, account)
}

// AddPauser is a paid mutator transaction binding the contract method 0x82dc1ec4.
//
// Solidity: function addPauser(address account) returns()
func (_PauserRole *PauserRoleTransactor) AddPauser(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) {
	return _PauserRole.contract.Transact(opts, "addPauser", account)
}

// AddPauser is a paid mutator transaction binding the contract method 0x82dc1ec4.
//
// Solidity: function addPauser(address account) returns()
func (_PauserRole *PauserRoleSession) AddPauser(account common.Address) (*types.Transaction, error) {
	return _PauserRole.Contract.AddPauser(&_PauserRole.TransactOpts, account)
}

// AddPauser is a paid mutator transaction binding the contract method 0x82dc1ec4.
//
// Solidity: function addPauser(address account) returns()
func (_PauserRole *PauserRoleTransactorSession) AddPauser(account common.Address) (*types.Transaction, error) {
	return _PauserRole.Contract.AddPauser(&_PauserRole.TransactOpts, account)
}

// RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d.
//
// Solidity: function renouncePauser() returns()
func (_PauserRole *PauserRoleTransactor) RenouncePauser(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _PauserRole.contract.Transact(opts, "renouncePauser")
}

// RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d.
//
// Solidity: function renouncePauser() returns()
func (_PauserRole *PauserRoleSession) RenouncePauser() (*types.Transaction, error) {
	return _PauserRole.Contract.RenouncePauser(&_PauserRole.TransactOpts)
}

// RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d.
//
// Solidity: function renouncePauser() returns()
func (_PauserRole *PauserRoleTransactorSession) RenouncePauser() (*types.Transaction, error) {
	return _PauserRole.Contract.RenouncePauser(&_PauserRole.TransactOpts)
}

// PauserRolePauserAddedIterator is returned from FilterPauserAdded and is used to iterate over the raw logs and unpacked data for PauserAdded events raised by the PauserRole contract.
type PauserRolePauserAddedIterator struct {
	Event *PauserRolePauserAdded // 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 *PauserRolePauserAddedIterator) 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(PauserRolePauserAdded)
			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(PauserRolePauserAdded)
		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 *PauserRolePauserAddedIterator) Error() error {
	return it.fail
}

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

// PauserRolePauserAdded represents a PauserAdded event raised by the PauserRole contract.
type PauserRolePauserAdded struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterPauserAdded is a free log retrieval operation binding the contract event 0x6719d08c1888103bea251a4ed56406bd0c3e69723c8a1686e017e7bbe159b6f8.
//
// Solidity: event PauserAdded(address indexed account)
func (_PauserRole *PauserRoleFilterer) FilterPauserAdded(opts *bind.FilterOpts, account []common.Address) (*PauserRolePauserAddedIterator, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _PauserRole.contract.FilterLogs(opts, "PauserAdded", accountRule)
	if err != nil {
		return nil, err
	}
	return &PauserRolePauserAddedIterator{contract: _PauserRole.contract, event: "PauserAdded", logs: logs, sub: sub}, nil
}

// WatchPauserAdded is a free log subscription operation binding the contract event 0x6719d08c1888103bea251a4ed56406bd0c3e69723c8a1686e017e7bbe159b6f8.
//
// Solidity: event PauserAdded(address indexed account)
func (_PauserRole *PauserRoleFilterer) WatchPauserAdded(opts *bind.WatchOpts, sink chan<- *PauserRolePauserAdded, account []common.Address) (event.Subscription, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _PauserRole.contract.WatchLogs(opts, "PauserAdded", accountRule)
	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(PauserRolePauserAdded)
				if err := _PauserRole.contract.UnpackLog(event, "PauserAdded", 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
}

// ParsePauserAdded is a log parse operation binding the contract event 0x6719d08c1888103bea251a4ed56406bd0c3e69723c8a1686e017e7bbe159b6f8.
//
// Solidity: event PauserAdded(address indexed account)
func (_PauserRole *PauserRoleFilterer) ParsePauserAdded(log types.Log) (*PauserRolePauserAdded, error) {
	event := new(PauserRolePauserAdded)
	if err := _PauserRole.contract.UnpackLog(event, "PauserAdded", log); err != nil {
		return nil, err
	}
	return event, nil
}

// PauserRolePauserRemovedIterator is returned from FilterPauserRemoved and is used to iterate over the raw logs and unpacked data for PauserRemoved events raised by the PauserRole contract.
type PauserRolePauserRemovedIterator struct {
	Event *PauserRolePauserRemoved // 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 *PauserRolePauserRemovedIterator) 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(PauserRolePauserRemoved)
			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(PauserRolePauserRemoved)
		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 *PauserRolePauserRemovedIterator) Error() error {
	return it.fail
}

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

// PauserRolePauserRemoved represents a PauserRemoved event raised by the PauserRole contract.
type PauserRolePauserRemoved struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterPauserRemoved is a free log retrieval operation binding the contract event 0xcd265ebaf09df2871cc7bd4133404a235ba12eff2041bb89d9c714a2621c7c7e.
//
// Solidity: event PauserRemoved(address indexed account)
func (_PauserRole *PauserRoleFilterer) FilterPauserRemoved(opts *bind.FilterOpts, account []common.Address) (*PauserRolePauserRemovedIterator, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _PauserRole.contract.FilterLogs(opts, "PauserRemoved", accountRule)
	if err != nil {
		return nil, err
	}
	return &PauserRolePauserRemovedIterator{contract: _PauserRole.contract, event: "PauserRemoved", logs: logs, sub: sub}, nil
}

// WatchPauserRemoved is a free log subscription operation binding the contract event 0xcd265ebaf09df2871cc7bd4133404a235ba12eff2041bb89d9c714a2621c7c7e.
//
// Solidity: event PauserRemoved(address indexed account)
func (_PauserRole *PauserRoleFilterer) WatchPauserRemoved(opts *bind.WatchOpts, sink chan<- *PauserRolePauserRemoved, account []common.Address) (event.Subscription, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _PauserRole.contract.WatchLogs(opts, "PauserRemoved", accountRule)
	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(PauserRolePauserRemoved)
				if err := _PauserRole.contract.UnpackLog(event, "PauserRemoved", 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
}

// ParsePauserRemoved is a log parse operation binding the contract event 0xcd265ebaf09df2871cc7bd4133404a235ba12eff2041bb89d9c714a2621c7c7e.
//
// Solidity: event PauserRemoved(address indexed account)
func (_PauserRole *PauserRoleFilterer) ParsePauserRemoved(log types.Log) (*PauserRolePauserRemoved, error) {
	event := new(PauserRolePauserRemoved)
	if err := _PauserRole.contract.UnpackLog(event, "PauserRemoved", log); err != nil {
		return nil, err
	}
	return event, nil
}

// PauserRoleRenounceTargetABI is the input ABI used to generate the binding from.
const PauserRoleRenounceTargetABI = "[{\"constant\":false,\"inputs\":[],\"name\":\"renouncePauser\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"

// PauserRoleRenounceTargetFuncSigs maps the 4-byte function signature to its string representation.
var PauserRoleRenounceTargetFuncSigs = map[string]string{
	"6ef8d66d": "renouncePauser()",
}

// PauserRoleRenounceTarget is an auto generated Go binding around an Ethereum contract.
type PauserRoleRenounceTarget struct {
	PauserRoleRenounceTargetCaller     // Read-only binding to the contract
	PauserRoleRenounceTargetTransactor // Write-only binding to the contract
	PauserRoleRenounceTargetFilterer   // Log filterer for contract events
}

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

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

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

// PauserRoleRenounceTargetSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type PauserRoleRenounceTargetSession struct {
	Contract     *PauserRoleRenounceTarget // 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
}

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

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

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

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

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

// NewPauserRoleRenounceTarget creates a new instance of PauserRoleRenounceTarget, bound to a specific deployed contract.
func NewPauserRoleRenounceTarget(address common.Address, backend bind.ContractBackend) (*PauserRoleRenounceTarget, error) {
	contract, err := bindPauserRoleRenounceTarget(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &PauserRoleRenounceTarget{PauserRoleRenounceTargetCaller: PauserRoleRenounceTargetCaller{contract: contract}, PauserRoleRenounceTargetTransactor: PauserRoleRenounceTargetTransactor{contract: contract}, PauserRoleRenounceTargetFilterer: PauserRoleRenounceTargetFilterer{contract: contract}}, nil
}

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

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

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

// bindPauserRoleRenounceTarget binds a generic wrapper to an already deployed contract.
func bindPauserRoleRenounceTarget(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(PauserRoleRenounceTargetABI))
	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 (_PauserRoleRenounceTarget *PauserRoleRenounceTargetRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _PauserRoleRenounceTarget.Contract.PauserRoleRenounceTargetCaller.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 (_PauserRoleRenounceTarget *PauserRoleRenounceTargetRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _PauserRoleRenounceTarget.Contract.PauserRoleRenounceTargetTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _PauserRoleRenounceTarget.Contract.PauserRoleRenounceTargetTransactor.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 (_PauserRoleRenounceTarget *PauserRoleRenounceTargetCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _PauserRoleRenounceTarget.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 (_PauserRoleRenounceTarget *PauserRoleRenounceTargetTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _PauserRoleRenounceTarget.Contract.contract.Transfer(opts)
}

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

// RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d.
//
// Solidity: function renouncePauser() returns()
func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetTransactor) RenouncePauser(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _PauserRoleRenounceTarget.contract.Transact(opts, "renouncePauser")
}

// RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d.
//
// Solidity: function renouncePauser() returns()
func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetSession) RenouncePauser() (*types.Transaction, error) {
	return _PauserRoleRenounceTarget.Contract.RenouncePauser(&_PauserRoleRenounceTarget.TransactOpts)
}

// RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d.
//
// Solidity: function renouncePauser() returns()
func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetTransactorSession) RenouncePauser() (*types.Transaction, error) {
	return _PauserRoleRenounceTarget.Contract.RenouncePauser(&_PauserRoleRenounceTarget.TransactOpts)
}

// PowerTONIABI is the input ABI used to generate the binding from.
const PowerTONIABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"currentRound\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"endRound\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"init\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"onDeposit\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"onWithdraw\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"powerOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"roundDuration\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"seigManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"start\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalDeposits\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"round\",\"type\":\"uint256\"}],\"name\":\"winnerOf\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"wton\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"

// PowerTONIFuncSigs maps the 4-byte function signature to its string representation.
var PowerTONIFuncSigs = map[string]string{
	"8a19c8bc": "currentRound()",
	"749aa2d9": "endRound()",
	"e1c7392a": "init()",
	"412c6d50": "onDeposit(address,address,uint256)",
	"f850ffaa": "onWithdraw(address,address,uint256)",
	"1ac84690": "powerOf(address)",
	"f7cb789a": "roundDuration()",
	"6fb7f558": "seigManager()",
	"be9a6555": "start()",
	"7d882097": "totalDeposits()",
	"8cb5d700": "winnerOf(uint256)",
	"8d62d949": "wton()",
}

// PowerTONI is an auto generated Go binding around an Ethereum contract.
type PowerTONI struct {
	PowerTONICaller     // Read-only binding to the contract
	PowerTONITransactor // Write-only binding to the contract
	PowerTONIFilterer   // Log filterer for contract events
}

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

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

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

// PowerTONISession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type PowerTONISession struct {
	Contract     *PowerTONI        // 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
}

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

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

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

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

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

// NewPowerTONI creates a new instance of PowerTONI, bound to a specific deployed contract.
func NewPowerTONI(address common.Address, backend bind.ContractBackend) (*PowerTONI, error) {
	contract, err := bindPowerTONI(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &PowerTONI{PowerTONICaller: PowerTONICaller{contract: contract}, PowerTONITransactor: PowerTONITransactor{contract: contract}, PowerTONIFilterer: PowerTONIFilterer{contract: contract}}, nil
}

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

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

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

// bindPowerTONI binds a generic wrapper to an already deployed contract.
func bindPowerTONI(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(PowerTONIABI))
	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 (_PowerTONI *PowerTONIRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _PowerTONI.Contract.PowerTONICaller.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 (_PowerTONI *PowerTONIRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _PowerTONI.Contract.PowerTONITransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_PowerTONI *PowerTONIRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _PowerTONI.Contract.PowerTONITransactor.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 (_PowerTONI *PowerTONICallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _PowerTONI.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 (_PowerTONI *PowerTONITransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _PowerTONI.Contract.contract.Transfer(opts)
}

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

// CurrentRound is a free data retrieval call binding the contract method 0x8a19c8bc.
//
// Solidity: function currentRound() constant returns(uint256)
func (_PowerTONI *PowerTONICaller) CurrentRound(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _PowerTONI.contract.Call(opts, out, "currentRound")
	return *ret0, err
}

// CurrentRound is a free data retrieval call binding the contract method 0x8a19c8bc.
//
// Solidity: function currentRound() constant returns(uint256)
func (_PowerTONI *PowerTONISession) CurrentRound() (*big.Int, error) {
	return _PowerTONI.Contract.CurrentRound(&_PowerTONI.CallOpts)
}

// CurrentRound is a free data retrieval call binding the contract method 0x8a19c8bc.
//
// Solidity: function currentRound() constant returns(uint256)
func (_PowerTONI *PowerTONICallerSession) CurrentRound() (*big.Int, error) {
	return _PowerTONI.Contract.CurrentRound(&_PowerTONI.CallOpts)
}

// PowerOf is a free data retrieval call binding the contract method 0x1ac84690.
//
// Solidity: function powerOf(address account) constant returns(uint256)
func (_PowerTONI *PowerTONICaller) PowerOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _PowerTONI.contract.Call(opts, out, "powerOf", account)
	return *ret0, err
}

// PowerOf is a free data retrieval call binding the contract method 0x1ac84690.
//
// Solidity: function powerOf(address account) constant returns(uint256)
func (_PowerTONI *PowerTONISession) PowerOf(account common.Address) (*big.Int, error) {
	return _PowerTONI.Contract.PowerOf(&_PowerTONI.CallOpts, account)
}

// PowerOf is a free data retrieval call binding the contract method 0x1ac84690.
//
// Solidity: function powerOf(address account) constant returns(uint256)
func (_PowerTONI *PowerTONICallerSession) PowerOf(account common.Address) (*big.Int, error) {
	return _PowerTONI.Contract.PowerOf(&_PowerTONI.CallOpts, account)
}

// RoundDuration is a free data retrieval call binding the contract method 0xf7cb789a.
//
// Solidity: function roundDuration() constant returns(uint256)
func (_PowerTONI *PowerTONICaller) RoundDuration(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _PowerTONI.contract.Call(opts, out, "roundDuration")
	return *ret0, err
}

// RoundDuration is a free data retrieval call binding the contract method 0xf7cb789a.
//
// Solidity: function roundDuration() constant returns(uint256)
func (_PowerTONI *PowerTONISession) RoundDuration() (*big.Int, error) {
	return _PowerTONI.Contract.RoundDuration(&_PowerTONI.CallOpts)
}

// RoundDuration is a free data retrieval call binding the contract method 0xf7cb789a.
//
// Solidity: function roundDuration() constant returns(uint256)
func (_PowerTONI *PowerTONICallerSession) RoundDuration() (*big.Int, error) {
	return _PowerTONI.Contract.RoundDuration(&_PowerTONI.CallOpts)
}

// SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
//
// Solidity: function seigManager() constant returns(address)
func (_PowerTONI *PowerTONICaller) SeigManager(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _PowerTONI.contract.Call(opts, out, "seigManager")
	return *ret0, err
}

// SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
//
// Solidity: function seigManager() constant returns(address)
func (_PowerTONI *PowerTONISession) SeigManager() (common.Address, error) {
	return _PowerTONI.Contract.SeigManager(&_PowerTONI.CallOpts)
}

// SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
//
// Solidity: function seigManager() constant returns(address)
func (_PowerTONI *PowerTONICallerSession) SeigManager() (common.Address, error) {
	return _PowerTONI.Contract.SeigManager(&_PowerTONI.CallOpts)
}

// TotalDeposits is a free data retrieval call binding the contract method 0x7d882097.
//
// Solidity: function totalDeposits() constant returns(uint256)
func (_PowerTONI *PowerTONICaller) TotalDeposits(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _PowerTONI.contract.Call(opts, out, "totalDeposits")
	return *ret0, err
}

// TotalDeposits is a free data retrieval call binding the contract method 0x7d882097.
//
// Solidity: function totalDeposits() constant returns(uint256)
func (_PowerTONI *PowerTONISession) TotalDeposits() (*big.Int, error) {
	return _PowerTONI.Contract.TotalDeposits(&_PowerTONI.CallOpts)
}

// TotalDeposits is a free data retrieval call binding the contract method 0x7d882097.
//
// Solidity: function totalDeposits() constant returns(uint256)
func (_PowerTONI *PowerTONICallerSession) TotalDeposits() (*big.Int, error) {
	return _PowerTONI.Contract.TotalDeposits(&_PowerTONI.CallOpts)
}

// WinnerOf is a free data retrieval call binding the contract method 0x8cb5d700.
//
// Solidity: function winnerOf(uint256 round) constant returns(address)
func (_PowerTONI *PowerTONICaller) WinnerOf(opts *bind.CallOpts, round *big.Int) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _PowerTONI.contract.Call(opts, out, "winnerOf", round)
	return *ret0, err
}

// WinnerOf is a free data retrieval call binding the contract method 0x8cb5d700.
//
// Solidity: function winnerOf(uint256 round) constant returns(address)
func (_PowerTONI *PowerTONISession) WinnerOf(round *big.Int) (common.Address, error) {
	return _PowerTONI.Contract.WinnerOf(&_PowerTONI.CallOpts, round)
}

// WinnerOf is a free data retrieval call binding the contract method 0x8cb5d700.
//
// Solidity: function winnerOf(uint256 round) constant returns(address)
func (_PowerTONI *PowerTONICallerSession) WinnerOf(round *big.Int) (common.Address, error) {
	return _PowerTONI.Contract.WinnerOf(&_PowerTONI.CallOpts, round)
}

// Wton is a free data retrieval call binding the contract method 0x8d62d949.
//
// Solidity: function wton() constant returns(address)
func (_PowerTONI *PowerTONICaller) Wton(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _PowerTONI.contract.Call(opts, out, "wton")
	return *ret0, err
}

// Wton is a free data retrieval call binding the contract method 0x8d62d949.
//
// Solidity: function wton() constant returns(address)
func (_PowerTONI *PowerTONISession) Wton() (common.Address, error) {
	return _PowerTONI.Contract.Wton(&_PowerTONI.CallOpts)
}

// Wton is a free data retrieval call binding the contract method 0x8d62d949.
//
// Solidity: function wton() constant returns(address)
func (_PowerTONI *PowerTONICallerSession) Wton() (common.Address, error) {
	return _PowerTONI.Contract.Wton(&_PowerTONI.CallOpts)
}

// EndRound is a paid mutator transaction binding the contract method 0x749aa2d9.
//
// Solidity: function endRound() returns()
func (_PowerTONI *PowerTONITransactor) EndRound(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _PowerTONI.contract.Transact(opts, "endRound")
}

// EndRound is a paid mutator transaction binding the contract method 0x749aa2d9.
//
// Solidity: function endRound() returns()
func (_PowerTONI *PowerTONISession) EndRound() (*types.Transaction, error) {
	return _PowerTONI.Contract.EndRound(&_PowerTONI.TransactOpts)
}

// EndRound is a paid mutator transaction binding the contract method 0x749aa2d9.
//
// Solidity: function endRound() returns()
func (_PowerTONI *PowerTONITransactorSession) EndRound() (*types.Transaction, error) {
	return _PowerTONI.Contract.EndRound(&_PowerTONI.TransactOpts)
}

// Init is a paid mutator transaction binding the contract method 0xe1c7392a.
//
// Solidity: function init() returns()
func (_PowerTONI *PowerTONITransactor) Init(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _PowerTONI.contract.Transact(opts, "init")
}

// Init is a paid mutator transaction binding the contract method 0xe1c7392a.
//
// Solidity: function init() returns()
func (_PowerTONI *PowerTONISession) Init() (*types.Transaction, error) {
	return _PowerTONI.Contract.Init(&_PowerTONI.TransactOpts)
}

// Init is a paid mutator transaction binding the contract method 0xe1c7392a.
//
// Solidity: function init() returns()
func (_PowerTONI *PowerTONITransactorSession) Init() (*types.Transaction, error) {
	return _PowerTONI.Contract.Init(&_PowerTONI.TransactOpts)
}

// OnDeposit is a paid mutator transaction binding the contract method 0x412c6d50.
//
// Solidity: function onDeposit(address rootchain, address account, uint256 amount) returns()
func (_PowerTONI *PowerTONITransactor) OnDeposit(opts *bind.TransactOpts, rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _PowerTONI.contract.Transact(opts, "onDeposit", rootchain, account, amount)
}

// OnDeposit is a paid mutator transaction binding the contract method 0x412c6d50.
//
// Solidity: function onDeposit(address rootchain, address account, uint256 amount) returns()
func (_PowerTONI *PowerTONISession) OnDeposit(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _PowerTONI.Contract.OnDeposit(&_PowerTONI.TransactOpts, rootchain, account, amount)
}

// OnDeposit is a paid mutator transaction binding the contract method 0x412c6d50.
//
// Solidity: function onDeposit(address rootchain, address account, uint256 amount) returns()
func (_PowerTONI *PowerTONITransactorSession) OnDeposit(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _PowerTONI.Contract.OnDeposit(&_PowerTONI.TransactOpts, rootchain, account, amount)
}

// OnWithdraw is a paid mutator transaction binding the contract method 0xf850ffaa.
//
// Solidity: function onWithdraw(address rootchain, address account, uint256 amount) returns()
func (_PowerTONI *PowerTONITransactor) OnWithdraw(opts *bind.TransactOpts, rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _PowerTONI.contract.Transact(opts, "onWithdraw", rootchain, account, amount)
}

// OnWithdraw is a paid mutator transaction binding the contract method 0xf850ffaa.
//
// Solidity: function onWithdraw(address rootchain, address account, uint256 amount) returns()
func (_PowerTONI *PowerTONISession) OnWithdraw(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _PowerTONI.Contract.OnWithdraw(&_PowerTONI.TransactOpts, rootchain, account, amount)
}

// OnWithdraw is a paid mutator transaction binding the contract method 0xf850ffaa.
//
// Solidity: function onWithdraw(address rootchain, address account, uint256 amount) returns()
func (_PowerTONI *PowerTONITransactorSession) OnWithdraw(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _PowerTONI.Contract.OnWithdraw(&_PowerTONI.TransactOpts, rootchain, account, amount)
}

// Start is a paid mutator transaction binding the contract method 0xbe9a6555.
//
// Solidity: function start() returns()
func (_PowerTONI *PowerTONITransactor) Start(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _PowerTONI.contract.Transact(opts, "start")
}

// Start is a paid mutator transaction binding the contract method 0xbe9a6555.
//
// Solidity: function start() returns()
func (_PowerTONI *PowerTONISession) Start() (*types.Transaction, error) {
	return _PowerTONI.Contract.Start(&_PowerTONI.TransactOpts)
}

// Start is a paid mutator transaction binding the contract method 0xbe9a6555.
//
// Solidity: function start() returns()
func (_PowerTONI *PowerTONITransactorSession) Start() (*types.Transaction, error) {
	return _PowerTONI.Contract.Start(&_PowerTONI.TransactOpts)
}

// RolesABI is the input ABI used to generate the binding from.
const RolesABI = "[]"

// RolesBin is the compiled bytecode used for deploying new contracts.
var RolesBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a723158208b71254ffd63ec0cdf069ebd57900b2eed3f2d5481f989be20e2f19c163e323b64736f6c634300050c0032"

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

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(RolesBin), backend)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &Roles{RolesCaller: RolesCaller{contract: contract}, RolesTransactor: RolesTransactor{contract: contract}, RolesFilterer: RolesFilterer{contract: contract}}, nil
}

// Roles is an auto generated Go binding around an Ethereum contract.
type Roles struct {
	RolesCaller     // Read-only binding to the contract
	RolesTransactor // Write-only binding to the contract
	RolesFilterer   // Log filterer for contract events
}

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

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

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

// RolesSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type RolesSession struct {
	Contract     *Roles            // 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
}

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

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

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

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

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

// NewRoles creates a new instance of Roles, bound to a specific deployed contract.
func NewRoles(address common.Address, backend bind.ContractBackend) (*Roles, error) {
	contract, err := bindRoles(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &Roles{RolesCaller: RolesCaller{contract: contract}, RolesTransactor: RolesTransactor{contract: contract}, RolesFilterer: RolesFilterer{contract: contract}}, nil
}

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

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

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

// bindRoles binds a generic wrapper to an already deployed contract.
func bindRoles(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(RolesABI))
	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 (_Roles *RolesRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _Roles.Contract.RolesCaller.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 (_Roles *RolesRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _Roles.Contract.RolesTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_Roles *RolesRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _Roles.Contract.RolesTransactor.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 (_Roles *RolesCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _Roles.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 (_Roles *RolesTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _Roles.Contract.contract.Transfer(opts)
}

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

// RootChainIABI is the input ABI used to generate the binding from.
const RootChainIABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"currentFork\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"isRootChain\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"forkNumber\",\"type\":\"uint256\"}],\"name\":\"lastEpoch\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"operator\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"

// RootChainIFuncSigs maps the 4-byte function signature to its string representation.
var RootChainIFuncSigs = map[string]string{
	"183d2d1c": "currentFork()",
	"420bb4b8": "isRootChain()",
	"11e4c914": "lastEpoch(uint256)",
	"570ca735": "operator()",
}

// RootChainI is an auto generated Go binding around an Ethereum contract.
type RootChainI struct {
	RootChainICaller     // Read-only binding to the contract
	RootChainITransactor // Write-only binding to the contract
	RootChainIFilterer   // Log filterer for contract events
}

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

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

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

// RootChainISession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type RootChainISession struct {
	Contract     *RootChainI       // 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
}

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

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

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

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

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

// NewRootChainI creates a new instance of RootChainI, bound to a specific deployed contract.
func NewRootChainI(address common.Address, backend bind.ContractBackend) (*RootChainI, error) {
	contract, err := bindRootChainI(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &RootChainI{RootChainICaller: RootChainICaller{contract: contract}, RootChainITransactor: RootChainITransactor{contract: contract}, RootChainIFilterer: RootChainIFilterer{contract: contract}}, nil
}

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

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

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

// bindRootChainI binds a generic wrapper to an already deployed contract.
func bindRootChainI(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(RootChainIABI))
	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 (_RootChainI *RootChainIRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _RootChainI.Contract.RootChainICaller.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 (_RootChainI *RootChainIRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _RootChainI.Contract.RootChainITransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_RootChainI *RootChainIRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _RootChainI.Contract.RootChainITransactor.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 (_RootChainI *RootChainICallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _RootChainI.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 (_RootChainI *RootChainITransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _RootChainI.Contract.contract.Transfer(opts)
}

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

// CurrentFork is a free data retrieval call binding the contract method 0x183d2d1c.
//
// Solidity: function currentFork() constant returns(uint256)
func (_RootChainI *RootChainICaller) CurrentFork(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _RootChainI.contract.Call(opts, out, "currentFork")
	return *ret0, err
}

// CurrentFork is a free data retrieval call binding the contract method 0x183d2d1c.
//
// Solidity: function currentFork() constant returns(uint256)
func (_RootChainI *RootChainISession) CurrentFork() (*big.Int, error) {
	return _RootChainI.Contract.CurrentFork(&_RootChainI.CallOpts)
}

// CurrentFork is a free data retrieval call binding the contract method 0x183d2d1c.
//
// Solidity: function currentFork() constant returns(uint256)
func (_RootChainI *RootChainICallerSession) CurrentFork() (*big.Int, error) {
	return _RootChainI.Contract.CurrentFork(&_RootChainI.CallOpts)
}

// IsRootChain is a free data retrieval call binding the contract method 0x420bb4b8.
//
// Solidity: function isRootChain() constant returns(bool)
func (_RootChainI *RootChainICaller) IsRootChain(opts *bind.CallOpts) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _RootChainI.contract.Call(opts, out, "isRootChain")
	return *ret0, err
}

// IsRootChain is a free data retrieval call binding the contract method 0x420bb4b8.
//
// Solidity: function isRootChain() constant returns(bool)
func (_RootChainI *RootChainISession) IsRootChain() (bool, error) {
	return _RootChainI.Contract.IsRootChain(&_RootChainI.CallOpts)
}

// IsRootChain is a free data retrieval call binding the contract method 0x420bb4b8.
//
// Solidity: function isRootChain() constant returns(bool)
func (_RootChainI *RootChainICallerSession) IsRootChain() (bool, error) {
	return _RootChainI.Contract.IsRootChain(&_RootChainI.CallOpts)
}

// LastEpoch is a free data retrieval call binding the contract method 0x11e4c914.
//
// Solidity: function lastEpoch(uint256 forkNumber) constant returns(uint256)
func (_RootChainI *RootChainICaller) LastEpoch(opts *bind.CallOpts, forkNumber *big.Int) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _RootChainI.contract.Call(opts, out, "lastEpoch", forkNumber)
	return *ret0, err
}

// LastEpoch is a free data retrieval call binding the contract method 0x11e4c914.
//
// Solidity: function lastEpoch(uint256 forkNumber) constant returns(uint256)
func (_RootChainI *RootChainISession) LastEpoch(forkNumber *big.Int) (*big.Int, error) {
	return _RootChainI.Contract.LastEpoch(&_RootChainI.CallOpts, forkNumber)
}

// LastEpoch is a free data retrieval call binding the contract method 0x11e4c914.
//
// Solidity: function lastEpoch(uint256 forkNumber) constant returns(uint256)
func (_RootChainI *RootChainICallerSession) LastEpoch(forkNumber *big.Int) (*big.Int, error) {
	return _RootChainI.Contract.LastEpoch(&_RootChainI.CallOpts, forkNumber)
}

// Operator is a free data retrieval call binding the contract method 0x570ca735.
//
// Solidity: function operator() constant returns(address)
func (_RootChainI *RootChainICaller) Operator(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _RootChainI.contract.Call(opts, out, "operator")
	return *ret0, err
}

// Operator is a free data retrieval call binding the contract method 0x570ca735.
//
// Solidity: function operator() constant returns(address)
func (_RootChainI *RootChainISession) Operator() (common.Address, error) {
	return _RootChainI.Contract.Operator(&_RootChainI.CallOpts)
}

// Operator is a free data retrieval call binding the contract method 0x570ca735.
//
// Solidity: function operator() constant returns(address)
func (_RootChainI *RootChainICallerSession) Operator() (common.Address, error) {
	return _RootChainI.Contract.Operator(&_RootChainI.CallOpts)
}

// RootChainRegistryIABI is the input ABI used to generate the binding from.
const RootChainRegistryIABI = "[{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"seigManager\",\"type\":\"address\"}],\"name\":\"deployCoinage\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"numRootChains\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"register\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"seigManager\",\"type\":\"address\"}],\"name\":\"registerAndDeployCoinage\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"rootchainByIndex\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"rootchains\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"unregister\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"

// RootChainRegistryIFuncSigs maps the 4-byte function signature to its string representation.
var RootChainRegistryIFuncSigs = map[string]string{
	"85108604": "deployCoinage(address,address)",
	"b2b604d0": "numRootChains()",
	"4420e486": "register(address)",
	"bcb1a71e": "registerAndDeployCoinage(address,address)",
	"821f602c": "rootchainByIndex(uint256)",
	"02a15299": "rootchains(address)",
	"2ec2c246": "unregister(address)",
}

// RootChainRegistryI is an auto generated Go binding around an Ethereum contract.
type RootChainRegistryI struct {
	RootChainRegistryICaller     // Read-only binding to the contract
	RootChainRegistryITransactor // Write-only binding to the contract
	RootChainRegistryIFilterer   // Log filterer for contract events
}

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

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

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

// RootChainRegistryISession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type RootChainRegistryISession struct {
	Contract     *RootChainRegistryI // 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
}

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

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

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

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

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

// NewRootChainRegistryI creates a new instance of RootChainRegistryI, bound to a specific deployed contract.
func NewRootChainRegistryI(address common.Address, backend bind.ContractBackend) (*RootChainRegistryI, error) {
	contract, err := bindRootChainRegistryI(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &RootChainRegistryI{RootChainRegistryICaller: RootChainRegistryICaller{contract: contract}, RootChainRegistryITransactor: RootChainRegistryITransactor{contract: contract}, RootChainRegistryIFilterer: RootChainRegistryIFilterer{contract: contract}}, nil
}

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

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

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

// bindRootChainRegistryI binds a generic wrapper to an already deployed contract.
func bindRootChainRegistryI(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(RootChainRegistryIABI))
	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 (_RootChainRegistryI *RootChainRegistryIRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _RootChainRegistryI.Contract.RootChainRegistryICaller.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 (_RootChainRegistryI *RootChainRegistryIRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _RootChainRegistryI.Contract.RootChainRegistryITransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_RootChainRegistryI *RootChainRegistryIRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _RootChainRegistryI.Contract.RootChainRegistryITransactor.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 (_RootChainRegistryI *RootChainRegistryICallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _RootChainRegistryI.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 (_RootChainRegistryI *RootChainRegistryITransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _RootChainRegistryI.Contract.contract.Transfer(opts)
}

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

// NumRootChains is a free data retrieval call binding the contract method 0xb2b604d0.
//
// Solidity: function numRootChains() constant returns(uint256)
func (_RootChainRegistryI *RootChainRegistryICaller) NumRootChains(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _RootChainRegistryI.contract.Call(opts, out, "numRootChains")
	return *ret0, err
}

// NumRootChains is a free data retrieval call binding the contract method 0xb2b604d0.
//
// Solidity: function numRootChains() constant returns(uint256)
func (_RootChainRegistryI *RootChainRegistryISession) NumRootChains() (*big.Int, error) {
	return _RootChainRegistryI.Contract.NumRootChains(&_RootChainRegistryI.CallOpts)
}

// NumRootChains is a free data retrieval call binding the contract method 0xb2b604d0.
//
// Solidity: function numRootChains() constant returns(uint256)
func (_RootChainRegistryI *RootChainRegistryICallerSession) NumRootChains() (*big.Int, error) {
	return _RootChainRegistryI.Contract.NumRootChains(&_RootChainRegistryI.CallOpts)
}

// RootchainByIndex is a free data retrieval call binding the contract method 0x821f602c.
//
// Solidity: function rootchainByIndex(uint256 index) constant returns(address)
func (_RootChainRegistryI *RootChainRegistryICaller) RootchainByIndex(opts *bind.CallOpts, index *big.Int) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _RootChainRegistryI.contract.Call(opts, out, "rootchainByIndex", index)
	return *ret0, err
}

// RootchainByIndex is a free data retrieval call binding the contract method 0x821f602c.
//
// Solidity: function rootchainByIndex(uint256 index) constant returns(address)
func (_RootChainRegistryI *RootChainRegistryISession) RootchainByIndex(index *big.Int) (common.Address, error) {
	return _RootChainRegistryI.Contract.RootchainByIndex(&_RootChainRegistryI.CallOpts, index)
}

// RootchainByIndex is a free data retrieval call binding the contract method 0x821f602c.
//
// Solidity: function rootchainByIndex(uint256 index) constant returns(address)
func (_RootChainRegistryI *RootChainRegistryICallerSession) RootchainByIndex(index *big.Int) (common.Address, error) {
	return _RootChainRegistryI.Contract.RootchainByIndex(&_RootChainRegistryI.CallOpts, index)
}

// Rootchains is a free data retrieval call binding the contract method 0x02a15299.
//
// Solidity: function rootchains(address rootchain) constant returns(bool)
func (_RootChainRegistryI *RootChainRegistryICaller) Rootchains(opts *bind.CallOpts, rootchain common.Address) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _RootChainRegistryI.contract.Call(opts, out, "rootchains", rootchain)
	return *ret0, err
}

// Rootchains is a free data retrieval call binding the contract method 0x02a15299.
//
// Solidity: function rootchains(address rootchain) constant returns(bool)
func (_RootChainRegistryI *RootChainRegistryISession) Rootchains(rootchain common.Address) (bool, error) {
	return _RootChainRegistryI.Contract.Rootchains(&_RootChainRegistryI.CallOpts, rootchain)
}

// Rootchains is a free data retrieval call binding the contract method 0x02a15299.
//
// Solidity: function rootchains(address rootchain) constant returns(bool)
func (_RootChainRegistryI *RootChainRegistryICallerSession) Rootchains(rootchain common.Address) (bool, error) {
	return _RootChainRegistryI.Contract.Rootchains(&_RootChainRegistryI.CallOpts, rootchain)
}

// DeployCoinage is a paid mutator transaction binding the contract method 0x85108604.
//
// Solidity: function deployCoinage(address rootchain, address seigManager) returns(bool)
func (_RootChainRegistryI *RootChainRegistryITransactor) DeployCoinage(opts *bind.TransactOpts, rootchain common.Address, seigManager common.Address) (*types.Transaction, error) {
	return _RootChainRegistryI.contract.Transact(opts, "deployCoinage", rootchain, seigManager)
}

// DeployCoinage is a paid mutator transaction binding the contract method 0x85108604.
//
// Solidity: function deployCoinage(address rootchain, address seigManager) returns(bool)
func (_RootChainRegistryI *RootChainRegistryISession) DeployCoinage(rootchain common.Address, seigManager common.Address) (*types.Transaction, error) {
	return _RootChainRegistryI.Contract.DeployCoinage(&_RootChainRegistryI.TransactOpts, rootchain, seigManager)
}

// DeployCoinage is a paid mutator transaction binding the contract method 0x85108604.
//
// Solidity: function deployCoinage(address rootchain, address seigManager) returns(bool)
func (_RootChainRegistryI *RootChainRegistryITransactorSession) DeployCoinage(rootchain common.Address, seigManager common.Address) (*types.Transaction, error) {
	return _RootChainRegistryI.Contract.DeployCoinage(&_RootChainRegistryI.TransactOpts, rootchain, seigManager)
}

// Register is a paid mutator transaction binding the contract method 0x4420e486.
//
// Solidity: function register(address rootchain) returns(bool)
func (_RootChainRegistryI *RootChainRegistryITransactor) Register(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) {
	return _RootChainRegistryI.contract.Transact(opts, "register", rootchain)
}

// Register is a paid mutator transaction binding the contract method 0x4420e486.
//
// Solidity: function register(address rootchain) returns(bool)
func (_RootChainRegistryI *RootChainRegistryISession) Register(rootchain common.Address) (*types.Transaction, error) {
	return _RootChainRegistryI.Contract.Register(&_RootChainRegistryI.TransactOpts, rootchain)
}

// Register is a paid mutator transaction binding the contract method 0x4420e486.
//
// Solidity: function register(address rootchain) returns(bool)
func (_RootChainRegistryI *RootChainRegistryITransactorSession) Register(rootchain common.Address) (*types.Transaction, error) {
	return _RootChainRegistryI.Contract.Register(&_RootChainRegistryI.TransactOpts, rootchain)
}

// RegisterAndDeployCoinage is a paid mutator transaction binding the contract method 0xbcb1a71e.
//
// Solidity: function registerAndDeployCoinage(address rootchain, address seigManager) returns(bool)
func (_RootChainRegistryI *RootChainRegistryITransactor) RegisterAndDeployCoinage(opts *bind.TransactOpts, rootchain common.Address, seigManager common.Address) (*types.Transaction, error) {
	return _RootChainRegistryI.contract.Transact(opts, "registerAndDeployCoinage", rootchain, seigManager)
}

// RegisterAndDeployCoinage is a paid mutator transaction binding the contract method 0xbcb1a71e.
//
// Solidity: function registerAndDeployCoinage(address rootchain, address seigManager) returns(bool)
func (_RootChainRegistryI *RootChainRegistryISession) RegisterAndDeployCoinage(rootchain common.Address, seigManager common.Address) (*types.Transaction, error) {
	return _RootChainRegistryI.Contract.RegisterAndDeployCoinage(&_RootChainRegistryI.TransactOpts, rootchain, seigManager)
}

// RegisterAndDeployCoinage is a paid mutator transaction binding the contract method 0xbcb1a71e.
//
// Solidity: function registerAndDeployCoinage(address rootchain, address seigManager) returns(bool)
func (_RootChainRegistryI *RootChainRegistryITransactorSession) RegisterAndDeployCoinage(rootchain common.Address, seigManager common.Address) (*types.Transaction, error) {
	return _RootChainRegistryI.Contract.RegisterAndDeployCoinage(&_RootChainRegistryI.TransactOpts, rootchain, seigManager)
}

// Unregister is a paid mutator transaction binding the contract method 0x2ec2c246.
//
// Solidity: function unregister(address rootchain) returns(bool)
func (_RootChainRegistryI *RootChainRegistryITransactor) Unregister(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) {
	return _RootChainRegistryI.contract.Transact(opts, "unregister", rootchain)
}

// Unregister is a paid mutator transaction binding the contract method 0x2ec2c246.
//
// Solidity: function unregister(address rootchain) returns(bool)
func (_RootChainRegistryI *RootChainRegistryISession) Unregister(rootchain common.Address) (*types.Transaction, error) {
	return _RootChainRegistryI.Contract.Unregister(&_RootChainRegistryI.TransactOpts, rootchain)
}

// Unregister is a paid mutator transaction binding the contract method 0x2ec2c246.
//
// Solidity: function unregister(address rootchain) returns(bool)
func (_RootChainRegistryI *RootChainRegistryITransactorSession) Unregister(rootchain common.Address) (*types.Transaction, error) {
	return _RootChainRegistryI.Contract.Unregister(&_RootChainRegistryI.TransactOpts, rootchain)
}

// SafeERC20ABI is the input ABI used to generate the binding from.
const SafeERC20ABI = "[]"

// SafeERC20Bin is the compiled bytecode used for deploying new contracts.
var SafeERC20Bin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a7231582045a04cb654e4c37bcd57cef5b1e4313fd04e0fbb06c03b04321592cfa5eb149764736f6c634300050c0032"

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

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(SafeERC20Bin), backend)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &SafeERC20{SafeERC20Caller: SafeERC20Caller{contract: contract}, SafeERC20Transactor: SafeERC20Transactor{contract: contract}, SafeERC20Filterer: SafeERC20Filterer{contract: contract}}, nil
}

// SafeERC20 is an auto generated Go binding around an Ethereum contract.
type SafeERC20 struct {
	SafeERC20Caller     // Read-only binding to the contract
	SafeERC20Transactor // Write-only binding to the contract
	SafeERC20Filterer   // Log filterer for contract events
}

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

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

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

// SafeERC20Session is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type SafeERC20Session struct {
	Contract     *SafeERC20        // 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
}

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

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

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

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

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

// NewSafeERC20 creates a new instance of SafeERC20, bound to a specific deployed contract.
func NewSafeERC20(address common.Address, backend bind.ContractBackend) (*SafeERC20, error) {
	contract, err := bindSafeERC20(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &SafeERC20{SafeERC20Caller: SafeERC20Caller{contract: contract}, SafeERC20Transactor: SafeERC20Transactor{contract: contract}, SafeERC20Filterer: SafeERC20Filterer{contract: contract}}, nil
}

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

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

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

// bindSafeERC20 binds a generic wrapper to an already deployed contract.
func bindSafeERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(SafeERC20ABI))
	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 (_SafeERC20 *SafeERC20Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _SafeERC20.Contract.SafeERC20Caller.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 (_SafeERC20 *SafeERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _SafeERC20.Contract.SafeERC20Transactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_SafeERC20 *SafeERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _SafeERC20.Contract.SafeERC20Transactor.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 (_SafeERC20 *SafeERC20CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _SafeERC20.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 (_SafeERC20 *SafeERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _SafeERC20.Contract.contract.Transfer(opts)
}

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

// SafeMathABI is the input ABI used to generate the binding from.
const SafeMathABI = "[]"

// SafeMathBin is the compiled bytecode used for deploying new contracts.
var SafeMathBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a7231582045f810ccb41cd151344ccf006ddfbe7c3c58a867d26e345c6576ae09178171dc64736f6c634300050c0032"

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

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(SafeMathBin), backend)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil
}

// SafeMath is an auto generated Go binding around an Ethereum contract.
type SafeMath struct {
	SafeMathCaller     // Read-only binding to the contract
	SafeMathTransactor // Write-only binding to the contract
	SafeMathFilterer   // Log filterer for contract events
}

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

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

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

// SafeMathSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type SafeMathSession struct {
	Contract     *SafeMath         // 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
}

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

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

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

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

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

// NewSafeMath creates a new instance of SafeMath, bound to a specific deployed contract.
func NewSafeMath(address common.Address, backend bind.ContractBackend) (*SafeMath, error) {
	contract, err := bindSafeMath(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil
}

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

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

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

// bindSafeMath binds a generic wrapper to an already deployed contract.
func bindSafeMath(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(SafeMathABI))
	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 (_SafeMath *SafeMathRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _SafeMath.Contract.SafeMathCaller.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 (_SafeMath *SafeMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _SafeMath.Contract.SafeMathTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_SafeMath *SafeMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _SafeMath.Contract.SafeMathTransactor.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 (_SafeMath *SafeMathCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _SafeMath.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 (_SafeMath *SafeMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _SafeMath.Contract.contract.Transfer(opts)
}

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

// SeigManagerABI is the input ABI used to generate the binding from.
const SeigManagerABI = "[{\"inputs\":[{\"internalType\":\"contractERC20Mintable\",\"name\":\"ton\",\"type\":\"address\"},{\"internalType\":\"contractERC20Mintable\",\"name\":\"wton\",\"type\":\"address\"},{\"internalType\":\"contractRootChainRegistryI\",\"name\":\"registry\",\"type\":\"address\"},{\"internalType\":\"contractDepositManagerI\",\"name\":\"depositManager\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"seigPerBlock\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"coinage\",\"type\":\"address\"}],\"name\":\"CoinageCreated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"Comitted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"previousRate\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newRate\",\"type\":\"uint256\"}],\"name\":\"CommissionRateSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totalStakedAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totalSupplyOfWTON\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"prevTotalSupply\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"nextTotalSupply\",\"type\":\"uint256\"}],\"name\":\"CommitLog1\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"Paused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"PauserAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"PauserRemoved\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totalSeig\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"stakedSeig\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"unstakedSeig\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"powertonSeig\",\"type\":\"uint256\"}],\"name\":\"SeigGiven\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"Unpaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"coinageBurnAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"totBurnAmount\",\"type\":\"uint256\"}],\"name\":\"UnstakeLog\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[],\"name\":\"DEFAULT_FACTOR\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"MAX_VALID_COMMISSION\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"MIN_VALID_COMMISSION\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"POWER_TON_DENOMINATOR\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"POWER_TON_NUMERATOR\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"addPauser\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"additionalTotBurnAmount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"totAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"coinages\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"commissionRates\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"deployCoinage\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"depositManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"isCommissionRateNegative\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"isOwner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isPauser\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"lastCommitBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"lastSeigBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"onCommit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"onDeposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"onTransfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"onWithdraw\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"pause\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"paused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"pausedBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"powerton\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"registry\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renouncePauser\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renouncePauser\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"seigPerBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"commissionRate\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"isCommissionRateNegative\",\"type\":\"bool\"}],\"name\":\"setCommissionRate\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"contractPowerTONI\",\"name\":\"powerton\",\"type\":\"address\"}],\"name\":\"setPowerTON\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"stakeOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"ton\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"tot\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"uncomittedStakeOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"unpause\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"unpausedBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"wton\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"

// SeigManagerFuncSigs maps the 4-byte function signature to its string representation.
var SeigManagerFuncSigs = map[string]string{
	"8bf91dc4": "DEFAULT_FACTOR()",
	"4123196f": "MAX_VALID_COMMISSION()",
	"a7dcc850": "MIN_VALID_COMMISSION()",
	"7bf8ae5b": "POWER_TON_DENOMINATOR()",
	"180975d3": "POWER_TON_NUMERATOR()",
	"82dc1ec4": "addPauser(address)",
	"48c8577e": "additionalTotBurnAmount(address,address,uint256)",
	"4c063c19": "coinages(address)",
	"7b056c1b": "commissionRates(address)",
	"833a774f": "deployCoinage(address)",
	"6c7ac9d8": "depositManager()",
	"5a16a416": "isCommissionRateNegative(address)",
	"8f32d59b": "isOwner()",
	"46fbf68e": "isPauser(address)",
	"c59f1046": "lastCommitBlock(address)",
	"f35c89e8": "lastSeigBlock()",
	"359c4d59": "onCommit()",
	"412c6d50": "onDeposit(address,address,uint256)",
	"4a393149": "onTransfer(address,address,uint256)",
	"f850ffaa": "onWithdraw(address,address,uint256)",
	"8da5cb5b": "owner()",
	"8456cb59": "pause()",
	"5c975abb": "paused()",
	"32053c99": "pausedBlock()",
	"3e832e1d": "powerton()",
	"7b103999": "registry()",
	"5f112c68": "renounceMinter(address)",
	"715018a6": "renounceOwnership()",
	"38bf3cfa": "renounceOwnership(address)",
	"6ef8d66d": "renouncePauser()",
	"41eb24bb": "renouncePauser(address)",
	"5f40a349": "seigPerBlock()",
	"4224ed66": "setCommissionRate(address,uint256,bool)",
	"41813020": "setPowerTON(address)",
	"ce4cb876": "stakeOf(address,address)",
	"cc48b947": "ton()",
	"a16d6aa7": "tot()",
	"f2fde38b": "transferOwnership(address)",
	"6d435421": "transferOwnership(address,address)",
	"fa9789c8": "uncomittedStakeOf(address,address)",
	"3f4ba83a": "unpause()",
	"1cc47890": "unpausedBlock()",
	"8d62d949": "wton()",
}

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

// DeploySeigManager deploys a new Ethereum contract, binding an instance of SeigManager to it.
func DeploySeigManager(auth *bind.TransactOpts, backend bind.ContractBackend, ton common.Address, wton common.Address, registry common.Address, depositManager common.Address, seigPerBlock *big.Int) (common.Address, *types.Transaction, *SeigManager, error) {
	parsed, err := abi.JSON(strings.NewReader(SeigManagerABI))
	if err != nil {
		return common.Address{}, nil, nil, err
	}

	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(SeigManagerBin), backend, ton, wton, registry, depositManager, seigPerBlock)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &SeigManager{SeigManagerCaller: SeigManagerCaller{contract: contract}, SeigManagerTransactor: SeigManagerTransactor{contract: contract}, SeigManagerFilterer: SeigManagerFilterer{contract: contract}}, nil
}

// SeigManager is an auto generated Go binding around an Ethereum contract.
type SeigManager struct {
	SeigManagerCaller     // Read-only binding to the contract
	SeigManagerTransactor // Write-only binding to the contract
	SeigManagerFilterer   // Log filterer for contract events
}

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

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

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

// SeigManagerSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type SeigManagerSession struct {
	Contract     *SeigManager      // 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
}

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

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

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

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

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

// NewSeigManager creates a new instance of SeigManager, bound to a specific deployed contract.
func NewSeigManager(address common.Address, backend bind.ContractBackend) (*SeigManager, error) {
	contract, err := bindSeigManager(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &SeigManager{SeigManagerCaller: SeigManagerCaller{contract: contract}, SeigManagerTransactor: SeigManagerTransactor{contract: contract}, SeigManagerFilterer: SeigManagerFilterer{contract: contract}}, nil
}

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

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

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

// bindSeigManager binds a generic wrapper to an already deployed contract.
func bindSeigManager(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(SeigManagerABI))
	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 (_SeigManager *SeigManagerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _SeigManager.Contract.SeigManagerCaller.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 (_SeigManager *SeigManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _SeigManager.Contract.SeigManagerTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_SeigManager *SeigManagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _SeigManager.Contract.SeigManagerTransactor.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 (_SeigManager *SeigManagerCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _SeigManager.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 (_SeigManager *SeigManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _SeigManager.Contract.contract.Transfer(opts)
}

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

// DEFAULTFACTOR is a free data retrieval call binding the contract method 0x8bf91dc4.
//
// Solidity: function DEFAULT_FACTOR() constant returns(uint256)
func (_SeigManager *SeigManagerCaller) DEFAULTFACTOR(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "DEFAULT_FACTOR")
	return *ret0, err
}

// DEFAULTFACTOR is a free data retrieval call binding the contract method 0x8bf91dc4.
//
// Solidity: function DEFAULT_FACTOR() constant returns(uint256)
func (_SeigManager *SeigManagerSession) DEFAULTFACTOR() (*big.Int, error) {
	return _SeigManager.Contract.DEFAULTFACTOR(&_SeigManager.CallOpts)
}

// DEFAULTFACTOR is a free data retrieval call binding the contract method 0x8bf91dc4.
//
// Solidity: function DEFAULT_FACTOR() constant returns(uint256)
func (_SeigManager *SeigManagerCallerSession) DEFAULTFACTOR() (*big.Int, error) {
	return _SeigManager.Contract.DEFAULTFACTOR(&_SeigManager.CallOpts)
}

// MAXVALIDCOMMISSION is a free data retrieval call binding the contract method 0x4123196f.
//
// Solidity: function MAX_VALID_COMMISSION() constant returns(uint256)
func (_SeigManager *SeigManagerCaller) MAXVALIDCOMMISSION(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "MAX_VALID_COMMISSION")
	return *ret0, err
}

// MAXVALIDCOMMISSION is a free data retrieval call binding the contract method 0x4123196f.
//
// Solidity: function MAX_VALID_COMMISSION() constant returns(uint256)
func (_SeigManager *SeigManagerSession) MAXVALIDCOMMISSION() (*big.Int, error) {
	return _SeigManager.Contract.MAXVALIDCOMMISSION(&_SeigManager.CallOpts)
}

// MAXVALIDCOMMISSION is a free data retrieval call binding the contract method 0x4123196f.
//
// Solidity: function MAX_VALID_COMMISSION() constant returns(uint256)
func (_SeigManager *SeigManagerCallerSession) MAXVALIDCOMMISSION() (*big.Int, error) {
	return _SeigManager.Contract.MAXVALIDCOMMISSION(&_SeigManager.CallOpts)
}

// MINVALIDCOMMISSION is a free data retrieval call binding the contract method 0xa7dcc850.
//
// Solidity: function MIN_VALID_COMMISSION() constant returns(uint256)
func (_SeigManager *SeigManagerCaller) MINVALIDCOMMISSION(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "MIN_VALID_COMMISSION")
	return *ret0, err
}

// MINVALIDCOMMISSION is a free data retrieval call binding the contract method 0xa7dcc850.
//
// Solidity: function MIN_VALID_COMMISSION() constant returns(uint256)
func (_SeigManager *SeigManagerSession) MINVALIDCOMMISSION() (*big.Int, error) {
	return _SeigManager.Contract.MINVALIDCOMMISSION(&_SeigManager.CallOpts)
}

// MINVALIDCOMMISSION is a free data retrieval call binding the contract method 0xa7dcc850.
//
// Solidity: function MIN_VALID_COMMISSION() constant returns(uint256)
func (_SeigManager *SeigManagerCallerSession) MINVALIDCOMMISSION() (*big.Int, error) {
	return _SeigManager.Contract.MINVALIDCOMMISSION(&_SeigManager.CallOpts)
}

// POWERTONDENOMINATOR is a free data retrieval call binding the contract method 0x7bf8ae5b.
//
// Solidity: function POWER_TON_DENOMINATOR() constant returns(uint256)
func (_SeigManager *SeigManagerCaller) POWERTONDENOMINATOR(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "POWER_TON_DENOMINATOR")
	return *ret0, err
}

// POWERTONDENOMINATOR is a free data retrieval call binding the contract method 0x7bf8ae5b.
//
// Solidity: function POWER_TON_DENOMINATOR() constant returns(uint256)
func (_SeigManager *SeigManagerSession) POWERTONDENOMINATOR() (*big.Int, error) {
	return _SeigManager.Contract.POWERTONDENOMINATOR(&_SeigManager.CallOpts)
}

// POWERTONDENOMINATOR is a free data retrieval call binding the contract method 0x7bf8ae5b.
//
// Solidity: function POWER_TON_DENOMINATOR() constant returns(uint256)
func (_SeigManager *SeigManagerCallerSession) POWERTONDENOMINATOR() (*big.Int, error) {
	return _SeigManager.Contract.POWERTONDENOMINATOR(&_SeigManager.CallOpts)
}

// POWERTONNUMERATOR is a free data retrieval call binding the contract method 0x180975d3.
//
// Solidity: function POWER_TON_NUMERATOR() constant returns(uint256)
func (_SeigManager *SeigManagerCaller) POWERTONNUMERATOR(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "POWER_TON_NUMERATOR")
	return *ret0, err
}

// POWERTONNUMERATOR is a free data retrieval call binding the contract method 0x180975d3.
//
// Solidity: function POWER_TON_NUMERATOR() constant returns(uint256)
func (_SeigManager *SeigManagerSession) POWERTONNUMERATOR() (*big.Int, error) {
	return _SeigManager.Contract.POWERTONNUMERATOR(&_SeigManager.CallOpts)
}

// POWERTONNUMERATOR is a free data retrieval call binding the contract method 0x180975d3.
//
// Solidity: function POWER_TON_NUMERATOR() constant returns(uint256)
func (_SeigManager *SeigManagerCallerSession) POWERTONNUMERATOR() (*big.Int, error) {
	return _SeigManager.Contract.POWERTONNUMERATOR(&_SeigManager.CallOpts)
}

// AdditionalTotBurnAmount is a free data retrieval call binding the contract method 0x48c8577e.
//
// Solidity: function additionalTotBurnAmount(address rootchain, address account, uint256 amount) constant returns(uint256 totAmount)
func (_SeigManager *SeigManagerCaller) AdditionalTotBurnAmount(opts *bind.CallOpts, rootchain common.Address, account common.Address, amount *big.Int) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "additionalTotBurnAmount", rootchain, account, amount)
	return *ret0, err
}

// AdditionalTotBurnAmount is a free data retrieval call binding the contract method 0x48c8577e.
//
// Solidity: function additionalTotBurnAmount(address rootchain, address account, uint256 amount) constant returns(uint256 totAmount)
func (_SeigManager *SeigManagerSession) AdditionalTotBurnAmount(rootchain common.Address, account common.Address, amount *big.Int) (*big.Int, error) {
	return _SeigManager.Contract.AdditionalTotBurnAmount(&_SeigManager.CallOpts, rootchain, account, amount)
}

// AdditionalTotBurnAmount is a free data retrieval call binding the contract method 0x48c8577e.
//
// Solidity: function additionalTotBurnAmount(address rootchain, address account, uint256 amount) constant returns(uint256 totAmount)
func (_SeigManager *SeigManagerCallerSession) AdditionalTotBurnAmount(rootchain common.Address, account common.Address, amount *big.Int) (*big.Int, error) {
	return _SeigManager.Contract.AdditionalTotBurnAmount(&_SeigManager.CallOpts, rootchain, account, amount)
}

// Coinages is a free data retrieval call binding the contract method 0x4c063c19.
//
// Solidity: function coinages(address rootchain) constant returns(address)
func (_SeigManager *SeigManagerCaller) Coinages(opts *bind.CallOpts, rootchain common.Address) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "coinages", rootchain)
	return *ret0, err
}

// Coinages is a free data retrieval call binding the contract method 0x4c063c19.
//
// Solidity: function coinages(address rootchain) constant returns(address)
func (_SeigManager *SeigManagerSession) Coinages(rootchain common.Address) (common.Address, error) {
	return _SeigManager.Contract.Coinages(&_SeigManager.CallOpts, rootchain)
}

// Coinages is a free data retrieval call binding the contract method 0x4c063c19.
//
// Solidity: function coinages(address rootchain) constant returns(address)
func (_SeigManager *SeigManagerCallerSession) Coinages(rootchain common.Address) (common.Address, error) {
	return _SeigManager.Contract.Coinages(&_SeigManager.CallOpts, rootchain)
}

// CommissionRates is a free data retrieval call binding the contract method 0x7b056c1b.
//
// Solidity: function commissionRates(address rootchain) constant returns(uint256)
func (_SeigManager *SeigManagerCaller) CommissionRates(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "commissionRates", rootchain)
	return *ret0, err
}

// CommissionRates is a free data retrieval call binding the contract method 0x7b056c1b.
//
// Solidity: function commissionRates(address rootchain) constant returns(uint256)
func (_SeigManager *SeigManagerSession) CommissionRates(rootchain common.Address) (*big.Int, error) {
	return _SeigManager.Contract.CommissionRates(&_SeigManager.CallOpts, rootchain)
}

// CommissionRates is a free data retrieval call binding the contract method 0x7b056c1b.
//
// Solidity: function commissionRates(address rootchain) constant returns(uint256)
func (_SeigManager *SeigManagerCallerSession) CommissionRates(rootchain common.Address) (*big.Int, error) {
	return _SeigManager.Contract.CommissionRates(&_SeigManager.CallOpts, rootchain)
}

// DepositManager is a free data retrieval call binding the contract method 0x6c7ac9d8.
//
// Solidity: function depositManager() constant returns(address)
func (_SeigManager *SeigManagerCaller) DepositManager(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "depositManager")
	return *ret0, err
}

// DepositManager is a free data retrieval call binding the contract method 0x6c7ac9d8.
//
// Solidity: function depositManager() constant returns(address)
func (_SeigManager *SeigManagerSession) DepositManager() (common.Address, error) {
	return _SeigManager.Contract.DepositManager(&_SeigManager.CallOpts)
}

// DepositManager is a free data retrieval call binding the contract method 0x6c7ac9d8.
//
// Solidity: function depositManager() constant returns(address)
func (_SeigManager *SeigManagerCallerSession) DepositManager() (common.Address, error) {
	return _SeigManager.Contract.DepositManager(&_SeigManager.CallOpts)
}

// IsCommissionRateNegative is a free data retrieval call binding the contract method 0x5a16a416.
//
// Solidity: function isCommissionRateNegative(address rootchain) constant returns(bool)
func (_SeigManager *SeigManagerCaller) IsCommissionRateNegative(opts *bind.CallOpts, rootchain common.Address) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "isCommissionRateNegative", rootchain)
	return *ret0, err
}

// IsCommissionRateNegative is a free data retrieval call binding the contract method 0x5a16a416.
//
// Solidity: function isCommissionRateNegative(address rootchain) constant returns(bool)
func (_SeigManager *SeigManagerSession) IsCommissionRateNegative(rootchain common.Address) (bool, error) {
	return _SeigManager.Contract.IsCommissionRateNegative(&_SeigManager.CallOpts, rootchain)
}

// IsCommissionRateNegative is a free data retrieval call binding the contract method 0x5a16a416.
//
// Solidity: function isCommissionRateNegative(address rootchain) constant returns(bool)
func (_SeigManager *SeigManagerCallerSession) IsCommissionRateNegative(rootchain common.Address) (bool, error) {
	return _SeigManager.Contract.IsCommissionRateNegative(&_SeigManager.CallOpts, rootchain)
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_SeigManager *SeigManagerCaller) IsOwner(opts *bind.CallOpts) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "isOwner")
	return *ret0, err
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_SeigManager *SeigManagerSession) IsOwner() (bool, error) {
	return _SeigManager.Contract.IsOwner(&_SeigManager.CallOpts)
}

// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
//
// Solidity: function isOwner() constant returns(bool)
func (_SeigManager *SeigManagerCallerSession) IsOwner() (bool, error) {
	return _SeigManager.Contract.IsOwner(&_SeigManager.CallOpts)
}

// IsPauser is a free data retrieval call binding the contract method 0x46fbf68e.
//
// Solidity: function isPauser(address account) constant returns(bool)
func (_SeigManager *SeigManagerCaller) IsPauser(opts *bind.CallOpts, account common.Address) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "isPauser", account)
	return *ret0, err
}

// IsPauser is a free data retrieval call binding the contract method 0x46fbf68e.
//
// Solidity: function isPauser(address account) constant returns(bool)
func (_SeigManager *SeigManagerSession) IsPauser(account common.Address) (bool, error) {
	return _SeigManager.Contract.IsPauser(&_SeigManager.CallOpts, account)
}

// IsPauser is a free data retrieval call binding the contract method 0x46fbf68e.
//
// Solidity: function isPauser(address account) constant returns(bool)
func (_SeigManager *SeigManagerCallerSession) IsPauser(account common.Address) (bool, error) {
	return _SeigManager.Contract.IsPauser(&_SeigManager.CallOpts, account)
}

// LastCommitBlock is a free data retrieval call binding the contract method 0xc59f1046.
//
// Solidity: function lastCommitBlock(address rootchain) constant returns(uint256)
func (_SeigManager *SeigManagerCaller) LastCommitBlock(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "lastCommitBlock", rootchain)
	return *ret0, err
}

// LastCommitBlock is a free data retrieval call binding the contract method 0xc59f1046.
//
// Solidity: function lastCommitBlock(address rootchain) constant returns(uint256)
func (_SeigManager *SeigManagerSession) LastCommitBlock(rootchain common.Address) (*big.Int, error) {
	return _SeigManager.Contract.LastCommitBlock(&_SeigManager.CallOpts, rootchain)
}

// LastCommitBlock is a free data retrieval call binding the contract method 0xc59f1046.
//
// Solidity: function lastCommitBlock(address rootchain) constant returns(uint256)
func (_SeigManager *SeigManagerCallerSession) LastCommitBlock(rootchain common.Address) (*big.Int, error) {
	return _SeigManager.Contract.LastCommitBlock(&_SeigManager.CallOpts, rootchain)
}

// LastSeigBlock is a free data retrieval call binding the contract method 0xf35c89e8.
//
// Solidity: function lastSeigBlock() constant returns(uint256)
func (_SeigManager *SeigManagerCaller) LastSeigBlock(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "lastSeigBlock")
	return *ret0, err
}

// LastSeigBlock is a free data retrieval call binding the contract method 0xf35c89e8.
//
// Solidity: function lastSeigBlock() constant returns(uint256)
func (_SeigManager *SeigManagerSession) LastSeigBlock() (*big.Int, error) {
	return _SeigManager.Contract.LastSeigBlock(&_SeigManager.CallOpts)
}

// LastSeigBlock is a free data retrieval call binding the contract method 0xf35c89e8.
//
// Solidity: function lastSeigBlock() constant returns(uint256)
func (_SeigManager *SeigManagerCallerSession) LastSeigBlock() (*big.Int, error) {
	return _SeigManager.Contract.LastSeigBlock(&_SeigManager.CallOpts)
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_SeigManager *SeigManagerCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "owner")
	return *ret0, err
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_SeigManager *SeigManagerSession) Owner() (common.Address, error) {
	return _SeigManager.Contract.Owner(&_SeigManager.CallOpts)
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() constant returns(address)
func (_SeigManager *SeigManagerCallerSession) Owner() (common.Address, error) {
	return _SeigManager.Contract.Owner(&_SeigManager.CallOpts)
}

// Paused is a free data retrieval call binding the contract method 0x5c975abb.
//
// Solidity: function paused() constant returns(bool)
func (_SeigManager *SeigManagerCaller) Paused(opts *bind.CallOpts) (bool, error) {
	var (
		ret0 = new(bool)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "paused")
	return *ret0, err
}

// Paused is a free data retrieval call binding the contract method 0x5c975abb.
//
// Solidity: function paused() constant returns(bool)
func (_SeigManager *SeigManagerSession) Paused() (bool, error) {
	return _SeigManager.Contract.Paused(&_SeigManager.CallOpts)
}

// Paused is a free data retrieval call binding the contract method 0x5c975abb.
//
// Solidity: function paused() constant returns(bool)
func (_SeigManager *SeigManagerCallerSession) Paused() (bool, error) {
	return _SeigManager.Contract.Paused(&_SeigManager.CallOpts)
}

// PausedBlock is a free data retrieval call binding the contract method 0x32053c99.
//
// Solidity: function pausedBlock() constant returns(uint256)
func (_SeigManager *SeigManagerCaller) PausedBlock(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "pausedBlock")
	return *ret0, err
}

// PausedBlock is a free data retrieval call binding the contract method 0x32053c99.
//
// Solidity: function pausedBlock() constant returns(uint256)
func (_SeigManager *SeigManagerSession) PausedBlock() (*big.Int, error) {
	return _SeigManager.Contract.PausedBlock(&_SeigManager.CallOpts)
}

// PausedBlock is a free data retrieval call binding the contract method 0x32053c99.
//
// Solidity: function pausedBlock() constant returns(uint256)
func (_SeigManager *SeigManagerCallerSession) PausedBlock() (*big.Int, error) {
	return _SeigManager.Contract.PausedBlock(&_SeigManager.CallOpts)
}

// Powerton is a free data retrieval call binding the contract method 0x3e832e1d.
//
// Solidity: function powerton() constant returns(address)
func (_SeigManager *SeigManagerCaller) Powerton(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "powerton")
	return *ret0, err
}

// Powerton is a free data retrieval call binding the contract method 0x3e832e1d.
//
// Solidity: function powerton() constant returns(address)
func (_SeigManager *SeigManagerSession) Powerton() (common.Address, error) {
	return _SeigManager.Contract.Powerton(&_SeigManager.CallOpts)
}

// Powerton is a free data retrieval call binding the contract method 0x3e832e1d.
//
// Solidity: function powerton() constant returns(address)
func (_SeigManager *SeigManagerCallerSession) Powerton() (common.Address, error) {
	return _SeigManager.Contract.Powerton(&_SeigManager.CallOpts)
}

// Registry is a free data retrieval call binding the contract method 0x7b103999.
//
// Solidity: function registry() constant returns(address)
func (_SeigManager *SeigManagerCaller) Registry(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "registry")
	return *ret0, err
}

// Registry is a free data retrieval call binding the contract method 0x7b103999.
//
// Solidity: function registry() constant returns(address)
func (_SeigManager *SeigManagerSession) Registry() (common.Address, error) {
	return _SeigManager.Contract.Registry(&_SeigManager.CallOpts)
}

// Registry is a free data retrieval call binding the contract method 0x7b103999.
//
// Solidity: function registry() constant returns(address)
func (_SeigManager *SeigManagerCallerSession) Registry() (common.Address, error) {
	return _SeigManager.Contract.Registry(&_SeigManager.CallOpts)
}

// SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349.
//
// Solidity: function seigPerBlock() constant returns(uint256)
func (_SeigManager *SeigManagerCaller) SeigPerBlock(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "seigPerBlock")
	return *ret0, err
}

// SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349.
//
// Solidity: function seigPerBlock() constant returns(uint256)
func (_SeigManager *SeigManagerSession) SeigPerBlock() (*big.Int, error) {
	return _SeigManager.Contract.SeigPerBlock(&_SeigManager.CallOpts)
}

// SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349.
//
// Solidity: function seigPerBlock() constant returns(uint256)
func (_SeigManager *SeigManagerCallerSession) SeigPerBlock() (*big.Int, error) {
	return _SeigManager.Contract.SeigPerBlock(&_SeigManager.CallOpts)
}

// StakeOf is a free data retrieval call binding the contract method 0xce4cb876.
//
// Solidity: function stakeOf(address rootchain, address account) constant returns(uint256)
func (_SeigManager *SeigManagerCaller) StakeOf(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "stakeOf", rootchain, account)
	return *ret0, err
}

// StakeOf is a free data retrieval call binding the contract method 0xce4cb876.
//
// Solidity: function stakeOf(address rootchain, address account) constant returns(uint256)
func (_SeigManager *SeigManagerSession) StakeOf(rootchain common.Address, account common.Address) (*big.Int, error) {
	return _SeigManager.Contract.StakeOf(&_SeigManager.CallOpts, rootchain, account)
}

// StakeOf is a free data retrieval call binding the contract method 0xce4cb876.
//
// Solidity: function stakeOf(address rootchain, address account) constant returns(uint256)
func (_SeigManager *SeigManagerCallerSession) StakeOf(rootchain common.Address, account common.Address) (*big.Int, error) {
	return _SeigManager.Contract.StakeOf(&_SeigManager.CallOpts, rootchain, account)
}

// Ton is a free data retrieval call binding the contract method 0xcc48b947.
//
// Solidity: function ton() constant returns(address)
func (_SeigManager *SeigManagerCaller) Ton(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "ton")
	return *ret0, err
}

// Ton is a free data retrieval call binding the contract method 0xcc48b947.
//
// Solidity: function ton() constant returns(address)
func (_SeigManager *SeigManagerSession) Ton() (common.Address, error) {
	return _SeigManager.Contract.Ton(&_SeigManager.CallOpts)
}

// Ton is a free data retrieval call binding the contract method 0xcc48b947.
//
// Solidity: function ton() constant returns(address)
func (_SeigManager *SeigManagerCallerSession) Ton() (common.Address, error) {
	return _SeigManager.Contract.Ton(&_SeigManager.CallOpts)
}

// Tot is a free data retrieval call binding the contract method 0xa16d6aa7.
//
// Solidity: function tot() constant returns(address)
func (_SeigManager *SeigManagerCaller) Tot(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "tot")
	return *ret0, err
}

// Tot is a free data retrieval call binding the contract method 0xa16d6aa7.
//
// Solidity: function tot() constant returns(address)
func (_SeigManager *SeigManagerSession) Tot() (common.Address, error) {
	return _SeigManager.Contract.Tot(&_SeigManager.CallOpts)
}

// Tot is a free data retrieval call binding the contract method 0xa16d6aa7.
//
// Solidity: function tot() constant returns(address)
func (_SeigManager *SeigManagerCallerSession) Tot() (common.Address, error) {
	return _SeigManager.Contract.Tot(&_SeigManager.CallOpts)
}

// UncomittedStakeOf is a free data retrieval call binding the contract method 0xfa9789c8.
//
// Solidity: function uncomittedStakeOf(address rootchain, address account) constant returns(uint256)
func (_SeigManager *SeigManagerCaller) UncomittedStakeOf(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "uncomittedStakeOf", rootchain, account)
	return *ret0, err
}

// UncomittedStakeOf is a free data retrieval call binding the contract method 0xfa9789c8.
//
// Solidity: function uncomittedStakeOf(address rootchain, address account) constant returns(uint256)
func (_SeigManager *SeigManagerSession) UncomittedStakeOf(rootchain common.Address, account common.Address) (*big.Int, error) {
	return _SeigManager.Contract.UncomittedStakeOf(&_SeigManager.CallOpts, rootchain, account)
}

// UncomittedStakeOf is a free data retrieval call binding the contract method 0xfa9789c8.
//
// Solidity: function uncomittedStakeOf(address rootchain, address account) constant returns(uint256)
func (_SeigManager *SeigManagerCallerSession) UncomittedStakeOf(rootchain common.Address, account common.Address) (*big.Int, error) {
	return _SeigManager.Contract.UncomittedStakeOf(&_SeigManager.CallOpts, rootchain, account)
}

// UnpausedBlock is a free data retrieval call binding the contract method 0x1cc47890.
//
// Solidity: function unpausedBlock() constant returns(uint256)
func (_SeigManager *SeigManagerCaller) UnpausedBlock(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "unpausedBlock")
	return *ret0, err
}

// UnpausedBlock is a free data retrieval call binding the contract method 0x1cc47890.
//
// Solidity: function unpausedBlock() constant returns(uint256)
func (_SeigManager *SeigManagerSession) UnpausedBlock() (*big.Int, error) {
	return _SeigManager.Contract.UnpausedBlock(&_SeigManager.CallOpts)
}

// UnpausedBlock is a free data retrieval call binding the contract method 0x1cc47890.
//
// Solidity: function unpausedBlock() constant returns(uint256)
func (_SeigManager *SeigManagerCallerSession) UnpausedBlock() (*big.Int, error) {
	return _SeigManager.Contract.UnpausedBlock(&_SeigManager.CallOpts)
}

// Wton is a free data retrieval call binding the contract method 0x8d62d949.
//
// Solidity: function wton() constant returns(address)
func (_SeigManager *SeigManagerCaller) Wton(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _SeigManager.contract.Call(opts, out, "wton")
	return *ret0, err
}

// Wton is a free data retrieval call binding the contract method 0x8d62d949.
//
// Solidity: function wton() constant returns(address)
func (_SeigManager *SeigManagerSession) Wton() (common.Address, error) {
	return _SeigManager.Contract.Wton(&_SeigManager.CallOpts)
}

// Wton is a free data retrieval call binding the contract method 0x8d62d949.
//
// Solidity: function wton() constant returns(address)
func (_SeigManager *SeigManagerCallerSession) Wton() (common.Address, error) {
	return _SeigManager.Contract.Wton(&_SeigManager.CallOpts)
}

// AddPauser is a paid mutator transaction binding the contract method 0x82dc1ec4.
//
// Solidity: function addPauser(address account) returns()
func (_SeigManager *SeigManagerTransactor) AddPauser(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) {
	return _SeigManager.contract.Transact(opts, "addPauser", account)
}

// AddPauser is a paid mutator transaction binding the contract method 0x82dc1ec4.
//
// Solidity: function addPauser(address account) returns()
func (_SeigManager *SeigManagerSession) AddPauser(account common.Address) (*types.Transaction, error) {
	return _SeigManager.Contract.AddPauser(&_SeigManager.TransactOpts, account)
}

// AddPauser is a paid mutator transaction binding the contract method 0x82dc1ec4.
//
// Solidity: function addPauser(address account) returns()
func (_SeigManager *SeigManagerTransactorSession) AddPauser(account common.Address) (*types.Transaction, error) {
	return _SeigManager.Contract.AddPauser(&_SeigManager.TransactOpts, account)
}

// DeployCoinage is a paid mutator transaction binding the contract method 0x833a774f.
//
// Solidity: function deployCoinage(address rootchain) returns(bool)
func (_SeigManager *SeigManagerTransactor) DeployCoinage(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) {
	return _SeigManager.contract.Transact(opts, "deployCoinage", rootchain)
}

// DeployCoinage is a paid mutator transaction binding the contract method 0x833a774f.
//
// Solidity: function deployCoinage(address rootchain) returns(bool)
func (_SeigManager *SeigManagerSession) DeployCoinage(rootchain common.Address) (*types.Transaction, error) {
	return _SeigManager.Contract.DeployCoinage(&_SeigManager.TransactOpts, rootchain)
}

// DeployCoinage is a paid mutator transaction binding the contract method 0x833a774f.
//
// Solidity: function deployCoinage(address rootchain) returns(bool)
func (_SeigManager *SeigManagerTransactorSession) DeployCoinage(rootchain common.Address) (*types.Transaction, error) {
	return _SeigManager.Contract.DeployCoinage(&_SeigManager.TransactOpts, rootchain)
}

// OnCommit is a paid mutator transaction binding the contract method 0x359c4d59.
//
// Solidity: function onCommit() returns(bool)
func (_SeigManager *SeigManagerTransactor) OnCommit(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _SeigManager.contract.Transact(opts, "onCommit")
}

// OnCommit is a paid mutator transaction binding the contract method 0x359c4d59.
//
// Solidity: function onCommit() returns(bool)
func (_SeigManager *SeigManagerSession) OnCommit() (*types.Transaction, error) {
	return _SeigManager.Contract.OnCommit(&_SeigManager.TransactOpts)
}

// OnCommit is a paid mutator transaction binding the contract method 0x359c4d59.
//
// Solidity: function onCommit() returns(bool)
func (_SeigManager *SeigManagerTransactorSession) OnCommit() (*types.Transaction, error) {
	return _SeigManager.Contract.OnCommit(&_SeigManager.TransactOpts)
}

// OnDeposit is a paid mutator transaction binding the contract method 0x412c6d50.
//
// Solidity: function onDeposit(address rootchain, address account, uint256 amount) returns(bool)
func (_SeigManager *SeigManagerTransactor) OnDeposit(opts *bind.TransactOpts, rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _SeigManager.contract.Transact(opts, "onDeposit", rootchain, account, amount)
}

// OnDeposit is a paid mutator transaction binding the contract method 0x412c6d50.
//
// Solidity: function onDeposit(address rootchain, address account, uint256 amount) returns(bool)
func (_SeigManager *SeigManagerSession) OnDeposit(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _SeigManager.Contract.OnDeposit(&_SeigManager.TransactOpts, rootchain, account, amount)
}

// OnDeposit is a paid mutator transaction binding the contract method 0x412c6d50.
//
// Solidity: function onDeposit(address rootchain, address account, uint256 amount) returns(bool)
func (_SeigManager *SeigManagerTransactorSession) OnDeposit(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _SeigManager.Contract.OnDeposit(&_SeigManager.TransactOpts, rootchain, account, amount)
}

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

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

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

// OnWithdraw is a paid mutator transaction binding the contract method 0xf850ffaa.
//
// Solidity: function onWithdraw(address rootchain, address account, uint256 amount) returns(bool)
func (_SeigManager *SeigManagerTransactor) OnWithdraw(opts *bind.TransactOpts, rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _SeigManager.contract.Transact(opts, "onWithdraw", rootchain, account, amount)
}

// OnWithdraw is a paid mutator transaction binding the contract method 0xf850ffaa.
//
// Solidity: function onWithdraw(address rootchain, address account, uint256 amount) returns(bool)
func (_SeigManager *SeigManagerSession) OnWithdraw(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _SeigManager.Contract.OnWithdraw(&_SeigManager.TransactOpts, rootchain, account, amount)
}

// OnWithdraw is a paid mutator transaction binding the contract method 0xf850ffaa.
//
// Solidity: function onWithdraw(address rootchain, address account, uint256 amount) returns(bool)
func (_SeigManager *SeigManagerTransactorSession) OnWithdraw(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _SeigManager.Contract.OnWithdraw(&_SeigManager.TransactOpts, rootchain, account, amount)
}

// Pause is a paid mutator transaction binding the contract method 0x8456cb59.
//
// Solidity: function pause() returns()
func (_SeigManager *SeigManagerTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _SeigManager.contract.Transact(opts, "pause")
}

// Pause is a paid mutator transaction binding the contract method 0x8456cb59.
//
// Solidity: function pause() returns()
func (_SeigManager *SeigManagerSession) Pause() (*types.Transaction, error) {
	return _SeigManager.Contract.Pause(&_SeigManager.TransactOpts)
}

// Pause is a paid mutator transaction binding the contract method 0x8456cb59.
//
// Solidity: function pause() returns()
func (_SeigManager *SeigManagerTransactorSession) Pause() (*types.Transaction, error) {
	return _SeigManager.Contract.Pause(&_SeigManager.TransactOpts)
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
//
// Solidity: function renounceMinter(address target) returns()
func (_SeigManager *SeigManagerTransactor) RenounceMinter(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
	return _SeigManager.contract.Transact(opts, "renounceMinter", target)
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
//
// Solidity: function renounceMinter(address target) returns()
func (_SeigManager *SeigManagerSession) RenounceMinter(target common.Address) (*types.Transaction, error) {
	return _SeigManager.Contract.RenounceMinter(&_SeigManager.TransactOpts, target)
}

// RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
//
// Solidity: function renounceMinter(address target) returns()
func (_SeigManager *SeigManagerTransactorSession) RenounceMinter(target common.Address) (*types.Transaction, error) {
	return _SeigManager.Contract.RenounceMinter(&_SeigManager.TransactOpts, target)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
//
// Solidity: function renounceOwnership(address target) returns()
func (_SeigManager *SeigManagerTransactor) RenounceOwnership(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
	return _SeigManager.contract.Transact(opts, "renounceOwnership", target)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
//
// Solidity: function renounceOwnership(address target) returns()
func (_SeigManager *SeigManagerSession) RenounceOwnership(target common.Address) (*types.Transaction, error) {
	return _SeigManager.Contract.RenounceOwnership(&_SeigManager.TransactOpts, target)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
//
// Solidity: function renounceOwnership(address target) returns()
func (_SeigManager *SeigManagerTransactorSession) RenounceOwnership(target common.Address) (*types.Transaction, error) {
	return _SeigManager.Contract.RenounceOwnership(&_SeigManager.TransactOpts, target)
}

// RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_SeigManager *SeigManagerTransactor) RenounceOwnership0(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _SeigManager.contract.Transact(opts, "renounceOwnership0")
}

// RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_SeigManager *SeigManagerSession) RenounceOwnership0() (*types.Transaction, error) {
	return _SeigManager.Contract.RenounceOwnership0(&_SeigManager.TransactOpts)
}

// RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_SeigManager *SeigManagerTransactorSession) RenounceOwnership0() (*types.Transaction, error) {
	return _SeigManager.Contract.RenounceOwnership0(&_SeigManager.TransactOpts)
}

// RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
//
// Solidity: function renouncePauser(address target) returns()
func (_SeigManager *SeigManagerTransactor) RenouncePauser(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
	return _SeigManager.contract.Transact(opts, "renouncePauser", target)
}

// RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
//
// Solidity: function renouncePauser(address target) returns()
func (_SeigManager *SeigManagerSession) RenouncePauser(target common.Address) (*types.Transaction, error) {
	return _SeigManager.Contract.RenouncePauser(&_SeigManager.TransactOpts, target)
}

// RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
//
// Solidity: function renouncePauser(address target) returns()
func (_SeigManager *SeigManagerTransactorSession) RenouncePauser(target common.Address) (*types.Transaction, error) {
	return _SeigManager.Contract.RenouncePauser(&_SeigManager.TransactOpts, target)
}

// RenouncePauser0 is a paid mutator transaction binding the contract method 0x6ef8d66d.
//
// Solidity: function renouncePauser() returns()
func (_SeigManager *SeigManagerTransactor) RenouncePauser0(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _SeigManager.contract.Transact(opts, "renouncePauser0")
}

// RenouncePauser0 is a paid mutator transaction binding the contract method 0x6ef8d66d.
//
// Solidity: function renouncePauser() returns()
func (_SeigManager *SeigManagerSession) RenouncePauser0() (*types.Transaction, error) {
	return _SeigManager.Contract.RenouncePauser0(&_SeigManager.TransactOpts)
}

// RenouncePauser0 is a paid mutator transaction binding the contract method 0x6ef8d66d.
//
// Solidity: function renouncePauser() returns()
func (_SeigManager *SeigManagerTransactorSession) RenouncePauser0() (*types.Transaction, error) {
	return _SeigManager.Contract.RenouncePauser0(&_SeigManager.TransactOpts)
}

// SetCommissionRate is a paid mutator transaction binding the contract method 0x4224ed66.
//
// Solidity: function setCommissionRate(address rootchain, uint256 commissionRate, bool isCommissionRateNegative) returns(bool)
func (_SeigManager *SeigManagerTransactor) SetCommissionRate(opts *bind.TransactOpts, rootchain common.Address, commissionRate *big.Int, isCommissionRateNegative bool) (*types.Transaction, error) {
	return _SeigManager.contract.Transact(opts, "setCommissionRate", rootchain, commissionRate, isCommissionRateNegative)
}

// SetCommissionRate is a paid mutator transaction binding the contract method 0x4224ed66.
//
// Solidity: function setCommissionRate(address rootchain, uint256 commissionRate, bool isCommissionRateNegative) returns(bool)
func (_SeigManager *SeigManagerSession) SetCommissionRate(rootchain common.Address, commissionRate *big.Int, isCommissionRateNegative bool) (*types.Transaction, error) {
	return _SeigManager.Contract.SetCommissionRate(&_SeigManager.TransactOpts, rootchain, commissionRate, isCommissionRateNegative)
}

// SetCommissionRate is a paid mutator transaction binding the contract method 0x4224ed66.
//
// Solidity: function setCommissionRate(address rootchain, uint256 commissionRate, bool isCommissionRateNegative) returns(bool)
func (_SeigManager *SeigManagerTransactorSession) SetCommissionRate(rootchain common.Address, commissionRate *big.Int, isCommissionRateNegative bool) (*types.Transaction, error) {
	return _SeigManager.Contract.SetCommissionRate(&_SeigManager.TransactOpts, rootchain, commissionRate, isCommissionRateNegative)
}

// SetPowerTON is a paid mutator transaction binding the contract method 0x41813020.
//
// Solidity: function setPowerTON(address powerton) returns()
func (_SeigManager *SeigManagerTransactor) SetPowerTON(opts *bind.TransactOpts, powerton common.Address) (*types.Transaction, error) {
	return _SeigManager.contract.Transact(opts, "setPowerTON", powerton)
}

// SetPowerTON is a paid mutator transaction binding the contract method 0x41813020.
//
// Solidity: function setPowerTON(address powerton) returns()
func (_SeigManager *SeigManagerSession) SetPowerTON(powerton common.Address) (*types.Transaction, error) {
	return _SeigManager.Contract.SetPowerTON(&_SeigManager.TransactOpts, powerton)
}

// SetPowerTON is a paid mutator transaction binding the contract method 0x41813020.
//
// Solidity: function setPowerTON(address powerton) returns()
func (_SeigManager *SeigManagerTransactorSession) SetPowerTON(powerton common.Address) (*types.Transaction, error) {
	return _SeigManager.Contract.SetPowerTON(&_SeigManager.TransactOpts, powerton)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
//
// Solidity: function transferOwnership(address target, address newOwner) returns()
func (_SeigManager *SeigManagerTransactor) TransferOwnership(opts *bind.TransactOpts, target common.Address, newOwner common.Address) (*types.Transaction, error) {
	return _SeigManager.contract.Transact(opts, "transferOwnership", target, newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
//
// Solidity: function transferOwnership(address target, address newOwner) returns()
func (_SeigManager *SeigManagerSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) {
	return _SeigManager.Contract.TransferOwnership(&_SeigManager.TransactOpts, target, newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
//
// Solidity: function transferOwnership(address target, address newOwner) returns()
func (_SeigManager *SeigManagerTransactorSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) {
	return _SeigManager.Contract.TransferOwnership(&_SeigManager.TransactOpts, target, newOwner)
}

// TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_SeigManager *SeigManagerTransactor) TransferOwnership0(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
	return _SeigManager.contract.Transact(opts, "transferOwnership0", newOwner)
}

// TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_SeigManager *SeigManagerSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) {
	return _SeigManager.Contract.TransferOwnership0(&_SeigManager.TransactOpts, newOwner)
}

// TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_SeigManager *SeigManagerTransactorSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) {
	return _SeigManager.Contract.TransferOwnership0(&_SeigManager.TransactOpts, newOwner)
}

// Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a.
//
// Solidity: function unpause() returns()
func (_SeigManager *SeigManagerTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _SeigManager.contract.Transact(opts, "unpause")
}

// Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a.
//
// Solidity: function unpause() returns()
func (_SeigManager *SeigManagerSession) Unpause() (*types.Transaction, error) {
	return _SeigManager.Contract.Unpause(&_SeigManager.TransactOpts)
}

// Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a.
//
// Solidity: function unpause() returns()
func (_SeigManager *SeigManagerTransactorSession) Unpause() (*types.Transaction, error) {
	return _SeigManager.Contract.Unpause(&_SeigManager.TransactOpts)
}

// SeigManagerCoinageCreatedIterator is returned from FilterCoinageCreated and is used to iterate over the raw logs and unpacked data for CoinageCreated events raised by the SeigManager contract.
type SeigManagerCoinageCreatedIterator struct {
	Event *SeigManagerCoinageCreated // 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 *SeigManagerCoinageCreatedIterator) 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(SeigManagerCoinageCreated)
			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(SeigManagerCoinageCreated)
		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 *SeigManagerCoinageCreatedIterator) Error() error {
	return it.fail
}

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

// SeigManagerCoinageCreated represents a CoinageCreated event raised by the SeigManager contract.
type SeigManagerCoinageCreated struct {
	Rootchain common.Address
	Coinage   common.Address
	Raw       types.Log // Blockchain specific contextual infos
}

// FilterCoinageCreated is a free log retrieval operation binding the contract event 0x124cac1e701d08d642237ad795ddd275670e12f2cd956a26709721c68084c2b2.
//
// Solidity: event CoinageCreated(address indexed rootchain, address coinage)
func (_SeigManager *SeigManagerFilterer) FilterCoinageCreated(opts *bind.FilterOpts, rootchain []common.Address) (*SeigManagerCoinageCreatedIterator, error) {

	var rootchainRule []interface{}
	for _, rootchainItem := range rootchain {
		rootchainRule = append(rootchainRule, rootchainItem)
	}

	logs, sub, err := _SeigManager.contract.FilterLogs(opts, "CoinageCreated", rootchainRule)
	if err != nil {
		return nil, err
	}
	return &SeigManagerCoinageCreatedIterator{contract: _SeigManager.contract, event: "CoinageCreated", logs: logs, sub: sub}, nil
}

// WatchCoinageCreated is a free log subscription operation binding the contract event 0x124cac1e701d08d642237ad795ddd275670e12f2cd956a26709721c68084c2b2.
//
// Solidity: event CoinageCreated(address indexed rootchain, address coinage)
func (_SeigManager *SeigManagerFilterer) WatchCoinageCreated(opts *bind.WatchOpts, sink chan<- *SeigManagerCoinageCreated, rootchain []common.Address) (event.Subscription, error) {

	var rootchainRule []interface{}
	for _, rootchainItem := range rootchain {
		rootchainRule = append(rootchainRule, rootchainItem)
	}

	logs, sub, err := _SeigManager.contract.WatchLogs(opts, "CoinageCreated", rootchainRule)
	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(SeigManagerCoinageCreated)
				if err := _SeigManager.contract.UnpackLog(event, "CoinageCreated", 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
}

// ParseCoinageCreated is a log parse operation binding the contract event 0x124cac1e701d08d642237ad795ddd275670e12f2cd956a26709721c68084c2b2.
//
// Solidity: event CoinageCreated(address indexed rootchain, address coinage)
func (_SeigManager *SeigManagerFilterer) ParseCoinageCreated(log types.Log) (*SeigManagerCoinageCreated, error) {
	event := new(SeigManagerCoinageCreated)
	if err := _SeigManager.contract.UnpackLog(event, "CoinageCreated", log); err != nil {
		return nil, err
	}
	return event, nil
}

// SeigManagerComittedIterator is returned from FilterComitted and is used to iterate over the raw logs and unpacked data for Comitted events raised by the SeigManager contract.
type SeigManagerComittedIterator struct {
	Event *SeigManagerComitted // 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 *SeigManagerComittedIterator) 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(SeigManagerComitted)
			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(SeigManagerComitted)
		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 *SeigManagerComittedIterator) Error() error {
	return it.fail
}

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

// SeigManagerComitted represents a Comitted event raised by the SeigManager contract.
type SeigManagerComitted struct {
	Rootchain common.Address
	Raw       types.Log // Blockchain specific contextual infos
}

// FilterComitted is a free log retrieval operation binding the contract event 0x521cc65179761533a7c8d7a973291dd7baebb99a67edf5ef78e9c2b61a533d95.
//
// Solidity: event Comitted(address indexed rootchain)
func (_SeigManager *SeigManagerFilterer) FilterComitted(opts *bind.FilterOpts, rootchain []common.Address) (*SeigManagerComittedIterator, error) {

	var rootchainRule []interface{}
	for _, rootchainItem := range rootchain {
		rootchainRule = append(rootchainRule, rootchainItem)
	}

	logs, sub, err := _SeigManager.contract.FilterLogs(opts, "Comitted", rootchainRule)
	if err != nil {
		return nil, err
	}
	return &SeigManagerComittedIterator{contract: _SeigManager.contract, event: "Comitted", logs: logs, sub: sub}, nil
}

// WatchComitted is a free log subscription operation binding the contract event 0x521cc65179761533a7c8d7a973291dd7baebb99a67edf5ef78e9c2b61a533d95.
//
// Solidity: event Comitted(address indexed rootchain)
func (_SeigManager *SeigManagerFilterer) WatchComitted(opts *bind.WatchOpts, sink chan<- *SeigManagerComitted, rootchain []common.Address) (event.Subscription, error) {

	var rootchainRule []interface{}
	for _, rootchainItem := range rootchain {
		rootchainRule = append(rootchainRule, rootchainItem)
	}

	logs, sub, err := _SeigManager.contract.WatchLogs(opts, "Comitted", rootchainRule)
	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(SeigManagerComitted)
				if err := _SeigManager.contract.UnpackLog(event, "Comitted", 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
}

// ParseComitted is a log parse operation binding the contract event 0x521cc65179761533a7c8d7a973291dd7baebb99a67edf5ef78e9c2b61a533d95.
//
// Solidity: event Comitted(address indexed rootchain)
func (_SeigManager *SeigManagerFilterer) ParseComitted(log types.Log) (*SeigManagerComitted, error) {
	event := new(SeigManagerComitted)
	if err := _SeigManager.contract.UnpackLog(event, "Comitted", log); err != nil {
		return nil, err
	}
	return event, nil
}

// SeigManagerCommissionRateSetIterator is returned from FilterCommissionRateSet and is used to iterate over the raw logs and unpacked data for CommissionRateSet events raised by the SeigManager contract.
type SeigManagerCommissionRateSetIterator struct {
	Event *SeigManagerCommissionRateSet // 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 *SeigManagerCommissionRateSetIterator) 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(SeigManagerCommissionRateSet)
			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(SeigManagerCommissionRateSet)
		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 *SeigManagerCommissionRateSetIterator) Error() error {
	return it.fail
}

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

// SeigManagerCommissionRateSet represents a CommissionRateSet event raised by the SeigManager contract.
type SeigManagerCommissionRateSet struct {
	Rootchain    common.Address
	PreviousRate *big.Int
	NewRate      *big.Int
	Raw          types.Log // Blockchain specific contextual infos
}

// FilterCommissionRateSet is a free log retrieval operation binding the contract event 0x11841078e38c91feada06e1f8ded3697ab2dadc2583c52b14109b82ccd4f77d7.
//
// Solidity: event CommissionRateSet(address indexed rootchain, uint256 previousRate, uint256 newRate)
func (_SeigManager *SeigManagerFilterer) FilterCommissionRateSet(opts *bind.FilterOpts, rootchain []common.Address) (*SeigManagerCommissionRateSetIterator, error) {

	var rootchainRule []interface{}
	for _, rootchainItem := range rootchain {
		rootchainRule = append(rootchainRule, rootchainItem)
	}

	logs, sub, err := _SeigManager.contract.FilterLogs(opts, "CommissionRateSet", rootchainRule)
	if err != nil {
		return nil, err
	}
	return &SeigManagerCommissionRateSetIterator{contract: _SeigManager.contract, event: "CommissionRateSet", logs: logs, sub: sub}, nil
}

// WatchCommissionRateSet is a free log subscription operation binding the contract event 0x11841078e38c91feada06e1f8ded3697ab2dadc2583c52b14109b82ccd4f77d7.
//
// Solidity: event CommissionRateSet(address indexed rootchain, uint256 previousRate, uint256 newRate)
func (_SeigManager *SeigManagerFilterer) WatchCommissionRateSet(opts *bind.WatchOpts, sink chan<- *SeigManagerCommissionRateSet, rootchain []common.Address) (event.Subscription, error) {

	var rootchainRule []interface{}
	for _, rootchainItem := range rootchain {
		rootchainRule = append(rootchainRule, rootchainItem)
	}

	logs, sub, err := _SeigManager.contract.WatchLogs(opts, "CommissionRateSet", rootchainRule)
	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(SeigManagerCommissionRateSet)
				if err := _SeigManager.contract.UnpackLog(event, "CommissionRateSet", 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
}

// ParseCommissionRateSet is a log parse operation binding the contract event 0x11841078e38c91feada06e1f8ded3697ab2dadc2583c52b14109b82ccd4f77d7.
//
// Solidity: event CommissionRateSet(address indexed rootchain, uint256 previousRate, uint256 newRate)
func (_SeigManager *SeigManagerFilterer) ParseCommissionRateSet(log types.Log) (*SeigManagerCommissionRateSet, error) {
	event := new(SeigManagerCommissionRateSet)
	if err := _SeigManager.contract.UnpackLog(event, "CommissionRateSet", log); err != nil {
		return nil, err
	}
	return event, nil
}

// SeigManagerCommitLog1Iterator is returned from FilterCommitLog1 and is used to iterate over the raw logs and unpacked data for CommitLog1 events raised by the SeigManager contract.
type SeigManagerCommitLog1Iterator struct {
	Event *SeigManagerCommitLog1 // 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 *SeigManagerCommitLog1Iterator) 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(SeigManagerCommitLog1)
			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(SeigManagerCommitLog1)
		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 *SeigManagerCommitLog1Iterator) Error() error {
	return it.fail
}

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

// SeigManagerCommitLog1 represents a CommitLog1 event raised by the SeigManager contract.
type SeigManagerCommitLog1 struct {
	TotalStakedAmount *big.Int
	TotalSupplyOfWTON *big.Int
	PrevTotalSupply   *big.Int
	NextTotalSupply   *big.Int
	Raw               types.Log // Blockchain specific contextual infos
}

// FilterCommitLog1 is a free log retrieval operation binding the contract event 0x41a79a497d1457df24c25ab99f22349ae9aef4468429f0a781216e8dcf80c628.
//
// Solidity: event CommitLog1(uint256 totalStakedAmount, uint256 totalSupplyOfWTON, uint256 prevTotalSupply, uint256 nextTotalSupply)
func (_SeigManager *SeigManagerFilterer) FilterCommitLog1(opts *bind.FilterOpts) (*SeigManagerCommitLog1Iterator, error) {

	logs, sub, err := _SeigManager.contract.FilterLogs(opts, "CommitLog1")
	if err != nil {
		return nil, err
	}
	return &SeigManagerCommitLog1Iterator{contract: _SeigManager.contract, event: "CommitLog1", logs: logs, sub: sub}, nil
}

// WatchCommitLog1 is a free log subscription operation binding the contract event 0x41a79a497d1457df24c25ab99f22349ae9aef4468429f0a781216e8dcf80c628.
//
// Solidity: event CommitLog1(uint256 totalStakedAmount, uint256 totalSupplyOfWTON, uint256 prevTotalSupply, uint256 nextTotalSupply)
func (_SeigManager *SeigManagerFilterer) WatchCommitLog1(opts *bind.WatchOpts, sink chan<- *SeigManagerCommitLog1) (event.Subscription, error) {

	logs, sub, err := _SeigManager.contract.WatchLogs(opts, "CommitLog1")
	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(SeigManagerCommitLog1)
				if err := _SeigManager.contract.UnpackLog(event, "CommitLog1", 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
}

// ParseCommitLog1 is a log parse operation binding the contract event 0x41a79a497d1457df24c25ab99f22349ae9aef4468429f0a781216e8dcf80c628.
//
// Solidity: event CommitLog1(uint256 totalStakedAmount, uint256 totalSupplyOfWTON, uint256 prevTotalSupply, uint256 nextTotalSupply)
func (_SeigManager *SeigManagerFilterer) ParseCommitLog1(log types.Log) (*SeigManagerCommitLog1, error) {
	event := new(SeigManagerCommitLog1)
	if err := _SeigManager.contract.UnpackLog(event, "CommitLog1", log); err != nil {
		return nil, err
	}
	return event, nil
}

// SeigManagerOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the SeigManager contract.
type SeigManagerOwnershipTransferredIterator struct {
	Event *SeigManagerOwnershipTransferred // 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 *SeigManagerOwnershipTransferredIterator) 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(SeigManagerOwnershipTransferred)
			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(SeigManagerOwnershipTransferred)
		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 *SeigManagerOwnershipTransferredIterator) Error() error {
	return it.fail
}

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

// SeigManagerOwnershipTransferred represents a OwnershipTransferred event raised by the SeigManager contract.
type SeigManagerOwnershipTransferred struct {
	PreviousOwner common.Address
	NewOwner      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_SeigManager *SeigManagerFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*SeigManagerOwnershipTransferredIterator, error) {

	var previousOwnerRule []interface{}
	for _, previousOwnerItem := range previousOwner {
		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
	}
	var newOwnerRule []interface{}
	for _, newOwnerItem := range newOwner {
		newOwnerRule = append(newOwnerRule, newOwnerItem)
	}

	logs, sub, err := _SeigManager.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
	if err != nil {
		return nil, err
	}
	return &SeigManagerOwnershipTransferredIterator{contract: _SeigManager.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
}

// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_SeigManager *SeigManagerFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *SeigManagerOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {

	var previousOwnerRule []interface{}
	for _, previousOwnerItem := range previousOwner {
		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
	}
	var newOwnerRule []interface{}
	for _, newOwnerItem := range newOwner {
		newOwnerRule = append(newOwnerRule, newOwnerItem)
	}

	logs, sub, err := _SeigManager.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
	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(SeigManagerOwnershipTransferred)
				if err := _SeigManager.contract.UnpackLog(event, "OwnershipTransferred", 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
}

// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_SeigManager *SeigManagerFilterer) ParseOwnershipTransferred(log types.Log) (*SeigManagerOwnershipTransferred, error) {
	event := new(SeigManagerOwnershipTransferred)
	if err := _SeigManager.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
		return nil, err
	}
	return event, nil
}

// SeigManagerPausedIterator is returned from FilterPaused and is used to iterate over the raw logs and unpacked data for Paused events raised by the SeigManager contract.
type SeigManagerPausedIterator struct {
	Event *SeigManagerPaused // 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 *SeigManagerPausedIterator) 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(SeigManagerPaused)
			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(SeigManagerPaused)
		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 *SeigManagerPausedIterator) Error() error {
	return it.fail
}

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

// SeigManagerPaused represents a Paused event raised by the SeigManager contract.
type SeigManagerPaused struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterPaused is a free log retrieval operation binding the contract event 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258.
//
// Solidity: event Paused(address account)
func (_SeigManager *SeigManagerFilterer) FilterPaused(opts *bind.FilterOpts) (*SeigManagerPausedIterator, error) {

	logs, sub, err := _SeigManager.contract.FilterLogs(opts, "Paused")
	if err != nil {
		return nil, err
	}
	return &SeigManagerPausedIterator{contract: _SeigManager.contract, event: "Paused", logs: logs, sub: sub}, nil
}

// WatchPaused is a free log subscription operation binding the contract event 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258.
//
// Solidity: event Paused(address account)
func (_SeigManager *SeigManagerFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *SeigManagerPaused) (event.Subscription, error) {

	logs, sub, err := _SeigManager.contract.WatchLogs(opts, "Paused")
	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(SeigManagerPaused)
				if err := _SeigManager.contract.UnpackLog(event, "Paused", 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
}

// ParsePaused is a log parse operation binding the contract event 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258.
//
// Solidity: event Paused(address account)
func (_SeigManager *SeigManagerFilterer) ParsePaused(log types.Log) (*SeigManagerPaused, error) {
	event := new(SeigManagerPaused)
	if err := _SeigManager.contract.UnpackLog(event, "Paused", log); err != nil {
		return nil, err
	}
	return event, nil
}

// SeigManagerPauserAddedIterator is returned from FilterPauserAdded and is used to iterate over the raw logs and unpacked data for PauserAdded events raised by the SeigManager contract.
type SeigManagerPauserAddedIterator struct {
	Event *SeigManagerPauserAdded // 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 *SeigManagerPauserAddedIterator) 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(SeigManagerPauserAdded)
			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(SeigManagerPauserAdded)
		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 *SeigManagerPauserAddedIterator) Error() error {
	return it.fail
}

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

// SeigManagerPauserAdded represents a PauserAdded event raised by the SeigManager contract.
type SeigManagerPauserAdded struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterPauserAdded is a free log retrieval operation binding the contract event 0x6719d08c1888103bea251a4ed56406bd0c3e69723c8a1686e017e7bbe159b6f8.
//
// Solidity: event PauserAdded(address indexed account)
func (_SeigManager *SeigManagerFilterer) FilterPauserAdded(opts *bind.FilterOpts, account []common.Address) (*SeigManagerPauserAddedIterator, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _SeigManager.contract.FilterLogs(opts, "PauserAdded", accountRule)
	if err != nil {
		return nil, err
	}
	return &SeigManagerPauserAddedIterator{contract: _SeigManager.contract, event: "PauserAdded", logs: logs, sub: sub}, nil
}

// WatchPauserAdded is a free log subscription operation binding the contract event 0x6719d08c1888103bea251a4ed56406bd0c3e69723c8a1686e017e7bbe159b6f8.
//
// Solidity: event PauserAdded(address indexed account)
func (_SeigManager *SeigManagerFilterer) WatchPauserAdded(opts *bind.WatchOpts, sink chan<- *SeigManagerPauserAdded, account []common.Address) (event.Subscription, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _SeigManager.contract.WatchLogs(opts, "PauserAdded", accountRule)
	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(SeigManagerPauserAdded)
				if err := _SeigManager.contract.UnpackLog(event, "PauserAdded", 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
}

// ParsePauserAdded is a log parse operation binding the contract event 0x6719d08c1888103bea251a4ed56406bd0c3e69723c8a1686e017e7bbe159b6f8.
//
// Solidity: event PauserAdded(address indexed account)
func (_SeigManager *SeigManagerFilterer) ParsePauserAdded(log types.Log) (*SeigManagerPauserAdded, error) {
	event := new(SeigManagerPauserAdded)
	if err := _SeigManager.contract.UnpackLog(event, "PauserAdded", log); err != nil {
		return nil, err
	}
	return event, nil
}

// SeigManagerPauserRemovedIterator is returned from FilterPauserRemoved and is used to iterate over the raw logs and unpacked data for PauserRemoved events raised by the SeigManager contract.
type SeigManagerPauserRemovedIterator struct {
	Event *SeigManagerPauserRemoved // 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 *SeigManagerPauserRemovedIterator) 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(SeigManagerPauserRemoved)
			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(SeigManagerPauserRemoved)
		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 *SeigManagerPauserRemovedIterator) Error() error {
	return it.fail
}

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

// SeigManagerPauserRemoved represents a PauserRemoved event raised by the SeigManager contract.
type SeigManagerPauserRemoved struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterPauserRemoved is a free log retrieval operation binding the contract event 0xcd265ebaf09df2871cc7bd4133404a235ba12eff2041bb89d9c714a2621c7c7e.
//
// Solidity: event PauserRemoved(address indexed account)
func (_SeigManager *SeigManagerFilterer) FilterPauserRemoved(opts *bind.FilterOpts, account []common.Address) (*SeigManagerPauserRemovedIterator, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _SeigManager.contract.FilterLogs(opts, "PauserRemoved", accountRule)
	if err != nil {
		return nil, err
	}
	return &SeigManagerPauserRemovedIterator{contract: _SeigManager.contract, event: "PauserRemoved", logs: logs, sub: sub}, nil
}

// WatchPauserRemoved is a free log subscription operation binding the contract event 0xcd265ebaf09df2871cc7bd4133404a235ba12eff2041bb89d9c714a2621c7c7e.
//
// Solidity: event PauserRemoved(address indexed account)
func (_SeigManager *SeigManagerFilterer) WatchPauserRemoved(opts *bind.WatchOpts, sink chan<- *SeigManagerPauserRemoved, account []common.Address) (event.Subscription, error) {

	var accountRule []interface{}
	for _, accountItem := range account {
		accountRule = append(accountRule, accountItem)
	}

	logs, sub, err := _SeigManager.contract.WatchLogs(opts, "PauserRemoved", accountRule)
	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(SeigManagerPauserRemoved)
				if err := _SeigManager.contract.UnpackLog(event, "PauserRemoved", 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
}

// ParsePauserRemoved is a log parse operation binding the contract event 0xcd265ebaf09df2871cc7bd4133404a235ba12eff2041bb89d9c714a2621c7c7e.
//
// Solidity: event PauserRemoved(address indexed account)
func (_SeigManager *SeigManagerFilterer) ParsePauserRemoved(log types.Log) (*SeigManagerPauserRemoved, error) {
	event := new(SeigManagerPauserRemoved)
	if err := _SeigManager.contract.UnpackLog(event, "PauserRemoved", log); err != nil {
		return nil, err
	}
	return event, nil
}

// SeigManagerSeigGivenIterator is returned from FilterSeigGiven and is used to iterate over the raw logs and unpacked data for SeigGiven events raised by the SeigManager contract.
type SeigManagerSeigGivenIterator struct {
	Event *SeigManagerSeigGiven // 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 *SeigManagerSeigGivenIterator) 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(SeigManagerSeigGiven)
			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(SeigManagerSeigGiven)
		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 *SeigManagerSeigGivenIterator) Error() error {
	return it.fail
}

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

// SeigManagerSeigGiven represents a SeigGiven event raised by the SeigManager contract.
type SeigManagerSeigGiven struct {
	Rootchain    common.Address
	TotalSeig    *big.Int
	StakedSeig   *big.Int
	UnstakedSeig *big.Int
	PowertonSeig *big.Int
	Raw          types.Log // Blockchain specific contextual infos
}

// FilterSeigGiven is a free log retrieval operation binding the contract event 0x73600b95c31a4ed411c84c32eaa15178c77fdcd9d5c8123118e76c03b3dcd63b.
//
// Solidity: event SeigGiven(address indexed rootchain, uint256 totalSeig, uint256 stakedSeig, uint256 unstakedSeig, uint256 powertonSeig)
func (_SeigManager *SeigManagerFilterer) FilterSeigGiven(opts *bind.FilterOpts, rootchain []common.Address) (*SeigManagerSeigGivenIterator, error) {

	var rootchainRule []interface{}
	for _, rootchainItem := range rootchain {
		rootchainRule = append(rootchainRule, rootchainItem)
	}

	logs, sub, err := _SeigManager.contract.FilterLogs(opts, "SeigGiven", rootchainRule)
	if err != nil {
		return nil, err
	}
	return &SeigManagerSeigGivenIterator{contract: _SeigManager.contract, event: "SeigGiven", logs: logs, sub: sub}, nil
}

// WatchSeigGiven is a free log subscription operation binding the contract event 0x73600b95c31a4ed411c84c32eaa15178c77fdcd9d5c8123118e76c03b3dcd63b.
//
// Solidity: event SeigGiven(address indexed rootchain, uint256 totalSeig, uint256 stakedSeig, uint256 unstakedSeig, uint256 powertonSeig)
func (_SeigManager *SeigManagerFilterer) WatchSeigGiven(opts *bind.WatchOpts, sink chan<- *SeigManagerSeigGiven, rootchain []common.Address) (event.Subscription, error) {

	var rootchainRule []interface{}
	for _, rootchainItem := range rootchain {
		rootchainRule = append(rootchainRule, rootchainItem)
	}

	logs, sub, err := _SeigManager.contract.WatchLogs(opts, "SeigGiven", rootchainRule)
	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(SeigManagerSeigGiven)
				if err := _SeigManager.contract.UnpackLog(event, "SeigGiven", 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
}

// ParseSeigGiven is a log parse operation binding the contract event 0x73600b95c31a4ed411c84c32eaa15178c77fdcd9d5c8123118e76c03b3dcd63b.
//
// Solidity: event SeigGiven(address indexed rootchain, uint256 totalSeig, uint256 stakedSeig, uint256 unstakedSeig, uint256 powertonSeig)
func (_SeigManager *SeigManagerFilterer) ParseSeigGiven(log types.Log) (*SeigManagerSeigGiven, error) {
	event := new(SeigManagerSeigGiven)
	if err := _SeigManager.contract.UnpackLog(event, "SeigGiven", log); err != nil {
		return nil, err
	}
	return event, nil
}

// SeigManagerUnpausedIterator is returned from FilterUnpaused and is used to iterate over the raw logs and unpacked data for Unpaused events raised by the SeigManager contract.
type SeigManagerUnpausedIterator struct {
	Event *SeigManagerUnpaused // 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 *SeigManagerUnpausedIterator) 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(SeigManagerUnpaused)
			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(SeigManagerUnpaused)
		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 *SeigManagerUnpausedIterator) Error() error {
	return it.fail
}

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

// SeigManagerUnpaused represents a Unpaused event raised by the SeigManager contract.
type SeigManagerUnpaused struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterUnpaused is a free log retrieval operation binding the contract event 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa.
//
// Solidity: event Unpaused(address account)
func (_SeigManager *SeigManagerFilterer) FilterUnpaused(opts *bind.FilterOpts) (*SeigManagerUnpausedIterator, error) {

	logs, sub, err := _SeigManager.contract.FilterLogs(opts, "Unpaused")
	if err != nil {
		return nil, err
	}
	return &SeigManagerUnpausedIterator{contract: _SeigManager.contract, event: "Unpaused", logs: logs, sub: sub}, nil
}

// WatchUnpaused is a free log subscription operation binding the contract event 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa.
//
// Solidity: event Unpaused(address account)
func (_SeigManager *SeigManagerFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *SeigManagerUnpaused) (event.Subscription, error) {

	logs, sub, err := _SeigManager.contract.WatchLogs(opts, "Unpaused")
	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(SeigManagerUnpaused)
				if err := _SeigManager.contract.UnpackLog(event, "Unpaused", 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
}

// ParseUnpaused is a log parse operation binding the contract event 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa.
//
// Solidity: event Unpaused(address account)
func (_SeigManager *SeigManagerFilterer) ParseUnpaused(log types.Log) (*SeigManagerUnpaused, error) {
	event := new(SeigManagerUnpaused)
	if err := _SeigManager.contract.UnpackLog(event, "Unpaused", log); err != nil {
		return nil, err
	}
	return event, nil
}

// SeigManagerUnstakeLogIterator is returned from FilterUnstakeLog and is used to iterate over the raw logs and unpacked data for UnstakeLog events raised by the SeigManager contract.
type SeigManagerUnstakeLogIterator struct {
	Event *SeigManagerUnstakeLog // 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 *SeigManagerUnstakeLogIterator) 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(SeigManagerUnstakeLog)
			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(SeigManagerUnstakeLog)
		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 *SeigManagerUnstakeLogIterator) Error() error {
	return it.fail
}

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

// SeigManagerUnstakeLog represents a UnstakeLog event raised by the SeigManager contract.
type SeigManagerUnstakeLog struct {
	CoinageBurnAmount *big.Int
	TotBurnAmount     *big.Int
	Raw               types.Log // Blockchain specific contextual infos
}

// FilterUnstakeLog is a free log retrieval operation binding the contract event 0x650f673bb96a43afff4620ecc3f3e38e0cbfddebde9894e951ba2ceff7472f60.
//
// Solidity: event UnstakeLog(uint256 coinageBurnAmount, uint256 totBurnAmount)
func (_SeigManager *SeigManagerFilterer) FilterUnstakeLog(opts *bind.FilterOpts) (*SeigManagerUnstakeLogIterator, error) {

	logs, sub, err := _SeigManager.contract.FilterLogs(opts, "UnstakeLog")
	if err != nil {
		return nil, err
	}
	return &SeigManagerUnstakeLogIterator{contract: _SeigManager.contract, event: "UnstakeLog", logs: logs, sub: sub}, nil
}

// WatchUnstakeLog is a free log subscription operation binding the contract event 0x650f673bb96a43afff4620ecc3f3e38e0cbfddebde9894e951ba2ceff7472f60.
//
// Solidity: event UnstakeLog(uint256 coinageBurnAmount, uint256 totBurnAmount)
func (_SeigManager *SeigManagerFilterer) WatchUnstakeLog(opts *bind.WatchOpts, sink chan<- *SeigManagerUnstakeLog) (event.Subscription, error) {

	logs, sub, err := _SeigManager.contract.WatchLogs(opts, "UnstakeLog")
	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(SeigManagerUnstakeLog)
				if err := _SeigManager.contract.UnpackLog(event, "UnstakeLog", 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
}

// ParseUnstakeLog is a log parse operation binding the contract event 0x650f673bb96a43afff4620ecc3f3e38e0cbfddebde9894e951ba2ceff7472f60.
//
// Solidity: event UnstakeLog(uint256 coinageBurnAmount, uint256 totBurnAmount)
func (_SeigManager *SeigManagerFilterer) ParseUnstakeLog(log types.Log) (*SeigManagerUnstakeLog, error) {
	event := new(SeigManagerUnstakeLog)
	if err := _SeigManager.contract.UnpackLog(event, "UnstakeLog", log); err != nil {
		return nil, err
	}
	return event, nil
}

// SeigManagerIABI is the input ABI used to generate the binding from.
const SeigManagerIABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"DEFAULT_FACTOR\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"additionalTotBurnAmount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"totAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"coinages\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"commissionRates\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"deployCoinage\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"depositManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"lastCommitBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"lastSeigBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"onCommit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"onDeposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"onTransfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"onWithdraw\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"pausedBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"powerton\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"registry\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"seigPerBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"commission\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"isCommissionRateNegative\",\"type\":\"bool\"}],\"name\":\"setCommissionRate\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"stakeOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"ton\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"tot\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"uncomittedStakeOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"unpausedBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"wton\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"

// SeigManagerIFuncSigs maps the 4-byte function signature to its string representation.
var SeigManagerIFuncSigs = map[string]string{
	"8bf91dc4": "DEFAULT_FACTOR()",
	"48c8577e": "additionalTotBurnAmount(address,address,uint256)",
	"4c063c19": "coinages(address)",
	"7b056c1b": "commissionRates(address)",
	"833a774f": "deployCoinage(address)",
	"6c7ac9d8": "depositManager()",
	"c59f1046": "lastCommitBlock(address)",
	"f35c89e8": "lastSeigBlock()",
	"359c4d59": "onCommit()",
	"412c6d50": "onDeposit(address,address,uint256)",
	"4a393149": "onTransfer(address,address,uint256)",
	"f850ffaa": "onWithdraw(address,address,uint256)",
	"32053c99": "pausedBlock()",
	"3e832e1d": "powerton()",
	"7b103999": "registry()",
	"5f40a349": "seigPerBlock()",
	"4224ed66": "setCommissionRate(address,uint256,bool)",
	"ce4cb876": "stakeOf(address,address)",
	"cc48b947": "ton()",
	"a16d6aa7": "tot()",
	"fa9789c8": "uncomittedStakeOf(address,address)",
	"1cc47890": "unpausedBlock()",
	"8d62d949": "wton()",
}

// SeigManagerI is an auto generated Go binding around an Ethereum contract.
type SeigManagerI struct {
	SeigManagerICaller     // Read-only binding to the contract
	SeigManagerITransactor // Write-only binding to the contract
	SeigManagerIFilterer   // Log filterer for contract events
}

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

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

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

// SeigManagerISession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type SeigManagerISession struct {
	Contract     *SeigManagerI     // 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
}

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

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

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

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

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

// NewSeigManagerI creates a new instance of SeigManagerI, bound to a specific deployed contract.
func NewSeigManagerI(address common.Address, backend bind.ContractBackend) (*SeigManagerI, error) {
	contract, err := bindSeigManagerI(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &SeigManagerI{SeigManagerICaller: SeigManagerICaller{contract: contract}, SeigManagerITransactor: SeigManagerITransactor{contract: contract}, SeigManagerIFilterer: SeigManagerIFilterer{contract: contract}}, nil
}

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

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

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

// bindSeigManagerI binds a generic wrapper to an already deployed contract.
func bindSeigManagerI(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(SeigManagerIABI))
	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 (_SeigManagerI *SeigManagerIRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _SeigManagerI.Contract.SeigManagerICaller.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 (_SeigManagerI *SeigManagerIRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _SeigManagerI.Contract.SeigManagerITransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_SeigManagerI *SeigManagerIRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _SeigManagerI.Contract.SeigManagerITransactor.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 (_SeigManagerI *SeigManagerICallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
	return _SeigManagerI.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 (_SeigManagerI *SeigManagerITransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _SeigManagerI.Contract.contract.Transfer(opts)
}

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

// DEFAULTFACTOR is a free data retrieval call binding the contract method 0x8bf91dc4.
//
// Solidity: function DEFAULT_FACTOR() constant returns(uint256)
func (_SeigManagerI *SeigManagerICaller) DEFAULTFACTOR(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManagerI.contract.Call(opts, out, "DEFAULT_FACTOR")
	return *ret0, err
}

// DEFAULTFACTOR is a free data retrieval call binding the contract method 0x8bf91dc4.
//
// Solidity: function DEFAULT_FACTOR() constant returns(uint256)
func (_SeigManagerI *SeigManagerISession) DEFAULTFACTOR() (*big.Int, error) {
	return _SeigManagerI.Contract.DEFAULTFACTOR(&_SeigManagerI.CallOpts)
}

// DEFAULTFACTOR is a free data retrieval call binding the contract method 0x8bf91dc4.
//
// Solidity: function DEFAULT_FACTOR() constant returns(uint256)
func (_SeigManagerI *SeigManagerICallerSession) DEFAULTFACTOR() (*big.Int, error) {
	return _SeigManagerI.Contract.DEFAULTFACTOR(&_SeigManagerI.CallOpts)
}

// AdditionalTotBurnAmount is a free data retrieval call binding the contract method 0x48c8577e.
//
// Solidity: function additionalTotBurnAmount(address rootchain, address account, uint256 amount) constant returns(uint256 totAmount)
func (_SeigManagerI *SeigManagerICaller) AdditionalTotBurnAmount(opts *bind.CallOpts, rootchain common.Address, account common.Address, amount *big.Int) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManagerI.contract.Call(opts, out, "additionalTotBurnAmount", rootchain, account, amount)
	return *ret0, err
}

// AdditionalTotBurnAmount is a free data retrieval call binding the contract method 0x48c8577e.
//
// Solidity: function additionalTotBurnAmount(address rootchain, address account, uint256 amount) constant returns(uint256 totAmount)
func (_SeigManagerI *SeigManagerISession) AdditionalTotBurnAmount(rootchain common.Address, account common.Address, amount *big.Int) (*big.Int, error) {
	return _SeigManagerI.Contract.AdditionalTotBurnAmount(&_SeigManagerI.CallOpts, rootchain, account, amount)
}

// AdditionalTotBurnAmount is a free data retrieval call binding the contract method 0x48c8577e.
//
// Solidity: function additionalTotBurnAmount(address rootchain, address account, uint256 amount) constant returns(uint256 totAmount)
func (_SeigManagerI *SeigManagerICallerSession) AdditionalTotBurnAmount(rootchain common.Address, account common.Address, amount *big.Int) (*big.Int, error) {
	return _SeigManagerI.Contract.AdditionalTotBurnAmount(&_SeigManagerI.CallOpts, rootchain, account, amount)
}

// Coinages is a free data retrieval call binding the contract method 0x4c063c19.
//
// Solidity: function coinages(address rootchain) constant returns(address)
func (_SeigManagerI *SeigManagerICaller) Coinages(opts *bind.CallOpts, rootchain common.Address) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _SeigManagerI.contract.Call(opts, out, "coinages", rootchain)
	return *ret0, err
}

// Coinages is a free data retrieval call binding the contract method 0x4c063c19.
//
// Solidity: function coinages(address rootchain) constant returns(address)
func (_SeigManagerI *SeigManagerISession) Coinages(rootchain common.Address) (common.Address, error) {
	return _SeigManagerI.Contract.Coinages(&_SeigManagerI.CallOpts, rootchain)
}

// Coinages is a free data retrieval call binding the contract method 0x4c063c19.
//
// Solidity: function coinages(address rootchain) constant returns(address)
func (_SeigManagerI *SeigManagerICallerSession) Coinages(rootchain common.Address) (common.Address, error) {
	return _SeigManagerI.Contract.Coinages(&_SeigManagerI.CallOpts, rootchain)
}

// CommissionRates is a free data retrieval call binding the contract method 0x7b056c1b.
//
// Solidity: function commissionRates(address rootchain) constant returns(uint256)
func (_SeigManagerI *SeigManagerICaller) CommissionRates(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManagerI.contract.Call(opts, out, "commissionRates", rootchain)
	return *ret0, err
}

// CommissionRates is a free data retrieval call binding the contract method 0x7b056c1b.
//
// Solidity: function commissionRates(address rootchain) constant returns(uint256)
func (_SeigManagerI *SeigManagerISession) CommissionRates(rootchain common.Address) (*big.Int, error) {
	return _SeigManagerI.Contract.CommissionRates(&_SeigManagerI.CallOpts, rootchain)
}

// CommissionRates is a free data retrieval call binding the contract method 0x7b056c1b.
//
// Solidity: function commissionRates(address rootchain) constant returns(uint256)
func (_SeigManagerI *SeigManagerICallerSession) CommissionRates(rootchain common.Address) (*big.Int, error) {
	return _SeigManagerI.Contract.CommissionRates(&_SeigManagerI.CallOpts, rootchain)
}

// DepositManager is a free data retrieval call binding the contract method 0x6c7ac9d8.
//
// Solidity: function depositManager() constant returns(address)
func (_SeigManagerI *SeigManagerICaller) DepositManager(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _SeigManagerI.contract.Call(opts, out, "depositManager")
	return *ret0, err
}

// DepositManager is a free data retrieval call binding the contract method 0x6c7ac9d8.
//
// Solidity: function depositManager() constant returns(address)
func (_SeigManagerI *SeigManagerISession) DepositManager() (common.Address, error) {
	return _SeigManagerI.Contract.DepositManager(&_SeigManagerI.CallOpts)
}

// DepositManager is a free data retrieval call binding the contract method 0x6c7ac9d8.
//
// Solidity: function depositManager() constant returns(address)
func (_SeigManagerI *SeigManagerICallerSession) DepositManager() (common.Address, error) {
	return _SeigManagerI.Contract.DepositManager(&_SeigManagerI.CallOpts)
}

// LastCommitBlock is a free data retrieval call binding the contract method 0xc59f1046.
//
// Solidity: function lastCommitBlock(address rootchain) constant returns(uint256)
func (_SeigManagerI *SeigManagerICaller) LastCommitBlock(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManagerI.contract.Call(opts, out, "lastCommitBlock", rootchain)
	return *ret0, err
}

// LastCommitBlock is a free data retrieval call binding the contract method 0xc59f1046.
//
// Solidity: function lastCommitBlock(address rootchain) constant returns(uint256)
func (_SeigManagerI *SeigManagerISession) LastCommitBlock(rootchain common.Address) (*big.Int, error) {
	return _SeigManagerI.Contract.LastCommitBlock(&_SeigManagerI.CallOpts, rootchain)
}

// LastCommitBlock is a free data retrieval call binding the contract method 0xc59f1046.
//
// Solidity: function lastCommitBlock(address rootchain) constant returns(uint256)
func (_SeigManagerI *SeigManagerICallerSession) LastCommitBlock(rootchain common.Address) (*big.Int, error) {
	return _SeigManagerI.Contract.LastCommitBlock(&_SeigManagerI.CallOpts, rootchain)
}

// LastSeigBlock is a free data retrieval call binding the contract method 0xf35c89e8.
//
// Solidity: function lastSeigBlock() constant returns(uint256)
func (_SeigManagerI *SeigManagerICaller) LastSeigBlock(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManagerI.contract.Call(opts, out, "lastSeigBlock")
	return *ret0, err
}

// LastSeigBlock is a free data retrieval call binding the contract method 0xf35c89e8.
//
// Solidity: function lastSeigBlock() constant returns(uint256)
func (_SeigManagerI *SeigManagerISession) LastSeigBlock() (*big.Int, error) {
	return _SeigManagerI.Contract.LastSeigBlock(&_SeigManagerI.CallOpts)
}

// LastSeigBlock is a free data retrieval call binding the contract method 0xf35c89e8.
//
// Solidity: function lastSeigBlock() constant returns(uint256)
func (_SeigManagerI *SeigManagerICallerSession) LastSeigBlock() (*big.Int, error) {
	return _SeigManagerI.Contract.LastSeigBlock(&_SeigManagerI.CallOpts)
}

// PausedBlock is a free data retrieval call binding the contract method 0x32053c99.
//
// Solidity: function pausedBlock() constant returns(uint256)
func (_SeigManagerI *SeigManagerICaller) PausedBlock(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManagerI.contract.Call(opts, out, "pausedBlock")
	return *ret0, err
}

// PausedBlock is a free data retrieval call binding the contract method 0x32053c99.
//
// Solidity: function pausedBlock() constant returns(uint256)
func (_SeigManagerI *SeigManagerISession) PausedBlock() (*big.Int, error) {
	return _SeigManagerI.Contract.PausedBlock(&_SeigManagerI.CallOpts)
}

// PausedBlock is a free data retrieval call binding the contract method 0x32053c99.
//
// Solidity: function pausedBlock() constant returns(uint256)
func (_SeigManagerI *SeigManagerICallerSession) PausedBlock() (*big.Int, error) {
	return _SeigManagerI.Contract.PausedBlock(&_SeigManagerI.CallOpts)
}

// Powerton is a free data retrieval call binding the contract method 0x3e832e1d.
//
// Solidity: function powerton() constant returns(address)
func (_SeigManagerI *SeigManagerICaller) Powerton(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _SeigManagerI.contract.Call(opts, out, "powerton")
	return *ret0, err
}

// Powerton is a free data retrieval call binding the contract method 0x3e832e1d.
//
// Solidity: function powerton() constant returns(address)
func (_SeigManagerI *SeigManagerISession) Powerton() (common.Address, error) {
	return _SeigManagerI.Contract.Powerton(&_SeigManagerI.CallOpts)
}

// Powerton is a free data retrieval call binding the contract method 0x3e832e1d.
//
// Solidity: function powerton() constant returns(address)
func (_SeigManagerI *SeigManagerICallerSession) Powerton() (common.Address, error) {
	return _SeigManagerI.Contract.Powerton(&_SeigManagerI.CallOpts)
}

// Registry is a free data retrieval call binding the contract method 0x7b103999.
//
// Solidity: function registry() constant returns(address)
func (_SeigManagerI *SeigManagerICaller) Registry(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _SeigManagerI.contract.Call(opts, out, "registry")
	return *ret0, err
}

// Registry is a free data retrieval call binding the contract method 0x7b103999.
//
// Solidity: function registry() constant returns(address)
func (_SeigManagerI *SeigManagerISession) Registry() (common.Address, error) {
	return _SeigManagerI.Contract.Registry(&_SeigManagerI.CallOpts)
}

// Registry is a free data retrieval call binding the contract method 0x7b103999.
//
// Solidity: function registry() constant returns(address)
func (_SeigManagerI *SeigManagerICallerSession) Registry() (common.Address, error) {
	return _SeigManagerI.Contract.Registry(&_SeigManagerI.CallOpts)
}

// SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349.
//
// Solidity: function seigPerBlock() constant returns(uint256)
func (_SeigManagerI *SeigManagerICaller) SeigPerBlock(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManagerI.contract.Call(opts, out, "seigPerBlock")
	return *ret0, err
}

// SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349.
//
// Solidity: function seigPerBlock() constant returns(uint256)
func (_SeigManagerI *SeigManagerISession) SeigPerBlock() (*big.Int, error) {
	return _SeigManagerI.Contract.SeigPerBlock(&_SeigManagerI.CallOpts)
}

// SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349.
//
// Solidity: function seigPerBlock() constant returns(uint256)
func (_SeigManagerI *SeigManagerICallerSession) SeigPerBlock() (*big.Int, error) {
	return _SeigManagerI.Contract.SeigPerBlock(&_SeigManagerI.CallOpts)
}

// StakeOf is a free data retrieval call binding the contract method 0xce4cb876.
//
// Solidity: function stakeOf(address rootchain, address account) constant returns(uint256)
func (_SeigManagerI *SeigManagerICaller) StakeOf(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManagerI.contract.Call(opts, out, "stakeOf", rootchain, account)
	return *ret0, err
}

// StakeOf is a free data retrieval call binding the contract method 0xce4cb876.
//
// Solidity: function stakeOf(address rootchain, address account) constant returns(uint256)
func (_SeigManagerI *SeigManagerISession) StakeOf(rootchain common.Address, account common.Address) (*big.Int, error) {
	return _SeigManagerI.Contract.StakeOf(&_SeigManagerI.CallOpts, rootchain, account)
}

// StakeOf is a free data retrieval call binding the contract method 0xce4cb876.
//
// Solidity: function stakeOf(address rootchain, address account) constant returns(uint256)
func (_SeigManagerI *SeigManagerICallerSession) StakeOf(rootchain common.Address, account common.Address) (*big.Int, error) {
	return _SeigManagerI.Contract.StakeOf(&_SeigManagerI.CallOpts, rootchain, account)
}

// Ton is a free data retrieval call binding the contract method 0xcc48b947.
//
// Solidity: function ton() constant returns(address)
func (_SeigManagerI *SeigManagerICaller) Ton(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _SeigManagerI.contract.Call(opts, out, "ton")
	return *ret0, err
}

// Ton is a free data retrieval call binding the contract method 0xcc48b947.
//
// Solidity: function ton() constant returns(address)
func (_SeigManagerI *SeigManagerISession) Ton() (common.Address, error) {
	return _SeigManagerI.Contract.Ton(&_SeigManagerI.CallOpts)
}

// Ton is a free data retrieval call binding the contract method 0xcc48b947.
//
// Solidity: function ton() constant returns(address)
func (_SeigManagerI *SeigManagerICallerSession) Ton() (common.Address, error) {
	return _SeigManagerI.Contract.Ton(&_SeigManagerI.CallOpts)
}

// Tot is a free data retrieval call binding the contract method 0xa16d6aa7.
//
// Solidity: function tot() constant returns(address)
func (_SeigManagerI *SeigManagerICaller) Tot(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _SeigManagerI.contract.Call(opts, out, "tot")
	return *ret0, err
}

// Tot is a free data retrieval call binding the contract method 0xa16d6aa7.
//
// Solidity: function tot() constant returns(address)
func (_SeigManagerI *SeigManagerISession) Tot() (common.Address, error) {
	return _SeigManagerI.Contract.Tot(&_SeigManagerI.CallOpts)
}

// Tot is a free data retrieval call binding the contract method 0xa16d6aa7.
//
// Solidity: function tot() constant returns(address)
func (_SeigManagerI *SeigManagerICallerSession) Tot() (common.Address, error) {
	return _SeigManagerI.Contract.Tot(&_SeigManagerI.CallOpts)
}

// UncomittedStakeOf is a free data retrieval call binding the contract method 0xfa9789c8.
//
// Solidity: function uncomittedStakeOf(address rootchain, address account) constant returns(uint256)
func (_SeigManagerI *SeigManagerICaller) UncomittedStakeOf(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManagerI.contract.Call(opts, out, "uncomittedStakeOf", rootchain, account)
	return *ret0, err
}

// UncomittedStakeOf is a free data retrieval call binding the contract method 0xfa9789c8.
//
// Solidity: function uncomittedStakeOf(address rootchain, address account) constant returns(uint256)
func (_SeigManagerI *SeigManagerISession) UncomittedStakeOf(rootchain common.Address, account common.Address) (*big.Int, error) {
	return _SeigManagerI.Contract.UncomittedStakeOf(&_SeigManagerI.CallOpts, rootchain, account)
}

// UncomittedStakeOf is a free data retrieval call binding the contract method 0xfa9789c8.
//
// Solidity: function uncomittedStakeOf(address rootchain, address account) constant returns(uint256)
func (_SeigManagerI *SeigManagerICallerSession) UncomittedStakeOf(rootchain common.Address, account common.Address) (*big.Int, error) {
	return _SeigManagerI.Contract.UncomittedStakeOf(&_SeigManagerI.CallOpts, rootchain, account)
}

// UnpausedBlock is a free data retrieval call binding the contract method 0x1cc47890.
//
// Solidity: function unpausedBlock() constant returns(uint256)
func (_SeigManagerI *SeigManagerICaller) UnpausedBlock(opts *bind.CallOpts) (*big.Int, error) {
	var (
		ret0 = new(*big.Int)
	)
	out := ret0
	err := _SeigManagerI.contract.Call(opts, out, "unpausedBlock")
	return *ret0, err
}

// UnpausedBlock is a free data retrieval call binding the contract method 0x1cc47890.
//
// Solidity: function unpausedBlock() constant returns(uint256)
func (_SeigManagerI *SeigManagerISession) UnpausedBlock() (*big.Int, error) {
	return _SeigManagerI.Contract.UnpausedBlock(&_SeigManagerI.CallOpts)
}

// UnpausedBlock is a free data retrieval call binding the contract method 0x1cc47890.
//
// Solidity: function unpausedBlock() constant returns(uint256)
func (_SeigManagerI *SeigManagerICallerSession) UnpausedBlock() (*big.Int, error) {
	return _SeigManagerI.Contract.UnpausedBlock(&_SeigManagerI.CallOpts)
}

// Wton is a free data retrieval call binding the contract method 0x8d62d949.
//
// Solidity: function wton() constant returns(address)
func (_SeigManagerI *SeigManagerICaller) Wton(opts *bind.CallOpts) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _SeigManagerI.contract.Call(opts, out, "wton")
	return *ret0, err
}

// Wton is a free data retrieval call binding the contract method 0x8d62d949.
//
// Solidity: function wton() constant returns(address)
func (_SeigManagerI *SeigManagerISession) Wton() (common.Address, error) {
	return _SeigManagerI.Contract.Wton(&_SeigManagerI.CallOpts)
}

// Wton is a free data retrieval call binding the contract method 0x8d62d949.
//
// Solidity: function wton() constant returns(address)
func (_SeigManagerI *SeigManagerICallerSession) Wton() (common.Address, error) {
	return _SeigManagerI.Contract.Wton(&_SeigManagerI.CallOpts)
}

// DeployCoinage is a paid mutator transaction binding the contract method 0x833a774f.
//
// Solidity: function deployCoinage(address rootchain) returns(bool)
func (_SeigManagerI *SeigManagerITransactor) DeployCoinage(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) {
	return _SeigManagerI.contract.Transact(opts, "deployCoinage", rootchain)
}

// DeployCoinage is a paid mutator transaction binding the contract method 0x833a774f.
//
// Solidity: function deployCoinage(address rootchain) returns(bool)
func (_SeigManagerI *SeigManagerISession) DeployCoinage(rootchain common.Address) (*types.Transaction, error) {
	return _SeigManagerI.Contract.DeployCoinage(&_SeigManagerI.TransactOpts, rootchain)
}

// DeployCoinage is a paid mutator transaction binding the contract method 0x833a774f.
//
// Solidity: function deployCoinage(address rootchain) returns(bool)
func (_SeigManagerI *SeigManagerITransactorSession) DeployCoinage(rootchain common.Address) (*types.Transaction, error) {
	return _SeigManagerI.Contract.DeployCoinage(&_SeigManagerI.TransactOpts, rootchain)
}

// OnCommit is a paid mutator transaction binding the contract method 0x359c4d59.
//
// Solidity: function onCommit() returns(bool)
func (_SeigManagerI *SeigManagerITransactor) OnCommit(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _SeigManagerI.contract.Transact(opts, "onCommit")
}

// OnCommit is a paid mutator transaction binding the contract method 0x359c4d59.
//
// Solidity: function onCommit() returns(bool)
func (_SeigManagerI *SeigManagerISession) OnCommit() (*types.Transaction, error) {
	return _SeigManagerI.Contract.OnCommit(&_SeigManagerI.TransactOpts)
}

// OnCommit is a paid mutator transaction binding the contract method 0x359c4d59.
//
// Solidity: function onCommit() returns(bool)
func (_SeigManagerI *SeigManagerITransactorSession) OnCommit() (*types.Transaction, error) {
	return _SeigManagerI.Contract.OnCommit(&_SeigManagerI.TransactOpts)
}

// OnDeposit is a paid mutator transaction binding the contract method 0x412c6d50.
//
// Solidity: function onDeposit(address rootchain, address account, uint256 amount) returns(bool)
func (_SeigManagerI *SeigManagerITransactor) OnDeposit(opts *bind.TransactOpts, rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _SeigManagerI.contract.Transact(opts, "onDeposit", rootchain, account, amount)
}

// OnDeposit is a paid mutator transaction binding the contract method 0x412c6d50.
//
// Solidity: function onDeposit(address rootchain, address account, uint256 amount) returns(bool)
func (_SeigManagerI *SeigManagerISession) OnDeposit(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _SeigManagerI.Contract.OnDeposit(&_SeigManagerI.TransactOpts, rootchain, account, amount)
}

// OnDeposit is a paid mutator transaction binding the contract method 0x412c6d50.
//
// Solidity: function onDeposit(address rootchain, address account, uint256 amount) returns(bool)
func (_SeigManagerI *SeigManagerITransactorSession) OnDeposit(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _SeigManagerI.Contract.OnDeposit(&_SeigManagerI.TransactOpts, rootchain, account, amount)
}

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

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

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

// OnWithdraw is a paid mutator transaction binding the contract method 0xf850ffaa.
//
// Solidity: function onWithdraw(address rootchain, address account, uint256 amount) returns(bool)
func (_SeigManagerI *SeigManagerITransactor) OnWithdraw(opts *bind.TransactOpts, rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _SeigManagerI.contract.Transact(opts, "onWithdraw", rootchain, account, amount)
}

// OnWithdraw is a paid mutator transaction binding the contract method 0xf850ffaa.
//
// Solidity: function onWithdraw(address rootchain, address account, uint256 amount) returns(bool)
func (_SeigManagerI *SeigManagerISession) OnWithdraw(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _SeigManagerI.Contract.OnWithdraw(&_SeigManagerI.TransactOpts, rootchain, account, amount)
}

// OnWithdraw is a paid mutator transaction binding the contract method 0xf850ffaa.
//
// Solidity: function onWithdraw(address rootchain, address account, uint256 amount) returns(bool)
func (_SeigManagerI *SeigManagerITransactorSession) OnWithdraw(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
	return _SeigManagerI.Contract.OnWithdraw(&_SeigManagerI.TransactOpts, rootchain, account, amount)
}

// SetCommissionRate is a paid mutator transaction binding the contract method 0x4224ed66.
//
// Solidity: function setCommissionRate(address rootchain, uint256 commission, bool isCommissionRateNegative) returns(bool)
func (_SeigManagerI *SeigManagerITransactor) SetCommissionRate(opts *bind.TransactOpts, rootchain common.Address, commission *big.Int, isCommissionRateNegative bool) (*types.Transaction, error) {
	return _SeigManagerI.contract.Transact(opts, "setCommissionRate", rootchain, commission, isCommissionRateNegative)
}

// SetCommissionRate is a paid mutator transaction binding the contract method 0x4224ed66.
//
// Solidity: function setCommissionRate(address rootchain, uint256 commission, bool isCommissionRateNegative) returns(bool)
func (_SeigManagerI *SeigManagerISession) SetCommissionRate(rootchain common.Address, commission *big.Int, isCommissionRateNegative bool) (*types.Transaction, error) {
	return _SeigManagerI.Contract.SetCommissionRate(&_SeigManagerI.TransactOpts, rootchain, commission, isCommissionRateNegative)
}

// SetCommissionRate is a paid mutator transaction binding the contract method 0x4224ed66.
//
// Solidity: function setCommissionRate(address rootchain, uint256 commission, bool isCommissionRateNegative) returns(bool)
func (_SeigManagerI *SeigManagerITransactorSession) SetCommissionRate(rootchain common.Address, commission *big.Int, isCommissionRateNegative bool) (*types.Transaction, error) {
	return _SeigManagerI.Contract.SetCommissionRate(&_SeigManagerI.TransactOpts, rootchain, commission, isCommissionRateNegative)
}

// TokenControllerABI is the input ABI used to generate the binding from.
const TokenControllerABI = "[{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"onApprove\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"onTransfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"proxyPayment\",\"outputs\":[{\"internalType\":\"bool\",\"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) 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) 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) returns(bool)
func (_TokenController *TokenControllerTransactorSession) ProxyPayment(_owner common.Address) (*types.Transaction, error) {
	return _TokenController.Contract.ProxyPayment(&_TokenController.TransactOpts, _owner)
}