rct Namespace Reference

Classes
struct	boroSig
struct	ctkey
struct	ecdhTuple
struct	geDsmp
struct	key
struct	mgSig
struct	rangeSig
struct	rctSig
struct	rctSigBase
struct	rctSigPrunable

Typedefs
typedef unsigned char *	Bytes
typedef vector< key >	keyV
typedef vector< keyV >	keyM
typedef vector< ctkey >	ctkeyV
typedef vector< ctkeyV >	ctkeyM
typedef uint64_t	xmr_amount
typedef unsigned int	bits[ATOMS]
typedef key	key64[64]

Enumerations
enum	{ RCTTypeNull = 0, RCTTypeFull = 1, RCTTypeSimple = 2 }

Functions
keyM	keyMInit (size_t rows, size_t cols)
void	skGen (key &sk)
key	skGen ()
keyV	skvGen (size_t rows)
key	pkGen ()
void	skpkGen (key &sk, key &pk)
tuple< key, key >	skpkGen ()
void	genC (key &C, const key &a, xmr_amount amount)
tuple< ctkey, ctkey >	ctskpkGen (xmr_amount amount)
tuple< ctkey, ctkey >	ctskpkGen (const key &bH)
key	zeroCommit (xmr_amount amount)
key	commit (xmr_amount amount, const key &mask)
xmr_amount	randXmrAmount (xmr_amount upperlimit)
void	scalarmultBase (key &aG, const key &a)
key	scalarmultBase (const key &a)
void	scalarmultKey (key &aP, const key &P, const key &a)
key	scalarmultKey (const key &P, const key &a)
key	scalarmultH (const key &a)
void	addKeys (key &AB, const key &A, const key &B)
void	addKeys1 (key &aGB, const key &a, const key &B)
void	addKeys2 (key &aGbB, const key &a, const key &b, const key &B)
void	precomp (ge_dsmp rv, const key &B)
void	addKeys3 (key &aAbB, const key &a, const key &A, const key &b, const ge_dsmp B)
void	subKeys (key &AB, const key &A, const key &B)
bool	equalKeys (const key &a, const key &b)
void	cn_fast_hash (key &hash, const void *data, const std::size_t l)
void	hash_to_scalar (key &hash, const void *data, const std::size_t l)
void	cn_fast_hash (key &hash, const key &in)
void	hash_to_scalar (key &hash, const key &in)
key	cn_fast_hash (const key &in)
key	hash_to_scalar (const key &in)
key	cn_fast_hash128 (const void *in)
key	hash_to_scalar128 (const void *in)
key	cn_fast_hash (const ctkeyV &PC)
key	hash_to_scalar (const ctkeyV &PC)
key	cn_fast_hash (const keyV &keys)
key	hash_to_scalar (const keyV &keys)
key	cn_fast_hash (const key64 keys)
key	hash_to_scalar (const key64 keys)
key	hashToPointSimple (const key &hh)
key	hashToPoint (const key &hh)
void	hashToPoint (key &pointk, const key &hh)
void	sumKeys (key &Csum, const keyV &Cis)
void	ecdhEncode (ecdhTuple &unmasked, const key &sharedSec)
void	ecdhDecode (ecdhTuple &masked, const key &sharedSec)
key	zero ()
void	zero (key &z)
key	identity ()
void	identity (key &Id)
key	curveOrder ()
void	curveOrder (key &l)
void	copy (key &AA, const key &A)
key	copy (const key &A)
void	cn_fast_hash (key &hash, const void *data, const size_t l)
void	hash_to_scalar (key &hash, const void *data, const size_t l)
void	sumKeys (key &Csum, const key &Cis)
boroSig	genBorromean (const key64 x, const key64 P1, const key64 P2, const bits indices)
bool	verifyBorromean (const boroSig &bb, const key64 P1, const key64 P2)
keyV	keyImageV (const keyV &xx)
mgSig	MLSAG_Gen (const key &message, const keyM &pk, const keyV &xx, const unsigned int index, size_t dsRows)
bool	MLSAG_Ver (const key &message, const keyM &pk, const mgSig &rv, size_t dsRows)
rangeSig	proveRange (key &C, key &mask, const xmr_amount &amount)
bool	verRange (const key &C, const rangeSig &as)
key	get_pre_mlsag_hash (const rctSig &rv)
mgSig	proveRctMG (const key &message, const ctkeyM &pubs, const ctkeyV &inSk, const ctkeyV &outSk, const ctkeyV &outPk, unsigned int index, key txnFeeKey)
mgSig	proveRctMGSimple (const key &message, const ctkeyV &pubs, const ctkey &inSk, const key &a, const key &Cout, unsigned int index)
bool	verRctMG (const mgSig &mg, const ctkeyM &pubs, const ctkeyV &outPk, key txnFeeKey, const key &message)
bool	verRctMGSimple (const key &message, const mgSig &mg, const ctkeyV &pubs, const key &C)
void	getKeyFromBlockchain (ctkey &a, size_t reference_index)
tuple< ctkeyM, xmr_amount >	populateFromBlockchain (ctkeyV inPk, int mixin)
xmr_amount	populateFromBlockchainSimple (ctkeyV &mixRing, const ctkey &inPk, int mixin)
rctSig	genRct (const key &message, const ctkeyV &inSk, const keyV &destinations, const vector< xmr_amount > &amounts, const ctkeyM &mixRing, const keyV &amount_keys, unsigned int index, ctkeyV &outSk)
rctSig	genRct (const key &message, const ctkeyV &inSk, const ctkeyV &inPk, const keyV &destinations, const vector< xmr_amount > &amounts, const keyV &amount_keys, const int mixin)
rctSig	genRctSimple (const key &message, const ctkeyV &inSk, const keyV &destinations, const vector< xmr_amount > &inamounts, const vector< xmr_amount > &outamounts, xmr_amount txnFee, const ctkeyM &mixRing, const keyV &amount_keys, const std::vector< unsigned int > &index, ctkeyV &outSk)
rctSig	genRctSimple (const key &message, const ctkeyV &inSk, const ctkeyV &inPk, const keyV &destinations, const vector< xmr_amount > &inamounts, const vector< xmr_amount > &outamounts, const keyV &amount_keys, xmr_amount txnFee, unsigned int mixin)
bool	verRct (const rctSig &rv, bool semantics)
bool	verRctSimple (const rctSig &rv, bool semantics)
xmr_amount	decodeRct (const rctSig &rv, const key &sk, unsigned int i, key &mask)
xmr_amount	decodeRct (const rctSig &rv, const key &sk, unsigned int i)
xmr_amount	decodeRctSimple (const rctSig &rv, const key &sk, unsigned int i, key &mask)
xmr_amount	decodeRctSimple (const rctSig &rv, const key &sk, unsigned int i)
mgSig	proveRctMG (const ctkeyM &pubs, const ctkeyV &inSk, const keyV &outMasks, const ctkeyV &outPk, unsigned int index, key txnFee, const key &message)
static bool	verRct (const rctSig &rv)
static bool	verRctSimple (const rctSig &rv)
void	dp (key a)
void	dp (bool a)
void	dp (const char *a, int l)
void	dp (keyV a)
void	dp (keyM a)
void	dp (xmr_amount vali)
void	dp (bits amountb)
void	dp (const char *st)
void	d2h (key &amounth, const xmr_amount in)
key	d2h (const xmr_amount in)
void	d2b (bits amountb, xmr_amount val)
xmr_amount	h2d (const key &test)
void	h2b (bits amountb2, const key &test)
void	b2h (key &amountdh, const bits amountb2)
xmr_amount	b2d (bits amountb)
static const rct::key	pk2rct (const crypto::public_key &pk)
static const rct::key	sk2rct (const crypto::secret_key &sk)
static const rct::key	ki2rct (const crypto::key_image &ki)
static const rct::key	hash2rct (const crypto::hash &h)
static const crypto::public_key	rct2pk (const rct::key &k)
static const crypto::secret_key	rct2sk (const rct::key &k)
static const crypto::key_image	rct2ki (const rct::key &k)
static const crypto::hash	rct2hash (const rct::key &k)
static bool	operator== (const rct::key &k0, const crypto::public_key &k1)
static bool	operator!= (const rct::key &k0, const crypto::public_key &k1)

