ͲͲ
ò
ǡǡͲȀʹͲͲͻ
ͳǤͲͷȋ
Ȍ
ǣͲͲ
ͲͲ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͶ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͶ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͶ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͷ
ͷ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ͷ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͺ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͻ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͳͳ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͳ͵
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͳͷ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͳͷ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͳ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͳ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͳͻ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͳͻ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤʹͲ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤʹͳ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤʹͳ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤʹʹ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤʹ͵
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤʹ͵
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤʹͶ
ȋǦȌǣ
Ȍǣ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤʹ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤʹ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵Ͳ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵ͳ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵ͳ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵͵
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵ͷ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵ͷ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵
ʹͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
Ȁ
Ȁ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵ͺ
Ǩ
ǨǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵ͺ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵ͻ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵ͻ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͶͲ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ
ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͶͲ
͵ͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ͳǡ
Ǥ ǡ
ǡ
ǡ
ǡ
Ǥ
Ǥ
Ǥ ǡ
ǡ
ǡ
ǦǦ
Ǥ
ǣ
ͳǤ
ȋǡ Ǧ
ǡ
ǡ
Ȍ
ʹǤ
ǡ
ǡ
͵Ǥ Ǥ ǡ
ͶǤ
Ǧ
ͷǤ
ǡ
ǡ
ǡ
ǡ
ȋ
ȋ
Ȍ
ǡ
ǡ
Ǥ
Ǥ
ʹǡ
Ǥ
Ǥ
ǯǤ
Ǥǡ
ǡ
ǡ
ǡ
Ǥ
ͳͷʹΨʹͲͲͻ
ͷʹΨʹͲͲͻǡ
ǣ
ǣȀȀ
ǤǤ
ȀǦ
ȀȀʹͲͲͻȀͲͷȀ
ȀȀʹͲͲͻȀͲͷȀǦǦ
Ǧ
ǦͲͻǤ
ʹ
ǡ
ǡǨͻǡ
Ǩͻǡ
ǡ
Ǥ ǡ ǡ
Dzdzͻȋ
Dzdzͻȋ
ʹ͵
ǡ
ʹ͵
ǡȌǤ
ͶͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ǡ
ǡ
ǡ
͵
Ǥ
ǡ
Ǥ
Ǥ
ǡ
Ǥ
ǡ
Dzdz
Dzdz
ǡ
Ͷ
ǤDz
Dz
dzǤ
dzǤ
Ǥ
Dz
dzǡ
ͷǤ
ǡǡ
ǡ
Ǥ
ǡ
ǡ
ȋͳȌǤ
ǡ
Ǥ
Ǥ
ǯ
ǡ
ǯ
ǡ
ͻǤ
Ͳ͵
ʹ
Ͳ͵
ʹǡ
ǡ
ͻǤ͵Ǥ
ͳͳǤͲͳͺǤʹͺͲǤʹ
ʹͲͲͺ
ʹͲͲͺǤ
ǣ
ǣ
•
•
•
•
•
•
•
ǣͳͳǤͲͳͺ
ǣͳͳǤͲͳͺ
ǣͳ͵
ǣͳ͵ǦͲͻǦͲͺ
ǣͳͳǤͲͳͺǤʹͺͲǤʹ
ǣͳͳǤͲͳͺǤʹͺͲǤʹ
ǣͳ
ǣͳǦͳͲǦͲͺ
ͲͲͳ
ͻ
ǣǦʹͶ
ͻ
ͻ
ǡ
ǡ
ǡ
Ǧǡ
ǡǡ
ǡ
Ǧ
Ǥ
ͳ
ͳ
Ȃ
͵ΪΪ
ΪΪ
ǡ
Ǥǡ
ǡ
Ǥǡǡ
Ǥ
Ǥ
ͶǷͲȀ
ǷͲȀ
dzǡ
ǣȀȀǤ
Ǥ
ȀȀ͵͵Ͳʹ
ǣȀȀǤ
Ǥ
ȀȀ͵͵Ͳʹ
DzͲ
Ͳ
dzǡ
ǣȀȀǤ
Ǥ
ȀȀͳʹͶ͵
ǣȀȀǤ
Ǥ
ȀȀͳʹͶ͵
ͷǣȀȀǤ
ǤȀ̱Ȁ
ȀͲ
ǣȀȀǤ
ǤȀ̱Ȁ
ȀͲǦ
ǦǦ
ǦǤ
ͷͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ǡ
ǯ
Ǥ ǡ
Ǥ
Ǥ
ͷ
ͷ
ǡǡ
ǡ
ǡ
ͷ
ͷǡ
ǡ
Ǥ
ǡ
Ǥ
ǡ
Dz dz
DzdzǤǡ
DzdzǤǡ
ǡ
Ǥ
ǡ
ǡ
Ǥ
ͻ ͷ ǡǡ
Ǥ
Ǥ
ǡ
Ǥ
Ǥ
Ǥ
ǡ
ǡ
Ǥ
ͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ǡ
ǦǦ
ȋȌ Ǥ
Ǥ͵ʹ
͵ʹ
ǡ
Ǥ
ǡ
Ǥ
ǡ
Ǥ
ǡ
ǡ
Ǥ
Ǧ
Ǥ
Ǥ
Ǥ ǡ
ǦǦ
ǡ
Ǥ
ǡ
ǡ
ǤǤ
Ǥ
ǡ
Ǥ
͵ʹ
͵ʹ
ȋʹȌǤ
ǡ
ǡ
Ǥ
ǡ
Ǥ
ǡ
ǡ
Ǥǡ
Ǥ ǡ
ǣ̳̳̳ǡ
Ǥ
Ǥ
ǡ
Ǥ
ǡǤǤ
Ǥ
ͻ͵Ǥʹͺ
͵ǤʹͺȂǯ
͵ʹ
Ǩ
͵ʹ
Ǩ
Ǥ
ǣǣȋ
ǣǣȋȌǤ
Ͳ͵Ǥʹǡ
ͲͺͲͲͲͲͲͲǤ
Dz
dz ǡ
ǣȀȀǤǦǤ
ͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ǯ
Ǥ
ȋǤȌǤ ǯ
ͳͷͶǤ
ͳͷͶǤ
ͷǣ
Ǥ
ǣ
Ǥ
ǡ
ǯ
ǡ
ǯ
Ǥ
Ǥ
ǡ
ǡ
ͳͷͲǣ
.text:FA717B50 sub_FA717B50
.text:FA717B50
LDR
PC, =0xF855E9B5
=0xF855E
.text:FA717B54 dword_FA717B54
DCD 0xF855E9B5
.text:FA717B58 sub_FA717B58
.text:FA717B58
LDR
..text:FA717B5C dword_FA717B5C
PC, =0xF8550561
=0xF8550
DCD 0xF8550561
.text:FA717B60 sub_FA717B60
.text:FA717B60
LDR
PC, =0xF855061F
=0xF8550
.text:FA717B64 dword_FA717B64
DCD 0xF855061F
(…)
ͷǣ
ͷǣ
ǡ
ǡ
Ǥ
ǡ
ǡ
ǡ
ǡǤǤǤ
ǡ
ǡ
ǡǤ
ǡǤ
ǡ Ͳ ǡ
ͺͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ǡ
ǡ
ͺ
Ǥ
Ǥ
Ǥ
ǡǡ
ǡǡ
ǣ
ǣ
•
•
ǣ
Ǥ
Ǥ
ǣ ǡǡ
Ǥǡ
Ǥǡ
ǦǦ
Ǥ
Ǥ
Ͳǡ
ͻǤ
Ǥ
Ǥǡ
ǡ
͵ʹ
͵ʹǤ
ʹǤ
ǣ
ǣǤ
ǣȋȌ
ȋȌ
Ͳ͵
Ǥ
ʹ
ʹ
Ǥ
ͺ
ǡ
Ǥ
ǡ
Ǥ
ͻǣȀȀǤǤǤ
Ȁ̴
̴
ǣȀȀǤǤǤ
Ȁ̴
̴̴ȀȀȀͲ̴̴Ȁ
̴ȀȀȀͲ̴̴Ȁ
ͻͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
my $entryaddr = unpack("L", substr($img, 0x10, 4));
my ($nexports, $ expaddr) = unpack("LL", substr($img, 0x3C, 8));
print sprintf ("entrypoint address: 0x%04x\nnumber
0x%04x nnumber of exports: 0x%04x\nexport
0x%04x
directory: 0x%04x\n",
n", $entryaddr, $nexports, $expaddr);
my $offs = $expaddr - $entryaddr + 0x78;
my @exports;
for (my
my $i = 0; $i < $nexports; $i++) {
my $addr = unpack("L", substr($img, $offs + $i * 4, 4));
push @exports, $addr;
print sprintf ("0x%08x\n",
n", $addr - 1);
}
ǣ
ȋȌ
ǡ
ǡ
Ͳ Ǥ
Ǥ
ǡ ͵ ʹǡ
ǣ
Ͳ̴͵̴ʹ̴̴ͳǤͳ̳
͵ʹ̳̳ͷ̳̳
ǣ̳Ͳ̳
̳Ͳ̴͵̴ʹ̴̴ͳǤͳ
ǡ
ǡ
Ǥ
Ǥ
Ǥ
Ǥ
Ǥǣ
$ nm --demangle
/cygdrive/c/S60/devices/S60_3rd_FP2_SDK_v1.1/epoc32/release/armv5/lib/euser.lib
/cygdrive/c/S60/devices/S60_3rd_FP2_SDK_v1.1/epoc32/release/armv5/lib/euser.lib
euser{000a0000}-1.o:
U #<DLL>euser{000a0000}[100039e5].dll#<\DLL>1
#<DLL>euser{000a0000}[100039e5].dll#<
00000000 t $a
00000004 t $d
00000000 T PanicTFixedArray()
00000004 t theImportedSymbol
euser{000a0000}-10.o:
U #<DLL>euser{000a0000}[100039e5].dll#<\DLL>a
#<DLL>euser{000a0000}[100039e5].dll#<
00000000 t $a
00000004 t $d
00000000 T CHeartbeat::NewL(int)
00000004 t theImportedSymbol
euser{000a0000}-100.o:
U #<DLL>euser{000a0000}[100039e5].dll#<\DLL>64
#<DLL>euser{000a0000}[100039e5].dll
00000000 t $a
00000004 t $d
00000000 T TMonthName::TMonthName(TMonth)
00000004 t theImportedSymbol
(…)
ǣ
ǣ
ͳͲͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
Ͳ
ȋ
Ȍǡ
ͳͲǤ
ǡ
ǡȏȐ̷ȏȐ̴ȏȐǤ
ǡ
ǡ
ǣ
•
•
•
•
•
ǡ
ǡ
ǡ
Ǥ
Ǥ
$ sqlite3.exe all.db
SQLite version 3.6.14.2
Enter ".help" for instructions
Enter SQL statements terminated with
wi
a ";"
sqlite> select dllname,addr,ordinal,fname from symbols
symbols where dllname='EUser.dll'
order by ordinal;
EUser.dll|4166372448|1|PanicTFixedArray()
EUser.dll|4166331014|2|CCirBuffer::Get()
EUser.dll|4166331050|3|CCirBuffer::Put(int)
EUser.dll|4166330976|4|CCirBuffer::CCirBuffer()
4|CCirBuffer::CCirBuffer()
EUser.dll|4166330976|5|CCirBuffer::CCirBuffer()
EUser.dll|4166330998|6|CCirBuffer::~CCirBuffer()
EUser.dll|4166330990|7|CCirBuffer::~CCirBuffer()
EUser.dll|4166330990|8|CCirBuffer::~CCirBuffer()
EUser.dll|4166337630|9|CHeartbeat:
EUser.dll|4166337630|9|CHeartbeat::New(int)
EUser.dll|4166337736|10|CHeartbeat::NewL(int)
EUser.dll|4166337772|11|CHeartbeat::RunL()
EUser.dll|4166337766|12|CHeartbeat::Start(TTimerLockSpec, MBeating*)
EUser.dll|4166337766|12|CHeartbeat::Start(TTimerLockSpec,
EUser.dll|4166337618|13|CHeartbeat::CHeartbeat(int)
EUser.dll|4166337618|14|CHeartbeat:
EUser.dll|4166337618|14|CHeartbeat::CHeartbeat(int)
EUser.dll|4166337750|15|CHeartbeat::~CHeartbeat()
EUser.dll|4166337748|16|CHeartbeat::~CHeartbeat()
EUser.dll|4166337748|17|CHeartbeat::~CHeartbeat()
(…)
ͺǣ
ͺǣ
ǡ
ǡ
Ǥ
Ǥ
ǡ ǡ
Ǥ
Ǥ
ͳͲ
ȋǤǤȌǤ
ȋǤǤȌǤ
ͳͳͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
import sqlite3
conn = sqlite3.connect('c:\
\\n96_11_018.db')
conn.text_factory = str
c = conn.cursor()
ea = ScreenEA()
while (Word(ea) == 0xf004):
addr = Dword(ea + 4) - 1
c.execute('select shortname,fname from symbols where
where addr =?',(addr,))
row = c.fetchone()
print addr, row
MakeNameEx(ea, row[0], SN_NOCHECK)
MakeComm(ea,row[1]);
ea += 8
ͻǣ
ͻǣ
ͳͷͶ
ͳͷͶ
ǡ
Ǥǯ
ȋ
ǡ
ȌǤ
ȋ
ǡ
ȌǤ
ǣ
ͳʹͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ǡ
Ǥ
ǡ
ǡ
ȋǤǤǤȌͳͳǤ
ǡ
Ǥ ǡ
Ͳ͵ ʹȋͻȌǡ
ʹȋͻȌǡ
Ǥǡʹ
Ǥǡʹ
ǡ
ǡ
ǤǤǤǤ ȋDz dzȌ Ǥ
ǡ
ȋȌ
ȋȌǤ
ǡ
ǡ
ǡ
ǡ
Ǥ
ǤǤ
Ǥ
Ǥ
Ǥ
Ǥ
ǯǣ
ǣ
ldr pc, 0xf88a633d (strcpy) in mdfh264payloadformat.dll!
md
ldr pc, 0xf88aa203 (sprintf) in mdfh264payloadformat.dll!
mdfh264payloadforma
ldr pc, 0xf88a62bb (strcat) in mdfh264payloadformat.dll!
mdfh264payloadformat
ldr pc, 0xf88aa203 (sprintf) in xmlsec.dll!
ldr pc, 0xf88a62bb (strcat) in progdownfs.dll!
ldr pc, 0xf88a633d (strcpy) in progdownfs.dll!
ldr pc, 0xf88a633d (strcpy) in WebCore.dll!
ldr pc, 0xf88aa203 (sprintf) in mdfvidrender.dll!
ldr pc, 0xf88a633d (strcpy) in mdfvidrender.dll!
ldr pc, 0xf88a62bb (strcat) in mdfvidrender.dll!
ldr pc, 0xf88a62bb (strcat)
strcat) in wmarender.dll!
ldr pc, 0xf88aa203 (sprintf) in wmarender.dll!
ldr pc, 0xf88a633d (strcpy) in wmarender.dll!
ldr pc, 0xf88a633d (strcpy) in vidsite.dll!
ldr pc, 0xf88aa203 (sprintf) in vidsite.dll!
ldr pc, 0xf88a62bb (strcat) in vidsite.dll!
ldr pc, 0xf88a62bb (strcat) in mp4fformat.dll!
ldr pc, 0xf88a633d (strcpy) in mp4fformat.dll!
ldr pc, 0xf88aa203 (sprintf) in mp4fformat.dll!
(...)
ͻǣ
ͻǣ
ͳͳ
Ǥ
Ǥ ǡ
ǡ
ȋ
ȋ
ȌǤ
ͳ͵ͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ͷǡǡ
ǡ
ǡ
ȋǤ
ȋǤȌǤ
ǡ
Ǥ
ǡ
ǡ
ǡ
ǡ
ǡ
ǡ
Ǥ
Ǥ ǡ
Ǥǡ
Ǥ
ǡ
Ǥ
ǡǡ
ǡǡ
Ǥ
Ǩ
ͳͶͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ǡ
ǡ
ǫ
ǡ
Ǥ
ǤǡǤ
ǡ
ǯǤ
ǡ
ǯ
Ǥ
ǣ
ǣ
ǡ
ǯ
ǡ
ǯ
Ǧ
ΪΪ Ǥ ǡ
ǡ
Ǩ
Ǥ
Ǥ
ǡ
ǡ
ǡ
Ǥ
ȋȌǡ
ǡ
ǡ Ǥ
ǡǡǤ
ǡǡǤ
ǡ
ǡ
ǡ
Ǥ
Ǥ Ͷ
Ǥ
Ǥ
ͺǣ
Ǥ
ǣ
ǣ
Ǥ
ǣ
ȋȌ
ǡ
ǤǦ
ȋȌǡ
ǡ
ǡ
Ǥ
ǡ
Ǥ
Ǥ ǡ
ͳͷͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ǡ
Ǥ
Ǥ
ȋͶȌǤ
ǡ
Ǥ ǡ Ǥ
ǡ
Ǥ
Ǥ
ǡ
Ǥ
Ȃ
ǡ
Ǥ ǡ
Ǥ
Ǥ
Ǥ
Ǥ ǡ
Ͳ ͵
ͳʹ
ʹ Ǥ
Ǥ
ǡ
Ǥ
ǡ
Ǥ
ǡ
Ǥ
ǡ
Ǥ
ǡ
Ǥ
ǡ
ǡ
Ǥ ǡǡ
ȋ Dz
dzȌ
dzȌ
Ǥ
Ǥ
ͳʹͻͲ
ͻͲ͵Ǥʹǡ
Ǥʹǡ
ʹͲͲͻǤ
ǡ
ʹͲͲͻǤ
ǡ
ǯ Ǥ
Ǥ
ǡ
Ǩ
ǣȀȀǤǦǤ
Ȁ
Ǥ
Ȁ
Ǥ
ͳͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ͻǣ
Ǥ
ǣ
ǣ
Ǥ
ǣ
ȋȌ
ǯǤ
ǯǤǡ
ǡ
Ǥ
Ǥ
Ǥ
ǡǡ
ǡǡ
Ǥ
Ǥ
Ǥ
Ǥ
ǡ
ǡ
ǡ
Ǥ
ǡ
ǫ
ǫ
Dz
dzǤ
Dz
dzǤ
̳̳Ǥ
ͳ͵
ȋȌ
ȋȌ
Ǥ
ǡǤ
ͼǣ
Ȁ
Ǥ
ǣ
ǣ
Ȁ
Ǥ
ǣ
ȋȌ
ͳ͵ǡ
ǡ
Ǥ
Ǥ
ǡ ǡ
Ǥ
Ȁ
ǡ
Ȁ
ǡȋ͵ȌǤ
ͳͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ǡ
Ǥ
ǡǡ
Ǥ
ǡ
Ǥ
ǡ
Ǥ
ͳͶ
Ǥ ǯ
ǯ
Ǥ
ǡǡ
ǡǡ
ǤǤ
Ǥ
ͽǣ
ͳͶǣȀȀǤǤ
Ȁ
ǣȀȀǤǤ
Ȁ
ͳͺͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
Ǯǯ ǡ
ͳͷǤǤ
Ǥ
ǡ
ǡǫ
ǡǫǡ
ȋȌǡ
Ȍǡ
Ǥ ǡ
ǡ
Ǥ
Ǥ
ǡ
Ǥ
Ǥ
ǡ ǡ
ǡ
Ǥ
ǣ
ǡǡ
Ǥ
Ǩ
ǡ
ǡ
ǡ
ǡ
Ǥ
ǡ
Ǥ
Ǥ
Ǥ
ǡ
ǡ
ǡ
ǫ
Ǥ
Ǥ
̴Ͳ
ʹͲͲͻͳǤ
Ǥ
Ǥ
Ǥ
̳̳̳
ǡ
ǣǡ
ǣǡ
ǡ
ǡ
Ǥ
Ǥ
̳̳̳̳
Ǥ
ǡ
ǡ
Ǥ
ǡ ǯ
DzǤdz
ǣ̳
̳̳̳Ǥ
ǣ̳
̳ ǣǤ
ǣǤ
ǣǣȋDzǤdzȌǡ
ǤǤ
̳̳̳
Ǥ
ͳͷ
ΪΪ
ΪΪ
Ȁ
Ǥ
Ȁ
Ǥ
ΪΪ
ΪΪ
ȋȌǤ
ͳǣȀȀǤ
ǤȀȀȀǤǫ
ǣȀȀǤ
ǤȀȀȀǤǫ
αͳͶ͵Ͷͻͻ
ͳͻͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ǡ
ǡǣ̳̳̳ǤǤ
ǡ
ǡǡ
ǡǡ
Ǥ
ΪΪ
ΪΪ
ǣǣ
ȋȌ
Ǥ
LOCAL_C void MainL()
{
_LIT(KPath,"E:\\subst
subst\\");
RFs fs;
TInt i, err;
CleanupClosePushL(fs);
User::LeaveIfError(fs.Connect());
for (i = 0; i < 25; i++) {
err = fs.SetSubst(KPath, i);
}
fs.Close();
CleanupStack::PopAndDestroy();
}
ͼǣ
ͼǣ
ǡ
ǡ
ǡ
ǡ
Ǥ
Ȃ
ǡ
Ǥ
Ǥ ǡ
Ǥǡ
ǯ ǡ
Dzdz
Ǥ
Ǥ
ǡ
Ǥ
Ǥ
Ȃ
Ǥ
Ǥ
ǡǡ
Ǥ
Ǥ ǡ
ǯ
ͳǤǣ
Ǥ
•
•
•
Ǥǣ
Ǥǣ
Ǥ
Ǥǣ
Ǥ
Ǥǣ
Ǥǣ
ǡ
ǡǯ
Ǥ
ͳ͵ǤͲǤͺͲ͵
͵ǤͲǤͺͲ͵ǤʹǤ
ʹͲͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
Ǥ
Ǥǡ
Ǥǡ
ǡ
Ǥ
Ǥ
Ǥ
ǡ
Ǥ
ǡ
ͲͳͲǤ Ǥ
Ǥǡ
Ǥǡ
ǣǣȋȌ
Ǥ
ǡ
Ǥ
Ǥ
Ǥ
ǡ
Ǥǡ
Ǥ
ǡ
ǡ
ǡ
ǡ
Ǥ
ǣǣȋȌ
Ǥ
ǣǣ
ǡ
ǡ
Ǥ
ǣ
ȋȌ
Ȍ
;ǣ
ȋ
Ǥ
ͲͳʹͷͲȋ
ͲͳʹͷͲȋͲͻͳͶȌǣ
11 00 00 ea (branch +44)
ǡ
ǯ
Ǥǡ
ǡ
Ǥǡ
ǡ
Ǩ
Ǩ
Ǥ
Ǥǣǣȋ
ǣǣȋȌ
Ǥǡ
Ǥǡ
ͲͳͶǡ
ǡ
ͲͳͶǡ
ǡ
ʹͳͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
Ǥ
Ͳͻ
ǡ
Ͳͻ
ǡ
ȋͲȌ
ȋͲȌǤ
Ͳ͵ͺ͵ͺȋ
Ͳ͵ͺ͵ͺȋͲͻȌǣ
00 00 a0 e0 (mov r0,0)
Ϳǣ
ǣ
ȋȌ
ȋȌ
ǡ
Ǥǣ̳̳
ǡ
̳
ͳͺǤ
ǡǡ
ǡ
ǡ
Ǥ ǡ
ǡ
ǤǤ
ͳͲǡǡ
ǡ
Ǥ
Ǥ
ͳͺ
Ƿ
Dz ǡ
ǡ Ǥ
ǫ
ǫ ȀȀȀ
ǡ
ǫȀȀȀ
ǡ
Ǥ
ǡ
ǡ
Ǩ
ǡ
Ǩ
Ǥ
ǡ
Ǥ
ʹʹͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ͷͶǣ
ǣ
ǡ
ǡ
ǡǡ
ǡǯ
Ǥ
Ǥ
ǡ
ǡ
Ǥǡ
ǡ
ǡ
Ǥ
͵Ǥ
ǤΪΪ͵
ǤΪΪ͵
Ǥ
ǯǡ
ǯǡ
Ǥ
ǡ
ǡ
ǡ
Ǥ
Ǥ
ʹ͵ͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
//-----------------------------------------------------------------------------------------------------------------------------------------------// Add header
void metrotrk_t::prepend_hdr(void)
{
size_t len = pkt.size();
prepend_byte((uchar)len);
prepend_byte((uchar)len
byte((uchar)len >> 8);
prepend_byte(0x90);
prepend_byte(0x01);
}
ͽǣ
ͽǣ
ȋεͷǤͷȌ
ȋεͷǤͷȌͳͻǤ
ǡ
ǡ
ǡ
ǡ
Ǥ
ǡ
ǡ
Ǥ
Ǥǡ
ǡ
ǡǤ
ǡ
Ǥ ǡ
ΪΪ̴
ǡ
̴
ǡ
̴
ǡ
Ǥ
ǯ
ǯǡ
ǡ
ǡ
ǡ
Ǥ
ǦǤ
ǡ
̴
ǡ
̴
ȋȌ
Ǥ
Ǥ
Ǥ
ǡ
ǡ
ǣ
•
•
•
•
•
•
•
Ǥ
Ǥ
ʹͲǤǡ
Ǥ
Ǥǡ
Ǥ
ͳͻǣȀȀǤǦǤ
ȀȀͷͷȀǤ
Ǥ
ȀȀͷͷȀǤ
ʹͶͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
̴
Ǥ
struct __declspec(dllexport) metrotrk_t
{
(…)
public:
metrotrk_t(void) {fp_handle_notification = NULL; debug_debugger=0;}
debug_debugger=0;}
~metrotrk_t(void) { term(); }
void setdebug(bool which);
bool init(int port);
void term(void);
bool reset(void);
bool ping(void);
bool connect(void);
bool disconnect(void);
bool set_notification_func(handle_notification_func h);
bool support_mask(uchar mask[32], uchar *protocol_level);
*protocol_l
bool cpu_type(trk_cpuinfo_t *cpuinfo);
int open_file(const char *name, trk_open_mode_t mode);
ssize_t write_file(int h, const void *bytes, size_t size);
ssize_t read_file(int h, void *bytes, size_t size);
bool seek_file(int h, uint32 off, int seek_mode); //
/ SEEK_...
bool close_file(int h, int timestamp);
bool install_file(const
ll_file(const char *fname, char drive);
bool create_process(
const char *fname,
const char *args,
trk_process_info_t *pi);
int attach_process(int pid); // returns tid
bool resume_thread(int pid, int tid);
bool step_thread(int
t pid, int tid, int32 start, int32 end, bool stepinto);
stepin
bool suspend_thread(int pid, int tid);
int add_bpt(int pid, int tid, int32 addr, size_t len,
len, int count, bool
thumb_mode);
bool del_bpt(int bid);
bool change_bpt_thread(int bid, int tid);
bool terminate_process(int pid);
ssize_t read_memory(int pid, int tid, int32 addr, void
void *bytes, size_t size);
ssize_t write_memory(int pid, int tid, int32 addr, const void *bytes, size_t
size);
bool read_regs(int pid, int tid, int regnum, int nregs,
nr
uint32 *values);
bool write_regs(int pid, int tid, int regnum, int nregs,
nregs, const uint32 *values);
bool get_process_list(proclist_t &proclist);
bool get_thread_list(int pid, thread_list_t *threadlist);
*thread
bool poll_for_event(int timeout);
int32 current_pid(void)
t_pid(void) const { return tpi.pid; }
bool recv_packet(uchar *seq, int timeout);
bool send_reply_ok(uchar seq);
uchar extract_byte(int &i);
uint16 extract_int16(int &i);
uint32 extract_int32(int &i);
string extract_pstr(int &i);
string extract_asciiz(int
t_asciiz(int &i);
};
;ǣ
̸
;ǣ
̸
ȋήήȀȌ
ȋήήȀȌ
ʹͲǡ
ǡ
ǡ
ǡ
Ǥ
Ǥ
ǡ
Ǧ
ǡ
ǡ
ǡ ǡ
ǡ
Ǥ
Ǥ
Ǥ
ʹͷͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ȋǦȌ
Ȍ
ǣ
ǡ
ǡ
ͻ ǯ
Ǥ
ǡ
ǡ
Ǥ
Ǥǡ
Ǥ
Ǥ
Ǥ
ǡ
Ǥ ȋȌǡ
Ǥ
Ǥ
Ǥ
ǣ
ǣ
ǡ
ǡǤǤ
Ǥ
Ǥ
Ǥ
Ǥ
ǡ
ǡǤ
Ǥ
ǣ
ǡ
ǡǤǤ
ǡǤǤ
ǡǤǤ
Ǥ
Ǥǡ
Ǥ
Ǥǡ
ǡ ǡ
Ǥ
Ǥ
ǡ
ǡ
Ǥ
ǡ
Ǥ
Ǥǣ ǡ
Ǥǣǡ
Ǥǡ
Ǥǡǡ
ǫ
ǣǣȋȌ
ǣǣȋȌ
Ǥ
Ǥ
Ǥ
ǡ
Ǥ
Ǥ ͻ
Ǥ
LOCAL_C void MainL() {
CCommandLineArguments* args = CCommandLineArguments::NewLC();
CCommandLineArguments::NewLC();
TInt nArgs = args->Count();
>Count();
if (nArgs != 2) {
console->Printf(_L("missing
>Printf(_L("missing filename parameter! Exiting\n"));
Exiting
} else {
TPtrC filename(args->Arg(1));
filename(args
console->Printf(_L("trying
>Printf(_L("trying to handle file: %S\n"),
%S n"), &filename);
ʹͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
CDocumentHandler* handler = CDocumentHandler::NewL(NULL);
CleanupStack::PushL(handler);
TDataType emptyDataType = TDataType();
handler->OpenFileL(filename,
>OpenFileL(filename, emptyDataType);
}
CleanupStack::PopAndDestroy(); // handler
CleanupStack::PopAndDestroy(); // args
}
Ϳǣ
Ϳǣ
ȋήήȌ
Ǥ
Ǥ
ǡ
ǡ
ǡ ǡ ǣǣȋȌ
ǣǣȋȌ ȋ
Ǥ
Ǥ ȌǤ
Ǥ
ͳͲǤ
Ǥ
ͳͲǤ
LOCAL_C void MainL() {
RProcess process;
_LIT(KTrkPath, "");
TThreadId app_threadid;
CApaCommandLine* cmdLine;
cmdLine=CApaCommandLine::NewLC();
cmdLine->SetExecutableNameL(_L("C:
SetExecutableNameL(_L("C:\\sys\\bin\\trkguiapp.exe"));
trkguiapp.exe"));
cmdLine->SetCommandL(
>SetCommandL( EApaCommandRun );
RApaLsSession ls;
User::LeaveIfError(ls.Connect());
while(1) {
User::After(120000000);
User::LeaveIfError(
User::LeaveIfError(ls.StartApp(*cmdLine,app_threadid))
);
}
CleanupStack::PopAndDestroy();
anupStack::PopAndDestroy(); // cmdLine
}
ͷͶ
ͷͶǣ
ȋήήȌ
ǡ
ǡ
ǡ
ǤΪΪ
ΪΪ
ǣ
ͳǤ
ʹǤ
͵Ǥ
ǡ
ǡ
ͶǤ
ͷǤ
Ǥ
Ǥ
ͺǤ
ͻǤ
ǡ
ǡ
ͳͲǤ
ʹͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
Ǥ
Ǥ
int handle_file_remote(char *sourcefile, char *targetfile,
*targetfile, char *appname) {
proclist_t proclist;
// list of processes
process
thread_list_t threads;
// list of threads
trk_process_info_t pi;
// info about debugged process
trk->set_notification_func(&handle_notification);
>set_notification_func(&handle_notification);
if (debuglevel > 1) {
trk->setdebug(true);
>setdebug(true);
}
if (!(copy_file(sourcefile, targetfile, trk))) {
printf("Failed to copy file to target device. Exiting\
Exiti \n");
return 0;
}
if ( !(trk->create_process("C:
>create_process("C:\\sys\\bin\\launcher.exe",
launcher.exe", targetfile,
&pi)) || !(trk->get_thread_list(pi.pid,
>get_thread_list(pi.pid, &threads)))
{
printf("Failed to start launcher application. Exiting\
Exiti \n");
return 0;
}
trk->resume_thread(pi.pid,
>resume_thread(pi.pid, threads.front().tid);
for(int i = 0; i < 10; i ++) {
trk->poll_for_event(1000);
>poll_for_event(1000);
}
trk->terminate_process(pi.pid);
>terminate_process(pi.pid);
if ( !trk->get_process_list(proclist)
>get_process_list(proclist) )
{
printf("Failed to get list of running processes. Exiting
Exiting\n");
return 0;
}
int real_pid = 0;
for ( int i=proclist.size()
i=proclist.size()-1; i >= 0; i-- ) {
if (strstr(proclist[i].name.c_str(), appname)) {
if (debuglevel) {
printf("Handler application found!\n",
found!
proclist[i].name.c_str());
printf("%s n", proclist[i].name.c_str());
printf("%s\n",
}
real_pid = proclist[i].pid;
procl
}
}
if (!real_pid) {
printf("Failed to find handler application\n");
application
return 0;
}
if ( !trk->attach_process(real_pid))
>attach_process(real_pid)) {
printf("Failed to attach to target process\n");
process
return 0;
}
for(int i = 0; i < 100; i ++) {
ʹͺͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
trk->poll_for_event(100);
poll_for_event(100);
}
trk->terminate_process(real_pid);
>terminate_process(real_pid);
printf("Process terminated.\n");
terminated.
return 0;
}
ͷͷǣ
ͷͷǣ
ȋήήȀȌ
ȋήήȀȌ
ǡ
ǡ
Ǥ
ǡ
ȋ
ȋ
ȌǤ
case TrkNotifyStopped:
{
uint32 ea = extract_int32(i, pkt);
uint32 pid = extract_int32(i, pkt);
uint32 tid = extract_int32(i, pkt);
printf("Exception: pid = %d, tid = %d, pc=0x%08x\n",
pc=0x%08x n", pid, tid, ea);
printf("Description: %s\n",
%s
desc.c_str());
printf("---------------------------------------------------------------------------------\n",
n", pid, tid, ea);
uint32 rvals[17];
trk->read_regs(pid,
>read_regs(pid, tid, 0, 17, rvals);
for (int i = 0; i < 17; i++) {
printf("%cR%d: %08X", i%4 == 0 ? '\n'
' n' : ' ', i, rvals[i]);
}
printf("\n");
trk->terminate_process(pid);
e_process(pid);
}
ͷǣ
ͷǣ
ȋήήȀȌ
ȋήήȀȌ
ʹͻͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
Ǥ ǡ
Ǥǡǡ
Ǥǡǡ
ʹͳǤ
ȋͷȌǤ
ͳǤ
Ͳͳ̴͵̴ʹ͵̴Ǥ͵
ͳͷͻ
Ͷȋ͵
Ǥʹ͵
ͶȌ
Ǧ
Ͳʹ̴͵̴Ͷ̴ʹǤ͵
ͳǤͳ
Ͷȋ͵
ǦͶ
ͶȌ
Ͷ
Ͳ͵̴Ͷ̴ʹͶ̴ʹǤͶ
ͳͷ
ǦͶ
Ͷ
̷ͳǤ͵
ͲͶ̴Ǥ
Ͳͷ̴̴ͻǤ
ͳʹͺ
ʹʹǤʹ
ͶͶͲ
ͶͲ
ȋǤʹͶȌǡ
ͻ
ǤʹʹǤͳǡ
Ǧͳ
ͻǤʹ
ͻ
ͷǣ
ǣ
ǣ
•
•
•
͵ʹȋʹͲͶͺǤȌ
͵ʹȋʹͲͶͺ
Ͷȋ
ͶȋʹͲͶͺǤȌ
ͶȋʹͲͶͺ
ʹͲͶͺǤȌ
Ͳ
̴
̴ʹʹͳʹͲͲͺͲͺʹͷͻǤ
Ͳ
̴
̴ʹʹͳʹͲͲͺͲͺʹͷ
ʹͳ
ǡ
ǡ
Ǥǡ
Ǥǡ
ǡ
ǡ
Ǯ
ǯǤ
͵ͲͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ͷͷǣȋ
ǣȋ
Ȍ
ǡǤ
ǡ
Ǥ
ǡ
Ȁ
ǡ
Ȁ
Ǥ
Ǥ
ǡ
ǡ
ǡ
Ǥ
ǡ
Ǥ
Ǥ
ǣ
Ǥ
ͳǤ
ǡ
Ǥǡ
ǡ
Ǥ
Ǥ
ʹǤ
ǡ
ǤǤ
ǡ ͳ ͵
Ǥǡǡ
ǡǡ
Ǥ
ʹʹǡ
Ǥ ǡ
Ǥ
Ǥ
ʹʹ
Ǥ
Ǥ
͵ͳͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ͲͳͶ
Ͳ͵
Ͳ
Ͳʹ
Ͳͺʹͷ͵
ͲͻͳͲͲʹ
ͳͻ
ͳ
ͳ
ʹͲ͵͵Ͷͺ
ͲʹȋͶȀʹȌ
ͲʹȋͶȀʹȌ
ͲͳȋǤʹ͵ȀȌ
ͲͶȋȌ
ͲʹȋͶȀʹȌ
ͲͶȋȌ
Ͳ͵ȋǤʹͶȀʹȌ
ʹͺ
ʹͳͳʹͶ
ʹ͵
ʹ͵
Ͷͷ
ʹ͵
Ͳͺͷͷͷ
Ͳͺͷͷͷ
ȏȐ
ȏȐ
Ͳͺͷͷͷ
Ͳͺͷͷͷ
ȏȐ
Ȑ
ȏȐ
ȏȐ
ͲʹȋͶȀʹȌ
Ͳ͵ȋǤʹͶȀʹȌ
ʹ͵
Ͳͺͷͷͷ
ȏȐ
ʹͻ͵ʹ
ͲͶȋȌ
ȏȐ
Ǥ
Ǥ
Ǥ
Ǥ
Ǥ
Ǥ
ʹͶ
Ǥ
Ǥ
ʹͶ
Ǥ
Ǥ
ʹ͵
ͻ
ͲͶȋȌ
ȏȐ
Ǥ
͵ͷ
͵ʹ͵ͺ
ͲʹȋͶȀʹȌ
ͲͶȋȌ
ʹ͵
Ͷʹͳͺ
ͺͶ
Ͷͻ
ͺͷͷͳͷ
͵͵͵Ͷ
ͷͲͷ
Ͷ
Ͳ͵ȋǤʹͶȀʹȌ
Ͳ͵ȋǤʹͶȀʹȌ
ͲͶȋȌ
Ͳ͵ȋͶȌ
ͲʹȋͶȀʹȌ
Ͳ͵ȋǤʹͶȀʹȌ
ʹ͵
ʹ͵
ʹ͵
ʹ͵
Ͳͺͷͷͷ
ȏȐ
ȏȐ
ȏȐ
ȏȐ
Ͳͺͷͷͷ
Ͳͺͷͷͷ
ȏȐ
ȏȐ
Ͳͺͷͷͷ
Ͳͺͷͷͷ
ȏȐ
ȏȐ
ͺͺ
ͷ͵
ͲͶȋȌ
ȏȐ
ȏȐ
ͻʹ
Ͷͻ
ͻ͵ͷͻͶ
ͻͶͻͲͳ
ͲʹȋͶȀʹȌ
Ͳ͵ȋǤʹͶȀʹȌ
ͲͶȋȌ
ʹ͵
Ͳͺͷͷͷ
ȏȐ
ȏȐ
ȏȐ
ȏȐ
ȏȐ
ȏȐ
ͷ
ʹͳͲ
ʹ
ͶͶͳͳͲ
͵
ʹͶ
ͳ
ͳ͵Ͳ
Ͷ
͵
͵ͻͲ
ͷ
ͳͺʹ
ͲͶȋȌ
ͲʹȋͶȀʹȌ
Ͳ͵ȋͶȌ
Ͳ͵ȋǤʹͶȀʹȌ
ͲʹȋͶȀʹȌ
ͲʹȋͶȀʹȌ
Ͳ͵ȋǤʹͶȀʹȌ
ʹ͵
ʹ͵
ʹ͵
ʹ͵
ʹ͵
ȏȐ
ȏȐ
Ͳͺͷͷͷ
Ͳͺͷͷͷ
Ͳͺͷͷͷ
Ͳͺͷͷͷ
Ͳͺͷͷͷ
ȏȐ
ȏȐ
ͺʹ
ͻͻʹ͵
ͳʹ͵ͷ
ͻͳͷͷ
ʹͺͺ
ͲʹȋͶȀʹȌ
Ͳ͵ȋͶȌ
Ͳ͵ȋǤʹͶȀʹȌ
Ͳ͵ȋͶȌ
ͲͶȋȌ
ʹ͵
ʹ͵
ʹ͵
Ͳͺͷͷͷ
Ͳͺͷͷͷ
ȏȐ
ȏȐ
Ͳͺͷͷͷ
ȏȐ
ȏȐ
ȏȐ
ȏȐ
ͻͳͷ͵
Ͷ͵ͻ
ͲʹȋͶȀʹȌ
Ͳ͵ȋǤʹͶȀʹȌ
ʹ͵
ʹ͵
Ͳͺͷͷͷ
Ͳͺͷͷͷ
Ǥ
Ǥ
Ǥ
Ǥ
Ǥ
Ǥ
Ǥ
Ǥ
ʹͶ
Ǥ
Ǥ
Ǥ
Ǥ
Ǥ
Ǥ
Ǥ
Ǥ
Ǥ
Ǥ
Ǥ
Ǥ
ʹͶ
Ǥ
Ǥ
Ǥ
Ǥ
Ǥ
Ǥ
ͺͻ
Ǥ
Ǥ
Ǥ
ǣ
͵ʹͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ͻ
ͳͳǤͲͳͺǤ
ͳ ͳ ǡ
ǡ
ͻǤ
ǡ
ͻǤ
Ǥ
ͻǤ
ǡ
ǡ
ǡ
Ǥ
Ǥ
ǡ
ǡ
ʹ͵Ǥǡ
ʹ͵
Ǥǡ
ʹ͵
ȋȌǤ
ȋ
ǡ
Ǥ
ͳͶ
Ǥ
ǡ
Ǥ
Ǥ ͓ͳͻ
ͳ
ͳ
͓
Ǥ
ȏȐǤ
ǤǤ
Ǥ
ǣ
ǣ
ͷǣǤ
ͷǣǤ
ȋȌ
ȋȌ
ǡ ͵
ΪͳǤ
͵ǡ
Ǥ
͵ȏ
ȐǤ
ȋͳͶȌǤ
ȋͳͶȌǤ
ͷͺǣ
͵
ǡ
ǡ
Ǥ
Ǥ
ʹ͵
ǡ
ǤǡǤ
ǤǡǤ
͵͵ͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ǡ
ǡ
ǡǡ
Ǥ
Ǥ
Ǥ
Ǥ
ǣ
ͳǤ ǡ
ǡ
ȋȌ
ȋȌ
Ȍ
ʹǤ ͳ
ͳ
͵Ǥ
ǡ
ȋȌ
ȋȌ
ǡ
ȋ͵ȌǤ
Ǥ
͵
͵
ǮǯȋͶͳͶͳͶͳͶͳȌǣ
ǮǯȋͶͳͶͳͶͳͶͳȌǣ
ͷͻǣͶ
ͷͻǣͶͺͷͺͷͺͷͺͷ
ͺͷͺͷͺͷͺͷ
ǡ
ǡ
ȋǤǤȌ
ȋǤǤȌ
Ǥ
Ǥ
͵ͶͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ǡ
ǡ
Ǥ
ǡ
ǡ
Ǥ
Ǥ
ǡ
ǡ
Ǥ
ǡ
Ǥ
ǡ
ǡ
ǡǡ
ǡ
ǡǡ
Ǥ
Ǥ
Ǥ
ǡ
Ǥ
ǡ
ǡ
Ͳǡ
ǤǤ
ǡ
ǡ
ǡ
Ǥ
Ǥǡ
Ǥ
Ǥ
ǡ
Ǩ
ǡ
Ǥ
ǡ
ǡ
ǡǡ
Ǥ
Ǥ
ǡ
Ǥ
ǡ
ǡ
Ǯ
ǯ
Ǥ
ǡǡ
Ǥ
Ǥ
ǣ
Ǥ
ǣ
•
•
•
•
•
ǡ
ʹͶ
ʹͶ
ǯǤ
ǯǤ
Ǥ
͵ͷͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
Ȁ
Ǥ
Ǥ
ǫ
ǫ
ǫ
ǫ
ǫ
Ǥ
Ȁ
ȋͳȌǡǯ
Ȁ
ǡǯ
Ǥ
ȋͳȌ
ȋͳȌ
ǡ
ǡ
Ǥ
ǡ
ǡ
ǡ
Ǥ
ǯ
Ǥ
Ǥ
ǫǡ
ǫǡ
ǫǡ
Ǥ
Ǥ
ͳǤ
ʹǤ
͵Ǥ
ͶǤ
ǣǣȋǮǣ̳̳̳̳̳̳̳̳̳ǯȌ
ǣ̳̳̳̳̳̳̳̳Ǥ
ǣǣȋȌ
ǣǣȋȌ
ǣǣȋǮǤǯȌ
ǣǣȋǮǤǯȌ
Ǥ
Ǥ
ǡ
ǡ
Ǥ
Ǥ
Ǥ
ǡ ǡ
Ǥ
Ǥ
ǣ
#!/usr/bin/perl
my @caps = ("TCB",
"CommDD",
"PowerMgmt",
"MultimediaDD",
"ReadDeviceData",
"WriteDeviceData",
"DRM",
"TrustedUI",
"ProtServ",
"DiskAdmin",
"NetworkControl",
"AllFiles",
"SwEvent",
͵ͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
"NetworkServices",
"LocalServices",
"ReadUserData",
"WriteUserData",
"Location",
"SurroundingsDD",
"UserEnvironment");
$fn = shift @ARGV;
open(F, $fn) || die "could not open input file! $! \n";
seek(F, 0x4C, SEEK_SET);
read(F, $buf, 4);
close(F);
my ($caps) = unpack("L", $buf);
$nbit = 0x1;
for ($i = 0; $i < 20; $i ++) {
if ($caps & $nbit) {
print @caps[$i]."+";
}
$nbit <<= 1;
}
ͷͼǣ
ȋȌ
ȋȌ
ȋ
ȋ
ȌǤͳǤ
ǤͳǤ
$ perl getcap.pl ZBIN/MediaPlayer.exe
MultimediaDD
ReadDeviceData
WriteDeviceData
DRM
DiskAdmin
SwEvent
NetworkServices
LocalServices
ReadUserData
WriteUserData
Location
UserEnvironment
ͷ
ͷͽǣǤ
ǡǤǡǡ
Ǩ
ǡǤǡ
ǡ
Ǩ
Ǥǡ
Ǥǡ
Ǥ
Ǥǡ
Ǥǡ
Ǥ ǡ
ǡ
Ǥ
ǡ
ǡ
Ǥ
ǡ
Ǩ
Ǩ
ǯ
Ǥ
Ǥ
ǣ
͵ͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
•
•
•
•
•
•
ǡ
ǡǡ
ǡ
ǡǡ
ǯ
ǯ
ǯ
Ǧ
ǡ
ǡ
Ǥ
Ǥ
ǡ
ǤDz
dz
Dz
dz
Ǥͳʹ
Ǥ
ͷǣ
ǣ
ǣ
ǡ
ʹͷǤ
Ǥ
Ǩ
ʹͲͲͺǡ
ǡ
Ǥ
Ǥ
ǡ Ͳǡ
ʹͷǣȀȀǤǤǤ
Ȁ̴
̴
ǣȀȀǤǤǤ
Ȁ̴
̴̴Ȁ̴Ȁ̴̴̴ΪΪǤ
̴Ȁ̴Ȁ̴̴̴ΪΪǤ
͵ͺͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ȋȌ
Ǥ
Ǥ
Ǥ
Ǥ
Ǥ
ǯ
ǯǡ
ʹͲͲͻʹǤ
Ǥ
Ǥ
ǡ
Ȁ
ǯ
ǯ
ǡ
Ǥ
ǡ
Ǥ
Ǥ
ǡ ǡ
ǡ
ȋ
ȋ
ȌǤ
ǤǦǤ
Ǥ
ȋͲͲͲͲͲǡ
ǡǡȌȂ
ǡ
ǡ
Ǥ
Ǥ
ǡǡ
ǡǡ
Ǧ
Ǥ
Ǥ
ͳǤǡǤǣ
ǣ
Ǥ
Ǥ
ȏȐʹͲͲͺǤǣȀȀǤ
Ǥ
ȀȀ
ǣȀȀǤ
Ǥ
ȀȀǦǦͲͺȀǦǦͲͺǦȀ
Ȁ
Ǧ
ǦͲͺǦǦ
Ǧ
ǦǤǤ
ʹǤȋȌǡǤ
ȋȌǡǤͲ
Ǥ
Ͳ
ǤȏȐ
ǣȀȀǤ
ǤȀȀ̴̴̴ Ͳ̴
̴̴Ǧ
ǣȀȀǤ
ǤȀȀ̴̴̴̴Ͳ̴
̴̴
̴ͳͶǤǤ
͵ǤǡǤǣ
ǣǦǤǤǤǣƬǡǡ
ǣƬǡǡ
ʹͲͲͷǤǦͳ͵ͻͺǦͲǦͶͲǦͲʹͷʹͶ
ͲʹͷʹͶǦǤ
ͶǤ
Ǥ
Ǥ
ǤȏȐ
ȏȐ
ǤǡʹͲͲͶǤ
ǣȀȀǤ
Ǥ
ȀȀ̴̴Ȁ
Ȁ̴ȀǤǤ
ǣȀȀǤ
Ǥ
ȀȀ̴̴Ȁ
Ȁ̴ȀǤǤ
ʹǣȀȀǤǤȀʹͲͲͻȀͲ͵ȀͳʹȀ
ǣȀȀǤǤȀʹͲͲͻȀͲ͵ȀͳʹȀ
ǦǦǦȀ
͵ͻͶͲ
̹ʹͲͲͻ
ǣͲͲ
ͲͲ
ͷǤǡǤǤȏȐ
ǤȏȐͲͺͲʹǡʹͲͲǤ
ͲͺͲʹǡʹͲͲǤ
ǣȀȀǤ
Ǥ
ȀȀ
̴ʹͲͲ̴̴̴̴̴
ǣȀȀǤ
Ǥ
ȀȀ
̴ʹͲͲ̴̴̴
ǤǤ
Ǥ
ǡǤǣ
ήή
ǣ
ήήǤ
ǤǤǤǣ
ƬǤǡʹͲͲͷǤͲ
ƬǤǡʹͲͲͷǤͲǦͶͲǦͲʹͳ͵ͲǦǤ
ò
Ǥ
ǡ
ǡ
ǡ
Ǥ ʹͲͲͺ
ʹͲ ǡ
Ǥ
ǡ
Ǥ
Ǥ
Ǥ
ǡ
ǡ
Ǥ
Ǧ
ǡ
Ǥ
ǡǣȀȀ
ǣȀȀǤ
Ǧ
Ǥ
Ȁ
ǡ
ǡ
ǣ
ȏȐ
Ǧ
ȏȐ
ͶͲͶͲ
̹ʹͲͲͻ
© Copyright 2026 Paperzz