[
{
    "anonymous": false,
    "inputs": [
        {
            "indexed": false,
            "name": "version",
            "type": "string"
        },
        {
            "indexed": true,
            "name": "implementation",
            "type": "address"
        }
    ],
    "name": "Upgraded",
    "type": "event"
},
{
    "constant": false,
    "inputs": [
        {
            "name": "newOwner",
            "type": "address"
        }
    ],
    "name": "transferProxyOwnership",
    "outputs": [],
    "payable": false,
    "stateMutability": "nonpayable",
    "type": "function"
},
{
    "payable": true,
    "stateMutability": "payable",
    "type": "fallback"
},
{
    "anonymous": false,
    "inputs": [
        {
            "indexed": false,
            "name": "previousOwner",
            "type": "address"
        },
        {
            "indexed": false,
            "name": "newOwner",
            "type": "address"
        }
    ],
    "name": "ProxyOwnershipTransferred",
    "type": "event"
},
{
    "inputs": [
        {
            "name": "_owner",
            "type": "address"
        }
    ],
    "payable": false,
    "stateMutability": "nonpayable",
    "type": "constructor"
},
{
    "constant": false,
    "inputs": [
        {
            "name": "version",
            "type": "string"
        },
        {
            "name": "implementation",
            "type": "address"
        }
    ],
    "name": "upgradeTo",
    "outputs": [],
    "payable": false,
    "stateMutability": "nonpayable",
    "type": "function"
},
{
    "constant": false,
    "inputs": [
        {
            "name": "version",
            "type": "string"
        },
        {
            "name": "implementation",
            "type": "address"
        },
        {
            "name": "data",
            "type": "bytes"
        }
    ],
    "name": "upgradeToAndCall",
    "outputs": [],
    "payable": true,
    "stateMutability": "payable",
    "type": "function"
},
{
    "constant": true,
    "inputs": [],
    "name": "implementation",
    "outputs": [
        {
            "name": "",
            "type": "address"
        }
    ],
    "payable": false,
    "stateMutability": "view",
    "type": "function"
},
{
    "constant": true,
    "inputs": [],
    "name": "proxyOwner",
    "outputs": [
        {
            "name": "",
            "type": "address"
        }
    ],
    "payable": false,
    "stateMutability": "view",
    "type": "function"
},
{
    "constant": true,
    "inputs": [],
    "name": "upgradeabilityOwner",
    "outputs": [
        {
            "name": "",
            "type": "address"
        }
    ],
    "payable": false,
    "stateMutability": "view",
    "type": "function"
},
{
    "constant": true,
    "inputs": [],
    "name": "version",
    "outputs": [
        {
            "name": "",
            "type": "string"
        }
    ],
    "payable": false,
    "stateMutability": "view",
    "type": "function"
}

mapping(bytes32 => uint256) internal uintStorage;
mapping(bytes32 => string) internal stringStorage;
mapping(bytes32 => address) internal addressStorage;
mapping(bytes32 => bytes) internal bytesStorage;
mapping(bytes32 => bool) internal boolStorage;
mapping(bytes32 => int256) internal intStorage;

/**
* @dev Tells the address of the owner
* @return the address of the owner
*/
function upgradeabilityOwner() public view returns (address) {
    return _upgradeabilityOwner;
}

/**
* @dev Sets the address of the owner
*/
function setUpgradeabilityOwner(address newUpgradeabilityOwner) internal {
    _upgradeabilityOwner = newUpgradeabilityOwner;
}

/**
* @dev Fallback function allowing to perform a delegatecall to the given implementation.
* This function will return whatever the implementation call returns
*/
function () public payable {
    address _impl = implementation();
    require(_impl != address(0));
    bytes memory data = msg.data;

    assembly {
        let result := delegatecall(gas, _impl, add(data, 0x20), mload(data), 0, 0)
        let size := returndatasize

        let ptr := mload(0x40)
        returndatacopy(ptr, 0, size)

        switch result
        case 0 { revert(ptr, size) }
        default { return(ptr, size) }
    }
}

/**
* @dev Tells the address of the implementation where every call will be delegated.
* @return address of the implementation to which it will be delegated
*/
function implementation() public view returns (address);

// Address of the current implementation
address internal _implementation;

/**
* @dev Tells the version name of the current implementation
* @return string representing the name of the current version
*/
function version() public view returns (string) {
    return _version;
}

/**
* @dev Tells the address of the current implementation
* @return address of the current implementation
*/
function implementation() public view returns (address) {
    return _implementation;
}

/**
* @dev Upgrades the implementation address
* @param version representing the version name of the new implementation to be set
* @param implementation representing the address of the new implementation to be set
*/
function _upgradeTo(string version, address implementation) internal {
    require(_implementation != implementation);
    _version = version;
    _implementation = implementation;
    Upgraded(version, implementation);
}

/**
* @dev the constructor sets the original owner of the contract to the sender account.
*/
function OwnedUpgradeabilityProxy(address _owner) public {
    setUpgradeabilityOwner(_owner);
}

/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyProxyOwner() {
    require(msg.sender == proxyOwner());
    _;
}

/**
* @dev Tells the address of the proxy owner
* @return the address of the proxy owner
*/
function proxyOwner() public view returns (address) {
    return upgradeabilityOwner();
}

/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferProxyOwnership(address newOwner) public onlyProxyOwner {
    require(newOwner != address(0));
    ProxyOwnershipTransferred(proxyOwner(), newOwner);
    setUpgradeabilityOwner(newOwner);
}

/**
* @dev Allows the upgradeability owner to upgrade the current version of the proxy.
* @param version representing the version name of the new implementation to be set.
* @param implementation representing the address of the new implementation to be set.
*/
function upgradeTo(string version, address implementation) public onlyProxyOwner {
    _upgradeTo(version, implementation);
}

/**
* @dev Allows the upgradeability owner to upgrade the current version of the proxy and call the new implementation
* to initialize whatever is needed through a low level call.
* @param version representing the version name of the new implementation to be set.
* @param implementation representing the address of the new implementation to be set.
* @param data represents the msg.data to bet sent in the low level call. This parameter may include the function
* signature of the implementation to be called with the needed payload
*/
function upgradeToAndCall(string version, address implementation, bytes data) payable public onlyProxyOwner {
    upgradeTo(version, implementation);
    require(this.call.value(msg.value)(data));
}

function EternalStorageProxyForStormMultisender(address _owner) public OwnedUpgradeabilityProxy(_owner) {}