Variables
static const key	Z = { {0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 } }
static const key	I = { {0x01, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 } }
static const key	L = { {0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10 } }
static const key	H = { {0x8b, 0x65, 0x59, 0x70, 0x15, 0x37, 0x99, 0xaf, 0x2a, 0xea, 0xdc, 0x9f, 0xf1, 0xad, 0xd0, 0xea, 0x6c, 0x72, 0x51, 0xd5, 0x41, 0x54, 0xcf, 0xa9, 0x2c, 0x17, 0x3a, 0x0d, 0xd3, 0x9c, 0x1f, 0x94} }
static const key64	H2

Typedef Documentation

bits

typedef unsigned int rct::bits[ATOMS]

Bytes

typedef unsigned char* rct::Bytes

ctkeyM

typedef vector<ctkeyV> rct::ctkeyM

ctkeyV

typedef vector<ctkey> rct::ctkeyV

key64

typedef key rct::key64[64]

keyM

typedef vector<keyV> rct::keyM

keyV

typedef vector<key> rct::keyV

xmr_amount

typedef uint64_t rct::xmr_amount

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
RCTTypeNull
RCTTypeFull
RCTTypeSimple

Function Documentation

addKeys()

void rct::addKeys	(	key &	AB,
		const key &	A,
		const key &	B
	)

