address x = 0x123;address myAddress = this;if (x.balance < 10 && myAddress.balance >= 10) x.transfer(10);

address nameReg = 0x72ba7d8e73fe8eb666ea66babc8116a41bfb10e2;nameReg.call("register", "MyName");nameReg.call(bytes4(keccak256("fun(uint256)")), a);

pragma solidity ^0.4.0;contract test {    enum ActionChoices { GoLeft, GoRight, GoStraight, SitStill }    ActionChoices choice;    ActionChoices constant defaultChoice = ActionChoices.GoStraight;    function setGoStraight() {        choice = ActionChoices.GoStraight;    }    // Since enum types are not part of the ABI, the signature of "getChoice"    // will automatically be changed to "getChoice() returns (uint8)"    // for all matters external to Solidity. The integer type used is just    // large enough to hold all enum values, i.e. if you have more values,    // `uint16` will be used and so on.    function getChoice() returns (ActionChoices) {        return choice;    }    function getDefaultChoice() returns (uint) {        return uint(defaultChoice);    }}

function (<parameter types>) {internal|external} [constant] [payable] [returns (<return types>)]

pragma solidity ^0.4.5;library ArrayUtils {  // internal functions can be used in internal library functions because  // they will be part of the same code context  function map(uint[] memory self, function (uint) returns (uint) f)    internal    returns (uint[] memory r)  {    r = new uint[](self.length);    for (uint i = 0; i < self.length; i++) {      r[i] = f(self[i]);    }  }  function reduce(    uint[] memory self,    function (uint, uint) returns (uint) f  )    internal    returns (uint)  {    r = self[0];    for (uint i = 1; i < self.length; i++) {      r = f(r, self[i]);    }  }  function range(uint length) internal returns (uint[] memory r) {    r = new uint[](length);    for (uint i = 0; i < r.length; i++) {      r[i] = i;    }  }}contract Pyramid {  using ArrayUtils for *;  function pyramid(uint l) returns (uint) {    return ArrayUtils.range(l).map(square).reduce(sum);  }  function square(uint x) internal returns (uint) {    return x * x;  }  function sum(uint x, uint y) internal returns (uint) {    return x + y;  }}

pragma solidity ^0.4.11;contract Oracle {  struct Request {    bytes data;    function(bytes memory) external callback;  }  Request[] requests;  event NewRequest(uint);  function query(bytes data, function(bytes memory) external callback) {    requests.push(Request(data, callback));    NewRequest(requests.length - 1);  }  function reply(uint requestID, bytes response) {    // Here goes the check that the reply comes from a trusted source    requests[requestID].callback(response);  }}contract OracleUser {  Oracle constant oracle = Oracle(0x1234567); // known contract  function buySomething() {    oracle.query("USD", this.oracleResponse);  }  function oracleResponse(bytes response) {    require(msg.sender == address(oracle));    // Use the data  }}

pragma solidity ^0.4.0;contract C {    uint[] x; // the data location of x is storage    // the data location of memoryArray is memory    function f(uint[] memoryArray) {        x = memoryArray; // works, copies the whole array to storage        var y = x; // works, assigns a pointer, data location of y is storage        y[7]; // fine, returns the 8th element        y.length = 2; // fine, modifies x through y        delete x; // fine, clears the array, also modifies y        // The following does not work; it would need to create a new temporary /        // unnamed array in storage, but storage is "statically" allocated:        // y = memoryArray;        // This does not work either, since it would "reset" the pointer, but there        // is no sensible location it could point to.        // delete y;        g(x); // calls g, handing over a reference to x        h(x); // calls h and creates an independent, temporary copy in memory    }    function g(uint[] storage storageArray) internal {}    function h(uint[] memoryArray) {}}

pragma solidity ^0.4.0;contract C {    function f(uint len) {        uint[] memory a = new uint[](7);        bytes memory b = new bytes(len);        // Here we have a.length == 7 and b.length == len        a[6] = 8;    }}

pragma solidity ^0.4.0;contract C {    function f() {        g([uint(1), 2, 3]);    }    function g(uint[3] _data) {        // ...    }}

pragma solidity ^0.4.0;contract C {    function f() {        // The next line creates a type error because uint[3] memory        // cannot be converted to uint[] memory.        uint[] x = [uint(1), 3, 4];}

pragma solidity ^0.4.0;contract ArrayContract {    uint[2**20] m_aLotOfIntegers;    // Note that the following is not a pair of dynamic arrays but a    // dynamic array of pairs (i.e. of fixed size arrays of length two).    bool[2][] m_pairsOfFlags;    // newPairs is stored in memory - the default for function arguments    function setAllFlagPairs(bool[2][] newPairs) {        // assignment to a storage array replaces the complete array        m_pairsOfFlags = newPairs;    }    function setFlagPair(uint index, bool flagA, bool flagB) {        // access to a non-existing index will throw an exception        m_pairsOfFlags[index][0] = flagA;        m_pairsOfFlags[index][1] = flagB;    }    function changeFlagArraySize(uint newSize) {        // if the new size is smaller, removed array elements will be cleared        m_pairsOfFlags.length = newSize;    }    function clear() {        // these clear the arrays completely        delete m_pairsOfFlags;        delete m_aLotOfIntegers;        // identical effect here        m_pairsOfFlags.length = 0;    }    bytes m_byteData;    function byteArrays(bytes data) {        // byte arrays ("bytes") are different as they are stored without padding,        // but can be treated identical to "uint8[]"        m_byteData =http://www.mamicode.com/ data;        m_byteData.length += 7;        m_byteData[3] = 8;        delete m_byteData[2];    }    function addFlag(bool[2] flag) returns (uint) {        return m_pairsOfFlags.push(flag);    }    function createMemoryArray(uint size) returns (bytes) {        // Dynamic memory arrays are created using `new`:        uint[2][] memory arrayOfPairs = new uint[2][](size);        // Create a dynamic byte array:        bytes memory b = new bytes(200);        for (uint i = 0; i < b.length; i++)            b[i] = byte(i);        return b;    }}

pragma solidity ^0.4.11;contract CrowdFunding {    // Defines a new type with two fields.    struct Funder {        address addr;        uint amount;    }    struct Campaign {        address beneficiary;        uint fundingGoal;        uint numFunders;        uint amount;        mapping (uint => Funder) funders;    }    uint numCampaigns;    mapping (uint => Campaign) campaigns;    function newCampaign(address beneficiary, uint goal) returns (uint campaignID) {        campaignID = numCampaigns++; // campaignID is return variable        // Creates new struct and saves in storage. We leave out the mapping type.        campaigns[campaignID] = Campaign(beneficiary, goal, 0, 0);    }    function contribute(uint campaignID) payable {        Campaign c = campaigns[campaignID];        // Creates a new temporary memory struct, initialised with the given values        // and copies it over to storage.        // Note that you can also use Funder(msg.sender, msg.value) to initialise.        c.funders[c.numFunders++] = Funder({addr: msg.sender, amount: msg.value});        c.amount += msg.value;    }    function checkGoalReached(uint campaignID) returns (bool reached) {        Campaign c = campaigns[campaignID];        if (c.amount < c.fundingGoal)            return false;        uint amount = c.amount;        c.amount = 0;        c.beneficiary.transfer(amount);        return true;    }}

pragma solidity ^0.4.0;contract MappingExample {    mapping(address => uint) public balances;    function update(uint newBalance) {        balances[msg.sender] = newBalance;    }}contract MappingUser {    function f() returns (uint) {        return MappingExample(<address>).balances(this);    }}

pragma solidity ^0.4.0;contract DeleteExample {    uint data;    uint[] dataArray;    function f() {        uint x = data;        delete x; // sets x to 0, does not affect data        delete data; // sets data to 0, does not affect x which still holds a copy        uint[] y = dataArray;        delete dataArray; // this sets dataArray.length to zero, but as uint[] is a complex object, also        // y is affected which is an alias to the storage object        // On the other hand: "delete y" is not valid, as assignments to local variables        // referencing storage objects can only be made from existing storage objects.    }}

int8 y = -3;uint x = uint(y);

uint32 a = 0x12345678;uint16 b = uint16(a); // b will be 0x5678 now