ͲͲ ò ǡǡͲȀʹͲͲͻ ͳǤͲͷȋ Ȍ ǣͲͲ ͲͲ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͶ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͶ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͶ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͷ ͷ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ͷ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͺ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͻ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͳͳ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͳ͵ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͳͷ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͳͷ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͳ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͳ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͳͻ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͳͻ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤʹͲ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤʹͳ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤʹͳ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤʹʹ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤʹ͵ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤʹ͵ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤʹͶ ȋǦȌǣ Ȍǣ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤʹ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤʹ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵Ͳ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵ͳ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵ͳ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵͵ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵ͷ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵ͷ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵ ʹͶͲ ̹ʹͲͲͻ ǣͲͲ ͲͲ Ȁ Ȁ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵ͺ Ǩ ǨǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵ͺ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵ͻ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ͵ͻ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͶͲ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤ ǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤǤͶͲ ͵ͶͲ ̹ʹͲͲͻ ǣͲͲ ͲͲ ͳǡ Ǥ ǡ ǡ ǡ ǡ Ǥ Ǥ Ǥ ǡ ǡ ǡ ǦǦ Ǥ ǣ ͳǤ ȋǡ Ǧ ǡ ǡ Ȍ ʹǤ ǡ ǡ ͵Ǥ Ǥ ǡ ͶǤ Ǧ ͷǤ ǡ ǡ ǡ ǡ ȋ ȋ Ȍ ǡ ǡ Ǥ Ǥ ʹǡ Ǥ Ǥ ǯǤ Ǥǡ ǡ ǡ ǡ Ǥ ͳͷʹΨʹͲͲͻ ͷʹΨʹͲͲͻǡ ǣ ǣȀȀ ǤǤ ȀǦ ȀȀʹͲͲͻȀͲͷȀ ȀȀʹͲͲͻȀͲͷȀǦǦ Ǧ ǦͲͻǤ ʹ ǡ ǡǨͻǡ Ǩͻǡ ǡ Ǥ ǡ ǡ 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 2025 Paperzz