addKeys1()

void rct::addKeys1	(	key &	aGB,
		const key &	a,
		const key &	B
	)

addKeys2()

void rct::addKeys2	(	key &	aGbB,
		const key &	a,
		const key &	b,
		const key &	B
	)

addKeys3()

void rct::addKeys3	(	key &	aAbB,
		const key &	a,
		const key &	A,
		const key &	b,
		const ge_dsmp	B
	)

b2d()

xmr_amount rct::b2d

(

bits

amountb

)

b2h()

void rct::b2h	(	key &	amountdh,
		const bits	amountb2
	)

cn_fast_hash() [1/7]

void rct::cn_fast_hash	(	key &	hash,
		const void *	data,
		const size_t	l
	)

cn_fast_hash() [2/7]

void rct::cn_fast_hash	(	key &	hash,
		const void *	data,
		const std::size_t	l
	)

cn_fast_hash() [3/7]

void rct::cn_fast_hash	(	key &	hash,
		const key &	in
	)

cn_fast_hash() [4/7]

key rct::cn_fast_hash

(

const key &

in

)

cn_fast_hash() [5/7]

key rct::cn_fast_hash

(

const ctkeyV &

PC

)

cn_fast_hash() [6/7]

key rct::cn_fast_hash

(

const keyV &

keys

)

cn_fast_hash() [7/7]

key rct::cn_fast_hash

(

const key64

keys

)

cn_fast_hash128()

key rct::cn_fast_hash128

(

const void *

in

)

commit()

key rct::commit	(	xmr_amount	amount,
		const key &	mask
	)

copy() [1/2]

void rct::copy ( key &  AA, const key &  A  )

inline

copy() [2/2]

key rct::copy ( const key &  A )

inline

ctskpkGen() [1/2]

tuple< ctkey, ctkey > rct::ctskpkGen

(

xmr_amount

amount

)

ctskpkGen() [2/2]

tuple< ctkey, ctkey > rct::ctskpkGen

(

const key &

bH

)

curveOrder() [1/2]

key rct::curveOrder ( )

inline

curveOrder() [2/2]

void rct::curveOrder ( key &  l )

