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
}
NewAddressFilterer creates a new log filterer instance of Address, bound to a specific deployed contract.
package peruntoken
import (
	"math/big"
	"strings"
	ethereum "github.com/ethereum/go-ethereum"
	"github.com/ethereum/go-ethereum/accounts/abi"
	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/event"
)
var (
	_ = big.NewInt
	_ = strings.NewReader
	_ = ethereum.NotFound
	_ = bind.Bind
	_ = common.Big1
	_ = types.BloomLookup
	_ = event.NewSubscription
)
const AddressABI = "[]"
var AddressBin = "0x60566023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220a66ed51987e807a004421fbf3f7c10a448049e1a0fc8b6dcb32f19f6c06fbe0964736f6c63430007040033"
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
}
type Address struct {
	AddressCaller      
	AddressTransactor  
	AddressFilterer    
}
type AddressCaller struct {
	contract *bind.BoundContract  
}
type AddressTransactor struct {
	contract *bind.BoundContract  
}
type AddressFilterer struct {
	contract *bind.BoundContract  
}
type AddressSession struct {
	Contract     *Address           
	CallOpts     bind.CallOpts      
	TransactOpts bind.TransactOpts  
}
type AddressCallerSession struct {
	Contract *AddressCaller  
	CallOpts bind.CallOpts   
}
type AddressTransactorSession struct {
	Contract     *AddressTransactor  
	TransactOpts bind.TransactOpts   
}
type AddressRaw struct {
	Contract *Address  
}
type AddressCallerRaw struct {
	Contract *AddressCaller  
}
type AddressTransactorRaw struct {
	Contract *AddressTransactor  
}
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
}
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
}
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
}