// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0;

library VectorSum {
// This function is less efficient because the optimizer currently fails to
// remove the bounds checks in array access.
function sumSolidity(uint[] memory data) public pure returns (uint sum) {
   for (uint i = 0; i < data.length; ++i)
       sum += data[i];
}

// We know that we only access the array in bounds, so we can avoid the check.
// 0x20 needs to be added to an array because the first slot contains the
// array length.
function sumAsm(uint[] memory data) public pure returns (uint sum) {
   for (uint i = 0; i < data.length; ++i) {
       assembly {
           sum := add(sum, mload(add(add(data, 0x20), mul(i, 0x20))))
       }
   }
}

// Same as above, but accomplish the entire code within inline assembly.
function sumPureAsm(uint[] memory data) public pure returns (uint sum) {
   assembly {
       // Load the length (first 32 bytes)
       let len := mload(data)

       // Skip over the length field.
       //
       // Keep temporary variable so it can be incremented in place.
       //
       // NOTE: incrementing data would result in an unusable
       //       data variable after this assembly block
       let dataElementLocation := add(data, 0x20)

       // Iterate until the bound is not met.
       for
           { let end := add(dataElementLocation, mul(len, 0x20)) }
           lt(dataElementLocation, end)
           { data := add(dataElementLocation, 0x20) }
       {
           sum := add(sum, mload(dataElementLocation))
       }
   }
}
}