inline

d2b()

void rct::d2b	(	bits	amountb,
		xmr_amount	val
	)

d2h() [1/2]

void rct::d2h	(	key &	amounth,
		const xmr_amount	in
	)

d2h() [2/2]

key rct::d2h

(

const xmr_amount

in

)

decodeRct() [1/2]

xmr_amount rct::decodeRct	(	const rctSig &	rv,
		const key &	sk,
		unsigned int	i,
		key &	mask
	)

decodeRct() [2/2]

xmr_amount rct::decodeRct	(	const rctSig &	rv,
		const key &	sk,
		unsigned int	i
	)

decodeRctSimple() [1/2]

xmr_amount rct::decodeRctSimple	(	const rctSig &	rv,
		const key &	sk,
		unsigned int	i,
		key &	mask
	)

decodeRctSimple() [2/2]

xmr_amount rct::decodeRctSimple	(	const rctSig &	rv,
		const key &	sk,
		unsigned int	i
	)

dp() [1/8]

void rct::dp

(

key

a

)

dp() [2/8]

void rct::dp

(

bool

a

)

dp() [3/8]

void rct::dp	(	const char *	a,
		int	l
	)

dp() [4/8]

void rct::dp

(

keyV

a

)

dp() [5/8]

void rct::dp

(

keyM

a

)

dp() [6/8]

void rct::dp

(

xmr_amount

vali

)

dp() [7/8]

void rct::dp

(

bits

amountb

)

dp() [8/8]

void rct::dp

(

const char *

st

)

ecdhDecode()

void rct::ecdhDecode	(	ecdhTuple &	masked,
		const key &	sharedSec
	)

ecdhEncode()

void rct::ecdhEncode	(	ecdhTuple &	unmasked,
		const key &	sharedSec
	)

equalKeys()

bool rct::equalKeys	(	const key &	a,
		const key &	b
	)

genBorromean()

boroSig rct::genBorromean	(	const key64	x,
		const key64	P1,
		const key64	P2,
		const bits	indices
	)

genC()

void rct::genC	(	key &	C,
		const key &	a,
		xmr_amount	amount
	)

genRct() [1/2]

rctSig rct::genRct	(	const key &	message,
		const ctkeyV &	inSk,
		const keyV &	destinations,
		const vector< xmr_amount > &	amounts,
		const ctkeyM &	mixRing,
		const keyV &	amount_keys,
		unsigned int	index,
		ctkeyV &	outSk
	)

genRct() [2/2]

rctSig rct::genRct	(	const key &	message,
		const ctkeyV &	inSk,
		const ctkeyV &	inPk,
		const keyV &	destinations,
		const vector< xmr_amount > &	amounts,
		const keyV &	amount_keys,
		const int	mixin
	)

genRctSimple() [1/2]

rctSig rct::genRctSimple	(	const key &	message,
		const ctkeyV &	inSk,
		const keyV &	destinations,
		const vector< xmr_amount > &	inamounts,
		const vector< xmr_amount > &	outamounts,
		xmr_amount	txnFee,
		const ctkeyM &	mixRing,
		const keyV &	amount_keys,
		const std::vector< unsigned int > &	index,
		ctkeyV &	outSk
	)

genRctSimple() [2/2]

rctSig rct::genRctSimple	(	const key &	message,
		const ctkeyV &	inSk,
		const ctkeyV &	inPk,
		const keyV &	destinations,
		const vector< xmr_amount > &	inamounts,
		const vector< xmr_amount > &	outamounts,
		const keyV &	amount_keys,
		xmr_amount	txnFee,
		unsigned int	mixin
	)

get_pre_mlsag_hash()

key rct::get_pre_mlsag_hash

(

const rctSig &

rv

)

getKeyFromBlockchain()

void rct::getKeyFromBlockchain	(	ctkey &	a,
		size_t	reference_index
	)

h2b()

void rct::h2b	(	bits	amountb2,
		const key &	test
	)

