```\nFile: contracts\libraries\SafeCall.sol\n    function callWithMinGas(\n        address _target,\n        uint256 _minGas,\n        uint256 _value,\n        bytes memory _calldata\n    ) internal returns (bool) {\n        bool _success;\n        assembly {\n            // Assertion: gasleft() >= ((_minGas + 200) * 64) / 63\n            //\n            // Because EIP-150 ensures that, a maximum of 63/64ths of the remaining gas in the call\n            // frame may be passed to a subcontext, we need to ensure that the gas will not be\n            // truncated to hold this function's invariant: "If a call is performed by\n            // `callWithMinGas`, it must receive at least the specified minimum gas limit." In\n            // addition, exactly 51 gas is consumed between the below `GAS` opcode and the `CALL`\n            // opcode, so it is factored in with some extra room for error.\n            if lt(gas(), div(mul(64, add(_minGas, 200)), 63)) {\n                // Store the "Error(string)" selector in scratch space.\n                mstore(0, 0x08c379a0)\n                // Store the pointer to the string length in scratch space.\n                mstore(32, 32)\n                // Store the string.\n                //\n                // SAFETY:\n                // - We pad the beginning of the string with two zero bytes as well as the\n                // length (24) to ensure that we override the free memory pointer at offset\n                // 0x40. This is necessary because the free memory pointer is likely to\n                // be greater than 1 byte when this function is called, but it is incredibly\n                // unlikely that it will be greater than 3 bytes. As for the data within\n                // 0x60, it is ensured that it is 0 due to 0x60 being the zero offset.\n                // - It's fine to clobber the free memory pointer, we're reverting.\n                mstore(88, 0x0000185361666543616c6c3a204e6f7420656e6f75676820676173)\n\n                // Revert with 'Error("SafeCall: Not enough gas")'\n                revert(28, 100)\n            }\n\n            // The call will be supplied at least (((_minGas + 200) * 64) / 63) - 49 gas due to the\n            // above assertion. This ensures that, in all circumstances, the call will\n            // receive at least the minimum amount of gas specified.\n            // We can prove this property by solving the inequalities:\n            // ((((_minGas + 200) * 64) / 63) - 49) >= _minGas\n            // ((((_minGas + 200) * 64) / 63) - 51) * (63 / 64) >= _minGas\n            // Both inequalities hold true for all possible values of `_minGas`.\n            _success := call(\n                gas(), // gas\n                _target, // recipient\n                _value, // ether value\n                add(_calldata, 32), // inloc\n                mload(_calldata), // inlen\n                0x00, // outloc\n                0x00 // outlen\n            )\n        }\n        return _success;\n    }\n```\n