468 lines
13 KiB
Nim
468 lines
13 KiB
Nim
|
# Nimbus
|
|||
|
|
# Copyright (c) 2018 Status Research & Development GmbH
|
|||
|
|
# Licensed under either of
|
|||
|
|
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
|
|||
|
|
# http://www.apache.org/licenses/LICENSE-2.0)
|
|||
|
|
# * MIT license ([LICENSE-MIT](LICENSE-MIT) or
|
|||
|
|
# http://opensource.org/licenses/MIT)
|
|||
|
|
# at your option. This file may not be copied, modified, or distributed except
|
|||
|
|
# according to those terms.
|
|||
|
|
|
|||
|
|
## EVM Opcode Handlers: Arithmetic and Logic Operators
|
|||
|
|
## ===================================================
|
|||
|
|
##
|
|||
|
|
|
|||
|
|
const
|
|||
|
|
kludge {.intdefine.}: int = 0
|
|||
|
|
breakCircularDependency {.used.} = kludge > 0
|
|||
|
|
|
|||
|
|
import
|
|||
|
|
./oph_defs,
|
|||
|
|
stint
|
|||
|
|
|
|||
|
|
# ------------------------------------------------------------------------------
|
|||
|
|
# Kludge BEGIN
|
|||
|
|
# ------------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
when not breakCircularDependency:
|
|||
|
|
import
|
|||
|
|
../../../constants,
|
|||
|
|
../../stack,
|
|||
|
|
../../v2computation,
|
|||
|
|
../../v2types,
|
|||
|
|
../gas_meter,
|
|||
|
|
../utils/v2utils_numeric,
|
|||
|
|
../v2gas_costs,
|
|||
|
|
chronicles,
|
|||
|
|
eth/common,
|
|||
|
|
options,
|
|||
|
|
sets
|
|||
|
|
|
|||
|
|
else:
|
|||
|
|
import macros
|
|||
|
|
|
|||
|
|
# copied from stack.nim
|
|||
|
|
macro genTupleType(len: static[int], elemType: untyped): untyped =
|
|||
|
|
result = nnkTupleConstr.newNimNode()
|
|||
|
|
for i in 0 ..< len: result.add(elemType)
|
|||
|
|
|
|||
|
|
# function stubs from stack.nim (to satisfy compiler logic)
|
|||
|
|
proc push[T](x: Stack; n: T) = discard
|
|||
|
|
proc popInt(x: var Stack): UInt256 = discard
|
|||
|
|
proc popInt(x: var Stack, n: static[int]): auto =
|
|||
|
|
var rc: genTupleType(n, UInt256)
|
|||
|
|
return rc
|
|||
|
|
|
|||
|
|
# function stubs from v2utils_numeric.nim
|
|||
|
|
proc extractSign(v: var UInt256, sign: var bool) = discard
|
|||
|
|
proc setSign(v: var UInt256, sign: bool) = discard
|
|||
|
|
func safeInt(x: Uint256): int = discard
|
|||
|
|
|
|||
|
|
# ------------------------------------------------------------------------------
|
|||
|
|
# Kludge END
|
|||
|
|
# ------------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
# ------------------------------------------------------------------------------
|
|||
|
|
# Private, op handlers implementation
|
|||
|
|
# ------------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
const
|
|||
|
|
addOp: Vm2OpFn = proc (k: Vm2Ctx) =
|
|||
|
|
let (lhs, rhs) = k.cpt.stack.popInt(2)
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
lhs + rhs
|
|||
|
|
|
|||
|
|
mulOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (lhs, rhs) = k.cpt.stack.popInt(2)
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
lhs * rhs
|
|||
|
|
|
|||
|
|
subOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (lhs, rhs) = k.cpt.stack.popInt(2)
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
lhs - rhs
|
|||
|
|
|
|||
|
|
divideOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (lhs, rhs) = k.cpt.stack.popInt(2)
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
if rhs == 0:
|
|||
|
|
zero(Uint256)
|
|||
|
|
else:
|
|||
|
|
lhs div rhs
|
|||
|
|
|
|||
|
|
sdivOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (lhs, rhs) = k.cpt.stack.popInt(2)
|
|||
|
|
var r: UInt256
|
|||
|
|
if rhs != 0:
|
|||
|
|
var a = lhs
|
|||
|
|
var b = rhs
|
|||
|
|
var signA, signB: bool
|
|||
|
|
extractSign(a, signA)
|
|||
|
|
extractSign(b, signB)
|
|||
|
|
r = a div b
|
|||
|
|
setSign(r, signA xor signB)
|
|||
|
|
k.cpt.stack.push(r)
|
|||
|
|
|
|||
|
|
moduloOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (lhs, rhs) = k.cpt.stack.popInt(2)
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
if rhs == 0:
|
|||
|
|
zero(Uint256)
|
|||
|
|
else:
|
|||
|
|
lhs mod rhs
|
|||
|
|
|
|||
|
|
smodOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (lhs, rhs) = k.cpt.stack.popInt(2)
|
|||
|
|
var r: UInt256
|
|||
|
|
if rhs != 0:
|
|||
|
|
var sign: bool
|
|||
|
|
var v = lhs
|
|||
|
|
var m = rhs
|
|||
|
|
extractSign(m, sign)
|
|||
|
|
extractSign(v, sign)
|
|||
|
|
r = v mod m
|
|||
|
|
setSign(r, sign)
|
|||
|
|
k.cpt.stack.push(r)
|
|||
|
|
|
|||
|
|
addmodOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (lhs, rhs, modulus) = k.cpt.stack.popInt(3)
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
if modulus == 0:
|
|||
|
|
zero(UInt256)
|
|||
|
|
else:
|
|||
|
|
addmod(lhs, rhs, modulus)
|
|||
|
|
|
|||
|
|
mulmodOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (lhs, rhs, modulus) = k.cpt.stack.popInt(3)
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
if modulus == 0:
|
|||
|
|
zero(UInt256)
|
|||
|
|
else:
|
|||
|
|
mulmod(lhs, rhs, modulus)
|
|||
|
|
|
|||
|
|
expOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (base, exponent) = k.cpt.stack.popInt(2)
|
|||
|
|
when not breakCircularDependency:
|
|||
|
|
k.cpt.gasMeter.consumeGas(
|
|||
|
|
k.cpt.gasCosts[Exp].d_handler(exponent),
|
|||
|
|
reason = "EXP: exponent bytes")
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
if not base.isZero:
|
|||
|
|
base.pow(exponent)
|
|||
|
|
elif exponent.isZero:
|
|||
|
|
# https://github.com/ethereum/yellowpaper/issues/257
|
|||
|
|
# https://github.com/ethereum/tests/pull/460
|
|||
|
|
# https://github.com/ewasm/evm2wasm/issues/137
|
|||
|
|
1.u256
|
|||
|
|
else:
|
|||
|
|
zero(UInt256)
|
|||
|
|
|
|||
|
|
signExtendOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (bits, value) = k.cpt.stack.popInt(2)
|
|||
|
|
var res: UInt256
|
|||
|
|
if bits <= 31.u256:
|
|||
|
|
let
|
|||
|
|
one = 1.u256
|
|||
|
|
testBit = bits.truncate(int) * 8 + 7
|
|||
|
|
bitPos = one shl testBit
|
|||
|
|
mask = bitPos - one
|
|||
|
|
if not isZero(value and bitPos):
|
|||
|
|
res = value or (not mask)
|
|||
|
|
else:
|
|||
|
|
res = value and mask
|
|||
|
|
else:
|
|||
|
|
res = value
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
res
|
|||
|
|
|
|||
|
|
ltOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (lhs, rhs) = k.cpt.stack.popInt(2)
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
(lhs < rhs).uint.u256
|
|||
|
|
|
|||
|
|
gtOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (lhs, rhs) = k.cpt.stack.popInt(2)
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
(lhs > rhs).uint.u256
|
|||
|
|
|
|||
|
|
sltOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (lhs, rhs) = k.cpt.stack.popInt(2)
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
(cast[Int256](lhs) < cast[Int256](rhs)).uint.u256
|
|||
|
|
|
|||
|
|
sgtOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (lhs, rhs) = k.cpt.stack.popInt(2)
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
(cast[Int256](lhs) > cast[Int256](rhs)).uint.u256
|
|||
|
|
|
|||
|
|
eqOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (lhs, rhs) = k.cpt.stack.popInt(2)
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
(lhs == rhs).uint.u256
|
|||
|
|
|
|||
|
|
isZeroOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (value) = k.cpt.stack.popInt(1)
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
value.isZero.uint.u256
|
|||
|
|
|
|||
|
|
andOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (lhs, rhs) = k.cpt.stack.popInt(2)
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
lhs and rhs
|
|||
|
|
|
|||
|
|
orOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (lhs, rhs) = k.cpt.stack.popInt(2)
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
lhs or rhs
|
|||
|
|
|
|||
|
|
xorOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (lhs, rhs) = k.cpt.stack.popInt(2)
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
lhs xor rhs
|
|||
|
|
|
|||
|
|
notOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (value) = k.cpt.stack.popInt(1)
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
value.not
|
|||
|
|
|
|||
|
|
byteOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (position, value) = k.cpt.stack.popInt(2)
|
|||
|
|
let pos = position.truncate(int)
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
if pos >= 32 or pos < 0:
|
|||
|
|
zero(Uint256)
|
|||
|
|
else:
|
|||
|
|
when system.cpuEndian == bigEndian:
|
|||
|
|
cast[array[32, byte]](value)[pos].u256
|
|||
|
|
else:
|
|||
|
|
cast[array[32, byte]](value)[31 - pos].u256
|
|||
|
|
|
|||
|
|
# Constantinople's new opcodes
|
|||
|
|
|
|||
|
|
shlOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (shift, num) = k.cpt.stack.popInt(2)
|
|||
|
|
let shiftLen = shift.safeInt
|
|||
|
|
if shiftLen >= 256:
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
0
|
|||
|
|
else:
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
num shl shiftLen
|
|||
|
|
|
|||
|
|
shrOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let (shift, num) = k.cpt.stack.popInt(2)
|
|||
|
|
let shiftLen = shift.safeInt
|
|||
|
|
if shiftLen >= 256:
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
0
|
|||
|
|
else:
|
|||
|
|
# uint version of `shr`
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
num shr shiftLen
|
|||
|
|
|
|||
|
|
sarOp: Vm2OpFn = proc(k: Vm2Ctx) =
|
|||
|
|
let shiftLen = k.cpt.stack.popInt().safeInt
|
|||
|
|
let num = cast[Int256](k.cpt.stack.popInt())
|
|||
|
|
if shiftLen >= 256:
|
|||
|
|
if num.isNegative:
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
cast[Uint256]((-1).i256)
|
|||
|
|
else:
|
|||
|
|
k.cpt.stack. push:
|
|||
|
|
0
|
|||
|
|
else:
|
|||
|
|
# int version of `shr` then force the result
|
|||
|
|
# into uint256
|
|||
|
|
k.cpt.stack.push:
|
|||
|
|
cast[Uint256](num shr shiftLen)
|
|||
|
|
|
|||
|
|
# ------------------------------------------------------------------------------
|
|||
|
|
# Public, op exec table entries
|
|||
|
|
# ------------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
const
|
|||
|
|
vm2OpExecArithmetic*: seq[Vm2OpExec] = @[
|
|||
|
|
|
|||
|
|
(opCode: Add, ## 0x01, Addition
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Addition operation",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: addOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: Mul, ## 0x02, Multiplication
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Multiplication operation",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: mulOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: Sub, ## 0x03, Subtraction
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Subtraction operation",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: subOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: Div, ## 0x04, Division
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Integer division operation",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: divideOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: Sdiv, ## 0x05, Signed division
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Signed integer division operation (truncated)",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: sdivOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: Mod, ## 0x06, Modulo
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Modulo remainder operation",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: moduloOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: Smod, ## 0x07, Signed modulo
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Signed modulo remainder operation",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: smodOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: AddMod, ## 0x08, Modulo addition, Intermediate
|
|||
|
|
## computations do not roll over at 2^256
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Modulo addition operation",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: addmodOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: MulMod, ## 0x09, Modulo multiplication, Intermediate
|
|||
|
|
## computations do not roll over at 2^256
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Modulo multiplication operation",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: mulmodOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: Exp, ## 0x0a, Exponentiation
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Exponentiation operation",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: expOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: SignExtend, ## 0x0b, Extend 2's complemet length
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Extend length of two’s complement signed integer",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: signExtendOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: Lt, ## 0x10, Less-than
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Less-than comparison",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: ltOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: Gt, ## 0x11, Greater-than
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Greater-than comparison",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: gtOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: Slt, ## 0x12, Signed less-than
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Signed less-than comparison",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: sltOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: Sgt, ## 0x13, Signed greater-than
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Signed greater-than comparison",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: sgtOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: Eq, ## 0x14, Equality
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Equality comparison",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: eqOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: IsZero, ## 0x15, Not operator
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Simple not operator (Note: real Yellow Paper description)",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: isZeroOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: And, ## 0x16, AND
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Bitwise AND operation",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: andOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: Or, ## 0x17, OR
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Bitwise OR operation",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: orOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: Xor, ## 0x18, XOR
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Bitwise XOR operation",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: xorOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: Not, ## 0x19, NOT
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Bitwise NOT operation",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: notOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: Byte, ## 0x1a, Retrieve byte
|
|||
|
|
forks: Vm2OpAllForks,
|
|||
|
|
info: "Retrieve single byte from word",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: byteOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
# Constantinople's new opcodes
|
|||
|
|
|
|||
|
|
(opCode: Shl, ## 0x1b, Shift left
|
|||
|
|
forks: Vm2OpConstantinopleAndLater,
|
|||
|
|
info: "Shift left",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: shlOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: Shr, ## 0x1c, Shift right logical
|
|||
|
|
forks: Vm2OpConstantinopleAndLater,
|
|||
|
|
info: "Logical shift right",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: shrOp,
|
|||
|
|
post: vm2OpIgnore)),
|
|||
|
|
|
|||
|
|
(opCode: Sar, ## 0x1d, Shift right arithmetic
|
|||
|
|
forks: Vm2OpConstantinopleAndLater,
|
|||
|
|
info: "Arithmetic shift right",
|
|||
|
|
exec: (prep: vm2OpIgnore,
|
|||
|
|
run: sarOp,
|
|||
|
|
post: vm2OpIgnore))]
|
|||
|
|
|
|||
|
|
# ------------------------------------------------------------------------------
|
|||
|
|
# End
|
|||
|
|
# ------------------------------------------------------------------------------
|