h2d()

xmr_amount rct::h2d

(

const key &

test

)

hash2rct()

static const rct::key rct::hash2rct ( const crypto::hash &  h )

inlinestatic

hash_to_scalar() [1/7]

void rct::hash_to_scalar	(	key &	hash,
		const void *	data,
		const size_t	l
	)

hash_to_scalar() [2/7]

void rct::hash_to_scalar	(	key &	hash,
		const void *	data,
		const std::size_t	l
	)

hash_to_scalar() [3/7]

void rct::hash_to_scalar	(	key &	hash,
		const key &	in
	)

hash_to_scalar() [4/7]

key rct::hash_to_scalar

(

const key &

in

)

hash_to_scalar() [5/7]

key rct::hash_to_scalar

(

const ctkeyV &

PC

)

hash_to_scalar() [6/7]

key rct::hash_to_scalar

(

const keyV &

keys

)

hash_to_scalar() [7/7]

key rct::hash_to_scalar

(

const key64

keys

)

hash_to_scalar128()

key rct::hash_to_scalar128

(

const void *

in

)

hashToPoint() [1/2]

key rct::hashToPoint

(

const key &

hh

)

hashToPoint() [2/2]

void rct::hashToPoint	(	key &	pointk,
		const key &	hh
	)

hashToPointSimple()

key rct::hashToPointSimple

(

const key &

hh

)

identity() [1/2]

key rct::identity ( )

inline

identity() [2/2]

void rct::identity ( key &  Id )

inline

keyImageV()

keyV rct::keyImageV

(

const keyV &

xx

)

keyMInit()

keyM rct::keyMInit	(	size_t	rows,
		size_t	cols
	)

ki2rct()

static const rct::key rct::ki2rct ( const crypto::key_image &  ki )

inlinestatic

MLSAG_Gen()

mgSig rct::MLSAG_Gen	(	const key &	message,
		const keyM &	pk,
		const keyV &	xx,
		const unsigned int	index,
		size_t	dsRows
	)

MLSAG_Ver()

bool rct::MLSAG_Ver	(	const key &	message,
		const keyM &	pk,
		const mgSig &	rv,
		size_t	dsRows
	)

operator!=()

static bool rct::operator!= ( const rct::key &  k0, const crypto::public_key &  k1  )

inlinestatic

operator==()

static bool rct::operator== ( const rct::key &  k0, const crypto::public_key &  k1  )

inlinestatic

pk2rct()

static const rct::key rct::pk2rct ( const crypto::public_key &  pk )

inlinestatic

pkGen()

key rct::pkGen

(

)

populateFromBlockchain()

tuple< ctkeyM, xmr_amount > rct::populateFromBlockchain	(	ctkeyV	inPk,
		int	mixin
	)

populateFromBlockchainSimple()

xmr_amount rct::populateFromBlockchainSimple	(	ctkeyV &	mixRing,
		const ctkey &	inPk,
		int	mixin
	)

precomp()

void rct::precomp	(	ge_dsmp	rv,
		const key &	B
	)

proveRange()

rangeSig rct::proveRange	(	key &	C,
		key &	mask,
		const xmr_amount &	amount
	)

proveRctMG() [1/2]

mgSig rct::proveRctMG	(	const ctkeyM &	pubs,
		const ctkeyV &	inSk,
		const keyV &	outMasks,
		const ctkeyV &	outPk,
		unsigned int	index,
		key	txnFee,
		const key &	message
	)

proveRctMG() [2/2]

mgSig rct::proveRctMG	(	const key &	message,
		const ctkeyM &	pubs,
		const ctkeyV &	inSk,
		const ctkeyV &	outSk,
		const ctkeyV &	outPk,
		unsigned int	index,
		key	txnFeeKey
	)

proveRctMGSimple()

mgSig rct::proveRctMGSimple	(	const key &	message,
		const ctkeyV &	pubs,
		const ctkey &	inSk,
		const key &	a,
		const key &	Cout,
		unsigned int	index
	)

