* Proxy to support multisig op. Always return False.
	* Bug fix for unreachable block when OP_RETURN and OP_VERIFY are
used

	* Fix: Reversing a hash function should always be considered as
imposible. The fix consists into parsing the ast tree in depth.

	* Tests for symbolic execution

	* Fix signature constraints: enforce throught the constraints
	that it's not possible to find a valid signature for a given
	pubkey

	All operands are passed at once to the constraint function.
	It allows to create different conditions based on the order
	of the operands.

	Example: for the division, only the second operand
	must be != 0

	* Clean the way hash fucntions are represented
	* Add a util function to interpret the results

	* Now the operators really compute the hash if a known value
	  is passed to the operator. On the other hand, if a symbol
	  is passed, a symbol is returned.

	* False is encoded over 0 byte. The operators were returning
	  a value encoded over 1 byte.

	* Different memories should generate different symbols.
	* During a merge, entries from the other memory should be
	  "deepcopied"

	* OP_FALSE is supposed to be different from '00'

	* Integers values are represented in little endian format.
	* Moreover, BTC does not use two's complement representation.

	BTC specifies that arithmetics operands should be encoded
	with the least amount of bytes. With these new constraints,
	a script "82010288010193010388" is unsatisfiable.

	The operator is supposed to push the size of the top element
	without removing it.

	This has been fixed by preceeding an OP_DUP before the OP_SIZE
	which consumes the element.

	* This will help with the debugging, because printing
	 bitvectors are always printed as positive integers.
	* Abs operator fixed.

	This memory is no longer intended to be use because it doesn't
	support enough functionality. E.g. no RAM access.

To do:
	* Clean up the code
	* Implement the artihmetic constraints
	* Rewrite the function ` __min_bytes_needed`

	* Every script ends with a unique final block. Previously,
	 every script had 2 final blocks: one for successful execution,
	 one for failed ones.

	Note: this might not be the most effective implementation and
	might need to be revisited in the future.

	Time complexity in worst case scenario: O(V^2) where V is the
	number of vertices in the graph.

	See: https://wiki.python.org/moin/TimeComplexity

The responsibility to execute a code is delegated to a new class of
`Executer`. This will allow to change the way is run by using a
different executer.

	* OP_PICK implemented.

	* New tests for uncovered opcodes.

	* The memory, the machine and the operators work as independant
	  layers.
	  Memory only deal with words of memory.
	  While the BTCMachine deals with BTCVectors.
	  Finally, operators are totally agnostic of the underline
	  concepts.

	* Run the test only on the fully symbolic memory in order
	  to simplify the code. The other memories are going to be
	  deprecated.

	* This memory handles symbolic addresses (RAM style access),
	  symbolic size of the vectors and symbolic values.

	* Run the same testing scenarii on different types of memory.