func (_BColor *BColorRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _BColor.Contract.BColorCaller.contract.Call(opts, result, 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.
package balancer
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 BBronzeABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"getColor\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"
var BBronzeFuncSigs = map[string]string{
	"9a86139b": "getColor()",
}
var BBronzeBin = "0x6080604052348015600f57600080fd5b5060878061001e6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c80639a86139b14602d575b600080fd5b60336045565b60408051918252519081900360200190f35b6542524f4e5a4560d01b9056fea265627a7a72315820d3d552b78e7b2e77e5322e2b4f9dd135223e46ccfe5175ad6ad1064b13640ce664736f6c634300050c0032"
func DeployBBronze(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *BBronze, error) {
	parsed, err := abi.JSON(strings.NewReader(BBronzeABI))
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(BBronzeBin), backend)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &BBronze{BBronzeCaller: BBronzeCaller{contract: contract}, BBronzeTransactor: BBronzeTransactor{contract: contract}, BBronzeFilterer: BBronzeFilterer{contract: contract}}, nil
}
type BBronze struct {
	BBronzeCaller      
	BBronzeTransactor  
	BBronzeFilterer    
}
type BBronzeCaller struct {
	contract *bind.BoundContract  
}
type BBronzeTransactor struct {
	contract *bind.BoundContract  
}
type BBronzeFilterer struct {
	contract *bind.BoundContract  
}
type BBronzeSession struct {
	Contract     *BBronze           
	CallOpts     bind.CallOpts      
	TransactOpts bind.TransactOpts  
}
type BBronzeCallerSession struct {
	Contract *BBronzeCaller  
	CallOpts bind.CallOpts   
}
type BBronzeTransactorSession struct {
	Contract     *BBronzeTransactor  
	TransactOpts bind.TransactOpts   
}
type BBronzeRaw struct {
	Contract *BBronze  
}
type BBronzeCallerRaw struct {
	Contract *BBronzeCaller  
}
type BBronzeTransactorRaw struct {
	Contract *BBronzeTransactor  
}
func NewBBronze(address common.Address, backend bind.ContractBackend) (*BBronze, error) {
	contract, err := bindBBronze(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &BBronze{BBronzeCaller: BBronzeCaller{contract: contract}, BBronzeTransactor: BBronzeTransactor{contract: contract}, BBronzeFilterer: BBronzeFilterer{contract: contract}}, nil
}
func NewBBronzeCaller(address common.Address, caller bind.ContractCaller) (*BBronzeCaller, error) {
	contract, err := bindBBronze(address, caller, nil, nil)
	if err != nil {
		return nil, err
	}
	return &BBronzeCaller{contract: contract}, nil
}
func NewBBronzeTransactor(address common.Address, transactor bind.ContractTransactor) (*BBronzeTransactor, error) {
	contract, err := bindBBronze(address, nil, transactor, nil)
	if err != nil {
		return nil, err
	}
	return &BBronzeTransactor{contract: contract}, nil
}
func NewBBronzeFilterer(address common.Address, filterer bind.ContractFilterer) (*BBronzeFilterer, error) {
	contract, err := bindBBronze(address, nil, nil, filterer)
	if err != nil {
		return nil, err
	}
	return &BBronzeFilterer{contract: contract}, nil
}
func bindBBronze(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(BBronzeABI))
	if err != nil {
		return nil, err
	}
	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
}
func (_BBronze *BBronzeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _BBronze.Contract.BBronzeCaller.contract.Call(opts, result, method, params...)
}
func (_BBronze *BBronzeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _BBronze.Contract.BBronzeTransactor.contract.Transfer(opts)
}
func (_BBronze *BBronzeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _BBronze.Contract.BBronzeTransactor.contract.Transact(opts, method, params...)
}
func (_BBronze *BBronzeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _BBronze.Contract.contract.Call(opts, result, method, params...)
}
func (_BBronze *BBronzeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _BBronze.Contract.contract.Transfer(opts)
}
func (_BBronze *BBronzeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _BBronze.Contract.contract.Transact(opts, method, params...)
}
func (_BBronze *BBronzeCaller) GetColor(opts *bind.CallOpts) ([32]byte, error) {
	var out []interface{}
	err := _BBronze.contract.Call(opts, &out, "getColor")
	if err != nil {
		return *new([32]byte), err
	}
	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
	return out0, err
}
func (_BBronze *BBronzeSession) GetColor() ([32]byte, error) {
	return _BBronze.Contract.GetColor(&_BBronze.CallOpts)
}
func (_BBronze *BBronzeCallerSession) GetColor() ([32]byte, error) {
	return _BBronze.Contract.GetColor(&_BBronze.CallOpts)
}
const BColorABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"getColor\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"
var BColorFuncSigs = map[string]string{
	"9a86139b": "getColor()",
}
type BColor struct {
	BColorCaller      
	BColorTransactor  
	BColorFilterer    
}
type BColorCaller struct {
	contract *bind.BoundContract  
}
type BColorTransactor struct {
	contract *bind.BoundContract  
}
type BColorFilterer struct {
	contract *bind.BoundContract  
}
type BColorSession struct {
	Contract     *BColor            
	CallOpts     bind.CallOpts      
	TransactOpts bind.TransactOpts  
}
type BColorCallerSession struct {
	Contract *BColorCaller  
	CallOpts bind.CallOpts  
}
type BColorTransactorSession struct {
	Contract     *BColorTransactor  
	TransactOpts bind.TransactOpts  
}
type BColorRaw struct {
	Contract *BColor  
}
type BColorCallerRaw struct {
	Contract *BColorCaller  
}
type BColorTransactorRaw struct {
	Contract *BColorTransactor  
}
func NewBColor(address common.Address, backend bind.ContractBackend) (*BColor, error) {
	contract, err := bindBColor(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &BColor{BColorCaller: BColorCaller{contract: contract}, BColorTransactor: BColorTransactor{contract: contract}, BColorFilterer: BColorFilterer{contract: contract}}, nil
}
func NewBColorCaller(address common.Address, caller bind.ContractCaller) (*BColorCaller, error) {
	contract, err := bindBColor(address, caller, nil, nil)
	if err != nil {
		return nil, err
	}
	return &BColorCaller{contract: contract}, nil
}
func NewBColorTransactor(address common.Address, transactor bind.ContractTransactor) (*BColorTransactor, error) {
	contract, err := bindBColor(address, nil, transactor, nil)
	if err != nil {
		return nil, err
	}
	return &BColorTransactor{contract: contract}, nil
}
func NewBColorFilterer(address common.Address, filterer bind.ContractFilterer) (*BColorFilterer, error) {
	contract, err := bindBColor(address, nil, nil, filterer)
	if err != nil {
		return nil, err
	}
	return &BColorFilterer{contract: contract}, nil
}
func bindBColor(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(BColorABI))
	if err != nil {
		return nil, err
	}
	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
}