randXmrAmount()

xmr_amount rct::randXmrAmount

(

xmr_amount

upperlimit

)

rct2hash()

static const crypto::hash rct::rct2hash ( const rct::key &  k )

inlinestatic

rct2ki()

static const crypto::key_image rct::rct2ki ( const rct::key &  k )

inlinestatic

rct2pk()

static const crypto::public_key rct::rct2pk ( const rct::key &  k )

inlinestatic

rct2sk()

static const crypto::secret_key rct::rct2sk ( const rct::key &  k )

inlinestatic

scalarmultBase() [1/2]

void rct::scalarmultBase	(	key &	aG,
		const key &	a
	)

scalarmultBase() [2/2]

key rct::scalarmultBase

(

const key &

a

)

scalarmultH()

key rct::scalarmultH

(

const key &

a

)

scalarmultKey() [1/2]

void rct::scalarmultKey	(	key &	aP,
		const key &	P,
		const key &	a
	)

scalarmultKey() [2/2]

key rct::scalarmultKey	(	const key &	P,
		const key &	a
	)

sk2rct()

static const rct::key rct::sk2rct ( const crypto::secret_key &  sk )

inlinestatic

skGen() [1/2]

void rct::skGen

(

key &

sk

)

skGen() [2/2]

key rct::skGen

(

)

skpkGen() [1/2]

void rct::skpkGen	(	key &	sk,
		key &	pk
	)

skpkGen() [2/2]

tuple< key, key > rct::skpkGen

(

)

skvGen()

keyV rct::skvGen

(

size_t

rows

)

subKeys()

void rct::subKeys	(	key &	AB,
		const key &	A,
		const key &	B
	)

sumKeys() [1/2]

void rct::sumKeys	(	key &	Csum,
		const key &	Cis
	)

sumKeys() [2/2]

void rct::sumKeys	(	key &	Csum,
		const keyV &	Cis
	)

verifyBorromean()

bool rct::verifyBorromean	(	const boroSig &	bb,
		const key64	P1,
		const key64	P2
	)

verRange()

bool rct::verRange	(	const key &	C,
		const rangeSig &	as
	)

verRct() [1/2]

static bool rct::verRct ( const rctSig &  rv )

inlinestatic

verRct() [2/2]

bool rct::verRct	(	const rctSig &	rv,
		bool	semantics
	)

verRctMG()

bool rct::verRctMG	(	const mgSig &	mg,
		const ctkeyM &	pubs,
		const ctkeyV &	outPk,
		key	txnFeeKey,
		const key &	message
	)

verRctMGSimple()

bool rct::verRctMGSimple	(	const key &	message,
		const mgSig &	mg,
		const ctkeyV &	pubs,
		const key &	C
	)

verRctSimple() [1/2]

static bool rct::verRctSimple ( const rctSig &  rv )

inlinestatic

verRctSimple() [2/2]

bool rct::verRctSimple	(	const rctSig &	rv,
		bool	semantics
	)

zero() [1/2]

key rct::zero ( )

inline

zero() [2/2]

void rct::zero ( key &  z )

inline

zeroCommit()

key rct::zeroCommit

(

xmr_amount

amount

)

Variable Documentation

H

const key rct::H = { {0x8b, 0x65, 0x59, 0x70, 0x15, 0x37, 0x99, 0xaf, 0x2a, 0xea, 0xdc, 0x9f, 0xf1, 0xad, 0xd0, 0xea, 0x6c, 0x72, 0x51, 0xd5, 0x41, 0x54, 0xcf, 0xa9, 0x2c, 0x17, 0x3a, 0x0d, 0xd3, 0x9c, 0x1f, 0x94} }

static

H2

const key64 rct::H2

static

I

const key rct::I = { {0x01, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 } }

static

L

const key rct::L = { {0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10 } }

static

Z

const key rct::Z = { {0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 } }

static